//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: // // $NoKeywords: $ // //=============================================================================// // bot_hide.cpp // Mechanisms for using Hiding Spots in the Navigation Mesh // Author: Michael Booth, 2003-2004 #include "cbase.h" #include "bot.h" #include "cs_nav_pathfind.h" // memdbgon must be the last include file in a .cpp file!!! #include "tier0/memdbgon.h" //-------------------------------------------------------------------------------------------------------------- /** * If a player is at the given spot, return true */ bool IsSpotOccupied( CBaseEntity *me, const Vector &pos ) { const float closeRange = 75.0f; // 50 // is there a player in this spot float range; CBasePlayer *player = UTIL_GetClosestPlayer( pos, &range ); if (player != me) { if (player && range < closeRange) return true; } // is there is a hostage in this spot // BOTPORT: Implement hostage manager /* if (g_pHostages) { CHostage *hostage = g_pHostages->GetClosestHostage( *pos, &range ); if (hostage && hostage != me && range < closeRange) return true; } */ return false; } //-------------------------------------------------------------------------------------------------------------- class CollectHidingSpotsFunctor { public: CollectHidingSpotsFunctor( CBaseEntity *me, const Vector &origin, float range, int flags, Place place = UNDEFINED_PLACE ) : m_origin( origin ) { m_me = me; m_count = 0; m_range = range; m_flags = (unsigned char)flags; m_place = place; m_totalWeight = 0; } enum { MAX_SPOTS = 256 }; bool operator() ( CNavArea *area ) { // if a place is specified, only consider hiding spots from areas in that place if (m_place != UNDEFINED_PLACE && area->GetPlace() != m_place) return true; // collect all the hiding spots in this area const HidingSpotVector *pSpots = area->GetHidingSpots(); FOR_EACH_VEC( (*pSpots), it ) { const HidingSpot *spot = (*pSpots)[ it ]; // if we've filled up, stop searching if (m_count == MAX_SPOTS) { return false; } // make sure hiding spot is in range if (m_range > 0.0f) { if ((spot->GetPosition() - m_origin).IsLengthGreaterThan( m_range )) { continue; } } // if a Player is using this hiding spot, don't consider it if (IsSpotOccupied( m_me, spot->GetPosition() )) { // player is in hiding spot /// @todo Check if player is moving or sitting still continue; } if (spot->GetArea() && (spot->GetArea()->GetAttributes() & NAV_MESH_DONT_HIDE)) { // the area has been marked as DONT_HIDE since the last analysis, so let's ignore it continue; } // only collect hiding spots with matching flags if (m_flags & spot->GetFlags()) { m_hidingSpot[ m_count ] = &spot->GetPosition(); m_hidingSpotWeight[ m_count ] = m_totalWeight; // if it's an 'avoid' area, give it a low weight if ( spot->GetArea() && ( spot->GetArea()->GetAttributes() & NAV_MESH_AVOID ) ) { m_totalWeight += 1; } else { m_totalWeight += 2; } ++m_count; } } return (m_count < MAX_SPOTS); } /** * Remove the spot at index "i" */ void RemoveSpot( int i ) { if (m_count == 0) return; for( int j=i+1; j<m_count; ++j ) m_hidingSpot[j-1] = m_hidingSpot[j]; --m_count; } int GetRandomHidingSpot( void ) { int weight = RandomInt( 0, m_totalWeight-1 ); for ( int i=0; i<m_count-1; ++i ) { // if the next spot's starting weight is over the target weight, this spot is the one if ( m_hidingSpotWeight[i+1] >= weight ) { return i; } } // if we didn't find any, it's the last one return m_count - 1; } CBaseEntity *m_me; const Vector &m_origin; float m_range; const Vector *m_hidingSpot[ MAX_SPOTS ]; int m_hidingSpotWeight[ MAX_SPOTS ]; int m_totalWeight; int m_count; unsigned char m_flags; Place m_place; }; /** * Do a breadth-first search to find a nearby hiding spot and return it. * Don't pick a hiding spot that a Player is currently occupying. * @todo Clean up this mess */ const Vector *FindNearbyHidingSpot( CBaseEntity *me, const Vector &pos, float maxRange, bool isSniper, bool useNearest ) { CNavArea *startArea = TheNavMesh->GetNearestNavArea( pos ); if (startArea == NULL) return NULL; // collect set of nearby hiding spots if (isSniper) { CollectHidingSpotsFunctor collector( me, pos, maxRange, HidingSpot::IDEAL_SNIPER_SPOT ); SearchSurroundingAreas( startArea, pos, collector, maxRange ); if (collector.m_count) { int which = collector.GetRandomHidingSpot(); return collector.m_hidingSpot[ which ]; } else { // no ideal sniping spots, look for "good" sniping spots CollectHidingSpotsFunctor collector( me, pos, maxRange, HidingSpot::GOOD_SNIPER_SPOT ); SearchSurroundingAreas( startArea, pos, collector, maxRange ); if (collector.m_count) { int which = collector.GetRandomHidingSpot(); return collector.m_hidingSpot[ which ]; } // no sniping spots at all.. fall through and pick a normal hiding spot } } // collect hiding spots with decent "cover" CollectHidingSpotsFunctor collector( me, pos, maxRange, HidingSpot::IN_COVER ); SearchSurroundingAreas( startArea, pos, collector, maxRange ); if (collector.m_count == 0) { // no hiding spots at all - if we're not a sniper, try to find a sniper spot to use instead if (!isSniper) { return FindNearbyHidingSpot( me, pos, maxRange, true, useNearest ); } return NULL; } if (useNearest) { // return closest hiding spot const Vector *closest = NULL; float closeRangeSq = 9999999999.9f; for( int i=0; i<collector.m_count; ++i ) { float rangeSq = (*collector.m_hidingSpot[i] - pos).LengthSqr(); if (rangeSq < closeRangeSq) { closeRangeSq = rangeSq; closest = collector.m_hidingSpot[i]; } } return closest; } // select a hiding spot at random int which = collector.GetRandomHidingSpot(); return collector.m_hidingSpot[ which ]; } //-------------------------------------------------------------------------------------------------------------- /** * Select a random hiding spot among the nav areas that are tagged with the given place */ const Vector *FindRandomHidingSpot( CBaseEntity *me, Place place, bool isSniper ) { // collect set of nearby hiding spots if (isSniper) { CollectHidingSpotsFunctor collector( me, me->GetAbsOrigin(), -1.0f, HidingSpot::IDEAL_SNIPER_SPOT, place ); TheNavMesh->ForAllAreas( collector ); if (collector.m_count) { int which = RandomInt( 0, collector.m_count-1 ); return collector.m_hidingSpot[ which ]; } else { // no ideal sniping spots, look for "good" sniping spots CollectHidingSpotsFunctor collector( me, me->GetAbsOrigin(), -1.0f, HidingSpot::GOOD_SNIPER_SPOT, place ); TheNavMesh->ForAllAreas( collector ); if (collector.m_count) { int which = RandomInt( 0, collector.m_count-1 ); return collector.m_hidingSpot[ which ]; } // no sniping spots at all.. fall through and pick a normal hiding spot } } // collect hiding spots with decent "cover" CollectHidingSpotsFunctor collector( me, me->GetAbsOrigin(), -1.0f, HidingSpot::IN_COVER, place ); TheNavMesh->ForAllAreas( collector ); if (collector.m_count == 0) return NULL; // select a hiding spot at random int which = RandomInt( 0, collector.m_count-1 ); return collector.m_hidingSpot[ which ]; } //-------------------------------------------------------------------------------------------------------------------- /** * Select a nearby retreat spot. * Don't pick a hiding spot that a Player is currently occupying. * If "avoidTeam" is nonzero, avoid getting close to members of that team. */ const Vector *FindNearbyRetreatSpot( CBaseEntity *me, const Vector &start, float maxRange, int avoidTeam ) { CNavArea *startArea = TheNavMesh->GetNearestNavArea( start ); if (startArea == NULL) return NULL; // collect hiding spots with decent "cover" CollectHidingSpotsFunctor collector( me, start, maxRange, HidingSpot::IN_COVER ); SearchSurroundingAreas( startArea, start, collector, maxRange ); if (collector.m_count == 0) return NULL; // find the closest unoccupied hiding spot that crosses the least lines of fire and has the best cover for( int i=0; i<collector.m_count; ++i ) { // check if we would have to cross a line of fire to reach this hiding spot if (IsCrossingLineOfFire( start, *collector.m_hidingSpot[i], me )) { collector.RemoveSpot( i ); // back up a step, so iteration won't skip a spot --i; continue; } // check if there is someone on the avoidTeam near this hiding spot if (avoidTeam) { float range; if (UTIL_GetClosestPlayer( *collector.m_hidingSpot[i], avoidTeam, &range )) { const float dangerRange = 150.0f; if (range < dangerRange) { // there is an avoidable player too near this spot - remove it collector.RemoveSpot( i ); // back up a step, so iteration won't skip a spot --i; continue; } } } } if (collector.m_count <= 0) return NULL; // all remaining spots are ok - pick one at random int which = RandomInt( 0, collector.m_count-1 ); return collector.m_hidingSpot[ which ]; } //-------------------------------------------------------------------------------------------------------------------- /** * Functor to collect all hiding spots in range that we can reach before the enemy arrives. * NOTE: This only works for the initial rush. */ class CollectArriveFirstSpotsFunctor { public: CollectArriveFirstSpotsFunctor( CBaseEntity *me, const Vector &searchOrigin, float enemyArriveTime, float range, int flags ) : m_searchOrigin( searchOrigin ) { m_me = me; m_count = 0; m_range = range; m_flags = (unsigned char)flags; m_enemyArriveTime = enemyArriveTime; } enum { MAX_SPOTS = 256 }; bool operator() ( CNavArea *area ) { // collect all the hiding spots in this area const HidingSpotVector *pSpots = area->GetHidingSpots(); FOR_EACH_VEC( (*pSpots), it ) { const HidingSpot *spot = (*pSpots)[ it ]; // make sure hiding spot is in range if (m_range > 0.0f) { if ((spot->GetPosition() - m_searchOrigin).IsLengthGreaterThan( m_range )) { continue; } } // if a Player is using this hiding spot, don't consider it if (IsSpotOccupied( m_me, spot->GetPosition() )) { // player is in hiding spot /// @todo Check if player is moving or sitting still continue; } // only collect hiding spots with matching flags if (!(m_flags & spot->GetFlags())) { continue; } // only collect this hiding spot if we can reach it before the enemy arrives // NOTE: This assumes the area is fairly small and the difference of moving to the corner vs the center is small const float settleTime = 1.0f; if (spot->GetArea()->GetEarliestOccupyTime( m_me->GetTeamNumber() ) + settleTime < m_enemyArriveTime) { m_hidingSpot[ m_count++ ] = spot; } } // if we've filled up, stop searching if (m_count == MAX_SPOTS) return false; return true; } CBaseEntity *m_me; const Vector &m_searchOrigin; float m_range; float m_enemyArriveTime; unsigned char m_flags; const HidingSpot *m_hidingSpot[ MAX_SPOTS ]; int m_count; }; /** * Select a hiding spot that we can reach before the enemy arrives. * NOTE: This only works for the initial rush. */ const HidingSpot *FindInitialEncounterSpot( CBaseEntity *me, const Vector &searchOrigin, float enemyArriveTime, float maxRange, bool isSniper ) { CNavArea *startArea = TheNavMesh->GetNearestNavArea( searchOrigin ); if (startArea == NULL) return NULL; // collect set of nearby hiding spots if (isSniper) { CollectArriveFirstSpotsFunctor collector( me, searchOrigin, enemyArriveTime, maxRange, HidingSpot::IDEAL_SNIPER_SPOT ); SearchSurroundingAreas( startArea, searchOrigin, collector, maxRange ); if (collector.m_count) { int which = RandomInt( 0, collector.m_count-1 ); return collector.m_hidingSpot[ which ]; } else { // no ideal sniping spots, look for "good" sniping spots CollectArriveFirstSpotsFunctor collector( me, searchOrigin, enemyArriveTime, maxRange, HidingSpot::GOOD_SNIPER_SPOT ); SearchSurroundingAreas( startArea, searchOrigin, collector, maxRange ); if (collector.m_count) { int which = RandomInt( 0, collector.m_count-1 ); return collector.m_hidingSpot[ which ]; } // no sniping spots at all.. fall through and pick a normal hiding spot } } // collect hiding spots with decent "cover" CollectArriveFirstSpotsFunctor collector( me, searchOrigin, enemyArriveTime, maxRange, HidingSpot::IN_COVER | HidingSpot::EXPOSED ); SearchSurroundingAreas( startArea, searchOrigin, collector, maxRange ); if (collector.m_count == 0) return NULL; // select a hiding spot at random int which = RandomInt( 0, collector.m_count-1 ); return collector.m_hidingSpot[ which ]; }