H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-23 06:36:54 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
68483bd0f6
source-engine/game/server/ai_hint.cpp
nillerusr b06620b8c9 fpersmissive fixes
2022-06-15 21:59:06 +03:00

1688 lines
48 KiB
C++
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Hint node utilities and functions
//
// $NoKeywords: $
//=============================================================================//
// @TODO (toml 03-04-03): there is far too much duplicate code in here
#include "cbase.h"
#include "ai_hint.h"
#include "ai_network.h"
#include "ai_node.h"
#include "ai_basenpc.h"
#include "ai_networkmanager.h"
#include "ndebugoverlay.h"
#include "animation.h"
#include "tier1/strtools.h"
#include "mapentities_shared.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define REPORTFAILURE(text) if ( hintCriteria.HasFlag( bits_HINT_NODE_REPORT_FAILURES ) ) \
NDebugOverlay::Text( GetAbsOrigin(), text, false, 60 )
//==================================================
// CHintCriteria
//==================================================
CHintCriteria::CHintCriteria( void )
{
m_iFirstHintType = HINT_NONE;
m_iLastHintType = HINT_NONE;
m_strGroup = NULL_STRING;
m_iFlags = 0;
m_HintTypes.Purge();
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CHintCriteria::~CHintCriteria( void )
{
m_zoneInclude.Purge();
m_zoneExclude.Purge();
m_HintTypes.Purge();
}
//-----------------------------------------------------------------------------
// Purpose: Sets the hint type for this search criteria
// Input : nHintType - the hint type for this search criteria
//-----------------------------------------------------------------------------
void CHintCriteria::SetHintType( int nHintType )
{
m_iFirstHintType = nHintType;
m_iLastHintType = HINT_NONE;
m_HintTypes.Purge();
}
//-----------------------------------------------------------------------------
// Purpose: Add another type of hint that matches the search criteria
//-----------------------------------------------------------------------------
void CHintCriteria::AddHintType( int hintType )
{
m_HintTypes.AddToTail( hintType );
}
int CHintCriteria::NumHintTypes() const
{
return m_HintTypes.Count();
}
int CHintCriteria::GetHintType( int idx ) const
{
return m_HintTypes[ idx ];
}
bool CHintCriteria::MatchesSingleHintType() const
{
if ( m_HintTypes.Count() != 0 )
{
return false;
}
if ( m_iFirstHintType != HINT_ANY &&
m_iLastHintType == HINT_NONE )
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CHintCriteria::MatchesHintType( int hintType ) const
{
int c = m_HintTypes.Count();
for ( int i = 0; i < c; ++i )
{
if ( m_HintTypes[i] == hintType )
return true;
}
// See if we're trying to filter the nodes
if ( GetFirstHintType() != HINT_ANY )
{
if( GetLastHintType() == HINT_NONE )
{
// Searching for a single type of hint.
if( GetFirstHintType() != hintType )
return false;
}
else
{
// This search is for a range of hint types.
if( hintType < GetFirstHintType() || hintType > GetLastHintType() )
return false;
}
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Allows us to search for nodes within a range of consecutive types.
//-----------------------------------------------------------------------------
void CHintCriteria::SetHintTypeRange( int firstType, int lastType )
{
if( lastType < firstType )
{
DevMsg( 2, "Hint Type Range is backwards - Fixing up.\n" );
int temp;
temp = firstType;
firstType = lastType;
lastType = temp;
}
m_iFirstHintType = firstType;
m_iLastHintType = lastType;
m_HintTypes.Purge();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bitmask -
//-----------------------------------------------------------------------------
void CHintCriteria::SetFlag( int bitmask )
{
m_iFlags |= bitmask;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bitmask -
//-----------------------------------------------------------------------------
void CHintCriteria::ClearFlag( int bitmask )
{
m_iFlags &= ~bitmask;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : group -
//-----------------------------------------------------------------------------
void CHintCriteria::SetGroup( string_t group )
{
m_strGroup = group;
}
//-----------------------------------------------------------------------------
// Purpose: Adds a zone to a zone list
// Input : list - the list of zones to add the new zone to
// &position - the origin point of the zone
// radius - the radius of the zone
//-----------------------------------------------------------------------------
void CHintCriteria::AddZone( zoneList_t &list, const Vector &position, float radius )
{
int id = list.AddToTail();
list[id].position = position;
list[id].radiussqr = radius*radius;
}
//-----------------------------------------------------------------------------
// Purpose: Adds an include zone to the search criteria
// Input : &position - the origin point of the zone
// radius - the radius of the zone
//-----------------------------------------------------------------------------
void CHintCriteria::AddIncludePosition( const Vector &position, float radius )
{
AddZone( m_zoneInclude, position, radius );
}
//-----------------------------------------------------------------------------
// Purpose: Adds an exclude zone to the search criteria
// Input : &position - the origin point of the zone
// radius - the radius of the zone
//-----------------------------------------------------------------------------
void CHintCriteria::AddExcludePosition( const Vector &position, float radius )
{
AddZone( m_zoneExclude, position, radius );
}
//-----------------------------------------------------------------------------
// Purpose: Test to see if this position falls within any of the zones in the list
// Input : *zone - list of zones to test against
// &testPosition - position to test with
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
inline bool CHintCriteria::InZone( const zoneList_t &zone, const Vector &testPosition ) const
{
int numZones = zone.Count();
//Iterate through all zones in the list
for ( int i = 0; i < numZones; i++ )
{
if ( ((zone[i].position) - testPosition).LengthSqr() < (zone[i].radiussqr) )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Determine if a point within our include list
// Input : &testPosition - position to test with
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CHintCriteria::InIncludedZone( const Vector &testPosition ) const
{
return InZone( m_zoneInclude, testPosition );
}
//-----------------------------------------------------------------------------
// Purpose: Determine if a point within our exclude list
// Input : &testPosition - position to test with
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CHintCriteria::InExcludedZone( const Vector &testPosition ) const
{
return InZone( m_zoneExclude, testPosition );
}
//-----------------------------------------------------------------------------
// Init static variables
//-----------------------------------------------------------------------------
CAIHintVector CAI_HintManager::gm_AllHints;
CUtlMap< int, CAIHintVector > CAI_HintManager::gm_TypedHints( 0, 0, DefLessFunc( int ) );
CAI_Hint* CAI_HintManager::gm_pLastFoundHints[ CAI_HintManager::HINT_HISTORY ];
int CAI_HintManager::gm_nFoundHintIndex = 0;
CAI_Hint *CAI_HintManager::AddFoundHint( CAI_Hint *hint )
{
if ( hint )
{
CAI_HintManager::gm_nFoundHintIndex = ( CAI_HintManager::gm_nFoundHintIndex + 1 ) & CAI_HintManager::HINT_HISTORY_MASK;
gm_pLastFoundHints[ CAI_HintManager::gm_nFoundHintIndex ] = hint;
}
return hint;
}
int CAI_HintManager::GetFoundHintCount()
{
return CAI_HintManager::HINT_HISTORY;
}
CAI_Hint *CAI_HintManager::GetFoundHint( int index )
{
return gm_pLastFoundHints[ ( CAI_HintManager::gm_nFoundHintIndex + index ) & CAI_HintManager::HINT_HISTORY_MASK ];
}
CAI_Hint *CAI_HintManager::GetLastFoundHint()
{
for ( int i = 0; i < CAI_HintManager::HINT_HISTORY; ++i )
{
// Walk backward
int slot = ( ( CAI_HintManager::gm_nFoundHintIndex - i ) & CAI_HintManager::HINT_HISTORY_MASK );
if ( gm_pLastFoundHints[ slot ] )
return gm_pLastFoundHints[ slot ];
}
return NULL;
}
void CAI_HintManager::ResetFoundHints()
{
Q_memset( gm_pLastFoundHints, 0, sizeof( gm_pLastFoundHints ) );
CAI_HintManager::gm_nFoundHintIndex = 0;
}
bool CAI_HintManager::IsInFoundHintList( CAI_Hint *hint )
{
for ( int i = 0; i < CAI_HintManager::HINT_HISTORY; ++i )
{
if ( gm_pLastFoundHints[ i ] == hint )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
int CAI_HintManager::FindAllHints( CAI_BaseNPC *pNPC, const Vector &position, const CHintCriteria &hintCriteria, CUtlVector<CAI_Hint *> *pResult )
{
// If we have no hints, bail
int c = CAI_HintManager::gm_AllHints.Count();
if ( !c )
return NULL;
// Remove the nearest flag. It makes now sense with random.
bool hadNearest = hintCriteria.HasFlag( bits_HINT_NODE_NEAREST );
(const_cast<CHintCriteria &>(hintCriteria)).ClearFlag( bits_HINT_NODE_NEAREST );
// Now loop till we find a valid hint or return to the start
CAI_Hint *pTestHint;
for ( int i = 0; i < c; ++i )
{
pTestHint = CAI_HintManager::gm_AllHints[ i ];
Assert( pTestHint );
if ( pTestHint->HintMatchesCriteria( pNPC, hintCriteria, position, NULL ) )
pResult->AddToTail( pTestHint );
}
if ( hadNearest )
(const_cast<CHintCriteria &>(hintCriteria)).SetFlag( bits_HINT_NODE_NEAREST );
return pResult->Count();
}
//-----------------------------------------------------------------------------
// Purpose: Finds a random hint within the requested radious of the npc
// Builds a list of all suitable hints and chooses randomly from amongst them.
// Input : *pNPC -
// nHintType -
// nFlags -
// flMaxDist -
// Output : CAI_Hint
//-----------------------------------------------------------------------------
CAI_Hint *CAI_HintManager::FindHintRandom( CAI_BaseNPC *pNPC, const Vector &position, const CHintCriteria &hintCriteria )
{
CUtlVector<CAI_Hint *> hintList;
if ( FindAllHints( pNPC, position, hintCriteria, &hintList ) > 0 )
{
// Pick one randomly
return ( CAI_HintManager::AddFoundHint( hintList[ random->RandomInt( 0, hintList.Size() - 1 ) ] ) );
}
// start at the top of the list for the next search
CAI_HintManager::ResetFoundHints();
return NULL;
}
// #define HINT_PROFILING 1
#if defined( HINT_PROFILING )
static void AppendTimer( int idx, char *buf, size_t bufsize, CFastTimer& timer )
{
char s[ 32 ];
Q_snprintf( s, sizeof( s ), "%d %6.3f ms", idx, timer.GetDuration().GetMillisecondsF() );
Q_strncat( buf, s, bufsize );
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
// Input : *hintCriteria -
// Output : CAI_Hint
//-----------------------------------------------------------------------------
CAI_Hint *CAI_HintManager::FindHint( CAI_BaseNPC *pNPC, const Vector &position, const CHintCriteria &hintCriteria )
{
#if defined( HINT_PROFILING )
CFastTimer timer;
timer.Start();
#endif
bool singleType = hintCriteria.MatchesSingleHintType();
bool lookingForNearest = hintCriteria.HasFlag( bits_HINT_NODE_NEAREST );
bool bIgnoreHintType = true;
CUtlVector< CAIHintVector * > lists;
if ( singleType )
{
int slot = CAI_HintManager::gm_TypedHints.Find( hintCriteria.GetFirstHintType() );
if ( slot != CAI_HintManager::gm_TypedHints.InvalidIndex() )
{
lists.AddToTail( &CAI_HintManager::gm_TypedHints[ slot ] );
}
}
else
{
int typeCount = hintCriteria.NumHintTypes();
if ( typeCount > 0 )
{
for ( int listType = 0; listType < typeCount; ++listType )
{
int slot = CAI_HintManager::gm_TypedHints.Find( hintCriteria.GetHintType( listType ) );
if ( slot != CAI_HintManager::gm_TypedHints.InvalidIndex() )
{
lists.AddToTail( &CAI_HintManager::gm_TypedHints[ slot ] );
}
}
}
else
{
// Still need to check hint type in this case
lists.AddToTail( &CAI_HintManager::gm_AllHints );
bIgnoreHintType = false;
}
}
CAI_Hint *pBestHint = NULL;
int visited = 0;
int listCount = lists.Count();
if ( listCount == 0 )
return NULL;
// Try the fast match path
int i, count;
// Start with hint after the last one used
CAI_Hint *pTestHint = NULL;
float flBestDistance = MAX_TRACE_LENGTH;
if ( !lookingForNearest )
{
// Fast check of previous results
count = CAI_HintManager::GetFoundHintCount();
for ( i = 0; i < count; ++i )
{
pTestHint = CAI_HintManager::GetFoundHint( i );
if ( pTestHint )
{
Assert( dynamic_cast<CAI_Hint *>(pTestHint) != NULL );
++visited;
if ( pTestHint->HintMatchesCriteria( pNPC, hintCriteria, position, &flBestDistance ) )
{
#if defined( HINT_PROFILING )
Msg( "fast result visited %d\n", visited );
#endif
return pTestHint;
}
}
}
}
// Longer search, reset best distance
flBestDistance = MAX_TRACE_LENGTH;
for ( int listNum = 0; listNum < listCount; ++listNum )
{
CAIHintVector *list = lists[ listNum ];
count = list->Count();
// -------------------------------------------
// If we have no hints, bail
// -------------------------------------------
if ( !count )
continue;
// Now loop till we find a valid hint or return to the start
for ( i = 0 ; i < count; ++i )
{
pTestHint = list->Element( i );
Assert( pTestHint );
++visited;
Assert( dynamic_cast<CAI_Hint *>(pTestHint) != NULL );
if ( pTestHint->HintMatchesCriteria( pNPC, hintCriteria, position, &flBestDistance, false, bIgnoreHintType ) )
{
// If we were searching for the nearest, just note that this is now the nearest node
if ( lookingForNearest )
{
pBestHint = pTestHint;
}
else
{
// If we're not looking for the nearest, we're done
CAI_HintManager::AddFoundHint( pTestHint );
#if defined( HINT_PROFILING )
Msg( "visited %d\n", visited );
#endif
return pTestHint;
}
}
}
}
// Return the nearest node that we found
if ( pBestHint )
{
CAI_HintManager::AddFoundHint( pBestHint );
}
#if defined( HINT_PROFILING )
timer.End();
Msg( "visited %d\n", visited );
if ( !pBestHint )
{
Msg( "%i search failed for [%d] at pos %.3f %.3f %.3f [%.4f msec ~ %.4f msec per node]\n",
gpGlobals->tickcount,
pNPC ? pNPC->entindex() : -1,
position.x, position.y, position.z,
timer.GetDuration().GetMillisecondsF(),
timer.GetDuration().GetMillisecondsF()/MAX( (float)visited, 1.0f ) );
}
#endif
return pBestHint;
}
//-----------------------------------------------------------------------------
// Purpose: Searches for a hint node that this NPC cares about. If one is
// claims that hint node for this NPC so that no other NPCs
// try to use it.
//
// Input : nFlags - Search criterea. Can currently be one or more of the following:
// bits_HINT_NODE_VISIBLE - searches for visible hint nodes.
// bits_HINT_NODE_RANDOM - calls through the FindHintRandom and builds list of all matching
// nodes and picks randomly from among them. Note: Depending on number of hint nodes, this
// could be slower, so use with care.
//
// Output : Returns pointer to hint node if available hint node was found that matches the
// given criterea that this NPC also cares about. Otherwise, returns NULL
//-----------------------------------------------------------------------------
CAI_Hint* CAI_HintManager::FindHint( CAI_BaseNPC *pNPC, Hint_e nHintType, int nFlags, float flMaxDist, const Vector *pMaxDistFrom )
{
assert( pNPC != NULL );
if ( pNPC == NULL )
return NULL;
CHintCriteria hintCriteria;
hintCriteria.SetHintType( nHintType );
hintCriteria.SetFlag( nFlags );
// Using the NPC's hint group?
if ( nFlags & bits_HINT_NODE_USE_GROUP )
{
hintCriteria.SetGroup( pNPC->GetHintGroup() );
}
// Add the search position
Vector vecPosition = ( pMaxDistFrom != NULL ) ? (*pMaxDistFrom) : pNPC->GetAbsOrigin();
hintCriteria.AddIncludePosition( vecPosition, flMaxDist );
// If asking for a random node, use random logic instead
if ( nFlags & bits_HINT_NODE_RANDOM )
return FindHintRandom( pNPC, vecPosition, hintCriteria );
return FindHint( pNPC, vecPosition, hintCriteria );
}
//-----------------------------------------------------------------------------
// Purpose: Position only search
// Output : CAI_Hint
//-----------------------------------------------------------------------------
CAI_Hint *CAI_HintManager::FindHint( const Vector &position, const CHintCriteria &hintCriteria )
{
return FindHint( NULL, position, hintCriteria );
}
//-----------------------------------------------------------------------------
// Purpose: NPC only search
// Output : CAI_Hint
//-----------------------------------------------------------------------------
CAI_Hint *CAI_HintManager::FindHint( CAI_BaseNPC *pNPC, const CHintCriteria &hintCriteria )
{
assert( pNPC != NULL );
if ( pNPC == NULL )
return NULL;
return FindHint( pNPC, pNPC->GetAbsOrigin(), hintCriteria );
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
CAI_Hint* CAI_HintManager::CreateHint( HintNodeData *pNodeData, const char *pMapData )
{
// Reset last found hint if new node is added
CAI_HintManager::ResetFoundHints();
CAI_Hint *pHint = (CAI_Hint*)CreateEntityByName("ai_hint");
if ( pHint )
{
// First, parse the mapdata chunk we were passed
if ( pMapData )
{
CEntityMapData entData( (char*)pMapData );
pHint->ParseMapData( &entData );
// Restore the desired classname (parsing the mapdata stomps it)
pHint->SetClassname( "ai_hint" );
}
pHint->SetName( pNodeData->strEntityName );
pHint->SetAbsOrigin( pNodeData->vecPosition );
memcpy( &(pHint->m_NodeData), pNodeData, sizeof(HintNodeData) );
DispatchSpawn( pHint );
return pHint;
}
return NULL;
}
//------------------------------------------------------------------------------
void CAI_HintManager::AddHint( CAI_Hint *pHint )
{
// ---------------------------------
// Add to linked list of hints
// ---------------------------------
CAI_HintManager::gm_AllHints.AddToTail( pHint );
CAI_HintManager::AddHintByType( pHint );
}
void CAI_Hint::SetHintType( int hintType, bool force /*= false*/ )
{
if ( !force && hintType == m_NodeData.nHintType )
return;
CAI_HintManager::RemoveHintByType( this );
m_NodeData.nHintType = hintType;
CAI_HintManager::AddHintByType( this );
}
void CAI_HintManager::AddHintByType( CAI_Hint *pHint )
{
Hint_e type = pHint->HintType();
int slot = CAI_HintManager::gm_TypedHints.Find( type );
if ( slot == CAI_HintManager::gm_TypedHints.InvalidIndex() )
{
slot = CAI_HintManager::gm_TypedHints.Insert( type);
}
CAI_HintManager::gm_TypedHints[ slot ].AddToTail( pHint );
}
void CAI_HintManager::RemoveHintByType( CAI_Hint *pHintToRemove )
{
int slot = CAI_HintManager::gm_TypedHints.Find( pHintToRemove->HintType() );
if ( slot != CAI_HintManager::gm_TypedHints.InvalidIndex() )
{
CAI_HintManager::gm_TypedHints[ slot ].FindAndRemove( pHintToRemove );
}
}
//------------------------------------------------------------------------------
void CAI_HintManager::RemoveHint( CAI_Hint *pHintToRemove )
{
// --------------------------------------
// Remove from linked list of hints
// --------------------------------------
gm_AllHints.FindAndRemove( pHintToRemove );
RemoveHintByType( pHintToRemove );
if ( CAI_HintManager::IsInFoundHintList( pHintToRemove ) )
{
CAI_HintManager::ResetFoundHints();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *token -
// Output : int
//-----------------------------------------------------------------------------
int CAI_HintManager::GetFlags( const char *token )
{
int len = strlen( token );
if ( len <= 0 )
{
return bits_HINT_NODE_NONE;
}
char *lowercase = (char *)_alloca( len + 1 );
Q_strncpy( lowercase, token, len+1 );
strlwr( lowercase );
if ( strstr( "none", lowercase ) )
{
return bits_HINT_NODE_NONE;
}
int bits = 0;
if ( strstr( "visible", lowercase ) )
{
bits |= bits_HINT_NODE_VISIBLE;
}
if ( strstr( "nearest", lowercase ) )
{
bits |= bits_HINT_NODE_NEAREST;
}
if ( strstr( "random", lowercase ) )
{
bits |= bits_HINT_NODE_RANDOM;
}
// Can't be nearest and random, defer to nearest
if ( ( bits & bits_HINT_NODE_NEAREST ) &&
( bits & bits_HINT_NODE_RANDOM ) )
{
// Remove random
bits &= ~bits_HINT_NODE_RANDOM;
DevMsg( "HINTFLAGS:%s, inconsistent, the nearest node is never a random hint node, treating as nearest request!\n",
token );
}
return bits;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CAI_Hint *CAI_HintManager::GetFirstHint( AIHintIter_t *pIter )
{
if ( !gm_AllHints.Count() )
{
*pIter = (AIHintIter_t)(intp)gm_AllHints.InvalidIndex();
return NULL;
}
*pIter = (AIHintIter_t)0;
return gm_AllHints[0];
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CAI_Hint *CAI_HintManager::GetNextHint( AIHintIter_t *pIter )
{
if ( (intp)*pIter != gm_AllHints.InvalidIndex() )
{
intp i = ( (intp)*pIter ) + 1;
if ( gm_AllHints.Count() <= i )
{
*pIter = (AIHintIter_t)(intp)gm_AllHints.InvalidIndex();
return NULL;
}
*pIter = (AIHintIter_t)i;
return gm_AllHints[i];
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_HintManager::DumpHints()
{
AIHintIter_t iter;
CAI_Hint *pCurHint = GetFirstHint( &iter );
while (pCurHint)
{
const Vector &v = pCurHint->GetAbsOrigin();
Msg( "(%.1f, %.1f, %.1f) -- Node ID: %d; WC id %d; type %d\n",
v.x, v.y, v.z,
pCurHint->GetNodeId(),
pCurHint->GetWCId(),
pCurHint->HintType() );
pCurHint = GetNextHint( &iter );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_HintManager::ValidateHints()
{
#ifdef _DEBUG
int nTyped = 0;
FOR_EACH_VEC( gm_AllHints, i )
{
Assert( dynamic_cast<CAI_Hint *>(gm_AllHints[i]) != NULL );
}
for ( int i = gm_TypedHints.FirstInorder(); i != gm_TypedHints.InvalidIndex(); i = gm_TypedHints.NextInorder( i ) )
{
FOR_EACH_VEC( gm_TypedHints[i], j )
{
nTyped++;
Assert( dynamic_cast<CAI_Hint *>(gm_TypedHints[i][j]) != NULL );
}
}
Assert( gm_AllHints.Count() == nTyped );
#endif
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CAI_HintManager::DrawHintOverlays(float flDrawDuration)
{
int c = gm_AllHints.Count();
for ( int i = 0; i < c; ++i )
{
CAI_Hint *pHint = gm_AllHints[ i ];
int r = 0;
int g = 0;
int b = 255;
Vector vHintPos;
if (pHint->m_NodeData.nNodeID != NO_NODE)
{
vHintPos = g_pBigAINet->GetNode(pHint->m_NodeData.nNodeID)->GetPosition(g_pAINetworkManager->GetEditOps()->m_iHullDrawNum);
}
else
{
vHintPos = pHint->GetAbsOrigin();
}
if ( pHint->GetNodeId() != NO_NODE )
NDebugOverlay::Text( vHintPos + Vector(0,6,8), CFmtStr("(%d), (%d)", pHint->HintType(), pHint->GetNodeId()), true, flDrawDuration );
else
NDebugOverlay::Text( vHintPos + Vector(0,6,8), CFmtStr("(%d)", pHint->HintType()), true, flDrawDuration );
// If node is currently locked
if (pHint->m_NodeData.iDisabled)
{
r = 100;
g = 100;
b = 100;
}
else if (pHint->m_hHintOwner != NULL)
{
r = 255;
g = 0;
b = 0;
CBaseEntity* pOwner = pHint->User();
if (pOwner)
{
char owner[255];
Q_strncpy(owner,pOwner->GetDebugName(),sizeof(owner));
Vector loc = vHintPos;
loc.x+=6;
loc.y+=6;
loc.z+=6;
NDebugOverlay::Text( loc, owner, true, flDrawDuration );
NDebugOverlay::Line( vHintPos, pOwner->WorldSpaceCenter(), 128, 128, 128, false, 0);
}
}
else if (pHint->IsLocked())
{
r = 200;
g = 150;
b = 10;
}
NDebugOverlay::Box(vHintPos, Vector(-3,-3,-3), Vector(3,3,3), r,g,b,0,flDrawDuration);
// Draw line in facing direction
Vector offsetDir = 12.0 * Vector(cos(DEG2RAD(pHint->Yaw())),sin(DEG2RAD(pHint->Yaw())),0);
NDebugOverlay::Line(vHintPos, vHintPos+offsetDir, r,g,b,false,flDrawDuration);
}
}
//##################################################################
// > CAI_Hint
//##################################################################
LINK_ENTITY_TO_CLASS( ai_hint, CAI_Hint );
BEGIN_DATADESC( CAI_Hint )
DEFINE_EMBEDDED( m_NodeData ),
// m_nTargetNodeID (reset on load)
DEFINE_FIELD( m_hHintOwner, FIELD_EHANDLE),
DEFINE_FIELD( m_flNextUseTime, FIELD_TIME),
DEFINE_FIELD( m_vecForward, FIELD_VECTOR),
DEFINE_KEYFIELD( m_nodeFOV, FIELD_FLOAT, "nodeFOV" ),
DEFINE_THINKFUNC( EnableThink ),
// Inputs
DEFINE_INPUTFUNC( FIELD_VOID, "EnableHint", InputEnableHint ),
DEFINE_INPUTFUNC( FIELD_VOID, "DisableHint", InputDisableHint ),
// Outputs
DEFINE_OUTPUT( m_OnNPCStartedUsing, "OnNPCStartedUsing" ),
DEFINE_OUTPUT( m_OnNPCStoppedUsing, "OnNPCStoppedUsing" ),
END_DATADESC( );
//------------------------------------------------------------------------------
// Purpose :
//------------------------------------------------------------------------------
void CAI_Hint::InputEnableHint( inputdata_t &inputdata )
{
m_NodeData.iDisabled = false;
}
//------------------------------------------------------------------------------
// Purpose :
//------------------------------------------------------------------------------
void CAI_Hint::InputDisableHint( inputdata_t &inputdata )
{
m_NodeData.iDisabled = true;
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void CAI_Hint::Spawn( void )
{
// Cache off the forward vector
GetVectors( &m_vecForward, NULL, NULL );
if( m_nodeFOV != 360 )
{
// As a micro-optimization, leave the FOV at 360 to save us
// a dot product later when checking node FOV.
m_nodeFOV = cos( DEG2RAD(m_nodeFOV/2) );
}
SetSolid( SOLID_NONE );
}
void CAI_Hint::Activate()
{
BaseClass::Activate();
CAI_HintManager::AddHint( this );
}
void CAI_Hint::UpdateOnRemove( void )
{
CAI_HintManager::RemoveHint( this );
BaseClass::UpdateOnRemove();
}
//------------------------------------------------------------------------------
// Purpose : If connected to a node returns node position, otherwise
// returns local hint position
//
// NOTE: Assumes not using multiple AI networks
// Input :
// Output :
//------------------------------------------------------------------------------
void CAI_Hint::GetPosition(CBaseCombatCharacter *pBCC, Vector *vPosition)
{
if ( m_NodeData.nNodeID != NO_NODE )
{
*vPosition = g_pBigAINet->GetNodePosition( pBCC, m_NodeData.nNodeID );
}
else
{
*vPosition = GetAbsOrigin();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : hull -
// *vPosition -
//-----------------------------------------------------------------------------
void CAI_Hint::GetPosition( Hull_t hull, Vector *vPosition )
{
if ( m_NodeData.nNodeID != NO_NODE )
{
*vPosition = g_pBigAINet->GetNodePosition( hull, m_NodeData.nNodeID );
}
else
{
*vPosition = GetAbsOrigin();
}
}
//------------------------------------------------------------------------------
// Purpose : If connected to a node returns node direction, otherwise
// returns local hint direction
//
// NOTE: Assumes not using multiple AI networks
// Input :
// Output :
//------------------------------------------------------------------------------
Vector CAI_Hint::GetDirection( )
{
return UTIL_YawToVector( Yaw() );
}
//------------------------------------------------------------------------------
// Purpose : If connected to a node returns node yaw, otherwise
// returns local hint yaw
//
// NOTE: Assumes not using multiple AI networks
// Input :
// Output :
//------------------------------------------------------------------------------
float CAI_Hint::Yaw(void)
{
if (m_NodeData.nNodeID != NO_NODE)
{
return g_pBigAINet->GetNodeYaw(m_NodeData.nNodeID );
}
else
{
return GetLocalAngles().y;
}
}
//------------------------------------------------------------------------------
// Purpose : Returns if this is something that's interesting to look at
//
// NOTE: Assumes not using multiple AI networks
// Input :
// Output :
//------------------------------------------------------------------------------
bool CAI_Hint::IsViewable(void)
{
if (m_NodeData.iDisabled)
{
return false;
}
switch( HintType() )
{
case HINT_WORLD_VISUALLY_INTERESTING:
case HINT_WORLD_VISUALLY_INTERESTING_DONT_AIM:
case HINT_WORLD_VISUALLY_INTERESTING_STEALTH:
return true;
}
return false;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CAI_Hint::IsInNodeFOV( CBaseEntity *pOther )
{
if( m_nodeFOV == 360 )
{
return true;
}
#if 0
NDebugOverlay::Line( GetAbsOrigin(), GetAbsOrigin() + m_vecForward * 16, 255, 255, 0, false, 1 );
#endif
Vector vecToNPC = pOther->GetAbsOrigin() - GetAbsOrigin();
VectorNormalize( vecToNPC );
float flDot = DotProduct( vecToNPC, m_vecForward );
if( flDot > m_nodeFOV )
{
#if 0
NDebugOverlay::Line( GetAbsOrigin(), pOther->GetAbsOrigin(), 0, 255, 0, false, 1 );
#endif
return true;
}
#if 0
NDebugOverlay::Line( GetAbsOrigin(), pOther->GetAbsOrigin(), 255, 0, 0, false, 1 );
#endif
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Locks the node for use by an AI for hints
// Output : Returns true if the node was available for locking, false on failure.
//-----------------------------------------------------------------------------
bool CAI_Hint::Lock( CBaseEntity* pNPC )
{
if ( m_hHintOwner != pNPC && m_hHintOwner != NULL )
return false;
m_hHintOwner = pNPC;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Unlocks the node, making it available for hint use by other AIs.
// after the given delay time
//-----------------------------------------------------------------------------
void CAI_Hint::Unlock( float delay )
{
m_hHintOwner = NULL;
m_flNextUseTime = gpGlobals->curtime + delay;
}
//-----------------------------------------------------------------------------
// Purpose: Returns true is hint node is open for use
// Input :
// Output :
//-----------------------------------------------------------------------------
bool CAI_Hint::IsLockedBy( CBaseEntity *pNPC )
{
return (m_hHintOwner == pNPC);
};
//-----------------------------------------------------------------------------
// Purpose: Returns true is hint node is open for use
// Input :
// Output :
//-----------------------------------------------------------------------------
bool CAI_Hint::IsLocked( void )
{
if (m_NodeData.iDisabled)
{
return true;
}
if (gpGlobals->curtime < m_flNextUseTime)
{
return true;
}
if (m_hHintOwner != NULL)
{
return true;
}
return false;
};
//-----------------------------------------------------------------------------
// Purpose: Return true if pTestHint passes the criteria specified in hintCriteria
//-----------------------------------------------------------------------------
bool CAI_Hint::HintMatchesCriteria( CAI_BaseNPC *pNPC, const CHintCriteria &hintCriteria, const Vector &position, float *flNearestDistance, bool bIgnoreLock, bool bIgnoreHintType )
{
// Cannot be locked
if ( !bIgnoreLock && IsLocked() )
{
REPORTFAILURE( "Node is locked." );
return false;
}
if ( !bIgnoreHintType && !hintCriteria.MatchesHintType( HintType() ) )
{
return false;
}
if ( GetMinState() > NPC_STATE_IDLE || GetMaxState() < NPC_STATE_COMBAT )
{
if ( pNPC && ( pNPC->GetState() < GetMinState() || pNPC->GetState() > GetMaxState() ) )
{
REPORTFAILURE( "NPC not in correct state." );
return false;
}
}
// See if we're filtering by group name
if ( hintCriteria.GetGroup() != NULL_STRING )
{
AssertIsValidString( GetGroup() );
AssertIsValidString( hintCriteria.GetGroup() );
if ( GetGroup() == NULL_STRING || GetGroup() != hintCriteria.GetGroup() )
{
Assert(GetGroup() == NULL_STRING || strcmp( STRING(GetGroup()), STRING(hintCriteria.GetGroup())) != 0 );
REPORTFAILURE( "Doesn't match NPC hint group." );
return false;
}
}
// If we're watching for include zones, test it
if ( ( hintCriteria.HasIncludeZones() ) && ( hintCriteria.InIncludedZone( GetAbsOrigin() ) == false ) )
{
REPORTFAILURE( "Not inside include zones." );
return false;
}
// If we're watching for exclude zones, test it
if ( ( hintCriteria.HasExcludeZones() ) && ( hintCriteria.InExcludedZone( GetAbsOrigin() ) ) )
{
REPORTFAILURE( "Inside exclude zones." );
return false;
}
// See if the class handles this hint type
if ( ( pNPC != NULL ) && ( pNPC->FValidateHintType( this ) == false ) )
{
REPORTFAILURE( "NPC doesn't know how to handle that type." );
return false;
}
if ( hintCriteria.HasFlag(bits_HINT_NPC_IN_NODE_FOV) )
{
if ( pNPC == NULL )
{
AssertMsg(0,"Hint node attempted to verify NPC in node FOV without NPC!\n");
}
else
{
if( !IsInNodeFOV(pNPC) )
{
REPORTFAILURE( "NPC Not in hint's FOV" );
return false;
}
}
}
if ( hintCriteria.HasFlag( bits_HINT_NODE_IN_AIMCONE ) )
{
if ( pNPC == NULL )
{
AssertMsg( 0, "Hint node attempted to find node in aimcone without specifying NPC!\n" );
}
else
{
if( !pNPC->FInAimCone( GetAbsOrigin() ) )
{
REPORTFAILURE( "Hint isn't in NPC's aimcone" );
return false;
}
}
}
if ( hintCriteria.HasFlag( bits_HINT_NODE_IN_VIEWCONE ) )
{
if ( pNPC == NULL )
{
AssertMsg( 0, "Hint node attempted to find node in viewcone without specifying NPC!\n" );
}
else
{
if( !pNPC->FInViewCone( this ) )
{
REPORTFAILURE( "Hint isn't in NPC's viewcone" );
return false;
}
}
}
if ( hintCriteria.HasFlag( bits_HINT_NOT_CLOSE_TO_ENEMY ) )
{
if ( pNPC == NULL )
{
AssertMsg( 0, "Hint node attempted to find node not close to enemy without specifying NPC!\n" );
}
else
{
if( pNPC->GetEnemy() )
{
float flDistHintToEnemySqr = GetAbsOrigin().DistToSqr( pNPC->GetEnemy()->GetAbsOrigin() ) ;
if( flDistHintToEnemySqr < Square( 30.0f * 12.0f ) )
{
REPORTFAILURE( "Hint takes NPC close to Enemy" );
return false;
}
}
}
}
{
AI_PROFILE_SCOPE( HINT_FVisible );
// See if we're requesting a visible node
if ( hintCriteria.HasFlag( bits_HINT_NODE_VISIBLE ) )
{
if ( pNPC == NULL )
{
//NOTENOTE: If you're hitting this, you've asked for a visible node without specifing an NPC!
AssertMsg( 0, "Hint node attempted to find visible node without specifying NPC!\n" );
}
else
{
if( m_NodeData.nNodeID == NO_NODE )
{
// This is just an info_hint, not a node.
if( !pNPC->FVisible( this ) )
{
REPORTFAILURE( "Hint isn't visible to NPC." );
return false;
}
}
else
{
// This hint associated with a node.
trace_t tr;
Vector vHintPos;
GetPosition(pNPC,&vHintPos);
AI_TraceLine ( pNPC->EyePosition(), vHintPos + pNPC->GetViewOffset(), MASK_NPCSOLID_BRUSHONLY, pNPC, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0f )
{
REPORTFAILURE( "Node isn't visible to NPC." );
return false;
}
}
}
}
}
// Check for clear if requested
if ( hintCriteria.HasFlag( bits_HINT_NODE_CLEAR ) )
{
if ( pNPC == NULL )
{
//NOTENOTE: If you're hitting this, you've asked for a clear node without specifing an NPC!
AssertMsg( 0, "Hint node attempted to find clear node without specifying NPC!\n" );
}
else
{
trace_t tr;
// Can my bounding box fit there?
AI_TraceHull ( GetAbsOrigin(), GetAbsOrigin(), pNPC->WorldAlignMins(), pNPC->WorldAlignMaxs(),
MASK_SOLID, pNPC, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0 )
{
REPORTFAILURE( "Node isn't clear." );
return false;
}
}
}
// See if this is our next, closest node
if ( hintCriteria.HasFlag( bits_HINT_NODE_NEAREST ) )
{
Assert( flNearestDistance );
// Calculate our distance
float distance = (GetAbsOrigin() - position).Length();
// Must be closer than the current best
if ( distance > *flNearestDistance )
{
REPORTFAILURE( "Not the nearest node." );
return false;
}
// Remember the distance
*flNearestDistance = distance;
}
if ( hintCriteria.HasFlag(bits_HINT_HAS_LOS_TO_PLAYER|bits_HAS_EYEPOSITION_LOS_TO_PLAYER) )
{
CBasePlayer *pPlayer = AI_GetSinglePlayer();
if( pPlayer != NULL )
{
Vector vecDest = GetAbsOrigin();
if( hintCriteria.HasFlag(bits_HAS_EYEPOSITION_LOS_TO_PLAYER) )
{
vecDest += pNPC->GetDefaultEyeOffset();
}
if( !pPlayer->FVisible(vecDest) )
{
REPORTFAILURE( "Do not have LOS to player" );
return false;
}
}
}
// Must either be visible or not if requested
if ( hintCriteria.HasFlag( bits_HINT_NODE_NOT_VISIBLE_TO_PLAYER|bits_HINT_NODE_VISIBLE_TO_PLAYER ) )
{
bool bWasSeen = false;
// Test all potential seers
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex(i);
if ( pPlayer )
{
// Only spawn if the player's looking away from me
Vector vLookDir = pPlayer->EyeDirection3D();
Vector vTargetDir = GetAbsOrigin() - pPlayer->EyePosition();
VectorNormalize(vTargetDir);
float fDotPr = DotProduct(vLookDir,vTargetDir);
if ( fDotPr > 0 )
{
trace_t tr;
UTIL_TraceLine( pPlayer->EyePosition(), GetAbsOrigin(), MASK_SOLID_BRUSHONLY, pPlayer, COLLISION_GROUP_NONE, &tr);
if ( tr.fraction == 1.0 )
{
if ( hintCriteria.HasFlag( bits_HINT_NODE_NOT_VISIBLE_TO_PLAYER ) )
{
REPORTFAILURE( "Node is visible to player." );
return false;
}
bWasSeen = true;
}
}
}
}
if ( !bWasSeen && hintCriteria.HasFlag( bits_HINT_NODE_VISIBLE_TO_PLAYER ) )
{
REPORTFAILURE( "Node isn't visible to player." );
return false;
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Draw any debug text overlays
// Input :
// Output : Current text offset from the top
//-----------------------------------------------------------------------------
int CAI_Hint::DrawDebugTextOverlays(void)
{
int text_offset = BaseClass::DrawDebugTextOverlays();
if (m_debugOverlays & OVERLAY_TEXT_BIT)
{
char tempstr[512];
Q_snprintf(tempstr,sizeof(tempstr),"%s (%i)", GetHintTypeDescription( HintType() ), HintType());
EntityText(text_offset,tempstr,0);
text_offset++;
Q_snprintf(tempstr,sizeof(tempstr),"delay %f", MAX( 0.0f, m_flNextUseTime - gpGlobals->curtime ) ) ;
EntityText(text_offset,tempstr,0);
text_offset++;
if ( m_NodeData.iDisabled )
{
Q_snprintf(tempstr,sizeof(tempstr),"DISABLED" );
EntityText(text_offset,tempstr,0);
text_offset++;
}
}
return text_offset;
}
//-----------------------------------------------------------------------------
// Purpose: Constructor
// Input :
// Output :
//-----------------------------------------------------------------------------
CAI_Hint::CAI_Hint(void)
{
m_flNextUseTime = 0;
m_nTargetNodeID = NO_NODE;
}
//-----------------------------------------------------------------------------
// Purpose: Destructor
// Input :
// Output :
//-----------------------------------------------------------------------------
CAI_Hint::~CAI_Hint(void)
{
}
//-----------------------------------------------------------------------------
// Purpose: Sometimes FValidateHint, etc. will want to examine the underlying node to
// see if it's truly suitable ( e.g., in the same air/ground network of nodes? )
// Output : C_AINode *
//-----------------------------------------------------------------------------
CAI_Node *CAI_Hint::GetNode( void )
{
if ( m_NodeData.nNodeID != NO_NODE )
{
return g_pBigAINet->GetNode( m_NodeData.nNodeID, false );
}
return NULL;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CAI_Hint::DisableForSeconds( float flSeconds )
{
Unlock( flSeconds );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CAI_Hint::EnableThink()
{
SetDisabled( false );
SetThink( NULL );
}
void CAI_Hint::FixupTargetNode()
{
if ( m_NodeData.nTargetWCNodeID != -1 )
m_nTargetNodeID = g_pAINetworkManager->GetEditOps()->GetNodeIdFromWCId( m_NodeData.nTargetWCNodeID );
else
m_nTargetNodeID = NO_NODE;
}
void CAI_Hint::OnRestore()
{
BaseClass::OnRestore();
m_NodeData.nNodeID = g_pAINetworkManager->GetEditOps()->GetNodeIdFromWCId( m_NodeData.nWCNodeID );
FixupTargetNode();
CAI_Node *pNode = GetNode();
if ( !pNode )
{
if ( m_NodeData.nWCNodeID > 0 )
DevMsg("Warning: AI hint has incorrect or no AI node\n");
}
else
{
m_NodeData.vecPosition = pNode->GetOrigin();
Teleport( &m_NodeData.vecPosition, NULL, NULL );
pNode->SetHint( this );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_Hint::NPCStartedUsing( CAI_BaseNPC *pNPC )
{
m_OnNPCStartedUsing.Set( pNPC, pNPC, this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_Hint::NPCStoppedUsing( CAI_BaseNPC *pNPC )
{
m_OnNPCStoppedUsing.Set( pNPC, pNPC, this );
}
CON_COMMAND(ai_dump_hints, "")
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
CAI_HintManager::ValidateHints();
CAI_HintManager::DumpHints();
}
//-----------------------------------------------------------------------------
//
// hints - these MUST coincide with the HINTS listed under Hint_e
//
//-----------------------------------------------------------------------------
struct hinttypedescs_t
{
Hint_e iType;
const char *pszDesc;
};
hinttypedescs_t g_pszHintDescriptions[] =
{
{ HINT_NONE, "None" },
//{ HINT_NOT_USED_WORLD_DOOR, "Obsolete / Unused" },
{ HINT_WORLD_WINDOW, "World: Window" },
//{ HINT_NOT_USED_WORLD_BUTTON, "Obsolete / Unused" },
//{ HINT_NOT_USED_WORLD_MACHINERY, "Obsolete / Unused" },
//{ HINT_NOT_USED_WORLD_LEDGE, "Obsolete / Unused" },
//{ HINT_NOT_USED_WORLD_LIGHT_SOURCE, "Obsolete / Unused" },
//{ HINT_NOT_USED_WORLD_HEAT_SOURCE, "Obsolete / Unused" },
//{ HINT_NOT_USED_WORLD_BLINKING_LIGHT, "Obsolete / Unused" },
//{ HINT_NOT_USED_WORLD_BRIGHT_COLORS, "Obsolete / Unused" },
//{ HINT_NOT_USED_WORLD_HUMAN_BLOOD, "Obsolete / Unused" },
//{ HINT_NOT_USED_WORLD_ALIEN_BLOOD, "Obsolete / Unused" },
{ HINT_WORLD_WORK_POSITION, "Act Busy" },
{ HINT_WORLD_VISUALLY_INTERESTING, "World: Visually Interesting" },
{ HINT_WORLD_VISUALLY_INTERESTING_DONT_AIM, "World: Visually Interesting (Don't Aim)" },
{ HINT_WORLD_INHIBIT_COMBINE_MINES, "World: Inhibit Combine Mines" },
{ HINT_WORLD_VISUALLY_INTERESTING_STEALTH, "World: Visually Interesting (Stealth)" },
{ HINT_TACTICAL_COVER_MED, "Tactical: Cover Medium" },
{ HINT_TACTICAL_COVER_LOW, "Tactical: Cover Low" },
{ HINT_TACTICAL_SPAWN, "Tactical: Spawn" },
{ HINT_TACTICAL_PINCH, "Tactical: Pinch" },
//{ HINT_NOT_USED_TACTICAL_GUARD, "Obsolete / Unused" },
{ HINT_TACTICAL_ENEMY_DISADVANTAGED, "Tactical: Enemy Disadvantage" },
//{ HINT_NOT_USED_HEALTH_KIT, "Obsolete / Unused" },
//{ HINT_NOT_USED_URBAN_STREETCORNER, "Obsolete / Unused" },
//{ HINT_NOT_USED_URBAN_STREETLAMP, "Obsolete / Unused" },
//{ HINT_NOT_USED_URBAN_DARK_SPOT, "Obsolete / Unused" },
//{ HINT_NOT_USED_URBAN_POSTER, "Obsolete / Unused" },
//{ HINT_NOT_USED_URBAN_SHELTER, "Obsolete / Unused" },
//{ HINT_NOT_USED_ASSASSIN_SECLUDED, "Obsolete / Unused" },
//{ HINT_NOT_USED_ASSASSIN_RAFTERS, "Obsolete / Unused" },
//{ HINT_NOT_USED_ASSASSIN_GROUND, "Obsolete / Unused" },
//{ HINT_NOT_USED_ASSASSIN_MONKEYBARS, "Obsolete / Unused" },
{ HINT_ANTLION_BURROW_POINT, "Antlion: Burrow Point" },
{ HINT_ANTLION_THUMPER_FLEE_POINT, "Antlion: Thumper Flee Point" },
//{ HINT_HEADCRAB_BURROW_POINT, "Obsolete / Unused" },
//{ HINT_NOT_USED_ROLLER_PATROL_POINT, "Obsolete / Unused" },
//{ HINT_NOT_USED_ROLLER_CLEANUP_POINT, "Obsolete / Unused" },
//{ HINT_NOT_USED_PSTORM_ROCK_SPAWN, "Obsolete / Unused" },
{ HINT_CROW_FLYTO_POINT, "Crow: Flyto Point" },
//{ HINT_BUG_PATROL_POINT, "Obsolete / Unused" },
{ HINT_FOLLOW_WAIT_POINT, "Follow: Wait Point" },
{ HINT_JUMP_OVERRIDE, "Jump Override" },
{ HINT_PLAYER_SQUAD_TRANSITON_POINT, "Squad Transition Point" },
{ HINT_NPC_EXIT_POINT, "Act Busy: Exit Point" },
{ HINT_STRIDER_NODE, "Strider" },
{ HINT_PLAYER_ALLY_MOVE_AWAY_DEST, "Ally MoveAway Point" },
{ HINT_HL1_WORLD_MACHINERY, "HL1: World: Machinery" },
{ HINT_HL1_WORLD_BLINKING_LIGHT, "HL1: World: Blinking Light" },
{ HINT_HL1_WORLD_HUMAN_BLOOD, "HL1: World: Human Blood" },
{ HINT_HL1_WORLD_ALIEN_BLOOD, "HL1: World: Alien Blood" },
{ HINT_CSTRIKE_HOSTAGE_ESCAPE, "CS Port: Hostage Escape" },
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *GetHintTypeDescription( Hint_e iHintType )
{
for ( int i = 0; i < ARRAYSIZE(g_pszHintDescriptions); i++ )
{
if ( g_pszHintDescriptions[i].iType == iHintType )
return g_pszHintDescriptions[i].pszDesc;
}
return "Obsolete / Unused";
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *GetHintTypeDescription( CAI_Hint *pHint )
{
return GetHintTypeDescription( pHint->HintType() );
}
//-----------------------------------------------------------------------------
// Purpose: Debug command to drop hints into the world
//-----------------------------------------------------------------------------
void CC_ai_drop_hint( const CCommand &args )
{
CBasePlayer *pPlayer = ToBasePlayer( UTIL_GetCommandClient() );
if ( !pPlayer )
return;
if ( args.ArgC() < 2 )
{
Msg("Invalid hint type specified. Format: ai_drop_hint <hint type>\nValid hint types:\n");
for ( int i = 0; i < ARRAYSIZE(g_pszHintDescriptions); i++ )
{
Msg("%d : %s\n", g_pszHintDescriptions[i].iType, g_pszHintDescriptions[i].pszDesc );
}
return;
}
HintNodeData nodeData;
nodeData.strEntityName = MAKE_STRING("ai_drop_hint");
nodeData.vecPosition = pPlayer->EyePosition();
nodeData.nHintType = atoi( args[1] );
nodeData.nNodeID = NO_NODE;
nodeData.strGroup = NULL_STRING;
nodeData.iDisabled = false;
nodeData.iszActivityName = NULL_STRING;
nodeData.fIgnoreFacing = HIF_DEFAULT;
nodeData.minState = NPC_STATE_IDLE;
nodeData.maxState = NPC_STATE_COMBAT;
CAI_Hint *pHint = CAI_HintManager::CreateHint( &nodeData, NULL );
if ( pHint )
{
((CBaseEntity *)pHint)->Activate();
pHint->KeyValue( "nodeFOV", "360" );
pHint->m_debugOverlays |= (OVERLAY_TEXT_BIT | OVERLAY_BBOX_BIT);
}
}
ConCommand ai_drop_hint( "ai_drop_hint", CC_ai_drop_hint, "Drop an ai_hint at the player's current eye position.", FCVAR_CHEAT );
Reference in New Issue View Git Blame Copy Permalink