mirror of
https://github.com/s1lentq/ReGameDLL_CS.git
synced 2024-10-16 23:37:00 +03:00
1318 lines
33 KiB
C++
1318 lines
33 KiB
C++
/*
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at
|
|
* your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
* In addition, as a special exception, the author gives permission to
|
|
* link the code of this program with the Half-Life Game Engine ("HL
|
|
* Engine") and Modified Game Libraries ("MODs") developed by Valve,
|
|
* L.L.C ("Valve"). You must obey the GNU General Public License in all
|
|
* respects for all of the code used other than the HL Engine and MODs
|
|
* from Valve. If you modify this file, you may extend this exception
|
|
* to your version of the file, but you are not obligated to do so. If
|
|
* you do not wish to do so, delete this exception statement from your
|
|
* version.
|
|
*
|
|
*/
|
|
|
|
#ifndef NAV_AREA_H
|
|
#define NAV_AREA_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include <list>
|
|
//#include "nav.h"
|
|
|
|
class CNavArea;
|
|
|
|
enum
|
|
{
|
|
MAX_BLOCKED_AREAS = 256
|
|
};
|
|
|
|
void DestroyHidingSpots(void);
|
|
NOBODY void StripNavigationAreas(void);
|
|
//bool SaveNavigationMap(const char *filename);
|
|
//NavErrorType LoadNavigationMap(void);
|
|
NOBODY void DestroyNavigationMap(void);
|
|
|
|
enum NavEditCmdType
|
|
{
|
|
EDIT_NONE,
|
|
EDIT_DELETE,
|
|
EDIT_SPLIT,
|
|
EDIT_MERGE,
|
|
EDIT_JOIN,
|
|
EDIT_BREAK,
|
|
EDIT_MARK,
|
|
EDIT_ATTRIB_CROUCH,
|
|
EDIT_ATTRIB_JUMP,
|
|
EDIT_ATTRIB_PRECISE,
|
|
EDIT_ATTRIB_NO_JUMP,
|
|
EDIT_BEGIN_AREA,
|
|
EDIT_END_AREA,
|
|
EDIT_CONNECT,
|
|
EDIT_DISCONNECT,
|
|
EDIT_SPLICE,
|
|
EDIT_TOGGLE_PLACE_MODE,
|
|
EDIT_TOGGLE_PLACE_PAINTING,
|
|
EDIT_PLACE_FLOODFILL,
|
|
EDIT_PLACE_PICK,
|
|
EDIT_MARK_UNNAMED,
|
|
EDIT_WARP_TO_MARK,
|
|
EDIT_SELECT_CORNER,
|
|
EDIT_RAISE_CORNER,
|
|
EDIT_LOWER_CORNER,
|
|
};
|
|
|
|
//#define NO_CROUCH_SPOTS false
|
|
//class CBasePlayer;
|
|
//class CBaseEntity;
|
|
|
|
enum RouteType
|
|
{
|
|
FASTEST_ROUTE,
|
|
SAFEST_ROUTE,
|
|
};
|
|
|
|
/* <4c1845> ../game_shared/bot/nav_area.h:35 */
|
|
union NavConnect
|
|
{
|
|
unsigned int id;
|
|
CNavArea *area;
|
|
|
|
/* <4c26c6> ../game_shared/bot/nav_area.h:40 */
|
|
bool operator==(const NavConnect &other) const
|
|
{
|
|
return (area == other.area) ? true : false;
|
|
}
|
|
};
|
|
|
|
typedef std::list<NavConnect> NavConnectList;
|
|
|
|
enum LadderDirectionType
|
|
{
|
|
LADDER_UP = 0,
|
|
LADDER_DOWN,
|
|
NUM_LADDER_DIRECTIONS
|
|
};
|
|
|
|
|
|
/* <4c2fda> ../game_shared/bot/nav_area.h:63 */
|
|
class CNavLadder
|
|
{
|
|
public:
|
|
CNavLadder(void)
|
|
{
|
|
m_topForwardArea = NULL;
|
|
m_topRightArea = NULL;
|
|
m_topLeftArea = NULL;
|
|
m_topBehindArea = NULL;
|
|
m_bottomArea = NULL;
|
|
m_entity = NULL;
|
|
}
|
|
|
|
Vector m_top;
|
|
Vector m_bottom;
|
|
float m_length;
|
|
NavDirType m_dir;
|
|
Vector2D m_dirVector;
|
|
CBaseEntity *m_entity;
|
|
|
|
CNavArea *m_topForwardArea;
|
|
CNavArea *m_topLeftArea;
|
|
CNavArea *m_topRightArea;
|
|
CNavArea *m_topBehindArea;
|
|
CNavArea *m_bottomArea;
|
|
|
|
bool m_isDangling;
|
|
|
|
/* <4c2dc0> ../game_shared/bot/nav_area.h:88 */
|
|
void OnDestroyNotify(CNavArea *dead)
|
|
{
|
|
if (dead == m_topForwardArea)
|
|
m_topForwardArea = NULL;
|
|
|
|
if (dead == m_topLeftArea)
|
|
m_topLeftArea = NULL;
|
|
|
|
if (dead == m_topRightArea)
|
|
m_topRightArea = NULL;
|
|
|
|
if (dead == m_topBehindArea)
|
|
m_topBehindArea = NULL;
|
|
|
|
if (dead == m_bottomArea)
|
|
m_bottomArea = NULL;
|
|
}
|
|
|
|
};/* size: 68, cachelines: 2, members: 12 */
|
|
|
|
typedef std::list<CNavLadder *> NavLadderList;
|
|
|
|
class HidingSpot
|
|
{
|
|
public:
|
|
HidingSpot(void);
|
|
HidingSpot(const Vector *pos, unsigned char flags);
|
|
|
|
enum
|
|
{
|
|
IN_COVER = 0x01,
|
|
GOOD_SNIPER_SPOT = 0x02,
|
|
IDEAL_SNIPER_SPOT = 0x04
|
|
};
|
|
|
|
bool HasGoodCover(void) const
|
|
{
|
|
return (m_flags & IN_COVER) ? true : false;
|
|
}
|
|
bool IsGoodSniperSpot(void) const
|
|
{
|
|
return (m_flags & GOOD_SNIPER_SPOT) ? true : false;
|
|
}
|
|
bool IsIdealSniperSpot(void) const
|
|
{
|
|
return (m_flags & IDEAL_SNIPER_SPOT) ? true : false;
|
|
}
|
|
void SetFlags(unsigned char flags)
|
|
{
|
|
m_flags |= flags;
|
|
}
|
|
unsigned char GetFlags(void) const
|
|
{
|
|
return m_flags;
|
|
}
|
|
void Save(int fd, unsigned int version) const;
|
|
void Load(SteamFile *file, unsigned int version);
|
|
|
|
const Vector *GetPosition(void) const
|
|
{
|
|
return &m_pos;
|
|
}
|
|
unsigned int GetID(void) const
|
|
{
|
|
return m_id;
|
|
}
|
|
void Mark(void)
|
|
{
|
|
m_marker = IMPLEMENT_ARRAY(m_masterMarker);
|
|
}
|
|
bool IsMarked(void) const
|
|
{
|
|
return (m_marker == IMPLEMENT_ARRAY(m_masterMarker)) ? true : false;
|
|
}
|
|
static void ChangeMasterMarker(void)
|
|
{
|
|
IMPLEMENT_ARRAY(m_masterMarker)++;
|
|
}
|
|
|
|
private:
|
|
friend void DestroyHidingSpots(void);
|
|
|
|
Vector m_pos;
|
|
unsigned int m_id;
|
|
unsigned int m_marker;
|
|
unsigned char m_flags;
|
|
|
|
#ifdef HOOK_GAMEDLL
|
|
public:
|
|
#endif // HOOK_GAMEDLL
|
|
static unsigned int IMPLEMENT_ARRAY(m_nextID);
|
|
static unsigned int IMPLEMENT_ARRAY(m_masterMarker);
|
|
|
|
};/* size: 24, cachelines: 1, members: 6 */
|
|
|
|
typedef std::list<HidingSpot *> HidingSpotList;
|
|
|
|
/* <4ec0bd> ../game_shared/bot/nav_area.h:164 */
|
|
struct SpotOrder
|
|
{
|
|
float t;
|
|
union
|
|
{
|
|
HidingSpot *spot;
|
|
unsigned int id;
|
|
};
|
|
|
|
};/* size: 8, cachelines: 1, members: 2 */
|
|
|
|
typedef std::list<SpotOrder> SpotOrderList;
|
|
|
|
/* <4c3a51> ../game_shared/bot/nav_area.h:179 */
|
|
struct SpotEncounter
|
|
{
|
|
NavConnect from;
|
|
NavDirType fromDir;
|
|
NavConnect to;
|
|
NavDirType toDir;
|
|
Ray path;
|
|
SpotOrderList spotList;
|
|
|
|
};/* size: 48, cachelines: 1, members: 6 */
|
|
|
|
typedef std::list<SpotEncounter> SpotEncounterList;
|
|
typedef std::list<CNavArea *> NavAreaList;
|
|
|
|
class CNavArea
|
|
{
|
|
public:
|
|
CNavArea(CNavNode *nwNode, CNavNode *neNode, CNavNode *seNode, CNavNode *swNode);
|
|
CNavArea(void);
|
|
CNavArea(const Vector *corner, const Vector *otherCorner);
|
|
CNavArea(const Vector *nwCorner, const Vector *neCorner, const Vector *seCorner, const Vector *swCorner);
|
|
|
|
~CNavArea();
|
|
|
|
void ConnectTo(CNavArea *area, NavDirType dir);
|
|
void Disconnect(CNavArea *area);
|
|
|
|
void Save(FILE *fp) const;
|
|
void Save(int fd, unsigned int version);
|
|
|
|
void Load(SteamFile *file, unsigned int version);
|
|
NavErrorType PostLoad(void);
|
|
|
|
unsigned int GetID(void) const
|
|
{
|
|
return m_id;
|
|
}
|
|
void SetAttributes(unsigned char bits)
|
|
{
|
|
m_attributeFlags = bits;
|
|
}
|
|
unsigned char GetAttributes(void) const
|
|
{
|
|
return m_attributeFlags;
|
|
}
|
|
void SetPlace(Place place)
|
|
{
|
|
m_place = place;
|
|
}
|
|
Place GetPlace(void) const
|
|
{
|
|
return m_place;
|
|
}
|
|
|
|
bool IsOverlapping(const Vector *pos) const;
|
|
bool IsOverlapping(const CNavArea *area) const;
|
|
bool IsOverlappingX(const CNavArea *area) const;
|
|
bool IsOverlappingY(const CNavArea *area) const;
|
|
int GetPlayerCount(int teamID = 0, CBasePlayer *ignore = NULL) const;
|
|
float GetZ(const Vector *pos) const;
|
|
float GetZ(float x, float y) const;
|
|
bool Contains(const Vector *pos) const;
|
|
bool IsCoplanar(const CNavArea *area) const;
|
|
void GetClosestPointOnArea(const Vector *pos, Vector *close) const;
|
|
float GetDistanceSquaredToPoint(const Vector *pos) const;
|
|
bool IsDegenerate(void) const;
|
|
|
|
bool IsEdge(NavDirType dir) const;
|
|
|
|
int GetAdjacentCount(NavDirType dir) const
|
|
{
|
|
return m_connect[dir].size();
|
|
}
|
|
CNavArea *GetAdjacentArea(NavDirType dir, int i) const;
|
|
CNavArea *GetRandomAdjacentArea(NavDirType dir) const;
|
|
|
|
const NavConnectList *GetAdjacentList(NavDirType dir) const
|
|
{
|
|
return &m_connect[dir];
|
|
}
|
|
bool IsConnected(const CNavArea *area, NavDirType dir) const;
|
|
float ComputeHeightChange(const CNavArea *area);
|
|
|
|
const NavLadderList *GetLadderList(LadderDirectionType dir) const
|
|
{
|
|
return &m_ladder[dir];
|
|
}
|
|
|
|
void ComputePortal(const CNavArea *to, NavDirType dir, Vector *center, float *halfWidth) const;
|
|
void ComputeClosestPointInPortal(const CNavArea *to, NavDirType dir, const Vector *fromPos, Vector *closePos) const;
|
|
NavDirType ComputeDirection(Vector *point) const;
|
|
|
|
void SetClearedTimestamp(int teamID)
|
|
{
|
|
m_clearedTimestamp[teamID] = gpGlobals->time;
|
|
}
|
|
float GetClearedTimestamp(int teamID)
|
|
{
|
|
return m_clearedTimestamp[teamID];
|
|
}
|
|
const HidingSpotList *GetHidingSpotList(void) const
|
|
{
|
|
return &m_hidingSpotList;
|
|
}
|
|
void ComputeHidingSpots(void);
|
|
void ComputeSniperSpots(void);
|
|
|
|
SpotEncounter *GetSpotEncounter(const CNavArea *from, const CNavArea *to);
|
|
void ComputeSpotEncounters(void);
|
|
void IncreaseDanger(int teamID, float amount);
|
|
|
|
float GetDanger(int teamID);
|
|
float GetSizeX(void) const
|
|
{
|
|
return m_extent.hi.x - m_extent.lo.x;
|
|
}
|
|
float GetSizeY(void) const
|
|
{
|
|
return m_extent.hi.y - m_extent.lo.y;
|
|
}
|
|
const Extent *GetExtent(void) const
|
|
{
|
|
return &m_extent;
|
|
}
|
|
const Vector *GetCenter(void) const
|
|
{
|
|
return &m_center;
|
|
}
|
|
const Vector *GetCorner(NavCornerType corner) const;
|
|
|
|
struct ApproachInfo
|
|
{
|
|
NavConnect here;
|
|
NavConnect prev;
|
|
NavTraverseType prevToHereHow;
|
|
NavConnect next;
|
|
NavTraverseType hereToNextHow;
|
|
};
|
|
|
|
const ApproachInfo *GetApproachInfo(int i) const
|
|
{
|
|
return &m_approach[i];
|
|
}
|
|
int GetApproachInfoCount(void) const
|
|
{
|
|
return m_approachCount;
|
|
}
|
|
void ComputeApproachAreas(void);
|
|
static void MakeNewMarker(void)
|
|
{
|
|
IMPLEMENT_ARRAY(m_masterMarker)++;
|
|
if (IMPLEMENT_ARRAY(m_masterMarker) == 0)
|
|
IMPLEMENT_ARRAY(m_masterMarker) = 1;
|
|
}
|
|
void Mark(void)
|
|
{
|
|
m_marker = IMPLEMENT_ARRAY(m_masterMarker);
|
|
}
|
|
BOOL IsMarked(void) const
|
|
{
|
|
return (m_marker == IMPLEMENT_ARRAY(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;
|
|
void AddToOpenList(void);
|
|
void UpdateOnOpenList(void);
|
|
void RemoveFromOpenList(void);
|
|
static bool IsOpenListEmpty(void);
|
|
static CNavArea *PopOpenList(void);
|
|
|
|
bool IsClosed(void) const;
|
|
void AddToClosedList(void);
|
|
void RemoveFromClosedList(void);
|
|
|
|
static void ClearSearchLists(void);
|
|
|
|
void SetTotalCost(float value)
|
|
{
|
|
m_totalCost = value;
|
|
}
|
|
float GetTotalCost(void) const
|
|
{
|
|
return m_totalCost;
|
|
}
|
|
void SetCostSoFar(float value)
|
|
{
|
|
m_costSoFar = value;
|
|
}
|
|
float GetCostSoFar(void) const
|
|
{
|
|
return m_costSoFar;
|
|
}
|
|
|
|
void Draw(byte red, byte green, byte blue, int duration = 50);
|
|
void DrawConnectedAreas(void);
|
|
void DrawMarkedCorner(NavCornerType corner, byte red, byte green, byte blue, int duration = 50);
|
|
bool SplitEdit(bool splitAlongX, float splitEdge, CNavArea **outAlpha = NULL, CNavArea **outBeta = NULL);
|
|
bool MergeEdit(CNavArea *adj);
|
|
bool SpliceEdit(CNavArea *other);
|
|
void RaiseCorner(NavCornerType corner, int amount);
|
|
void AddLadderUp(CNavLadder *ladder)
|
|
{
|
|
m_ladder[LADDER_UP].push_back(ladder);
|
|
}
|
|
void AddLadderDown(CNavLadder *ladder)
|
|
{
|
|
m_ladder[LADDER_DOWN].push_back(ladder);
|
|
}
|
|
|
|
private:
|
|
bool IsHidingSpotCollision(const Vector *pos) const;
|
|
void AddSpotEncounters(const CNavArea *from, NavDirType fromDir, const CNavArea *to, NavDirType toDir);
|
|
void Strip(void);
|
|
void FinishMerge(CNavArea *adjArea);
|
|
void MergeAdjacentConnections(CNavArea *adjArea);
|
|
void AssignNodes(CNavArea *area);
|
|
void FinishSplitEdit(CNavArea *newArea, NavDirType ignoreEdge);
|
|
void OnDestroyNotify(CNavArea *dead);
|
|
void DecayDanger(void);
|
|
private:
|
|
friend void ConnectGeneratedAreas(void);
|
|
friend void MergeGeneratedAreas(void);
|
|
friend void MarkJumpAreas(void);
|
|
friend bool SaveNavigationMap(const char *filename);
|
|
friend NavErrorType LoadNavigationMap(void);
|
|
friend void DestroyNavigationMap(void);
|
|
friend void DestroyHidingSpots(void);
|
|
friend void StripNavigationAreas(void);
|
|
|
|
friend class CNavAreaGrid;
|
|
friend class CCSBotManager;
|
|
|
|
void Initialize(void);
|
|
|
|
#ifdef HOOK_GAMEDLL
|
|
public:
|
|
#endif // HOOK_GAMEDLL
|
|
static bool IMPLEMENT_ARRAY(m_isReset);
|
|
static unsigned int IMPLEMENT_ARRAY(m_nextID);
|
|
|
|
#ifdef HOOK_GAMEDLL
|
|
private:
|
|
#endif // HOOK_GAMEDLL
|
|
|
|
unsigned int m_id;
|
|
Extent m_extent;
|
|
Vector m_center;
|
|
unsigned char m_attributeFlags;
|
|
Place m_place;
|
|
|
|
float m_neZ;
|
|
float m_swZ;
|
|
|
|
enum { MAX_AREA_TEAMS = 2 };
|
|
|
|
float m_clearedTimestamp[MAX_AREA_TEAMS];
|
|
float m_danger[MAX_AREA_TEAMS];
|
|
float m_dangerTimestamp[MAX_AREA_TEAMS];
|
|
|
|
#if defined(_WIN32) && defined(HOOK_GAMEDLL)
|
|
int unknown_padding1;
|
|
#endif // HOOK_GAMEDLL
|
|
|
|
HidingSpotList m_hidingSpotList;
|
|
|
|
#if defined(_WIN32) && defined(HOOK_GAMEDLL)
|
|
int unknown_padding2;
|
|
#endif // HOOK_GAMEDLL
|
|
#ifdef HOOK_GAMEDLL
|
|
public:
|
|
#endif // HOOK_GAMEDLL
|
|
SpotEncounterList m_spotEncounterList;
|
|
|
|
enum { MAX_APPROACH_AREAS = 16 };
|
|
|
|
ApproachInfo m_approach[MAX_APPROACH_AREAS];//104
|
|
unsigned char m_approachCount;
|
|
|
|
#ifdef HOOK_GAMEDLL
|
|
public:
|
|
#endif // HOOK_GAMEDLL
|
|
static unsigned int IMPLEMENT_ARRAY(m_masterMarker);
|
|
|
|
#ifdef HOOK_GAMEDLL
|
|
private:
|
|
#endif // HOOK_GAMEDLL
|
|
|
|
unsigned int m_marker;
|
|
CNavArea *m_parent;
|
|
NavTraverseType m_parentHow;
|
|
float m_totalCost;
|
|
float m_costSoFar;
|
|
|
|
#ifdef HOOK_GAMEDLL
|
|
public:
|
|
#endif // HOOK_GAMEDLL
|
|
static CNavArea *IMPLEMENT_ARRAY(m_openList);
|
|
|
|
#ifdef HOOK_GAMEDLL
|
|
private:
|
|
#endif // HOOK_GAMEDLL
|
|
|
|
CNavArea *m_nextOpen;
|
|
CNavArea *m_prevOpen;
|
|
unsigned int m_openMarker;
|
|
|
|
#if defined(_WIN32) && defined(HOOK_GAMEDLL)
|
|
int unknown_padding3;
|
|
#endif // HOOK_GAMEDLL
|
|
NavConnectList m_connect[ NUM_DIRECTIONS ];
|
|
|
|
#if defined(_WIN32) && defined(HOOK_GAMEDLL)
|
|
int unknown_padding4;
|
|
int unknown_padding5;
|
|
|
|
int unknown_padding6;
|
|
int unknown_padding7;
|
|
#endif // HOOK_GAMEDLL
|
|
|
|
NavLadderList m_ladder[ NUM_LADDER_DIRECTIONS ];
|
|
|
|
#if defined(_WIN32) && defined(HOOK_GAMEDLL)
|
|
int unknown_padding8;
|
|
#endif // HOOK_GAMEDLL
|
|
|
|
CNavNode *m_node[ NUM_CORNERS ];
|
|
|
|
#if defined(_WIN32) && defined(HOOK_GAMEDLL)
|
|
int unknown_padding9;
|
|
#endif // HOOK_GAMEDLL
|
|
|
|
NavAreaList m_overlapList;
|
|
|
|
CNavArea *m_prevHash;
|
|
CNavArea *m_nextHash;
|
|
|
|
};/* size: 532, cachelines: 9, members: 32 */
|
|
|
|
extern NavAreaList TheNavAreaList;
|
|
|
|
/* <4c1534> ../game_shared/bot/nav_area.h:417 */
|
|
inline bool CNavArea::IsDegenerate(void) const
|
|
{
|
|
return (m_extent.lo.x >= m_extent.hi.x || m_extent.lo.y >= m_extent.hi.y);
|
|
}
|
|
|
|
/* <568e1d> ../game_shared/bot/nav_area.h:422 */
|
|
inline CNavArea *CNavArea::GetAdjacentArea(NavDirType dir, int i) const
|
|
{
|
|
NavConnectList::const_iterator iter;
|
|
for (iter = m_connect[dir].begin(); iter != m_connect[dir].end(); ++iter)
|
|
{
|
|
if (i == 0)
|
|
return (*iter).area;
|
|
--i;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/* <5a01dc> ../game_shared/bot/nav_area.h:435 */
|
|
inline bool CNavArea::IsOpen(void) const
|
|
{
|
|
return (m_openMarker == IMPLEMENT_ARRAY(m_masterMarker)) ? true : false;
|
|
}
|
|
|
|
/* <5a0a62> ../game_shared/bot/nav_area.h:440 */
|
|
inline bool CNavArea::IsOpenListEmpty(void)
|
|
{
|
|
return (IMPLEMENT_ARRAY(m_openList) != NULL) ? false : true;
|
|
}
|
|
|
|
/* <5a1483> ../game_shared/bot/nav_area.h:445 */
|
|
inline CNavArea *CNavArea::PopOpenList(void)
|
|
{
|
|
#ifndef HOOK_GAMEDLL
|
|
if (m_openList)
|
|
{
|
|
CNavArea *area = m_openList;
|
|
area->RemoveFromOpenList();
|
|
return area;
|
|
}
|
|
#else
|
|
if (IMPLEMENT_ARRAY(m_openList))
|
|
{
|
|
CNavArea *area = IMPLEMENT_ARRAY(m_openList);
|
|
area->RemoveFromOpenList();
|
|
return area;
|
|
}
|
|
#endif // HOOK_GAMEDLL
|
|
return NULL;
|
|
}
|
|
|
|
/* <5a0a2a> ../game_shared/bot/nav_area.h:460 */
|
|
inline bool CNavArea::IsClosed(void) const
|
|
{
|
|
if (IsMarked() && !IsOpen())
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/* <5a0a46> ../game_shared/bot/nav_area.h:468 */
|
|
inline void CNavArea::AddToClosedList(void)
|
|
{
|
|
Mark();
|
|
}
|
|
|
|
/* <5a01f8> ../game_shared/bot/nav_area.h:473 */
|
|
inline void CNavArea::RemoveFromClosedList(void)
|
|
{
|
|
|
|
}
|
|
|
|
/* <4cf943> ../game_shared/bot/nav_area.cpp:4947 */
|
|
class CNavAreaGrid
|
|
{
|
|
public:
|
|
CNavAreaGrid(void);
|
|
~CNavAreaGrid();
|
|
|
|
void Reset(void);
|
|
void Initialize(float minX, float maxX, float minY, float maxY);
|
|
void AddNavArea(CNavArea *area);
|
|
void RemoveNavArea(CNavArea *area);
|
|
unsigned int GetNavAreaCount(void) const
|
|
{
|
|
return m_areaCount;
|
|
}
|
|
CNavArea *GetNavArea(const Vector *pos, float beneathLimt = 120.0f) const;
|
|
CNavArea *GetNavAreaByID(unsigned int id) const;
|
|
CNavArea *GetNearestNavArea(const Vector *pos, bool anyZ = false) const;
|
|
|
|
Place GetPlace(const Vector *pos) const;
|
|
|
|
private:
|
|
|
|
inline int ComputeHashKey(unsigned int id) const
|
|
{
|
|
return id & 0xFF;
|
|
}
|
|
inline int WorldToGridX(float wx) const
|
|
{
|
|
int x = (wx - m_minX) / m_cellSize;
|
|
if (x < 0)
|
|
x = 0;
|
|
|
|
else if (x >= m_gridSizeX)
|
|
x = m_gridSizeX - 1;
|
|
|
|
return x;
|
|
}
|
|
inline int WorldToGridY(float wy) const
|
|
{
|
|
int y = (wy - m_minY) / m_cellSize;
|
|
if (y < 0)
|
|
y = 0;
|
|
else if (y >= m_gridSizeY)
|
|
y = m_gridSizeY - 1;
|
|
|
|
return y;
|
|
}
|
|
|
|
private:
|
|
const float m_cellSize;
|
|
NavAreaList *m_grid;
|
|
int m_gridSizeX;
|
|
int m_gridSizeY;
|
|
float m_minX;
|
|
float m_minY;
|
|
unsigned int m_areaCount;
|
|
|
|
enum { HASH_TABLE_SIZE = 256 };
|
|
CNavArea *m_hashTable[HASH_TABLE_SIZE];
|
|
|
|
};/* size: 1052, cachelines: 17, members: 8 */
|
|
|
|
class ShortestPathCost
|
|
{
|
|
public:
|
|
float operator() (CNavArea *area, CNavArea *fromArea, const CNavLadder *ladder)
|
|
{
|
|
if (fromArea == NULL)
|
|
{
|
|
return 0.0f;
|
|
}
|
|
else
|
|
{
|
|
float dist;
|
|
|
|
if (ladder)
|
|
dist = ladder->m_length;
|
|
else
|
|
dist = (*area->GetCenter() - *fromArea->GetCenter()).Length();
|
|
|
|
float cost = dist + fromArea->GetCostSoFar();
|
|
if (area->GetAttributes() & NAV_CROUCH)
|
|
{
|
|
const float crouchPenalty = 20.0f;
|
|
cost += crouchPenalty * dist;
|
|
}
|
|
if (area->GetAttributes() & NAV_JUMP)
|
|
{
|
|
const float jumpPenalty = 5.0f;
|
|
cost += jumpPenalty * dist;
|
|
}
|
|
return cost;
|
|
}
|
|
}
|
|
};/* size: 0, cachelines: 0, members: 0 */
|
|
|
|
/* <4c3e99> ../game_shared/bot/nav_area.h:679 */
|
|
template <typename CostFunctor>
|
|
bool NavAreaBuildPath(CNavArea *startArea, CNavArea *goalArea, const Vector *goalPos, CostFunctor &costFunc, CNavArea **closestArea = NULL)
|
|
{
|
|
if (closestArea)
|
|
*closestArea = NULL;
|
|
|
|
if (startArea == NULL)
|
|
return false;
|
|
|
|
if (goalArea == NULL && goalPos == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
startArea->SetParent(NULL);
|
|
if (startArea == goalArea)
|
|
{
|
|
goalArea->SetParent(NULL);
|
|
|
|
if (closestArea)
|
|
*closestArea = goalArea;
|
|
|
|
return true;
|
|
}
|
|
Vector actualGoalPos = (goalPos) ? *goalPos : *goalArea->GetCenter();
|
|
CNavArea::ClearSearchLists();
|
|
startArea->SetTotalCost((*startArea->GetCenter() - actualGoalPos).Length());
|
|
|
|
float initCost = costFunc(startArea, NULL, NULL);
|
|
if (initCost < 0.0f)
|
|
return false;
|
|
startArea->SetCostSoFar(initCost);
|
|
|
|
startArea->AddToOpenList();
|
|
|
|
if (closestArea)
|
|
*closestArea = startArea;
|
|
float closestAreaDist = startArea->GetTotalCost();
|
|
|
|
while (!CNavArea::IsOpenListEmpty())
|
|
{
|
|
CNavArea *area = CNavArea::PopOpenList();
|
|
if (area == goalArea)
|
|
{
|
|
if (closestArea)
|
|
*closestArea = goalArea;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool searchFloor = true;
|
|
int dir = NORTH;
|
|
const NavConnectList *floorList = area->GetAdjacentList(NORTH);
|
|
NavConnectList::const_iterator floorIter = floorList->begin();
|
|
|
|
bool ladderUp = true;
|
|
const NavLadderList *ladderList = NULL;
|
|
NavLadderList::const_iterator ladderIter;
|
|
enum
|
|
{
|
|
AHEAD = 0,
|
|
LEFT,
|
|
RIGHT,
|
|
BEHIND,
|
|
NUM_TOP_DIRECTIONS
|
|
};
|
|
int ladderTopDir;
|
|
|
|
while (true)
|
|
{
|
|
CNavArea *newArea;
|
|
NavTraverseType how;
|
|
const CNavLadder *ladder = NULL;
|
|
|
|
if (searchFloor)
|
|
{
|
|
if (floorIter == floorList->end())
|
|
{
|
|
++dir;
|
|
|
|
if (dir == NUM_DIRECTIONS)
|
|
{
|
|
searchFloor = false;
|
|
|
|
ladderList = area->GetLadderList(LADDER_UP);
|
|
ladderIter = ladderList->begin();
|
|
ladderTopDir = AHEAD;
|
|
}
|
|
else
|
|
{
|
|
|
|
floorList = area->GetAdjacentList((NavDirType)dir);
|
|
floorIter = floorList->begin();
|
|
}
|
|
continue;
|
|
}
|
|
|
|
newArea = (*floorIter).area;
|
|
how = (NavTraverseType)dir;
|
|
++floorIter;
|
|
}
|
|
else
|
|
{
|
|
if (ladderIter == ladderList->end())
|
|
{
|
|
if (!ladderUp)
|
|
break;
|
|
|
|
else
|
|
{
|
|
ladderUp = false;
|
|
ladderList = area->GetLadderList(LADDER_DOWN);
|
|
ladderIter = ladderList->begin();
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (ladderUp)
|
|
{
|
|
ladder = *ladderIter;
|
|
if (ladder->m_isDangling)
|
|
{
|
|
++ladderIter;
|
|
continue;
|
|
}
|
|
|
|
if (ladderTopDir == AHEAD)
|
|
newArea = ladder->m_topForwardArea;
|
|
else if (ladderTopDir == LEFT)
|
|
newArea = ladder->m_topLeftArea;
|
|
else if (ladderTopDir == RIGHT)
|
|
newArea = ladder->m_topRightArea;
|
|
else
|
|
{
|
|
++ladderIter;
|
|
continue;
|
|
}
|
|
|
|
how = GO_LADDER_UP;
|
|
++ladderTopDir;
|
|
}
|
|
else
|
|
{
|
|
newArea = (*ladderIter)->m_bottomArea;
|
|
how = GO_LADDER_DOWN;
|
|
ladder = (*ladderIter);
|
|
++ladderIter;
|
|
}
|
|
|
|
if (newArea == NULL)
|
|
continue;
|
|
}
|
|
|
|
if (newArea == area)
|
|
continue;
|
|
|
|
float newCostSoFar = costFunc(newArea, area, ladder);
|
|
if (newCostSoFar < 0.0f)
|
|
continue;
|
|
|
|
if ((newArea->IsOpen() || newArea->IsClosed()) && newArea->GetCostSoFar() <= newCostSoFar)
|
|
continue;
|
|
|
|
else
|
|
{
|
|
float newCostRemaining = (*newArea->GetCenter() - actualGoalPos).Length();
|
|
if (closestArea && newCostRemaining < closestAreaDist)
|
|
{
|
|
*closestArea = newArea;
|
|
closestAreaDist = newCostRemaining;
|
|
}
|
|
|
|
newArea->SetParent(area, how);
|
|
newArea->SetCostSoFar(newCostSoFar);
|
|
newArea->SetTotalCost(newCostSoFar + newCostRemaining);
|
|
|
|
if (newArea->IsClosed())
|
|
newArea->RemoveFromClosedList();
|
|
|
|
if (newArea->IsOpen())
|
|
newArea->UpdateOnOpenList();
|
|
else
|
|
newArea->AddToOpenList();
|
|
}
|
|
}
|
|
area->AddToClosedList();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* <3fcb64> ../game_shared/bot/nav_area.h:914 */
|
|
template <typename CostFunctor>
|
|
float NavAreaTravelDistance(CNavArea *startArea, CNavArea *endArea, CostFunctor &costFunc)
|
|
{
|
|
if (startArea == NULL)
|
|
return -1.0f;
|
|
|
|
if (endArea == NULL)
|
|
return -1.0f;
|
|
|
|
if (startArea == endArea)
|
|
return 0.0f;
|
|
|
|
if (NavAreaBuildPath(startArea, endArea, NULL, costFunc) == false)
|
|
return -1.0f;
|
|
|
|
float distance = 0.0f;
|
|
for (CNavArea *area = endArea; area->GetParent(); area = area->GetParent())
|
|
{
|
|
distance += (*area->GetCenter() - *area->GetParent()->GetCenter()).Length();
|
|
}
|
|
return distance;
|
|
}
|
|
|
|
// OVERLOAD
|
|
template <typename CostFunctor>
|
|
float NavAreaTravelDistance(const Vector *startPos, CNavArea *startArea, const Vector *goalPos, CostFunctor &costFunc)
|
|
{
|
|
if (startArea == NULL || startPos == NULL || goalPos == NULL)
|
|
return -1.0f;
|
|
|
|
CNavArea *goalArea = NULL;
|
|
if (NavAreaBuildPath(startArea, TheNavAreaGrid.GetNearestNavArea(goalPos), goalPos, costFunc, &goalArea) == false)
|
|
return -1.0f;
|
|
|
|
if (goalArea == NULL)
|
|
return -1.0f;
|
|
|
|
if (goalArea->GetParent() == NULL)
|
|
return (*goalPos - *startPos).Length();
|
|
|
|
else
|
|
{
|
|
CNavArea *area = goalArea->GetParent();
|
|
float distance = (*goalPos - *area->GetCenter()).Length();
|
|
|
|
for (; area->GetParent(); area = area->GetParent())
|
|
{
|
|
distance += (*area->GetCenter() - *area->GetParent()->GetCenter()).Length();
|
|
}
|
|
return distance;
|
|
}
|
|
}
|
|
|
|
/* <2e7572> ../game_shared/bot/nav_area.h:990 */
|
|
inline void AddAreaToOpenList(CNavArea *area, CNavArea *parent, const Vector *startPos, float maxRange)
|
|
{
|
|
if (area == NULL)
|
|
return;
|
|
|
|
if (!area->IsMarked())
|
|
{
|
|
area->Mark();
|
|
area->SetTotalCost(0.0f);
|
|
area->SetParent(parent);
|
|
|
|
if (maxRange > 0.0f)
|
|
{
|
|
Vector closePos;
|
|
area->GetClosestPointOnArea(startPos, &closePos);
|
|
if ((closePos - *startPos).Make2D().IsLengthLessThan(maxRange))
|
|
{
|
|
float distAlong = parent->GetCostSoFar();
|
|
distAlong += (*area->GetCenter() - *parent->GetCenter()).Length();
|
|
area->SetCostSoFar(distAlong);
|
|
|
|
if (distAlong <= 1.5f * maxRange)
|
|
area->AddToOpenList();
|
|
}
|
|
}
|
|
else
|
|
area->AddToOpenList();
|
|
}
|
|
}
|
|
|
|
/* <56903e> ../game_shared/bot/nav_area.h:1028 */
|
|
template <typename Functor>
|
|
void SearchSurroundingAreas(CNavArea *startArea, const Vector *startPos, Functor &func, float maxRange = -1.0f)
|
|
{
|
|
if (startArea == NULL || startPos == NULL)
|
|
return;
|
|
|
|
CNavArea::MakeNewMarker();
|
|
CNavArea::ClearSearchLists();
|
|
|
|
startArea->AddToOpenList();
|
|
startArea->SetTotalCost(0.0f);
|
|
startArea->SetCostSoFar(0.0f);
|
|
startArea->SetParent(NULL);
|
|
startArea->Mark();
|
|
|
|
while (!CNavArea::IsOpenListEmpty())
|
|
{
|
|
|
|
CNavArea *area = CNavArea::PopOpenList();
|
|
if (func(area))
|
|
{
|
|
for (int dir = 0; dir < NUM_DIRECTIONS; ++dir)
|
|
{
|
|
int count = area->GetAdjacentCount((NavDirType)dir);
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
CNavArea *adjArea = area->GetAdjacentArea((NavDirType)dir, i);
|
|
AddAreaToOpenList(adjArea, area, startPos, maxRange);
|
|
}
|
|
}
|
|
|
|
NavLadderList::const_iterator ladderIt;
|
|
const NavLadderList *ladderList = area->GetLadderList(LADDER_UP);
|
|
if (ladderList)
|
|
{
|
|
for (ladderIt = ladderList->begin(); ladderIt != ladderList->end(); ++ladderIt)
|
|
{
|
|
const CNavLadder *ladder = *ladderIt;
|
|
if (ladder->m_isDangling)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
AddAreaToOpenList(ladder->m_topForwardArea, area, startPos, maxRange);
|
|
AddAreaToOpenList(ladder->m_topLeftArea, area, startPos, maxRange);
|
|
AddAreaToOpenList(ladder->m_topRightArea, area, startPos, maxRange);
|
|
}
|
|
}
|
|
ladderList = area->GetLadderList(LADDER_DOWN);
|
|
if (ladderList)
|
|
{
|
|
for (ladderIt = ladderList->begin(); ladderIt != ladderList->end(); ++ladderIt)
|
|
{
|
|
const CNavLadder *ladder = *ladderIt;
|
|
AddAreaToOpenList(ladder->m_bottomArea, area, startPos, maxRange);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* <4c4137> ../game_shared/bot/nav_area.h:1109 */
|
|
template <typename Functor>
|
|
void ForAllAreas(Functor &func)
|
|
{
|
|
NavAreaList::iterator iter;
|
|
for (iter = TheNavAreaList.begin(); iter != TheNavAreaList.end(); ++iter)
|
|
{
|
|
CNavArea *area = *iter;
|
|
func(area);
|
|
}
|
|
}
|
|
|
|
/* <5497fa> ../game_shared/bot/nav_area.h:1143 */
|
|
class FarAwayFromPositionFunctor
|
|
{
|
|
public:
|
|
FarAwayFromPositionFunctor(const Vector *pos)
|
|
{
|
|
m_pos = pos;
|
|
}
|
|
|
|
float operator() (CNavArea *area, CNavArea *fromArea, const CNavLadder *ladder)
|
|
{
|
|
return 1.0f / (*m_pos - *area->GetCenter()).Length();
|
|
}
|
|
|
|
private:
|
|
const Vector *m_pos;
|
|
};/* size: 4, cachelines: 1, members: 1 */
|
|
|
|
/* <549838> ../game_shared/bot/nav_area.h:1162 */
|
|
template <typename CostFunctor>
|
|
CNavArea *FindMinimumCostArea(CNavArea *startArea, CostFunctor &costFunc)
|
|
{
|
|
const float minSize = 150.0f;
|
|
|
|
enum { NUM_CHEAP_AREAS = 32 };
|
|
struct
|
|
{
|
|
CNavArea *area;
|
|
float cost;
|
|
}
|
|
cheapAreaSet[NUM_CHEAP_AREAS];
|
|
int cheapAreaSetCount = 0;
|
|
|
|
NavAreaList::iterator iter;
|
|
for (iter = TheNavAreaList.begin(); iter != TheNavAreaList.end(); ++iter)
|
|
{
|
|
CNavArea *area = *iter;
|
|
const Extent *extent = area->GetExtent();
|
|
if (extent->hi.x - extent->lo.x < minSize || extent->hi.y - extent->lo.y < minSize)
|
|
continue;
|
|
|
|
float cost = costFunc(area, startArea, NULL);
|
|
if (cheapAreaSetCount < NUM_CHEAP_AREAS)
|
|
{
|
|
cheapAreaSet[cheapAreaSetCount].area = area;
|
|
cheapAreaSet[cheapAreaSetCount++].cost = cost;
|
|
}
|
|
else
|
|
{
|
|
int expensive = 0;
|
|
for (int i = 1; i < NUM_CHEAP_AREAS; i++)
|
|
if (cheapAreaSet[i].cost > cheapAreaSet[expensive].cost)
|
|
expensive = i;
|
|
|
|
if (cheapAreaSet[expensive].cost > cost)
|
|
{
|
|
cheapAreaSet[expensive].area = area;
|
|
cheapAreaSet[expensive].cost = cost;
|
|
}
|
|
}
|
|
}
|
|
if (cheapAreaSetCount)
|
|
{
|
|
return cheapAreaSet[RANDOM_LONG(0, cheapAreaSetCount-1)].area;
|
|
}
|
|
else
|
|
{
|
|
int numAreas = TheNavAreaList.size();
|
|
int which = RANDOM_LONG(0, numAreas-1);
|
|
|
|
NavAreaList::iterator iter;
|
|
for (iter = TheNavAreaList.begin(); iter != TheNavAreaList.end(); ++iter)
|
|
if (which-- == 0)
|
|
break;
|
|
|
|
return *iter;
|
|
}
|
|
}
|
|
|
|
#ifdef HOOK_GAMEDLL
|
|
|
|
typedef const Vector *(FIND_SPOT_CBASE)(CBaseEntity *, const Vector *, CNavArea *, float, int, bool);
|
|
|
|
typedef void (CNavArea::*SAVE_FD)(int fd, unsigned int version);
|
|
typedef void (CNavArea::*SAVE_FILE)(FILE *fp);
|
|
|
|
typedef void (CNavArea::*OVERLAP_VECTOR)(Vector *pos);
|
|
typedef void (CNavArea::*OVERLAP_CNAV)(CNavArea *area);
|
|
|
|
typedef float (CNavArea::*GETZ_VECTOR)(const Vector *pos) const;
|
|
typedef float (CNavArea::*GETZ_TWO_FLOAT)(float x, float y) const;
|
|
|
|
typedef void (HidingSpot::*HIDING_SPOT_VOID)(void);
|
|
typedef void (HidingSpot::*HIDING_SPOT_VECTOR)(const Vector *pos, unsigned char flags);
|
|
|
|
typedef void (HidingSpot::*CNAV_AREA_VOID)(void);
|
|
typedef void (HidingSpot::*CNAV_AREA_TWO_VECTOR)(const Vector *corner, const Vector *otherCorner);
|
|
typedef void (HidingSpot::*CNAV_AREA_VECTOR)(const Vector *nwCorner, const Vector *neCorner, const Vector *seCorner, const Vector *swCorner);
|
|
typedef void (HidingSpot::*CNAV_AREA_NAVNODE)(CNavNode *nwNode, class CNavNode *neNode, class CNavNode *seNode, class CNavNode *swNode);
|
|
|
|
#endif // HOOK_GAMEDLL
|
|
|
|
#ifdef HOOK_GAMEDLL
|
|
|
|
#define TheNavLadderList (*pTheNavLadderList)
|
|
#define TheHidingSpotList (*pTheHidingSpotList)
|
|
#define TheNavAreaList (*pTheNavAreaList)
|
|
#define TheNavAreaGrid (*pTheNavAreaGrid)
|
|
|
|
#define lastDrawTimestamp (*plastDrawTimestamp)
|
|
#define goodSizedAreaList (*pgoodSizedAreaList)
|
|
#define markedArea (*pmarkedArea)
|
|
#define lastSelectedArea (*plastSelectedArea)
|
|
#define markedCorner (*pmarkedCorner)
|
|
#define isCreatingNavArea (*pisCreatingNavArea)
|
|
//#define isAnchored (*pisAnchored)
|
|
//#define anchor (*panchor)
|
|
//#define isPlaceMode (*pisPlaceMode)
|
|
#define isPlacePainting (*pisPlacePainting)
|
|
#define editTimestamp (*peditTimestamp)
|
|
|
|
#define BlockedID (*pBlockedID)
|
|
#define BlockedIDCount (*pBlockedIDCount)
|
|
|
|
#endif // HOOK_GAMEDLL
|
|
|
|
extern NavLadderList TheNavLadderList;
|
|
extern HidingSpotList TheHidingSpotList;
|
|
extern NavAreaList TheNavAreaList;
|
|
extern CNavAreaGrid TheNavAreaGrid;
|
|
extern float lastDrawTimestamp;
|
|
extern NavAreaList goodSizedAreaList;
|
|
extern CNavArea *markedArea;
|
|
extern CNavArea *lastSelectedArea;
|
|
extern NavCornerType markedCorner;
|
|
extern bool isCreatingNavArea;
|
|
//extern bool isAnchored;
|
|
//extern Vector anchor;
|
|
//extern bool isPlaceMode;
|
|
extern bool isPlacePainting;
|
|
extern float editTimestamp;
|
|
|
|
extern unsigned int BlockedID[ MAX_BLOCKED_AREAS ];
|
|
extern int BlockedIDCount;
|
|
|
|
NOBODY bool IsHidingSpotInCover(const Vector *spot);
|
|
NOBODY void ClassifySniperSpot(HidingSpot *spot);
|
|
NOBODY void DestroyHidingSpots(void);
|
|
NOBODY void EditNavAreas(NavEditCmdType cmd);
|
|
bool GetGroundHeight(const Vector *pos, float *height, Vector *normal = NULL);
|
|
NOBODY bool GetSimpleGroundHeight(const Vector *pos, float *height, Vector *normal = NULL);
|
|
NOBODY inline bool IsAreaVisible(const Vector *pos, const CNavArea *area);
|
|
NOBODY CNavArea *GetMarkedArea(void);
|
|
void EditNavAreasReset(void);
|
|
NOBODY void DrawHidingSpots(const CNavArea *area);
|
|
NOBODY void IncreaseDangerNearby(int teamID, float amount, CNavArea *startArea, const Vector *pos, float maxRadius);
|
|
NOBODY void DrawDanger(void);
|
|
NOBODY bool IsSpotOccupied(CBaseEntity *me, const Vector *pos);
|
|
NOBODY const Vector *FindNearbyHidingSpot(CBaseEntity *me, const Vector *pos, CNavArea *startArea, float maxRange = 1000.0f, bool isSniper = false, bool useNearest = false);
|
|
NOBODY const Vector *FindNearbyRetreatSpot(CBaseEntity *me, const Vector *start, CNavArea *startArea, float maxRange = 1000.0f, int avoidTeam = 0, bool useCrouchAreas = true);
|
|
NOBODY bool IsCrossingLineOfFire(const Vector &start, const Vector &finish, CBaseEntity *ignore = NULL, int ignoreTeam = 0);
|
|
NOBODY const Vector *FindRandomHidingSpot(CBaseEntity *me, Place place, bool isSniper = false);
|
|
NOBODY HidingSpot *GetHidingSpotByID(unsigned int id);
|
|
void ApproachAreaAnalysisPrep(void);
|
|
void CleanupApproachAreaAnalysisPrep(void);
|
|
void DestroyLadders(void);
|
|
NOBODY void DestroyNavigationMap(void);
|
|
NOBODY void StripNavigationAreas(void);
|
|
NOBODY inline CNavArea *FindFirstAreaInDirection(const Vector *start, NavDirType dir, float range, float beneathLimit, CBaseEntity *traceIgnore, Vector *closePos);
|
|
NOBODY inline bool testJumpDown(const Vector *fromPos, const Vector *toPos);
|
|
NOBODY inline CNavArea *findJumpDownArea(const Vector *fromPos, NavDirType dir);
|
|
NOBODY void ConnectGeneratedAreas(void);
|
|
NOBODY void MergeGeneratedAreas(void);
|
|
NOBODY inline bool IsAreaRoughlySquare(const CNavArea *area);
|
|
NOBODY void SplitX(CNavArea *area);
|
|
NOBODY void SplitY(CNavArea *area);
|
|
NOBODY void SquareUpAreas(void);
|
|
NOBODY bool TestArea(CNavNode *node, int width, int height);
|
|
NOBODY int BuildArea(CNavNode *node, int width, int height);
|
|
NOBODY void BuildLadders(void);
|
|
NOBODY void MarkJumpAreas(void);
|
|
NOBODY void GenerateNavigationAreaMesh(void);
|
|
|
|
//refs
|
|
extern float (*pGetZ__Vector)(const Vector *pos);
|
|
extern CNavArea *(*pGetNearestNavArea)(const Vector *pos, bool anyZ);
|
|
extern CNavArea *(*pGetNavArea)(const Vector *pos, float beneathLimit);
|
|
extern void (*pDestroyNavigationMap)(void);
|
|
|
|
#endif // NAV_AREA_H
|