2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
// nav_area.h
// Navigation areas
// Author: Michael S. Booth (mike@turtlerockstudios.com), January 2003
# ifndef _NAV_AREA_H_
# define _NAV_AREA_H_
# include "nav_ladder.h"
# include "tier1/memstack.h"
// BOTPORT: Clean up relationship between team index and danger storage in nav areas
enum { MAX_NAV_TEAMS = 2 } ;
# ifdef STAGING_ONLY
inline void DebuggerBreakOnNaN_StagingOnly ( float val )
{
if ( IS_NAN ( val ) )
DebuggerBreak ( ) ;
}
# else
# define DebuggerBreakOnNaN_StagingOnly( _val )
# endif
class CFuncElevator ;
class CFuncNavPrerequisite ;
class CFuncNavCost ;
class CNavVectorNoEditAllocator
{
public :
CNavVectorNoEditAllocator ( ) ;
static void Reset ( ) ;
static void * Alloc ( size_t nSize ) ;
static void * Realloc ( void * pMem , size_t nSize ) ;
static void Free ( void * pMem ) ;
static size_t GetSize ( void * pMem ) ;
private :
static CMemoryStack m_memory ;
static void * m_pCurrent ;
static int m_nBytesCurrent ;
} ;
# if !defined(_X360)
typedef CUtlVectorUltraConservativeAllocator CNavVectorAllocator ;
# else
typedef CNavVectorNoEditAllocator CNavVectorAllocator ;
# endif
//-------------------------------------------------------------------------------------------------------------------
/**
* Functor interface for iteration
*/
class IForEachNavArea
{
public :
virtual bool Inspect ( const CNavArea * area ) = 0 ; // Invoked once on each area of the iterated set. Return false to stop iterating.
virtual void PostIteration ( bool wasCompleteIteration ) { } // Invoked after the iteration has ended. 'wasCompleteIteration' will be true if the entire set was iterated (ie: Inspect() never returned false)
} ;
//-------------------------------------------------------------------------------------------------------------------
/**
* The NavConnect union is used to refer to connections to areas
*/
struct NavConnect
{
NavConnect ( )
{
id = 0 ;
length = - 1 ;
}
union
{
unsigned int id ;
CNavArea * area ;
} ;
mutable float length ;
bool operator = = ( const NavConnect & other ) const
{
return ( area = = other . area ) ? true : false ;
}
} ;
typedef CUtlVectorUltraConservative < NavConnect , CNavVectorAllocator > NavConnectVector ;
//-------------------------------------------------------------------------------------------------------------------
/**
* The NavLadderConnect union is used to refer to connections to ladders
*/
union NavLadderConnect
{
unsigned int id ;
CNavLadder * ladder ;
bool operator = = ( const NavLadderConnect & other ) const
{
return ( ladder = = other . ladder ) ? true : false ;
}
} ;
typedef CUtlVectorUltraConservative < NavLadderConnect , CNavVectorAllocator > NavLadderConnectVector ;
//--------------------------------------------------------------------------------------------------------------
/**
* A HidingSpot is a good place for a bot to crouch and wait for enemies
*/
class HidingSpot
{
public :
virtual ~ HidingSpot ( ) { }
enum
{
IN_COVER = 0x01 , // in a corner with good hard cover nearby
GOOD_SNIPER_SPOT = 0x02 , // had at least one decent sniping corridor
IDEAL_SNIPER_SPOT = 0x04 , // can see either very far, or a large area, or both
EXPOSED = 0x08 // spot in the open, usually on a ledge or cliff
} ;
bool HasGoodCover ( void ) const { return ( m_flags & IN_COVER ) ? true : false ; } // return true if hiding spot in in cover
bool IsGoodSniperSpot ( void ) const { return ( m_flags & GOOD_SNIPER_SPOT ) ? true : false ; }
bool IsIdealSniperSpot ( void ) const { return ( m_flags & IDEAL_SNIPER_SPOT ) ? true : false ; }
bool IsExposed ( void ) const { return ( m_flags & EXPOSED ) ? true : false ; }
int GetFlags ( void ) const { return m_flags ; }
void Save ( CUtlBuffer & fileBuffer , unsigned int version ) const ;
void Load ( CUtlBuffer & fileBuffer , unsigned int version ) ;
NavErrorType PostLoad ( void ) ;
const Vector & GetPosition ( void ) const { return m_pos ; } // get the position of the hiding spot
unsigned int GetID ( void ) const { return m_id ; }
const CNavArea * GetArea ( void ) const { return m_area ; } // return nav area this hiding spot is within
void Mark ( void ) { m_marker = m_masterMarker ; }
bool IsMarked ( void ) const { return ( m_marker = = m_masterMarker ) ? true : false ; }
static void ChangeMasterMarker ( void ) { + + m_masterMarker ; }
public :
void SetFlags ( int flags ) { m_flags | = flags ; } // FOR INTERNAL USE ONLY
void SetPosition ( const Vector & pos ) { m_pos = pos ; } // FOR INTERNAL USE ONLY
private :
friend class CNavMesh ;
friend void ClassifySniperSpot ( HidingSpot * spot ) ;
HidingSpot ( void ) ; // must use factory to create
Vector m_pos ; // world coordinates of the spot
unsigned int m_id ; // this spot's unique ID
unsigned int m_marker ; // this spot's unique marker
CNavArea * m_area ; // the nav area containing this hiding spot
unsigned char m_flags ; // bit flags
static unsigned int m_nextID ; // used when allocating spot ID's
static unsigned int m_masterMarker ; // used to mark spots
} ;
typedef CUtlVectorUltraConservative < HidingSpot * > HidingSpotVector ;
extern HidingSpotVector TheHidingSpots ;
extern HidingSpot * GetHidingSpotByID ( unsigned int id ) ;
//--------------------------------------------------------------------------------------------------------------
/**
* Stores a pointer to an interesting " spot " , and a parametric distance along a path
*/
struct SpotOrder
{
float t ; // parametric distance along ray where this spot first has LOS to our path
union
{
HidingSpot * spot ; // the spot to look at
unsigned int id ; // spot ID for save/load
} ;
} ;
typedef CUtlVector < SpotOrder > SpotOrderVector ;
/**
* This struct stores possible path segments thru a CNavArea , and the dangerous spots
* to look at as we traverse that path segment .
*/
struct SpotEncounter
{
NavConnect from ;
NavDirType fromDir ;
NavConnect to ;
NavDirType toDir ;
Ray path ; // the path segment
SpotOrderVector spots ; // list of spots to look at, in order of occurrence
} ;
typedef CUtlVectorUltraConservative < SpotEncounter * > SpotEncounterVector ;
//-------------------------------------------------------------------------------------------------------------------
/**
* A CNavArea is a rectangular region defining a walkable area in the environment
*/
class CNavAreaCriticalData
{
protected :
// --- Begin critical data, which is heavily hit during pathing operations and carefully arranged for cache performance [7/24/2008 tom] ---
/* 0 */ Vector m_nwCorner ; // north-west corner position (2D mins)
/* 12 */ Vector m_seCorner ; // south-east corner position (2D maxs)
/* 24 */ float m_invDxCorners ;
/* 28 */ float m_invDyCorners ;
/* 32 */ float m_neZ ; // height of the implicit corner defined by (m_seCorner.x, m_nwCorner.y, m_neZ)
/* 36 */ float m_swZ ; // height of the implicit corner defined by (m_nwCorner.x, m_seCorner.y, m_neZ)
/* 40 */ Vector m_center ; // centroid of area
/* 52 */ unsigned char m_playerCount [ MAX_NAV_TEAMS ] ; // the number of players currently in this area
/* 54 */ bool m_isBlocked [ MAX_NAV_TEAMS ] ; // if true, some part of the world is preventing movement through this nav area
/* 56 */ unsigned int m_marker ; // used to flag the area as visited
/* 60 */ float m_totalCost ; // the distance so far plus an estimate of the distance left
/* 64 */ float m_costSoFar ; // distance travelled so far
/* 68 */ CNavArea * m_nextOpen , * m_prevOpen ; // only valid if m_openMarker == m_masterMarker
/* 76 */ unsigned int m_openMarker ; // if this equals the current marker value, we are on the open list
/* 80 */ int m_attributeFlags ; // set of attribute bit flags (see NavAttributeType)
//- connections to adjacent areas -------------------------------------------------------------------
/* 84 */ NavConnectVector m_connect [ NUM_DIRECTIONS ] ; // a list of adjacent areas for each direction
/* 100*/ NavLadderConnectVector m_ladder [ CNavLadder : : NUM_LADDER_DIRECTIONS ] ; // list of ladders leading up and down from this area
/* 108*/ NavConnectVector m_elevatorAreas ; // a list of areas reachable via elevator from this area
/* 112*/ unsigned int m_nearNavSearchMarker ; // used in GetNearestNavArea()
/* 116*/ CNavArea * m_parent ; // the area just prior to this on in the search path
/* 120*/ NavTraverseType m_parentHow ; // how we get from parent to us
/* 124*/ float m_pathLengthSoFar ; // length of path so far, needed for limiting pathfind max path length
/* *************** 360 cache line *************** */
/* 128*/ CFuncElevator * m_elevator ; // if non-NULL, this area is in an elevator's path. The elevator can transport us vertically to another area.
// --- End critical data ---
} ;
class CNavArea : protected CNavAreaCriticalData
{
public :
DECLARE_CLASS_NOBASE ( CNavArea )
CNavArea ( void ) ;
virtual ~ CNavArea ( ) ;
virtual void OnServerActivate ( void ) ; // (EXTEND) invoked when map is initially loaded
virtual void OnRoundRestart ( void ) ; // (EXTEND) invoked for each area when the round restarts
virtual void OnRoundRestartPreEntity ( void ) { } // invoked for each area when the round restarts, but before entities are deleted and recreated
virtual void OnEnter ( CBaseCombatCharacter * who , CNavArea * areaJustLeft ) { } // invoked when player enters this area
virtual void OnExit ( CBaseCombatCharacter * who , CNavArea * areaJustEntered ) { } // invoked when player exits this area
virtual void OnDestroyNotify ( CNavArea * dead ) ; // invoked when given area is going away
virtual void OnDestroyNotify ( CNavLadder * dead ) ; // invoked when given ladder is going away
virtual void OnEditCreateNotify ( CNavArea * newArea ) { } // invoked when given area has just been added to the mesh in edit mode
virtual void OnEditDestroyNotify ( CNavArea * deadArea ) { } // invoked when given area has just been deleted from the mesh in edit mode
virtual void OnEditDestroyNotify ( CNavLadder * deadLadder ) { } // invoked when given ladder has just been deleted from the mesh in edit mode
virtual void Save ( CUtlBuffer & fileBuffer , unsigned int version ) const ; // (EXTEND)
virtual NavErrorType Load ( CUtlBuffer & fileBuffer , unsigned int version , unsigned int subVersion ) ; // (EXTEND)
virtual NavErrorType PostLoad ( void ) ; // (EXTEND) invoked after all areas have been loaded - for pointer binding, etc
virtual void SaveToSelectedSet ( KeyValues * areaKey ) const ; // (EXTEND) saves attributes for the area to a KeyValues
virtual void RestoreFromSelectedSet ( KeyValues * areaKey ) ; // (EXTEND) restores attributes from a KeyValues
// for interactively building or generating nav areas
void Build ( CNavNode * nwNode , CNavNode * neNode , CNavNode * seNode , CNavNode * swNode ) ;
void Build ( const Vector & corner , const Vector & otherCorner ) ;
void Build ( const Vector & nwCorner , const Vector & neCorner , const Vector & seCorner , const Vector & swCorner ) ;
void ConnectTo ( CNavArea * area , NavDirType dir ) ; // connect this area to given area in given direction
void Disconnect ( CNavArea * area ) ; // disconnect this area from given area
void ConnectTo ( CNavLadder * ladder ) ; // connect this area to given ladder
void Disconnect ( CNavLadder * ladder ) ; // disconnect this area from given ladder
unsigned int GetID ( void ) const { return m_id ; } // return this area's unique ID
static void CompressIDs ( void ) ; // re-orders area ID's so they are continuous
unsigned int GetDebugID ( void ) const { return m_debugid ; }
void SetAttributes ( int bits ) { m_attributeFlags = bits ; }
int GetAttributes ( void ) const { return m_attributeFlags ; }
bool HasAttributes ( int bits ) const { return ( m_attributeFlags & bits ) ? true : false ; }
void RemoveAttributes ( int bits ) { m_attributeFlags & = ( ~ bits ) ; }
void SetPlace ( Place place ) { m_place = place ; } // set place descriptor
Place GetPlace ( void ) const { return m_place ; } // get place descriptor
void MarkAsBlocked ( int teamID , CBaseEntity * blocker , bool bGenerateEvent = true ) ; // An entity can force a nav area to be blocked
virtual void UpdateBlocked ( bool force = false , int teamID = TEAM_ANY ) ; // Updates the (un)blocked status of the nav area (throttled)
virtual bool IsBlocked ( int teamID , bool ignoreNavBlockers = false ) const ;
void UnblockArea ( int teamID = TEAM_ANY ) ; // clear blocked status for the given team(s)
void CheckFloor ( CBaseEntity * ignore ) ; // Checks if there is a floor under the nav area, in case a breakable floor is gone
void MarkObstacleToAvoid ( float obstructionHeight ) ;
void UpdateAvoidanceObstacles ( void ) ;
bool HasAvoidanceObstacle ( float maxObstructionHeight = StepHeight ) const ; // is there a large, immobile object obstructing this area
float GetAvoidanceObstacleHeight ( void ) const ; // returns the maximum height of the obstruction above the ground
# ifdef NEXT_BOT
bool HasPrerequisite ( CBaseCombatCharacter * actor = NULL ) const ; // return true if this area has a prerequisite that applies to the given actor
const CUtlVector < CHandle < CFuncNavPrerequisite > > & GetPrerequisiteVector ( void ) const ; // return vector of prerequisites that must be met before this area can be traversed
void RemoveAllPrerequisites ( void ) ;
void AddPrerequisite ( CFuncNavPrerequisite * prereq ) ;
# endif
void ClearAllNavCostEntities ( void ) ; // clear set of func_nav_cost entities that affect this area
void AddFuncNavCostEntity ( CFuncNavCost * cost ) ; // add the given func_nav_cost entity to the cost of this area
float ComputeFuncNavCost ( CBaseCombatCharacter * who ) const ; // return the cost multiplier of this area's func_nav_cost entities for the given actor
bool HasFuncNavAvoid ( void ) const ;
bool HasFuncNavPrefer ( void ) const ;
void CheckWaterLevel ( void ) ;
bool IsUnderwater ( void ) const { return m_isUnderwater ; }
bool IsOverlapping ( const Vector & pos , float tolerance = 0.0f ) const ; // return true if 'pos' is within 2D extents of area.
bool IsOverlapping ( const CNavArea * area ) const ; // return true if 'area' overlaps our 2D extents
bool IsOverlapping ( const Extent & extent ) const ; // return true if 'extent' overlaps our 2D extents
bool IsOverlappingX ( const CNavArea * area ) const ; // return true if 'area' overlaps our X extent
bool IsOverlappingY ( const CNavArea * area ) const ; // return true if 'area' overlaps our Y extent
2021-04-28 15:24:16 +00:00
inline float GetZ ( const Vector * RESTRICT pPos ) const RESTRICT ; // return Z of area at (x,y) of 'pos'
inline float GetZ ( const Vector & pos ) const RESTRICT ; // return Z of area at (x,y) of 'pos'
2020-04-22 16:56:21 +00:00
float GetZ ( float x , float y ) const RESTRICT ; // return Z of area at (x,y) of 'pos'
bool Contains ( const Vector & pos ) const ; // return true if given point is on or above this area, but no others
bool Contains ( const CNavArea * area ) const ;
bool IsCoplanar ( const CNavArea * area ) const ; // return true if this area and given area are approximately co-planar
void GetClosestPointOnArea ( const Vector * RESTRICT pPos , Vector * close ) const RESTRICT ; // return closest point to 'pos' on this area - returned point in 'close'
void GetClosestPointOnArea ( const Vector & pos , Vector * close ) const { return GetClosestPointOnArea ( & pos , close ) ; }
float GetDistanceSquaredToPoint ( const Vector & pos ) const ; // return shortest distance between point and this area
bool IsDegenerate ( void ) const ; // return true if this area is badly formed
bool IsRoughlySquare ( void ) const ; // return true if this area is approximately square
bool IsFlat ( void ) const ; // return true if this area is approximately flat
bool HasNodes ( void ) const ;
void GetNodes ( NavDirType dir , CUtlVector < CNavNode * > * nodes ) const ; // build a vector of nodes along the given direction
CNavNode * FindClosestNode ( const Vector & pos , NavDirType dir ) const ; // returns the closest node along the given edge to the given point
bool IsContiguous ( const CNavArea * other ) const ; // return true if the given area and 'other' share a colinear edge (ie: no drop-down or step/jump/climb)
float ComputeAdjacentConnectionHeightChange ( const CNavArea * destinationArea ) const ; // return height change between edges of adjacent nav areas (not actual underlying ground)
bool IsEdge ( NavDirType dir ) const ; // return true if there are no bi-directional links on the given side
bool IsDamaging ( void ) const ; // Return true if continuous damage (ie: fire) is in this area
void MarkAsDamaging ( float duration ) ; // Mark this area is damaging for the next 'duration' seconds
bool IsVisible ( const Vector & eye , Vector * visSpot = NULL ) const ; // return true if area is visible from the given eyepoint, return visible spot
int GetAdjacentCount ( NavDirType dir ) const { return m_connect [ dir ] . Count ( ) ; } // return number of connected areas in given direction
CNavArea * GetAdjacentArea ( NavDirType dir , int i ) const ; // return the i'th adjacent area in the given direction
CNavArea * GetRandomAdjacentArea ( NavDirType dir ) const ;
void CollectAdjacentAreas ( CUtlVector < CNavArea * > * adjVector ) const ; // build a vector of all adjacent areas
const NavConnectVector * GetAdjacentAreas ( NavDirType dir ) const { return & m_connect [ dir ] ; }
bool IsConnected ( const CNavArea * area , NavDirType dir ) const ; // return true if given area is connected in given direction
bool IsConnected ( const CNavLadder * ladder , CNavLadder : : LadderDirectionType dir ) const ; // return true if given ladder is connected in given direction
float ComputeGroundHeightChange ( const CNavArea * area ) ; // compute change in actual ground height from this area to given area
const NavConnectVector * GetIncomingConnections ( NavDirType dir ) const { return & m_incomingConnect [ dir ] ; } // get areas connected TO this area by a ONE-WAY link (ie: we have no connection back to them)
void AddIncomingConnection ( CNavArea * source , NavDirType incomingEdgeDir ) ;
const NavLadderConnectVector * GetLadders ( CNavLadder : : LadderDirectionType dir ) const { return & m_ladder [ dir ] ; }
CFuncElevator * GetElevator ( void ) const { Assert ( ! ( m_attributeFlags & NAV_MESH_HAS_ELEVATOR ) = = ( m_elevator = = NULL ) ) ; return ( m_attributeFlags & NAV_MESH_HAS_ELEVATOR ) ? m_elevator : NULL ; }
const NavConnectVector & GetElevatorAreas ( void ) const { return m_elevatorAreas ; } // return collection of areas reachable via elevator from this area
void ComputePortal ( const CNavArea * to , NavDirType dir , Vector * center , float * halfWidth ) const ; // compute portal to adjacent area
NavDirType ComputeLargestPortal ( const CNavArea * to , Vector * center , float * halfWidth ) const ; // compute largest portal to adjacent area, returning direction
void ComputeClosestPointInPortal ( const CNavArea * to , NavDirType dir , const Vector & fromPos , Vector * closePos ) const ; // compute closest point within the "portal" between to adjacent areas
NavDirType ComputeDirection ( Vector * point ) const ; // return direction from this area to the given point
//- for hunting algorithm ---------------------------------------------------------------------------
void SetClearedTimestamp ( int teamID ) ; // set this area's "clear" timestamp to now
float GetClearedTimestamp ( int teamID ) const ; // get time this area was marked "clear"
//- hiding spots ------------------------------------------------------------------------------------
const HidingSpotVector * GetHidingSpots ( void ) const { return & m_hidingSpots ; }
SpotEncounter * GetSpotEncounter ( const CNavArea * from , const CNavArea * to ) ; // given the areas we are moving between, return the spots we will encounter
int GetSpotEncounterCount ( void ) const { return m_spotEncounters . Count ( ) ; }
//- "danger" ----------------------------------------------------------------------------------------
void IncreaseDanger ( int teamID , float amount ) ; // increase the danger of this area for the given team
float GetDanger ( int teamID ) ; // return the danger of this area (decays over time)
virtual float GetDangerDecayRate ( void ) const ; // return danger decay rate per second
//- extents -----------------------------------------------------------------------------------------
float GetSizeX ( void ) const { return m_seCorner . x - m_nwCorner . x ; }
float GetSizeY ( void ) const { return m_seCorner . y - m_nwCorner . y ; }
void GetExtent ( Extent * extent ) const ; // return a computed extent (XY is in m_nwCorner and m_seCorner, Z is computed)
const Vector & GetCenter ( void ) const { return m_center ; }
Vector GetRandomPoint ( void ) const ;
Vector GetCorner ( NavCornerType corner ) const ;
void SetCorner ( NavCornerType corner , const Vector & newPosition ) ;
void ComputeNormal ( Vector * normal , bool alternate = false ) const ; // Computes the area's normal based on m_nwCorner. If 'alternate' is specified, m_seCorner is used instead.
void RemoveOrthogonalConnections ( NavDirType dir ) ;
//- occupy time ------------------------------------------------------------------------------------
float GetEarliestOccupyTime ( int teamID ) const ; // returns the minimum time for someone of the given team to reach this spot from their spawn
bool IsBattlefront ( void ) const { return m_isBattlefront ; } // true if this area is a "battlefront" - where rushing teams initially meet
//- player counting --------------------------------------------------------------------------------
void IncrementPlayerCount ( int teamID , int entIndex ) ; // add one player to this area's count
void DecrementPlayerCount ( int teamID , int entIndex ) ; // subtract one player from this area's count
unsigned char GetPlayerCount ( int teamID = 0 ) const ; // return number of players of given team currently within this area (team of zero means any/all)
//- lighting ----------------------------------------------------------------------------------------
float GetLightIntensity ( const Vector & pos ) const ; // returns a 0..1 light intensity for the given point
float GetLightIntensity ( float x , float y ) const ; // returns a 0..1 light intensity for the given point
float GetLightIntensity ( void ) const ; // returns a 0..1 light intensity averaged over the whole area
//- A* pathfinding algorithm ------------------------------------------------------------------------
static void MakeNewMarker ( void ) { + + m_masterMarker ; if ( m_masterMarker = = 0 ) m_masterMarker = 1 ; }
void Mark ( void ) { m_marker = m_masterMarker ; }
BOOL IsMarked ( void ) const { return ( m_marker = = m_masterMarker ) ? true : false ; }
void SetParent ( CNavArea * parent , NavTraverseType how = NUM_TRAVERSE_TYPES ) { m_parent = parent ; m_parentHow = how ; }
CNavArea * GetParent ( void ) const { return m_parent ; }
NavTraverseType GetParentHow ( void ) const { return m_parentHow ; }
bool IsOpen ( void ) const ; // true if on "open list"
void AddToOpenList ( void ) ; // add to open list in decreasing value order
void AddToOpenListTail ( void ) ; // add to tail of the open list
void UpdateOnOpenList ( void ) ; // a smaller value has been found, update this area on the open list
void RemoveFromOpenList ( void ) ;
static bool IsOpenListEmpty ( void ) ;
static CNavArea * PopOpenList ( void ) ; // remove and return the first element of the open list
bool IsClosed ( void ) const ; // true if on "closed list"
void AddToClosedList ( void ) ; // add to the closed list
void RemoveFromClosedList ( void ) ;
static void ClearSearchLists ( void ) ; // clears the open and closed lists for a new search
void SetTotalCost ( float value ) { DebuggerBreakOnNaN_StagingOnly ( value ) ; Assert ( value > = 0.0 & & ! IS_NAN ( value ) ) ; m_totalCost = value ; }
float GetTotalCost ( void ) const { DebuggerBreakOnNaN_StagingOnly ( m_totalCost ) ; return m_totalCost ; }
void SetCostSoFar ( float value ) { DebuggerBreakOnNaN_StagingOnly ( value ) ; Assert ( value > = 0.0 & & ! IS_NAN ( value ) ) ; m_costSoFar = value ; }
float GetCostSoFar ( void ) const { DebuggerBreakOnNaN_StagingOnly ( m_costSoFar ) ; return m_costSoFar ; }
void SetPathLengthSoFar ( float value ) { DebuggerBreakOnNaN_StagingOnly ( value ) ; Assert ( value > = 0.0 & & ! IS_NAN ( value ) ) ; m_pathLengthSoFar = value ; }
float GetPathLengthSoFar ( void ) const { DebuggerBreakOnNaN_StagingOnly ( m_pathLengthSoFar ) ; return m_pathLengthSoFar ; }
//- editing -----------------------------------------------------------------------------------------
virtual void Draw ( void ) const ; // draw area for debugging & editing
virtual void DrawFilled ( int r , int g , int b , int a , float deltaT = 0.1f , bool noDepthTest = true , float margin = 5.0f ) const ; // draw area as a filled rect of the given color
virtual void DrawSelectedSet ( const Vector & shift ) const ; // draw this area as part of a selected set
void DrawDragSelectionSet ( Color & dragSelectionSetColor ) const ;
void DrawConnectedAreas ( void ) const ;
void DrawHidingSpots ( void ) const ;
bool SplitEdit ( bool splitAlongX , float splitEdge , CNavArea * * outAlpha = NULL , CNavArea * * outBeta = NULL ) ; // split this area into two areas at the given edge
bool MergeEdit ( CNavArea * adj ) ; // merge this area and given adjacent area
bool SpliceEdit ( CNavArea * other ) ; // create a new area between this area and given area
void RaiseCorner ( NavCornerType corner , int amount , bool raiseAdjacentCorners = true ) ; // raise/lower a corner (or all corners if corner == NUM_CORNERS)
void PlaceOnGround ( NavCornerType corner , float inset = 0.0f ) ; // places a corner (or all corners if corner == NUM_CORNERS) on the ground
NavCornerType GetCornerUnderCursor ( void ) const ;
bool GetCornerHotspot ( NavCornerType corner , Vector hotspot [ NUM_CORNERS ] ) const ; // returns true if the corner is under the cursor
void Shift ( const Vector & shift ) ; // shift the nav area
//- ladders -----------------------------------------------------------------------------------------
void AddLadderUp ( CNavLadder * ladder ) ;
void AddLadderDown ( CNavLadder * ladder ) ;
//- generation and analysis -------------------------------------------------------------------------
virtual void ComputeHidingSpots ( void ) ; // analyze local area neighborhood to find "hiding spots" in this area - for map learning
virtual void ComputeSniperSpots ( void ) ; // analyze local area neighborhood to find "sniper spots" in this area - for map learning
virtual void ComputeSpotEncounters ( void ) ; // compute spot encounter data - for map learning
virtual void ComputeEarliestOccupyTimes ( void ) ;
virtual void CustomAnalysis ( bool isIncremental = false ) { } // for game-specific analysis
virtual bool ComputeLighting ( void ) ; // compute 0..1 light intensity at corners and center (requires client via listenserver)
bool TestStairs ( void ) ; // Test an area for being on stairs
virtual bool IsAbleToMergeWith ( CNavArea * other ) const ;
virtual void InheritAttributes ( CNavArea * first , CNavArea * second = NULL ) ;
//- visibility -------------------------------------------------------------------------------------
enum VisibilityType
{
NOT_VISIBLE = 0x00 ,
POTENTIALLY_VISIBLE = 0x01 ,
COMPLETELY_VISIBLE = 0x02 ,
} ;
VisibilityType ComputeVisibility ( const CNavArea * area , bool isPVSValid , bool bCheckPVS = true , bool * pOutsidePVS = NULL ) const ; // do actual line-of-sight traces to determine if any part of given area is visible from this area
void SetupPVS ( void ) const ;
bool IsInPVS ( void ) const ; // return true if this area is within the current PVS
struct AreaBindInfo // for pointer loading and binding
{
union
{
CNavArea * area ;
unsigned int id ;
} ;
unsigned char attributes ; // VisibilityType
bool operator = = ( const AreaBindInfo & other ) const
{
return ( area = = other . area ) ;
}
} ;
virtual bool IsEntirelyVisible ( const Vector & eye , const CBaseEntity * ignore = NULL ) const ; // return true if entire area is visible from given eyepoint (CPU intensive)
virtual bool IsPartiallyVisible ( const Vector & eye , const CBaseEntity * ignore = NULL ) const ; // return true if any portion of the area is visible from given eyepoint (CPU intensive)
virtual bool IsPotentiallyVisible ( const CNavArea * area ) const ; // return true if given area is potentially visible from somewhere in this area (very fast)
virtual bool IsPotentiallyVisibleToTeam ( int team ) const ; // return true if any portion of this area is visible to anyone on the given team (very fast)
virtual bool IsCompletelyVisible ( const CNavArea * area ) const ; // return true if given area is completely visible from somewhere in this area (very fast)
virtual bool IsCompletelyVisibleToTeam ( int team ) const ; // return true if given area is completely visible from somewhere in this area by someone on the team (very fast)
//-------------------------------------------------------------------------------------
/**
* Apply the functor to all navigation areas that are potentially
* visible from this area .
*/
template < typename Functor >
bool ForAllPotentiallyVisibleAreas ( Functor & func )
{
int i ;
+ + s_nCurrVisTestCounter ;
for ( i = 0 ; i < m_potentiallyVisibleAreas . Count ( ) ; + + i )
{
CNavArea * area = m_potentiallyVisibleAreas [ i ] . area ;
if ( ! area )
continue ;
// If this assertion triggers, an area is in here twice!
Assert ( area - > m_nVisTestCounter ! = s_nCurrVisTestCounter ) ;
area - > m_nVisTestCounter = s_nCurrVisTestCounter ;
if ( m_potentiallyVisibleAreas [ i ] . attributes = = NOT_VISIBLE )
continue ;
if ( func ( area ) = = false )
return false ;
}
// for each inherited area
if ( ! m_inheritVisibilityFrom . area )
return true ;
CAreaBindInfoArray & inherited = m_inheritVisibilityFrom . area - > m_potentiallyVisibleAreas ;
for ( i = 0 ; i < inherited . Count ( ) ; + + i )
{
if ( ! inherited [ i ] . area )
continue ;
// We may have visited this from m_potentiallyVisibleAreas
if ( inherited [ i ] . area - > m_nVisTestCounter = = s_nCurrVisTestCounter )
continue ;
// Theoretically, this shouldn't matter. But, just in case!
inherited [ i ] . area - > m_nVisTestCounter = s_nCurrVisTestCounter ;
if ( inherited [ i ] . attributes = = NOT_VISIBLE )
continue ;
if ( func ( inherited [ i ] . area ) = = false )
return false ;
}
return true ;
}
//-------------------------------------------------------------------------------------
/**
* Apply the functor to all navigation areas that are
* completely visible from somewhere in this area .
*/
template < typename Functor >
bool ForAllCompletelyVisibleAreas ( Functor & func )
{
int i ;
+ + s_nCurrVisTestCounter ;
for ( i = 0 ; i < m_potentiallyVisibleAreas . Count ( ) ; + + i )
{
CNavArea * area = m_potentiallyVisibleAreas [ i ] . area ;
if ( ! area )
continue ;
// If this assertion triggers, an area is in here twice!
Assert ( area - > m_nVisTestCounter ! = s_nCurrVisTestCounter ) ;
area - > m_nVisTestCounter = s_nCurrVisTestCounter ;
if ( ( m_potentiallyVisibleAreas [ i ] . attributes & COMPLETELY_VISIBLE ) = = 0 )
continue ;
if ( func ( area ) = = false )
return false ;
}
if ( ! m_inheritVisibilityFrom . area )
return true ;
// for each inherited area
CAreaBindInfoArray & inherited = m_inheritVisibilityFrom . area - > m_potentiallyVisibleAreas ;
for ( i = 0 ; i < inherited . Count ( ) ; + + i )
{
if ( ! inherited [ i ] . area )
continue ;
// We may have visited this from m_potentiallyVisibleAreas
if ( inherited [ i ] . area - > m_nVisTestCounter = = s_nCurrVisTestCounter )
continue ;
// Theoretically, this shouldn't matter. But, just in case!
inherited [ i ] . area - > m_nVisTestCounter = s_nCurrVisTestCounter ;
if ( ( inherited [ i ] . attributes & COMPLETELY_VISIBLE ) = = 0 )
continue ;
if ( func ( inherited [ i ] . area ) = = false )
return false ;
}
return true ;
}
private :
friend class CNavMesh ;
friend class CNavLadder ;
friend class CCSNavArea ; // allow CS load code to complete replace our default load behavior
static bool m_isReset ; // if true, don't bother cleaning up in destructor since everything is going away
/*
m_nwCorner
nw ne
+ - - - - - - - - - - - +
| + - - > x |
| | |
| v |
| y |
| |
+ - - - - - - - - - - - +
sw se
m_seCorner
*/
static unsigned int m_nextID ; // used to allocate unique IDs
unsigned int m_id ; // unique area ID
unsigned int m_debugid ;
Place m_place ; // place descriptor
CountdownTimer m_blockedTimer ; // Throttle checks on our blocked state while blocked
void UpdateBlockedFromNavBlockers ( void ) ; // checks if nav blockers are still blocking the area
bool m_isUnderwater ; // true if the center of the area is underwater
bool m_isBattlefront ;
float m_avoidanceObstacleHeight ; // if nonzero, a prop is obstructing movement through this nav area
CountdownTimer m_avoidanceObstacleTimer ; // Throttle checks on our obstructed state while obstructed
//- for hunting -------------------------------------------------------------------------------------
float m_clearedTimestamp [ MAX_NAV_TEAMS ] ; // time this area was last "cleared" of enemies
//- "danger" ----------------------------------------------------------------------------------------
float m_danger [ MAX_NAV_TEAMS ] ; // danger of this area, allowing bots to avoid areas where they died in the past - zero is no danger
float m_dangerTimestamp [ MAX_NAV_TEAMS ] ; // time when danger value was set - used for decaying
void DecayDanger ( void ) ;
//- hiding spots ------------------------------------------------------------------------------------
HidingSpotVector m_hidingSpots ;
bool IsHidingSpotCollision ( const Vector & pos ) const ; // returns true if an existing hiding spot is too close to given position
//- encounter spots ---------------------------------------------------------------------------------
SpotEncounterVector m_spotEncounters ; // list of possible ways to move thru this area, and the spots to look at as we do
void AddSpotEncounters ( const CNavArea * from , NavDirType fromDir , const CNavArea * to , NavDirType toDir ) ; // add spot encounter data when moving from area to area
float m_earliestOccupyTime [ MAX_NAV_TEAMS ] ; // min time to reach this spot from spawn
# ifdef DEBUG_AREA_PLAYERCOUNTS
CUtlVector < int > m_playerEntIndices [ MAX_NAV_TEAMS ] ;
# endif
//- lighting ----------------------------------------------------------------------------------------
float m_lightIntensity [ NUM_CORNERS ] ; // 0..1 light intensity at corners
//- A* pathfinding algorithm ------------------------------------------------------------------------
static unsigned int m_masterMarker ;
static CNavArea * m_openList ;
static CNavArea * m_openListTail ;
//- connections to adjacent areas -------------------------------------------------------------------
NavConnectVector m_incomingConnect [ NUM_DIRECTIONS ] ; // a list of adjacent areas for each direction that connect TO us, but we have no connection back to them
//---------------------------------------------------------------------------------------------------
CNavNode * m_node [ NUM_CORNERS ] ; // nav nodes at each corner of the area
void ResetNodes ( void ) ; // nodes are going away as part of an incremental nav generation
void Strip ( void ) ; // remove "analyzed" data from nav area
void FinishMerge ( CNavArea * adjArea ) ; // recompute internal data once nodes have been adjusted during merge
void MergeAdjacentConnections ( CNavArea * adjArea ) ; // for merging with "adjArea" - pick up all of "adjArea"s connections
void AssignNodes ( CNavArea * area ) ; // assign internal nodes to the given area
void FinishSplitEdit ( CNavArea * newArea , NavDirType ignoreEdge ) ; // given the portion of the original area, update its internal data
void CalcDebugID ( ) ;
# ifdef NEXT_BOT
CUtlVector < CHandle < CFuncNavPrerequisite > > m_prerequisiteVector ; // list of prerequisites that must be met before this area can be traversed
# endif
CNavArea * m_prevHash , * m_nextHash ; // for hash table in CNavMesh
void ConnectElevators ( void ) ; // find elevator connections between areas
int m_damagingTickCount ; // this area is damaging through this tick count
//- visibility --------------------------------------------------------------------------------------
void ComputeVisibilityToMesh ( void ) ; // compute visibility to surrounding mesh
void ResetPotentiallyVisibleAreas ( ) ;
static void ComputeVisToArea ( CNavArea * & pOtherArea ) ;
# ifndef _X360
typedef CUtlVectorConservative < AreaBindInfo > CAreaBindInfoArray ; // shaves 8 bytes off structure caused by need to support editing
# else
typedef CUtlVector < AreaBindInfo > CAreaBindInfoArray ; // Need to use this on 360 to support external allocation pattern
# endif
AreaBindInfo m_inheritVisibilityFrom ; // if non-NULL, m_potentiallyVisibleAreas becomes a list of additions and deletions (NOT_VISIBLE) to the list of this area
CAreaBindInfoArray m_potentiallyVisibleAreas ; // list of areas potentially visible from inside this area (after PostLoad(), use area portion of union)
bool m_isInheritedFrom ; // latch used during visibility inheritance computation
const CAreaBindInfoArray & ComputeVisibilityDelta ( const CNavArea * other ) const ; // return a list of the delta between our visibility list and the given adjacent area
uint32 m_nVisTestCounter ;
static uint32 s_nCurrVisTestCounter ;
CUtlVector < CHandle < CFuncNavCost > > m_funcNavCostVector ; // active, overlapping cost entities
} ;
typedef CUtlVector < CNavArea * > NavAreaVector ;
extern NavAreaVector TheNavAreas ;
//--------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------
//
// Inlines
//
# ifdef NEXT_BOT
//--------------------------------------------------------------------------------------------------------------
inline bool CNavArea : : HasPrerequisite ( CBaseCombatCharacter * actor ) const
{
return m_prerequisiteVector . Count ( ) > 0 ;
}
//--------------------------------------------------------------------------------------------------------------
inline const CUtlVector < CHandle < CFuncNavPrerequisite > > & CNavArea : : GetPrerequisiteVector ( void ) const
{
return m_prerequisiteVector ;
}
//--------------------------------------------------------------------------------------------------------------
inline void CNavArea : : RemoveAllPrerequisites ( void )
{
m_prerequisiteVector . RemoveAll ( ) ;
}
//--------------------------------------------------------------------------------------------------------------
inline void CNavArea : : AddPrerequisite ( CFuncNavPrerequisite * prereq )
{
if ( m_prerequisiteVector . Find ( prereq ) = = m_prerequisiteVector . InvalidIndex ( ) )
{
m_prerequisiteVector . AddToTail ( prereq ) ;
}
}
# endif
//--------------------------------------------------------------------------------------------------------------
inline float CNavArea : : GetDangerDecayRate ( void ) const
{
// one kill == 1.0, which we will forget about in two minutes
return 1.0f / 120.0f ;
}
//--------------------------------------------------------------------------------------------------------------
inline bool CNavArea : : IsDegenerate ( void ) const
{
return ( m_nwCorner . x > = m_seCorner . x | | m_nwCorner . y > = m_seCorner . y ) ;
}
//--------------------------------------------------------------------------------------------------------------
inline CNavArea * CNavArea : : GetAdjacentArea ( NavDirType dir , int i ) const
{
if ( ( i < 0 ) | | ( i > = m_connect [ dir ] . Count ( ) ) )
return NULL ;
return m_connect [ dir ] [ i ] . area ;
}
//--------------------------------------------------------------------------------------------------------------
inline bool CNavArea : : IsOpen ( void ) const
{
return ( m_openMarker = = m_masterMarker ) ? true : false ;
}
//--------------------------------------------------------------------------------------------------------------
inline bool CNavArea : : IsOpenListEmpty ( void )
{
Assert ( ( m_openList & & m_openList - > m_prevOpen = = NULL ) | | m_openList = = NULL ) ;
return ( m_openList ) ? false : true ;
}
//--------------------------------------------------------------------------------------------------------------
inline CNavArea * CNavArea : : PopOpenList ( void )
{
Assert ( ( m_openList & & m_openList - > m_prevOpen = = NULL ) | | m_openList = = NULL ) ;
if ( m_openList )
{
CNavArea * area = m_openList ;
// disconnect from list
area - > RemoveFromOpenList ( ) ;
area - > m_prevOpen = NULL ;
area - > m_nextOpen = NULL ;
Assert ( ( m_openList & & m_openList - > m_prevOpen = = NULL ) | | m_openList = = NULL ) ;
return area ;
}
Assert ( ( m_openList & & m_openList - > m_prevOpen = = NULL ) | | m_openList = = NULL ) ;
return NULL ;
}
//--------------------------------------------------------------------------------------------------------------
inline bool CNavArea : : IsClosed ( void ) const
{
if ( IsMarked ( ) & & ! IsOpen ( ) )
return true ;
return false ;
}
//--------------------------------------------------------------------------------------------------------------
inline void CNavArea : : AddToClosedList ( void )
{
Mark ( ) ;
}
//--------------------------------------------------------------------------------------------------------------
inline void CNavArea : : RemoveFromClosedList ( void )
{
// since "closed" is defined as visited (marked) and not on open list, do nothing
}
//--------------------------------------------------------------------------------------------------------------
inline void CNavArea : : SetClearedTimestamp ( int teamID )
{
m_clearedTimestamp [ teamID % MAX_NAV_TEAMS ] = gpGlobals - > curtime ;
}
//--------------------------------------------------------------------------------------------------------------
inline float CNavArea : : GetClearedTimestamp ( int teamID ) const
{
return m_clearedTimestamp [ teamID % MAX_NAV_TEAMS ] ;
}
//--------------------------------------------------------------------------------------------------------------
inline float CNavArea : : GetEarliestOccupyTime ( int teamID ) const
{
return m_earliestOccupyTime [ teamID % MAX_NAV_TEAMS ] ;
}
//--------------------------------------------------------------------------------------------------------------
inline bool CNavArea : : IsDamaging ( void ) const
{
return ( gpGlobals - > tickcount < = m_damagingTickCount ) ;
}
//--------------------------------------------------------------------------------------------------------------
inline void CNavArea : : MarkAsDamaging ( float duration )
{
m_damagingTickCount = gpGlobals - > tickcount + TIME_TO_TICKS ( duration ) ;
}
//--------------------------------------------------------------------------------------------------------------
inline bool CNavArea : : HasAvoidanceObstacle ( float maxObstructionHeight ) const
{
return m_avoidanceObstacleHeight > maxObstructionHeight ;
}
//--------------------------------------------------------------------------------------------------------------
inline float CNavArea : : GetAvoidanceObstacleHeight ( void ) const
{
return m_avoidanceObstacleHeight ;
}
//--------------------------------------------------------------------------------------------------------------
inline bool CNavArea : : IsVisible ( const Vector & eye , Vector * visSpot ) const
{
Vector corner ;
trace_t result ;
CTraceFilterNoNPCsOrPlayer traceFilter ( NULL , COLLISION_GROUP_NONE ) ;
const float offset = 0.75f * HumanHeight ;
// check center first
UTIL_TraceLine ( eye , GetCenter ( ) + Vector ( 0 , 0 , offset ) , MASK_BLOCKLOS_AND_NPCS | CONTENTS_IGNORE_NODRAW_OPAQUE , & traceFilter , & result ) ;
if ( result . fraction = = 1.0f )
{
// we can see this area
if ( visSpot )
{
* visSpot = GetCenter ( ) ;
}
return true ;
}
for ( int c = 0 ; c < NUM_CORNERS ; + + c )
{
corner = GetCorner ( ( NavCornerType ) c ) ;
UTIL_TraceLine ( eye , corner + Vector ( 0 , 0 , offset ) , MASK_BLOCKLOS_AND_NPCS | CONTENTS_IGNORE_NODRAW_OPAQUE , & traceFilter , & result ) ;
if ( result . fraction = = 1.0f )
{
// we can see this area
if ( visSpot )
{
* visSpot = corner ;
}
return true ;
}
}
return false ;
}
# ifndef DEBUG_AREA_PLAYERCOUNTS
inline void CNavArea : : IncrementPlayerCount ( int teamID , int entIndex )
{
teamID = teamID % MAX_NAV_TEAMS ;
if ( m_playerCount [ teamID ] = = 255 )
{
DevMsg ( " CNavArea::IncrementPlayerCount: Overflow \n " ) ;
return ;
}
+ + m_playerCount [ teamID ] ;
}
inline void CNavArea : : DecrementPlayerCount ( int teamID , int entIndex )
{
teamID = teamID % MAX_NAV_TEAMS ;
if ( m_playerCount [ teamID ] = = 0 )
{
DevMsg ( " CNavArea::IncrementPlayerCount: Underflow \n " ) ;
return ;
}
- - m_playerCount [ teamID ] ;
}
# endif // !DEBUG_AREA_PLAYERCOUNTS
inline unsigned char CNavArea : : GetPlayerCount ( int teamID ) const
{
if ( teamID )
{
return m_playerCount [ teamID % MAX_NAV_TEAMS ] ;
}
// sum all players
unsigned char total = 0 ;
for ( int i = 0 ; i < MAX_NAV_TEAMS ; + + i )
{
total + = m_playerCount [ i ] ;
}
return total ;
}
//--------------------------------------------------------------------------------------------------------------
/**
* Return Z of area at ( x , y ) of ' pos '
* Trilinear interpolation of Z values at quad edges .
* NOTE : pos - > z is not used .
*/
inline float CNavArea : : GetZ ( const Vector * RESTRICT pos ) const RESTRICT
{
return GetZ ( pos - > x , pos - > y ) ;
}
inline float CNavArea : : GetZ ( const Vector & pos ) const RESTRICT
{
return GetZ ( pos . x , pos . y ) ;
}
//--------------------------------------------------------------------------------------------------------------
/**
* Return the coordinates of the area ' s corner .
*/
inline Vector CNavArea : : GetCorner ( NavCornerType corner ) const
{
// @TODO: Confirm compiler does the "right thing" in release builds, or change this function to to take a pointer [2/4/2009 tom]
Vector pos ;
switch ( corner )
{
default :
Assert ( false & & " GetCorner: Invalid type " ) ;
case NORTH_WEST :
return m_nwCorner ;
case NORTH_EAST :
pos . x = m_seCorner . x ;
pos . y = m_nwCorner . y ;
pos . z = m_neZ ;
return pos ;
case SOUTH_WEST :
pos . x = m_nwCorner . x ;
pos . y = m_seCorner . y ;
pos . z = m_swZ ;
return pos ;
case SOUTH_EAST :
return m_seCorner ;
}
}
# endif // _NAV_AREA_H_