void S013010C_Aaron_Smith_Steering::Evade()
{
Vector2D TargetToEvade = mTank->GetTarget() - mTank->GetCentrePosition();
double lookAheadTime = TargetToEvade.Length() / (mTank->GetMaxSpeed() + mTank->GetEnemySpeed());
Flee(mTank->GetTarget() + mTank->GetEnemyVelocity() * lookAheadTime);
}
Vector3 SteeringBehaviors::Evade(const BaseEntity *pursuer) {
Vector3 toPursuer = pursuer->position - this->_vehicle->position;
double lookAheadTime = vectorMag(toPursuer) / (this->_vehicle->MaxSpeed() + pursuer->Speed());
lookAheadTime += this->LookAheadTime(this->_vehicle, pursuer->position);
return Flee(pursuer->position + pursuer->Velocity() * lookAheadTime);
};
Vec2 SteeringForce::Evade(const Vehicle *pursuer)
{
Vec2 ToPursuer = pursuer->getPosition()- m_pVehicle->getPosition();
//预测的时间正比于追逐着的距离，反比雨智能体的速度和
double LookAheadTime = ToPursuer.length()/(m_pVehicle->getMaxSpeed()+pursuer->getVeloctity().length());
return Flee(pursuer->getPosition()+pursuer->getVeloctity()*LookAheadTime);
}
Vector3 SteeringBehaviors::Calculate() {
this->_steeringForce.zero();
Vector3 force;
if(On(obstacle_avoidance)) {
double weightObstacleAvoidance = 10;
force = ObstacleAvoidance(((Agent*)this->_vehicle)->world->obstacles) *
weightObstacleAvoidance;
if (!AccumulateForce(_steeringForce, force)) return _steeringForce;
}
if(On(flee)) {
force = Flee(_vehicle->target);
if (!AccumulateForce(_steeringForce, force)) return _steeringForce;
}
if(On(seek)) {
force = Seek(_vehicle->target);
if (!AccumulateForce(_steeringForce, force)) return _steeringForce;
}
if(On(arrive)) {
force = Arrive(_vehicle->target, _deceleration);
if (!AccumulateForce(_steeringForce, force)) return _steeringForce;
}
if(On(pursue)) {
force = Pursue(this->evador1);
if (!AccumulateForce(_steeringForce, force)) return _steeringForce;
}
if(On(evade)) {
force = Evade(this->pursuer1);
if (!AccumulateForce(_steeringForce, force)) return _steeringForce;
}
if(On(wander)) {
force = Wander();
if(!AccumulateForce(_steeringForce, force)) return _steeringForce;
}
return _steeringForce;
};
void Stag::Update(sf::Vector2f target)
{
frameTime = frameClock.restart();
m_injuredSound.setPosition(m_position.x, m_position.y, 0);
m_deathSound.setPosition(m_position.x, m_position.y, 0);
if (!m_dead)
{
if (smellDetected)
{
m_emitter.SetAlive(true);
m_emitter.SetPosition(m_position);
}
m_emitter.Update(target);
if (Player::GetInstance()->m_selected == false)
{
m_selected = false;
}
if (m_health <= 0)
{
m_selected = false;
m_dead = true;
}
else if (m_health < 70 && m_health >= 20) // If the player attacked the Stag
{
Chase(target);
}
else if (m_health < 20 && m_health > 0)
{
Flee(target);
}
else
{
Move();
}
if (m_health == 0)
{
m_deathSound.setMinDistance(500);
m_deathSound.setPosition(m_position.x, m_position.y, 0);
m_deathSound.play();
Player::GetInstance()->IncreaseHealth(20);
Player::GetInstance()->SetMaxHealth(Player::GetInstance()->GetMaxHealth() + 3);
Player::GetInstance()->SetMaxStamina(Player::GetInstance()->GetMaxStamina() + 3);
}
}
}
Vector2D B020612E_Steering::CalculatePrioritised()
{
Vector2D force;
if (On(STEERING_OBSTACLEAVOIDANCE))
{
force = ObstacleAvoidance(ObstacleManager::Instance()->GetObstacles()) * 10.0f;
if (!AccumulateForce(_pSteeringForce, force))
return _pSteeringForce;
}
if (On(STEERING_FLEE))
{
force = Flee(_pTank->GetClick()) * 1.0f;
if (!AccumulateForce(_pSteeringForce, force))
return _pSteeringForce;
}
if (On(STEERING_SEEK))
{
force = Seek(_pTank->GetClick()) * 1.0f;
if (!AccumulateForce(_pSteeringForce, force))
return _pSteeringForce;
}
if (On(STEERING_WANDER))
{
force = Wander() * 1.0f;
if (!AccumulateForce(_pSteeringForce, force))
return _pSteeringForce;
}
if (On(STEERING_ARRIVE))
{
force = Arrive(_pTank->GetClick(), _pDeceleration) * 1.0f;
if (!AccumulateForce(_pSteeringForce, force))
return _pSteeringForce;
}
return _pSteeringForce;
}
//--------------------------- Hide ---------------------------------------
//
//------------------------------------------------------------------------
Vector2D SteeringBehavior::Hide()
{
double DistToClosest = MaxDouble;
Vector2D BestHidingSpot;
std::set<Obstacle*>::const_iterator curOb = Obstacle::getAll().begin();
std::set<Obstacle*>::const_iterator closest;
while(curOb != Obstacle::getAll().end())
{
//calculate the position of the hiding spot for this obstacle
Vector2D HidingSpot = GetHidingPosition((*curOb)->Pos(),
(*curOb)->BRadius(),
hideTarget->Pos());
//work in distance-squared space to find the closest hiding
//spot to the agent
double dist = Vec2DDistanceSq(HidingSpot, m_pMovingEntity->Pos());
if (dist < DistToClosest)
{
DistToClosest = dist;
BestHidingSpot = HidingSpot;
closest = curOb;
}
++curOb;
}//end while
//if no suitable obstacles found then Evade the hunter
if (DistToClosest == MaxFloat)
{
return Flee(hideTarget->Pos());
}
//else use Arrive on the hiding spot
return Arrive(BestHidingSpot, fast);
}
Vector2D B020612E_Steering::CalculateWeightedSum()
{
//if (On(STEERING_OBSTACLEAVOIDANCE))
//_pSteeringForce += ObstacleAvoidance();
if (On(STEERING_WANDER))
_pSteeringForce += Wander() * 1.0f;
if (On(STEERING_SEEK))
_pSteeringForce += Seek(_pTank->GetClick()) * 1.0f;
if (On(STEERING_FLEE))
_pSteeringForce += Flee(_pTank->GetClick()) * 1.0f;
if (On(STEERING_ARRIVE))
_pSteeringForce += Arrive(_pTank->GetClick(), _pDeceleration) * 1.0f;
if (On(STEERING_PURSUIT))
_pSteeringForce += Pursuit(_pTank->GetMotion(), _pTank->GetMouseVelocity()) * 1.0f;
//if (On(STEERING_PATHFOLLOWING))
// _pSteeringForce += FollowPath() * 0.5f;
_pSteeringForce.Truncate(_pTank->GetMaxForce());
return _pSteeringForce;
}
void Doe::Update(sf::Vector2f target)
{
m_injuredSound.setPosition(m_position.x, m_position.y, 0);
m_deathSound.setPosition(m_position.x, m_position.y, 0);
if (!m_dead)
{
if (smellDetected)
{
m_emitter.SetAlive(true);
m_emitter.SetPosition(m_position);
}
m_emitter.Update(target);
if (Player::GetInstance()->m_selected == false)
{
m_selected = false;
}
if (m_health <= 0)
{
m_selected = false;
m_dead = true;
}
else
{
Flee(target);
}
if (m_health == 0)
{
m_deathSound.setMinDistance(500);
m_deathSound.setPosition(m_position.x, m_position.y, 0);
m_deathSound.play();
Player::GetInstance()->IncreaseHealth(15);
Player::GetInstance()->SetMaxHealth(Player::GetInstance()->GetMaxHealth() + 2);
Player::GetInstance()->SetMaxStamina(Player::GetInstance()->GetMaxStamina() + 2);
}
}
}
//---------------------- 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;
}
//---------------------- 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;
}
Vector2D SteeringBehavior::CalculatePrioritized() {
Vector2D force;
//if (On(wall_avoidance))
//{
// force = WallAvoidance(m_pVehicle->World()->Walls()) *
// m_dWeightWallAvoidance;
// if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
//}
//if (On(obstacle_avoidance))
//{
// force = ObstacleAvoidance(m_pVehicle->World()->Obstacles()) *
// m_dWeightObstacleAvoidance;
// if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
//}
//if (On(evade))
//{
// assert(m_pTargetAgent1 && "Evade target not assigned");
// force = Evade(m_pTargetAgent1) * m_dWeightEvade;
// if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
//}
if (On(flee))
{
force = Flee(vehicle_->GetGameWorld()->Agents()) * m_dWeightFlee;
if (!AccumulateForce(steering_force_, force)) return steering_force_;
}
// The next three can be combined for flocking behavior (wander is
// Also a good behavior to add into this mix)
if (On(separation)) {
force = Separation(vehicle_->GetGameWorld()->Agents()) * m_dWeightSeparation;
if (!AccumulateForce(steering_force_, force)) return steering_force_;
}
if (On(alignment)) {
force = Alignment(vehicle_->GetGameWorld()->Agents()) * m_dWeightAlignment;
if (!AccumulateForce(steering_force_, force)) return steering_force_;
}
if (On(cohesion)) {
force = Cohesion(vehicle_->GetGameWorld()->Agents()) * m_dWeightCohesion;
if (!AccumulateForce(steering_force_, force)) return steering_force_;
}
//if (On(seek))
//{
// force = Seek(m_pVehicle->World()->Crosshair()) * m_dWeightSeek;
// if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
//}
//if (On(arrive))
//{
// force = Arrive(m_pVehicle->World()->Crosshair(), m_Deceleration) * m_dWeightArrive;
// if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
//}
if (On(wander)) {
force = Wander() * weight_wander_;
if (!AccumulateForce(steering_force_, force)) return steering_force_;
}
if (On(pursuit))
{
//assert(target_agent_ && "pursuit target not assigned");
force = Pursuit(target_agent_) * m_dWeightPursuit;
if (!AccumulateForce(steering_force_, force)) return steering_force_;
}
/*
if (On(offset_pursuit))
{
assert(m_pTargetAgent1 && "pursuit target not assigned");
assert(!m_vOffset.isZero() && "No offset assigned");
force = OffsetPursuit(m_pTargetAgent1, m_vOffset);
if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
}
if (On(interpose))
{
assert(m_pTargetAgent1 && m_pTargetAgent2 && "Interpose agents not assigned");
force = Interpose(m_pTargetAgent1, m_pTargetAgent2) * m_dWeightInterpose;
if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
}
if (On(hide))
{
assert(m_pTargetAgent1 && "Hide target not assigned");
force = Hide(m_pTargetAgent1, m_pVehicle->World()->Obstacles()) * m_dWeightHide;
if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
}
if (On(follow_path))
{
force = FollowPath() * m_dWeightFollowPath;
if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
}*/
return steering_force_;
}
//---------------------- 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
//------------------------------------------------------------------------
Vector2D SteeringBehavior::CalculatePrioritized(float dt)
{
//reset the steering force
m_vSteeringForce.Zero();
Vector2D force;
if (On(bounds_avoidance))
{
force = BoundsAvoidance() * m_dWeightBoundsAvoidance;
if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
}
if (On(obstacle_avoidance))
{
force = ObstacleAvoidance() * m_dWeightObstacleAvoidance;
if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
}
if (On(flee))
{
assert(fleeTarget && "Flee target not assigned");
force = Flee(fleeTarget->Pos()) * m_dWeightFlee;
if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
}
if (On(seek))
{
assert(seekTarget && "Seek target not assigned");
force = Seek(seekTarget->Pos()) * m_dWeightSeek;
if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
}
if (On(arrive))
{
assert(seekTarget && "Arrive target not assigned");
force = Arrive(seekTarget->Pos(), m_Deceleration) * m_dWeightArrive;
if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
}
if (On(wander))
{
force = Wander(dt) * m_dWeightWander;
if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
}
if (On(pursuit))
{
assert(pursuitTarget && "pursuit target not assigned");
force = Pursuit(pursuitTarget) * m_dWeightPursuit;
if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
}
if (On(offset_pursuit))
{
assert (pursuitTarget && "pursuit target not assigned");
force = OffsetPursuit(pursuitTarget, m_vOffset);
if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
}
if (On(hide))
{
assert(hideTarget && "Hide target not assigned");
force = Hide() * m_dWeightHide;
if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
}
if (On(forward)) {
force = Forward() * m_dWeightForward;
if (!AccumulateForce(m_vSteeringForce, force)) return m_vSteeringForce;
}
return m_vSteeringForce;
}
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;
}
//---------------------- CalculateWeightedSum ----------------------------
//
// this simply sums up all the active behaviors X their weights and
// truncates the result to the max available steering force before
// returning
//------------------------------------------------------------------------
Vector2D SteeringBehavior::CalculateWeightedSum(float dt)
{
//reset the steering force
m_vSteeringForce.Zero();
if (On(bounds_avoidance))
{
Vector2D force = BoundsAvoidance() * m_dWeightBoundsAvoidance;
/*if (!force.isZero()) {
std::cout << "avoid wall: " << force << std::endl;
}*/
m_vSteeringForce += force;
}
if (On(obstacle_avoidance))
{
Vector2D force = ObstacleAvoidance() * m_dWeightObstacleAvoidance;
/*if (!force.isZero()) {
std::cout << "avoid obst: " << force << std::endl;
}*/
m_vSteeringForce += force;
}
if (On(flee))
{
assert(fleeTarget && "Flee target not assigned");
m_vSteeringForce += Flee(fleeTarget->Pos()) * m_dWeightFlee;
}
if (On(seek))
{
assert(seekTarget && "Seek target not assigned");
m_vSteeringForce += Seek(seekTarget->Pos()) * m_dWeightSeek;
}
if (On(arrive))
{
assert(seekTarget && "Arrive target not assigned");
m_vSteeringForce += Arrive(seekTarget->Pos(), m_Deceleration) * m_dWeightArrive;
}
if (On(wander))
{
Vector2D force = Wander(dt) * m_dWeightWander;
//std::cout << "wander: " << force << std::endl;
m_vSteeringForce += force;
}
if (On(pursuit))
{
assert(pursuitTarget && "pursuit target not assigned");
m_vSteeringForce += Pursuit(pursuitTarget) * m_dWeightPursuit;
}
if (On(offset_pursuit))
{
assert (pursuitTarget && "pursuit target not assigned");
m_vSteeringForce += OffsetPursuit(pursuitTarget, m_vOffset) * m_dWeightOffsetPursuit;
}
if (On(hide))
{
assert(hideTarget && "Hide target not assigned");
m_vSteeringForce += Hide() * m_dWeightHide;
}
if (On(forward)) {
Vector2D force = Forward() * m_dWeightForward;
m_vSteeringForce += force;
}
//m_vSteeringForce.Truncate(m_pMovingEntity->MaxForce());
return m_vSteeringForce;
}
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;*/
}
Vector2D SteeringBehavior::CalculateWeightedSum()
{
//if (On(wall_avoidance))
//{
//m_vSteeringForce += WallAvoidance(m_pVehicle->World()->Walls()) *
// m_dWeightWallAvoidance;
//}
//
//if (On(obstacle_avoidance))
//{
//m_vSteeringForce += ObstacleAvoidance(m_pVehicle->World()->Obstacles()) *
// m_dWeightObstacleAvoidance;
//}
//if (On(evade))
//{
//assert(m_pTargetAgent1 && "Evade target not assigned");
//
//m_vSteeringForce += Evade(m_pTargetAgent1) * m_dWeightEvade;
//}
////these next three can be combined for flocking behavior (wander is
////also a good behavior to add into this mix)
//if (!isSpacePartitioningOn())
//{
//if (On(separation))
//{
// m_vSteeringForce += Separation(m_pVehicle->World()->Agents()) * m_dWeightSeparation;
//}
//if (On(allignment))
//{
// m_vSteeringForce += Alignment(m_pVehicle->World()->Agents()) * m_dWeightAlignment;
//}
//if (On(cohesion))
//{
// m_vSteeringForce += Cohesion(m_pVehicle->World()->Agents()) * m_dWeightCohesion;
//}
//}
//else
//{
//if (On(separation))
//{
// m_vSteeringForce += SeparationPlus(m_pVehicle->World()->Agents()) * m_dWeightSeparation;
//}
//if (On(allignment))
//{
// m_vSteeringForce += AlignmentPlus(m_pVehicle->World()->Agents()) * m_dWeightAlignment;
//}
//if (On(cohesion))
//{
// m_vSteeringForce += CohesionPlus(m_pVehicle->World()->Agents()) * m_dWeightCohesion;
//}
//}
//if (On(wander))
//{
//m_vSteeringForce += Wander() * m_dWeightWander;
//}
if (On(seek))
{
m_vSteeringForce += Seek(m_pVehicle->World()->Crosshair()) * m_dWeightSeek;
}
if (On(flee))
{
m_vSteeringForce += Flee(m_pVehicle->World()->Crosshair()) * m_dWeightFlee;
}
if (On(arrive))
{
m_vSteeringForce += Arrive(m_pVehicle->World()->Crosshair(), m_Deceleration) * m_dWeightArrive;
}
//if (On(pursuit))
//{
//assert(m_pTargetAgent1 && "pursuit target not assigned");
//m_vSteeringForce += Pursuit(m_pTargetAgent1) * m_dWeightPursuit;
//}
//if (On(offset_pursuit))
//{
//assert (m_pTargetAgent1 && "pursuit target not assigned");
//assert (!m_vOffset.isZero() && "No offset assigned");
//m_vSteeringForce += OffsetPursuit(m_pTargetAgent1, m_vOffset) * m_dWeightOffsetPursuit;
//}
//if (On(interpose))
//{
//assert (m_pTargetAgent1 && m_pTargetAgent2 && "Interpose agents not assigned");
//m_vSteeringForce += Interpose(m_pTargetAgent1, m_pTargetAgent2) * m_dWeightInterpose;
//}
//if (On(hide))
//{
//assert(m_pTargetAgent1 && "Hide target not assigned");
//m_vSteeringForce += Hide(m_pTargetAgent1, m_pVehicle->World()->Obstacles()) * m_dWeightHide;
//}
//if (On(follow_path))
//{
//m_vSteeringForce += FollowPath() * m_dWeightFollowPath;
//}
//m_vSteeringForce.Truncate(m_pVehicle->MaxForce());
//
//return m_vSteeringForce;
}
