d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
128 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 5b926feae6
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5b926feae6'
${ noResults }
source-engine/game/server/ai_hint.cpp

1687 lines
48 KiB
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)gm_AllHints.InvalidIndex();
return NULL;
}
*pIter = (AIHintIter_t)0;
return gm_AllHints[0];
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CAI_Hint *CAI_HintManager::GetNextHint( AIHintIter_t *pIter )
{
if ( (int)*pIter != gm_AllHints.InvalidIndex() )
{
int i = ( (int)*pIter ) + 1;
if ( gm_AllHints.Count() <= i )
{
*pIter = (AIHintIter_t)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 );