mirror of
https://github.com/alliedmodders/hl2sdk.git
synced 2024-12-23 01:59:43 +08:00
1070 lines
47 KiB
C++
1070 lines
47 KiB
C++
//========= 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
|
|
inline float GetZ( const Vector * RESTRICT pPos ) const ; // return Z of area at (x,y) of 'pos'
|
|
inline float GetZ( const Vector &pos ) const; // return Z of area at (x,y) of 'pos'
|
|
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_
|