370 lines
13 KiB
C++
370 lines
13 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Hint node utilities and functions.
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#ifndef AI_HINT_H
|
|
#define AI_HINT_H
|
|
#pragma once
|
|
|
|
#include "ai_initutils.h"
|
|
#include "tier1/utlmap.h"
|
|
|
|
// Flags for FindHintNode
|
|
#define bits_HINT_NODE_NONE 0x00000000
|
|
#define bits_HINT_NODE_VISIBLE 0x00000001
|
|
#define bits_HINT_NODE_NEAREST 0x00000002 // Choose the node nearest me
|
|
#define bits_HINT_NODE_RANDOM \
|
|
0x00000004 // Find a random hintnode meeting other criteria
|
|
#define bits_HINT_NODE_CLEAR \
|
|
0x00000008 // Only choose nodes that have clear room for my bounding box
|
|
// (requires NPC)
|
|
#define bits_HINT_NODE_USE_GROUP \
|
|
0x00000010 // Use the NPC's hintgroup when searching for a node (requires
|
|
// NPC)
|
|
#define bits_HINT_NODE_VISIBLE_TO_PLAYER 0x00000020
|
|
#define bits_HINT_NODE_NOT_VISIBLE_TO_PLAYER 0x00000040
|
|
#define bits_HINT_NODE_REPORT_FAILURES 0x00000080
|
|
#define bits_HINT_NODE_IN_VIEWCONE 0x00000100
|
|
#define bits_HINT_NODE_IN_AIMCONE 0x00000200
|
|
#define bits_HINT_NPC_IN_NODE_FOV \
|
|
0x00000400 // Is the searcher inside the hint node's FOV?
|
|
#define bits_HINT_NOT_CLOSE_TO_ENEMY \
|
|
0x00000800 // Hint must not be within 30 feet of my enemy
|
|
#define bits_HINT_HAS_LOS_TO_PLAYER \
|
|
0x00001000 // Like VISIBLE_TO_PLAYER but doesn't care about player's facing
|
|
#define bits_HAS_EYEPOSITION_LOS_TO_PLAYER \
|
|
0x00002000 // Like HAS LOS TO PLAYER, but checks NPC's eye position at the
|
|
// node, not node origin.
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// hints - these MUST coincide with the HINTS listed under
|
|
// info_node in the FGD file!
|
|
//
|
|
// For debugging, they must also coincide with g_pszHintDescriptions.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
enum Hint_e {
|
|
HINT_ANY = -1,
|
|
HINT_NONE = 0,
|
|
HINT_NOT_USED_WORLD_DOOR,
|
|
HINT_WORLD_WINDOW,
|
|
HINT_NOT_USED_WORLD_BUTTON,
|
|
HINT_NOT_USED_WORLD_MACHINERY,
|
|
HINT_NOT_USED_WORLD_LEDGE,
|
|
HINT_NOT_USED_WORLD_LIGHT_SOURCE,
|
|
HINT_NOT_USED_WORLD_HEAT_SOURCE,
|
|
HINT_NOT_USED_WORLD_BLINKING_LIGHT,
|
|
HINT_NOT_USED_WORLD_BRIGHT_COLORS,
|
|
HINT_NOT_USED_WORLD_HUMAN_BLOOD,
|
|
HINT_NOT_USED_WORLD_ALIEN_BLOOD,
|
|
|
|
HINT_WORLD_WORK_POSITION,
|
|
HINT_WORLD_VISUALLY_INTERESTING,
|
|
HINT_WORLD_VISUALLY_INTERESTING_DONT_AIM,
|
|
HINT_WORLD_INHIBIT_COMBINE_MINES,
|
|
HINT_WORLD_VISUALLY_INTERESTING_STEALTH,
|
|
|
|
HINT_TACTICAL_COVER_MED = 100,
|
|
HINT_TACTICAL_COVER_LOW,
|
|
HINT_TACTICAL_SPAWN,
|
|
HINT_TACTICAL_PINCH, // Exit / entrance to an arena
|
|
HINT_NOT_USED_TACTICAL_GUARD,
|
|
HINT_TACTICAL_ENEMY_DISADVANTAGED, // Disadvantageous position for the
|
|
// enemy
|
|
HINT_NOT_USED_HEALTH_KIT,
|
|
|
|
HINT_NOT_USED_URBAN_STREETCORNER = 200,
|
|
HINT_NOT_USED_URBAN_STREETLAMP,
|
|
HINT_NOT_USED_URBAN_DARK_SPOT,
|
|
HINT_NOT_USED_URBAN_POSTER,
|
|
HINT_NOT_USED_URBAN_SHELTER,
|
|
|
|
HINT_NOT_USED_ASSASSIN_SECLUDED = 300,
|
|
HINT_NOT_USED_ASSASSIN_RAFTERS,
|
|
HINT_NOT_USED_ASSASSIN_GROUND,
|
|
HINT_NOT_USED_ASSASSIN_MONKEYBARS,
|
|
|
|
HINT_ANTLION_BURROW_POINT = 400,
|
|
HINT_ANTLION_THUMPER_FLEE_POINT,
|
|
|
|
HINT_HEADCRAB_BURROW_POINT = 450,
|
|
HINT_HEADCRAB_EXIT_POD_POINT,
|
|
|
|
HINT_NOT_USED_ROLLER_PATROL_POINT = 500,
|
|
HINT_NOT_USED_ROLLER_CLEANUP_POINT,
|
|
|
|
HINT_NOT_USED_PSTORM_ROCK_SPAWN = 600,
|
|
|
|
HINT_CROW_FLYTO_POINT = 700,
|
|
|
|
// TF2 Hints
|
|
HINT_BUG_PATROL_POINT = 800,
|
|
|
|
// HL2 Hints
|
|
HINT_FOLLOW_WAIT_POINT = 900,
|
|
HINT_JUMP_OVERRIDE = 901,
|
|
HINT_PLAYER_SQUAD_TRANSITON_POINT = 902,
|
|
HINT_NPC_EXIT_POINT = 903,
|
|
HINT_STRIDER_NODE = 904,
|
|
|
|
HINT_PLAYER_ALLY_MOVE_AWAY_DEST = 950,
|
|
HINT_PLAYER_ALLY_FEAR_DEST,
|
|
|
|
// HL1 port hints
|
|
HINT_HL1_WORLD_MACHINERY = 1000,
|
|
HINT_HL1_WORLD_BLINKING_LIGHT,
|
|
HINT_HL1_WORLD_HUMAN_BLOOD,
|
|
HINT_HL1_WORLD_ALIEN_BLOOD,
|
|
|
|
// CS port hints
|
|
HINT_CSTRIKE_HOSTAGE_ESCAPE = 1100,
|
|
};
|
|
const char *GetHintTypeDescription(Hint_e iHintType);
|
|
const char *GetHintTypeDescription(CAI_Hint *pHint);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CHintCriteria
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class CHintCriteria {
|
|
public:
|
|
CHintCriteria();
|
|
~CHintCriteria();
|
|
|
|
bool HasFlag(int bitmask) const { return (m_iFlags & bitmask) != 0; }
|
|
void SetFlag(int bitmask);
|
|
void ClearFlag(int bitmask);
|
|
|
|
void SetGroup(string_t group);
|
|
string_t GetGroup(void) const { return m_strGroup; }
|
|
|
|
int GetFirstHintType(void) const { return m_iFirstHintType; }
|
|
int GetLastHintType(void) const { return m_iLastHintType; }
|
|
bool MatchesHintType(int hintType) const;
|
|
bool MatchesSingleHintType() const;
|
|
|
|
bool HasIncludeZones(void) const { return (m_zoneInclude.Count() != 0); }
|
|
bool HasExcludeZones(void) const { return (m_zoneExclude.Count() != 0); }
|
|
|
|
void AddIncludePosition(const Vector &position, float radius);
|
|
void AddExcludePosition(const Vector &position, float radius);
|
|
void SetHintType(int hintType);
|
|
void SetHintTypeRange(int firstType, int lastType);
|
|
void AddHintType(int hintType);
|
|
|
|
bool InIncludedZone(const Vector &testPosition) const;
|
|
bool InExcludedZone(const Vector &testPosition) const;
|
|
|
|
int NumHintTypes() const;
|
|
int GetHintType(int idx) const;
|
|
|
|
private:
|
|
struct hintZone_t {
|
|
Vector position;
|
|
float radiussqr;
|
|
};
|
|
|
|
typedef CUtlVector<hintZone_t> zoneList_t;
|
|
|
|
void AddZone(zoneList_t &list, const Vector &position, float radius);
|
|
bool InZone(const zoneList_t &zone, const Vector &testPosition) const;
|
|
|
|
CUtlVector<int> m_HintTypes;
|
|
|
|
int m_iFlags;
|
|
int m_iFirstHintType;
|
|
int m_iLastHintType;
|
|
string_t m_strGroup;
|
|
|
|
zoneList_t m_zoneInclude;
|
|
zoneList_t m_zoneExclude;
|
|
};
|
|
|
|
class CAI_Node;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CAI_HintManager
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DECLARE_POINTER_HANDLE(AIHintIter_t);
|
|
|
|
class CAIHintVector : public CUtlVector<CAI_Hint *> {
|
|
public:
|
|
CAIHintVector() : CUtlVector<CAI_Hint *>(1, 0) {}
|
|
|
|
CAIHintVector(const CAIHintVector &src) {
|
|
CopyArray(src.Base(), src.Count());
|
|
}
|
|
|
|
CAIHintVector &operator=(const CAIHintVector &src) {
|
|
CopyArray(src.Base(), src.Count());
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
class CAI_HintManager {
|
|
friend class CAI_Hint;
|
|
|
|
public:
|
|
// Hint node creation
|
|
static CAI_Hint *CreateHint(HintNodeData *pNodeData,
|
|
const char *pMapData = NULL);
|
|
static void DrawHintOverlays(float flDrawDuration);
|
|
|
|
static void AddHint(CAI_Hint *pTestHint);
|
|
static void RemoveHint(CAI_Hint *pTestHint);
|
|
static void AddHintByType(CAI_Hint *pHint);
|
|
static void RemoveHintByType(CAI_Hint *pHintToRemove);
|
|
|
|
// Interface for searching the hint node list
|
|
static CAI_Hint *FindHint(CAI_BaseNPC *pNPC, const Vector &position,
|
|
const CHintCriteria &hintCriteria);
|
|
static CAI_Hint *FindHint(CAI_BaseNPC *pNPC,
|
|
const CHintCriteria &hintCriteria);
|
|
static CAI_Hint *FindHint(const Vector &position,
|
|
const CHintCriteria &hintCriteria);
|
|
static CAI_Hint *FindHint(CAI_BaseNPC *pNPC, Hint_e nHintType, int nFlags,
|
|
float flMaxDist,
|
|
const Vector *pMaxDistFrom = NULL);
|
|
|
|
// Purpose: Finds a random suitable hint within the requested radious of the
|
|
// npc
|
|
static CAI_Hint *FindHintRandom(CAI_BaseNPC *pNPC, const Vector &position,
|
|
const CHintCriteria &hintCriteria);
|
|
static int FindAllHints(CAI_BaseNPC *pNPC, const Vector &position,
|
|
const CHintCriteria &hintCriteria,
|
|
CUtlVector<CAI_Hint *> *pResult);
|
|
static int FindAllHints(const Vector &position,
|
|
const CHintCriteria &hintCriteria,
|
|
CUtlVector<CAI_Hint *> *pResult) {
|
|
return FindAllHints(NULL, position, hintCriteria, pResult);
|
|
}
|
|
static int FindAllHints(CAI_BaseNPC *pNPC,
|
|
const CHintCriteria &hintCriteria,
|
|
CUtlVector<CAI_Hint *> *pResult) {
|
|
return FindAllHints(pNPC, pNPC->GetAbsOrigin(), hintCriteria, pResult);
|
|
}
|
|
static int GetFlags(const char *token);
|
|
|
|
static CAI_Hint *GetFirstHint(AIHintIter_t *pIter);
|
|
static CAI_Hint *GetNextHint(AIHintIter_t *pIter);
|
|
|
|
static void DumpHints();
|
|
|
|
static void ValidateHints();
|
|
|
|
private:
|
|
enum {
|
|
// MUST BE POWER OF 2
|
|
HINT_HISTORY = (1 << 3),
|
|
HINT_HISTORY_MASK = (HINT_HISTORY - 1)
|
|
};
|
|
|
|
static CAI_Hint *AddFoundHint(CAI_Hint *hint);
|
|
static int GetFoundHintCount();
|
|
static CAI_Hint *GetFoundHint(int index);
|
|
static CAI_Hint *GetLastFoundHint();
|
|
static void ResetFoundHints();
|
|
static bool IsInFoundHintList(CAI_Hint *hint);
|
|
|
|
static int gm_nFoundHintIndex;
|
|
static CAI_Hint *gm_pLastFoundHints[HINT_HISTORY]; // Last used hint
|
|
static CAIHintVector gm_AllHints; // A linked list of all hints
|
|
static CUtlMap<int, CAIHintVector> gm_TypedHints;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CAI_Hint
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class CAI_Hint : public CServerOnlyEntity {
|
|
DECLARE_CLASS(CAI_Hint, CServerOnlyEntity);
|
|
|
|
public:
|
|
CAI_Hint(void);
|
|
~CAI_Hint(void);
|
|
|
|
// Interface for specific nodes
|
|
bool Lock(CBaseEntity *pNPC); // Makes unavailable for hints
|
|
void Unlock(float delay = 0.0); // Makes available for hints after delay
|
|
bool IsLocked(void); // Whether this node is available for use.
|
|
bool IsLockedBy(
|
|
CBaseEntity *pNPC); // Whether this node is available for use.
|
|
void GetPosition(CBaseCombatCharacter *pBCC, Vector *vPosition);
|
|
void GetPosition(Hull_t hull, Vector *vPosition);
|
|
Vector GetDirection(void);
|
|
float Yaw(void);
|
|
CAI_Node *GetNode(void);
|
|
string_t GetGroup(void) const { return m_NodeData.strGroup; }
|
|
CBaseEntity *User(void) const { return m_hHintOwner; };
|
|
Hint_e HintType(void) const { return (Hint_e)m_NodeData.nHintType; };
|
|
void SetHintType(int hintType, bool force = false);
|
|
string_t HintActivityName(void) const { return m_NodeData.iszActivityName; }
|
|
int GetTargetNode(void) const { return m_nTargetNodeID; }
|
|
bool IsDisabled(void) const { return (m_NodeData.iDisabled != 0); }
|
|
void SetDisabled(bool bDisabled) { m_NodeData.iDisabled = bDisabled; }
|
|
void DisableForSeconds(float flSeconds);
|
|
void EnableThink();
|
|
void FixupTargetNode();
|
|
void NPCStartedUsing(CAI_BaseNPC *pNPC);
|
|
void NPCStoppedUsing(CAI_BaseNPC *pNPC);
|
|
|
|
HintIgnoreFacing_t GetIgnoreFacing() const {
|
|
return m_NodeData.fIgnoreFacing;
|
|
}
|
|
|
|
NPC_STATE GetMinState() const { return m_NodeData.minState; }
|
|
NPC_STATE GetMaxState() const { return m_NodeData.maxState; }
|
|
|
|
int GetNodeId() { return m_NodeData.nNodeID; }
|
|
int GetWCId() { return m_NodeData.nWCNodeID; }
|
|
|
|
bool HintMatchesCriteria(CAI_BaseNPC *pNPC,
|
|
const CHintCriteria &hintCriteria,
|
|
const Vector &position, float *flNearestDistance,
|
|
bool bIgnoreLock = false,
|
|
bool bIgnoreHintType = false);
|
|
bool IsInNodeFOV(CBaseEntity *pOther);
|
|
|
|
private:
|
|
void Spawn(void);
|
|
virtual void Activate();
|
|
virtual void UpdateOnRemove(void);
|
|
int DrawDebugTextOverlays(void);
|
|
virtual int ObjectCaps(void) {
|
|
return (BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION);
|
|
}
|
|
virtual void OnRestore();
|
|
bool IsViewable(void);
|
|
|
|
// Input handlers
|
|
void InputEnableHint(inputdata_t &inputdata);
|
|
void InputDisableHint(inputdata_t &inputdata);
|
|
|
|
private:
|
|
HintNodeData m_NodeData;
|
|
int m_nTargetNodeID;
|
|
EHANDLE m_hHintOwner; // Is hint locked (being used by NPC / NPC en-route
|
|
// to use it)
|
|
float m_flNextUseTime; // When can I be used again?
|
|
COutputEHANDLE m_OnNPCStartedUsing; // Triggered when an NPC has actively
|
|
// begun to use the node.
|
|
COutputEHANDLE m_OnNPCStoppedUsing; // Triggered when an NPC has finished
|
|
// using this node.
|
|
float m_nodeFOV;
|
|
Vector m_vecForward;
|
|
|
|
// The next hint in list of all hints
|
|
friend class CAI_HintManager;
|
|
|
|
DECLARE_DATADESC();
|
|
};
|
|
|
|
#define SF_ALLOW_JUMP_UP 65536
|
|
|
|
#endif // AI_HINT_H
|