//----------------------------------------------------------------------------- void Raven_TargetingSystem::Update() { double ClosestDistSoFar = MaxDouble; m_pCurrentTarget = 0; //grab a list of all the opponents the owner can sense std::list<Raven_Bot*> SensedBots; SensedBots = m_pOwner->GetSensoryMem()->GetListOfRecentlySensedOpponents(); std::list<Raven_Bot*>::const_iterator curBot = SensedBots.begin(); for (curBot; curBot != SensedBots.end(); ++curBot) { //make sure the bot is alive and that it is not the owner if ((*curBot)->isAlive() && (*curBot != m_pOwner) && (*curBot)->getEquipe()!=m_pOwner->getEquipe()) { double dist = Vec2DDistanceSq((*curBot)->Pos(), m_pOwner->Pos()); if (dist < ClosestDistSoFar) { ClosestDistSoFar = dist; m_pCurrentTarget = *curBot; } } } }
Raven_Bot* Raven_Projectile::GetClosestIntersectingBot(Vector2D From, Vector2D To)const { Raven_Bot* ClosestIntersectingBot = 0; double ClosestSoFar = MaxDouble; //iterate through all entities checking against the line segment FromTo std::list<Raven_Bot*>::const_iterator curBot; for (curBot = m_pWorld->GetAllBots().begin(); curBot != m_pWorld->GetAllBots().end(); ++curBot) { //make sure we don't check against the shooter of the projectile if ( ((*curBot)->ID() != m_iShooterID)) { //if the distance to FromTo is less than the entity's bounding radius then //there is an intersection if (DistToLineSegment(From, To, (*curBot)->Pos()) < (*curBot)->BRadius()) { //test to see if this is the closest so far double Dist = Vec2DDistanceSq((*curBot)->Pos(), m_vOrigin); if (Dist < ClosestSoFar) { Dist = ClosestSoFar; ClosestIntersectingBot = *curBot; } } } } return ClosestIntersectingBot; }
//------------------------ GetClosestNodeToPosition --------------------------- // // returns the index of the closest visible graph node to the given position //----------------------------------------------------------------------------- int Raven_PathPlanner::GetClosestNodeToPosition(Vector2D pos)const { double ClosestSoFar = MaxDouble; int ClosestNode = no_closest_node_found; //when the cell space is queried this the the range searched for neighboring //graph nodes. This value is inversely proportional to the density of a //navigation graph (less dense = bigger values) const double range = m_pOwner->GetWorld()->GetMap()->GetCellSpaceNeighborhoodRange(); //calculate the graph nodes that are neighboring this position m_pOwner->GetWorld()->GetMap()->GetCellSpace()->CalculateNeighbors(pos, range); //iterate through the neighbors and sum up all the position vectors for (NodeType* pN = m_pOwner->GetWorld()->GetMap()->GetCellSpace()->begin(); !m_pOwner->GetWorld()->GetMap()->GetCellSpace()->end(); pN = m_pOwner->GetWorld()->GetMap()->GetCellSpace()->next()) { //if the path between this node and pos is unobstructed calculate the //distance if (m_pOwner->canWalkBetween(pos, pN->Pos())) { double dist = Vec2DDistanceSq(pos, pN->Pos()); //keep a record of the closest so far if (dist < ClosestSoFar) { ClosestSoFar = dist; ClosestNode = pN->Index(); } } } return ClosestNode; }
void Rocket::TestForImpact() { //if the projectile has reached the target position or it hits an entity //or wall it should explode/inflict damage/whatever and then mark itself //as dead //test to see if the line segment connecting the rocket's current position //and previous position intersects with any bots. Raven_Bot* hit = GetClosestIntersectingBot(m_vPosition - m_vVelocity, m_vPosition); //if hit if (hit) { m_bImpacted = true; //send a message to the bot to let it know it's been hit, and who the //shot came from Dispatcher->DispatchMsg(SEND_MSG_IMMEDIATELY, m_iShooterID, hit->ID(), Msg_TakeThatMF, (void*)&m_iDamageInflicted); //test for bots within the blast radius and inflict damage InflictDamageOnBotsWithinBlastRadius(); } //test for impact with a wall double dist; if( FindClosestPointOfIntersectionWithWalls(m_vPosition - m_vVelocity, m_vPosition, dist, m_vImpactPoint, m_pWorld->GetMap()->GetWalls())) { m_bImpacted = true; //test for bots within the blast radius and inflict damage InflictDamageOnBotsWithinBlastRadius(); m_vPosition = m_vImpactPoint; return; } //test to see if rocket has reached target position. If so, test for //all bots in vicinity const double tolerance = 5.0; if (Vec2DDistanceSq(Pos(), m_vTarget) < tolerance*tolerance) { m_bImpacted = true; InflictDamageOnBotsWithinBlastRadius(); } }
Vector2D B020612E_Steering::FollowPath(){ if (Vec2DDistanceSq(_pPath->CurrentWaypoint()->waypoint->GetPosition(), _pTank->GetCentrePosition()) < (10 * 10)) _pPath->SetNextWaypoint(); if (!_pPath->Finished()) return Seek(_pPath->CurrentWaypoint()->waypoint->GetPosition()); else return Arrive(_pPath->CurrentWaypoint()->waypoint->GetPosition(), NORMAL); }
Entity* Projectile::GetClosestIntersectingEntity(Vector2D From, Vector2D To)const { Entity* ClosestIntersectingEntity = 0; double ClosestSoFar = MaxDouble; //iterate through all game entities std::list<Entity*>::const_iterator curEntity; for(curEntity = m_pWorld->GetAllEntities().begin(); curEntity != m_pWorld->GetAllEntities().end(); ++curEntity) { //don't check the entity who shot the projectile if(((*curEntity)->ID() != m_iShooterID)) { //if the distasnce to the segment between From and To is less than the entities bounding //radius then thre is an intersection if(DistToLineSegment(From, To, (*curEntity)->Pos()) < (*curEntity)->BRadius()) { //check if this the closest intersecting entity so far double Dist = Vec2DDistanceSq((*curEntity)->Pos(), m_vOrigin); //if so then set this to be the new closest entity if(Dist < ClosestSoFar) { Dist = ClosestSoFar; ClosestIntersectingEntity = *curEntity; } } } } return ClosestIntersectingEntity; }
//--------------------------- 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); }
//--------------------- GetPosOfClosestSwitch ----------------------------- // // returns the position of the closest visible switch that triggers the // door of the specified ID //----------------------------------------------------------------------------- Vector2D Raven_Game::GetPosOfClosestSwitch(Vector2D botPos, unsigned int doorID)const { std::vector<unsigned int> SwitchIDs; //first we need to get the ids of the switches attached to this door std::vector<Raven_Door*>::const_iterator curDoor; for (curDoor = m_pMap->GetDoors().begin(); curDoor != m_pMap->GetDoors().end(); ++curDoor) { if ((*curDoor)->ID() == doorID) { SwitchIDs = (*curDoor)->GetSwitchIDs(); break; } } Vector2D closest; double ClosestDist = MaxDouble; //now test to see which one is closest and visible std::vector<unsigned int>::iterator it; for (it = SwitchIDs.begin(); it != SwitchIDs.end(); ++it) { BaseGameEntity* trig = EntityMgr->GetEntityFromID(*it); if (isLOSOkay(botPos, trig->Pos())) { double dist = Vec2DDistanceSq(botPos, trig->Pos()); if ( dist < ClosestDist) { ClosestDist = dist; closest = trig->Pos(); } } } return closest; }
bool Level::isPathObstructed(Vector2D A, Vector2D B, double BoundingRadius)const { Vector2D ToB = Vec2DNormalize(B - A); Vector2D curPos = A; while (Vec2DDistanceSq(curPos, B) > BoundingRadius*BoundingRadius) { //advance curPos one step curPos += ToB * 0.5 * BoundingRadius; //test all walls against the new position //if (doWallsIntersectCircle(m_pMap->GetWalls(), curPos, BoundingRadius)) { return true; } } return false; }
//------------------------ isAtPosition --------------------------------------- // // returns true if the bot is close to the given position //----------------------------------------------------------------------------- bool Raven_Bot::isAtPosition(Vector2D pos)const { const static double tolerance = 10.0; return Vec2DDistanceSq(Pos(), pos) < tolerance * tolerance; }
bool GoalKeeper::BallWithinRangeForIntercept()const { return (Vec2DDistanceSq(Team()->HomeGoal()->Center(), Ball()->Pos()) <= Prm.GoalKeeperInterceptRangeSq); }
bool GoalKeeper::TooFarFromGoalMouth()const { return (Vec2DDistanceSq(Pos(), GetRearInterposeTarget()) > Prm.GoalKeeperInterceptRangeSq); }
bool PlayerBase::AtTarget() const { return (Vec2DDistanceSq(Pos(), Steering()->Target()) < 3.0); }
bool PlayerBase::BallWithinControlRange() const { double dist = Vec2DDistanceSq(this->Ball()->Pos(), Pos()); return (Vec2DDistanceSq(this->Ball()->Pos(), Pos()) < 0.4); }
bool PlayerBase::BallWithinReceivingRange() const { return (Vec2DDistanceSq(Pos(), Ball()->Pos()) < 0.3); }