Vector2D S013010C_Aaron_Smith_Steering::Calculate(float deltaTime)
{
Vector2D force;
Vector2D totalForce;
if (mIsObstacleAvoiding)
{
force = ObstacleAvoidance() * mObstacleAvoidanceWeight;
if (!AccumulateForce(totalForce, force)) return totalForce;
}
if (mIsWallAvoided)
{
force = WallAvoidance() * mWallAvoidWeight;
if (!AccumulateForce(totalForce, force)) return totalForce;
}
if (mIsWandering)
{
force = Wander(deltaTime) * mSeekWeight;
if (!AccumulateForce(totalForce, force)) return totalForce;
}
if (mIsPursuing)
{
force = Pursuing() * mPursuitWeight;
if (!AccumulateForce(totalForce, force)) return totalForce;
}
if (mIsSeeking)
{
force = Seek(mTank->GetTarget()) * mSeekWeight;
if (!AccumulateForce(totalForce, force)) return totalForce;
}
if (mIsArriving)
{
force = Arrive(mTank->GetTarget(), Deceleration::NORMAL) * mArriveWeight;
if (!AccumulateForce(totalForce, force)) return totalForce;
}
if (mIsFleeing)
{
force = Flee(mTank->GetTarget()) * mFleeWeight;
if (!AccumulateForce(totalForce, force)) return totalForce;
}
return totalForce;
//if (isFleeing) Flee(mTank->GetTarget());
//Vector2D totalForce;
/*for (Vector2D vec : mSteeringForces)
{
totalForce += vec;
}
mSteeringForces.clear();
return totalForce;*/
}
//---------------------- CalculatePrioritized ----------------------------
//
// this method calls each active steering behavior in order of priority
// and acumulates their forces until the max steering force magnitude
// is reached, at which time the function returns the steering force
// accumulated to that point
//------------------------------------------------------------------------
ofVec3f SteeringBehaviors::CalculatePrioritized() {
ofVec3f force;
if (On(wall_avoidance))
{
force = WallAvoidance(m_Vehicle->GameWorld()->getWalls()) * m_WeightObstacleAvoidance;
if (!AccumulateForce(m_SteeringForce, force)) return m_SteeringForce;
}
if (On(obstacle_avoidance))
{
force = ObstacleAvoidance(m_Vehicle->GameWorld()->getObstacles()) * m_WeightObstacleAvoidance;
if (!AccumulateForce(m_SteeringForce, force)) return m_SteeringForce;
}
if (On(flee))
{
force = Flee(m_Vehicle->Target()->Pos()) * m_WeightFlee;
if (!AccumulateForce(m_SteeringForce, force)) return m_SteeringForce;
}
if (On(repulsion))
{
//need to retage the guys!
force = Repulsion(m_Vehicle->oGroup()) * m_WeightRepulsion;
if (!AccumulateForce(m_SteeringForce, force)) return m_SteeringForce;
}
if (!isSpacePartioningOn())
{
if (On(separation))
{
force = Separation(m_Vehicle->rGroup()) * m_WeightSeparation;
if (!AccumulateForce(m_SteeringForce, force)) return m_SteeringForce;
}
if (On(alignment))
{
force = Alignment(m_Vehicle->rGroup()) * m_WeightAlignment;
if (!AccumulateForce(m_SteeringForce, force)) return m_SteeringForce;
}
if (On(cohesion))
{
force = Cohesion(m_Vehicle->rGroup()) * m_WeightCohesion;
if (!AccumulateForce(m_SteeringForce, force)) return m_SteeringForce;
}
}
else
{
if (On(separation))
{
force = SeparationPlus(m_Vehicle->rGroup()) * m_WeightSeparation;
if (!AccumulateForce(m_SteeringForce, force)) return m_SteeringForce;
}
if (On(alignment))
{
force = AlignmentPlus(m_Vehicle->rGroup()) * m_WeightAlignment;
if (!AccumulateForce(m_SteeringForce, force)) return m_SteeringForce;
}
if (On(cohesion))
{
force = CohesionPlus(m_Vehicle->rGroup()) * m_WeightCohesion;
if (!AccumulateForce(m_SteeringForce, force)) return m_SteeringForce;
}
}
if (On(seek))
{
force = Seek(m_Vehicle->Target()->Pos()) * m_WeightSeek;
if (!AccumulateForce(m_SteeringForce, force)) return m_SteeringForce;
}
if (On(arrive))
{
force = Arrive(m_Vehicle->Target()->Pos(), normal) * m_WeightArrive;
if (!AccumulateForce(m_SteeringForce, force)) return m_SteeringForce;
}
if (On(wander))
{
force = Wander() * m_WeightWander;
if (!AccumulateForce(m_SteeringForce, force)) return m_SteeringForce;
}
if (On(follow_path))
{
force = FollowPath() * m_WeightFollowPath;
if (!AccumulateForce(m_SteeringForce, force)) return m_SteeringForce;
}
return m_SteeringForce;
}
//---------------------- CalculateWeightedSum ----------------------------
//
// this simply sums up all the active behaviors X their weights and
// truncates the result to the max available steering force before
// returning
//------------------------------------------------------------------------
ofVec3f SteeringBehaviors::CalculateWeightedSum()
{
if (On(wall_avoidance))
{
m_SteeringForce += WallAvoidance(m_Vehicle->GameWorld()->getWalls()) * m_WeightObstacleAvoidance;
}
if (On(obstacle_avoidance))
{
m_SteeringForce += ObstacleAvoidance( m_Vehicle->GameWorld()->getObstacles() ) * m_WeightObstacleAvoidance;
}
if (On(seek))
{
m_SteeringForce += Seek(m_Vehicle->Target()->Pos()) * m_WeightSeek;
}
if (On(flee))
{
m_SteeringForce += Flee(m_Vehicle->Target()->Pos()) * m_WeightFlee;
}
if (On(arrive))
{
m_SteeringForce += Arrive(m_Vehicle->Target()->Pos(), normal) * m_WeightArrive;
}
if (!isSpacePartioningOn())
{
if (On(separation))
{
m_SteeringForce += Separation(m_Vehicle->rGroup()) * m_WeightSeparation;
}
if (On(alignment))
{
m_SteeringForce += Alignment(m_Vehicle->rGroup()) * m_WeightAlignment;
}
if (On(cohesion))
{
m_SteeringForce += Cohesion(m_Vehicle->rGroup()) * m_WeightCohesion;
}
}
else
{
if (On(separation))
{
m_SteeringForce += SeparationPlus(m_Vehicle->rGroup()) * m_WeightSeparation;
}
if (On(alignment))
{
m_SteeringForce += AlignmentPlus(m_Vehicle->rGroup()) * m_WeightAlignment;
}
if (On(cohesion))
{
m_SteeringForce += CohesionPlus(m_Vehicle->rGroup()) * m_WeightCohesion;
}
}
if (On(repulsion))
{
//need to retag the guys!
m_SteeringForce += Repulsion(m_Vehicle->oGroup()) * m_WeightRepulsion;
}
if (On(wander))
{
m_SteeringForce += Wander() * m_WeightWander;
}
if (On(follow_path))
{
m_SteeringForce += FollowPath() * m_WeightFollowPath;
}
m_SteeringForce.limit(m_Vehicle->MaxForce());
return m_SteeringForce;
}
Vec2 SteeringForce::Calculate()
{
m_vSteeringForce = Vec2::ZERO;
Vec2 force;
std::vector<Vehicle*> neighbors;
if (On(allignment)||On(separation)||On(cohesion)) {
if (m_pVehicle->isCellSpaceOn()) {
CellSpacePartition<Vehicle*>* cellSpace = GameData::Instance()->getCellSpace();
neighbors = cellSpace->getNeighbors();
}else{
auto data = GameData::Instance()->getEntityVector();
neighbors = tagNeighbors(m_pVehicle,data,SearchRad);
}
}
if (On(wall_avoidance)) {
auto data = GameData::Instance()->getWallls();
force = WallAvoidance(data);
if (!AccumulateForce(m_vSteeringForce, force)) {
return m_vSteeringForce;
}
}
if (On(obstacle_avoidance)) {
auto data = GameData::Instance()->getObstacle();
force = ObstacleAvoidance(data);
if (!AccumulateForce(m_vSteeringForce, force)) {
return m_vSteeringForce;
}
}
if (On(separation)) {
force = Separation(neighbors);
if (!AccumulateForce(m_vSteeringForce, force)) {
return m_vSteeringForce;
}
}
if (On(cohesion)) {
force = Cohesion(neighbors);
if (!AccumulateForce(m_vSteeringForce, force)) {
return m_vSteeringForce;
}
}
if (On(allignment)) {
force = Alignment(neighbors);
if (!AccumulateForce(m_vSteeringForce, force)) {
return m_vSteeringForce;
}
}
if (On(hide)) {
CCASSERT(m_pVehicle->getHideTarget()!=nullptr, "不存在躲避目标");
auto data = GameData::Instance()->getEntityVector();
force = Hide(m_pVehicle->getHideTarget(),data);
if (!AccumulateForce(m_vSteeringForce, force)) {
return m_vSteeringForce;
}
}
if (On(follow_path)) {
force = PathFollow();
if (!AccumulateForce(m_vSteeringForce, force)) {
return m_vSteeringForce;
}
}
if (On(seek)) {
force = Seek(m_pVehicle->getTarget());
if (!AccumulateForce(m_vSteeringForce, force)) {
return m_vSteeringForce;
}
}
if (On(flee)) {
force = Flee(m_pVehicle->getTarget());
if (!AccumulateForce(m_vSteeringForce, force)) {
return m_vSteeringForce;
}
}
if (On(arrive)) {
force = Arrive(m_pVehicle->getTarget(), fast);
if (!AccumulateForce(m_vSteeringForce, force)) {
return m_vSteeringForce;
}
}
if (On(offset_pursuit)) {
force = OffsetPursuit(m_pVehicle->getLeader(), m_pVehicle->getOffsetToLeader());
if (!AccumulateForce(m_vSteeringForce, force)) {
return m_vSteeringForce;
}
}
if (On(pursuit)) {
force = Pursuit(m_pVehicle->getEvaderv());
if (!AccumulateForce(m_vSteeringForce, force)) {
return m_vSteeringForce;
}
}
if (On(evade)) {
force = Evade(m_pVehicle->getPursuer());
if (!AccumulateForce(m_vSteeringForce, force)) {
return m_vSteeringForce;
}
}
if (On(wander)) {
force = Wander();
if (!AccumulateForce(m_vSteeringForce, force)) {
return m_vSteeringForce;
}
}
if (On(interpose)) {
force = Interpose(m_pVehicle->getInterposeA(), m_pVehicle->getInterposeB());
if (!AccumulateForce(m_vSteeringForce, force)) {
return m_vSteeringForce;
}
}
return m_vSteeringForce;
}
