mirror of
https://github.com/alliedmodders/hl2sdk.git
synced 2024-12-23 01:59:43 +08:00
1628 lines
44 KiB
C++
1628 lines
44 KiB
C++
//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "entitylist.h"
|
|
#include "utlvector.h"
|
|
#include "igamesystem.h"
|
|
#include "collisionutils.h"
|
|
#include "UtlSortVector.h"
|
|
#include "tier0/vprof.h"
|
|
#include "mapentities.h"
|
|
#include "client.h"
|
|
#include "ai_initutils.h"
|
|
#include "globalstate.h"
|
|
#include "datacache/imdlcache.h"
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
CBaseEntity *FindPickerEntity( CBasePlayer *pPlayer );
|
|
void SceneManager_ClientActive( CBasePlayer *player );
|
|
|
|
static CUtlVector<IServerNetworkable*> g_DeleteList;
|
|
|
|
CGlobalEntityList gEntList;
|
|
CBaseEntityList *g_pEntityList = &gEntList;
|
|
|
|
class CAimTargetManager : public IEntityListener
|
|
{
|
|
public:
|
|
// Called by CEntityListSystem
|
|
void LevelInitPreEntity()
|
|
{
|
|
gEntList.AddListenerEntity( this );
|
|
Clear();
|
|
}
|
|
void LevelShutdownPostEntity()
|
|
{
|
|
gEntList.RemoveListenerEntity( this );
|
|
Clear();
|
|
}
|
|
|
|
void Clear()
|
|
{
|
|
m_targetList.Purge();
|
|
}
|
|
|
|
void ForceRepopulateList()
|
|
{
|
|
Clear();
|
|
|
|
CBaseEntity *pEnt = gEntList.FirstEnt();
|
|
|
|
while( pEnt )
|
|
{
|
|
if( ShouldAddEntity(pEnt) )
|
|
AddEntity(pEnt);
|
|
|
|
pEnt = gEntList.NextEnt( pEnt );
|
|
}
|
|
}
|
|
|
|
bool ShouldAddEntity( CBaseEntity *pEntity )
|
|
{
|
|
return ((pEntity->GetFlags() & FL_AIMTARGET) != 0);
|
|
}
|
|
|
|
// IEntityListener
|
|
virtual void OnEntityCreated( CBaseEntity *pEntity ) {}
|
|
virtual void OnEntityDeleted( CBaseEntity *pEntity )
|
|
{
|
|
if ( !(pEntity->GetFlags() & FL_AIMTARGET) )
|
|
return;
|
|
RemoveEntity(pEntity);
|
|
}
|
|
void AddEntity( CBaseEntity *pEntity )
|
|
{
|
|
if ( pEntity->IsMarkedForDeletion() )
|
|
return;
|
|
m_targetList.AddToTail( pEntity );
|
|
}
|
|
void RemoveEntity( CBaseEntity *pEntity )
|
|
{
|
|
int index = m_targetList.Find( pEntity );
|
|
if ( m_targetList.IsValidIndex(index) )
|
|
{
|
|
m_targetList.FastRemove( index );
|
|
}
|
|
}
|
|
int ListCount() { return m_targetList.Count(); }
|
|
int ListCopy( CBaseEntity *pList[], int listMax )
|
|
{
|
|
int count = MIN(listMax, ListCount() );
|
|
memcpy( pList, m_targetList.Base(), sizeof(CBaseEntity *) * count );
|
|
return count;
|
|
}
|
|
|
|
private:
|
|
CUtlVector<CBaseEntity *> m_targetList;
|
|
};
|
|
|
|
static CAimTargetManager g_AimManager;
|
|
|
|
int AimTarget_ListCount()
|
|
{
|
|
return g_AimManager.ListCount();
|
|
}
|
|
int AimTarget_ListCopy( CBaseEntity *pList[], int listMax )
|
|
{
|
|
return g_AimManager.ListCopy( pList, listMax );
|
|
}
|
|
void AimTarget_ForceRepopulateList()
|
|
{
|
|
g_AimManager.ForceRepopulateList();
|
|
}
|
|
|
|
|
|
// used to sort the think list by nextthink
|
|
int __cdecl CompareEntityThinkTimes( const unsigned short *pIndex0, const unsigned short *pIndex1 )
|
|
{
|
|
float thinkTime0 = CBaseEntity::Instance( *pIndex0 )->GetNextThink();
|
|
float thinkTime1 = CBaseEntity::Instance( *pIndex1 )->GetNextThink();
|
|
|
|
// returns -1 if time0<time1, 1 if time0>time1, and zero if they are equal
|
|
if ( thinkTime0 > thinkTime1 )
|
|
return 1;
|
|
if ( thinkTime0 < thinkTime1 )
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
// Manages a list of all entities currently doing game simulation or thinking
|
|
// NOTE: This is usually a small subset of the global entity list, so it's
|
|
// an optimization to maintain this list incrementally rather than polling each
|
|
// frame.
|
|
class CSimThinkManager : public IEntityListener
|
|
{
|
|
public:
|
|
CSimThinkManager()
|
|
{
|
|
Clear();
|
|
}
|
|
void Clear()
|
|
{
|
|
m_simThinkList.Purge();
|
|
for ( size_t i = 0; i < ARRAYSIZE(m_entinfoIndex); i++ )
|
|
{
|
|
m_entinfoIndex[i] = 0xFFFF;
|
|
}
|
|
}
|
|
void LevelInitPreEntity()
|
|
{
|
|
gEntList.AddListenerEntity( this );
|
|
}
|
|
|
|
void LevelShutdownPostEntity()
|
|
{
|
|
gEntList.RemoveListenerEntity( this );
|
|
Clear();
|
|
}
|
|
|
|
void OnEntityCreated( CBaseEntity *pEntity )
|
|
{
|
|
Assert( m_entinfoIndex[pEntity->GetRefEHandle().GetEntryIndex()] == 0xFFFF );
|
|
}
|
|
void OnEntityDeleted( CBaseEntity *pEntity )
|
|
{
|
|
RemoveEntinfoIndex( pEntity->GetRefEHandle().GetEntryIndex() );
|
|
}
|
|
|
|
void RemoveEntinfoIndex( int index )
|
|
{
|
|
int listHandle = m_entinfoIndex[index];
|
|
// If this guy is in the active list, remove him
|
|
if ( listHandle != 0xFFFF )
|
|
{
|
|
Assert(m_simThinkList[listHandle] == index);
|
|
m_simThinkList.FastRemove( listHandle );
|
|
m_entinfoIndex[index] = 0xFFFF;
|
|
|
|
// fast remove shifted someone, update that someone
|
|
if ( listHandle < m_simThinkList.Count() )
|
|
{
|
|
m_entinfoIndex[m_simThinkList[listHandle]] = listHandle;
|
|
}
|
|
}
|
|
}
|
|
int ListCount()
|
|
{
|
|
return m_simThinkList.Count();
|
|
}
|
|
|
|
int ListCopy( CBaseEntity *pList[], int listMax )
|
|
{
|
|
int count = MIN(listMax, ListCount());
|
|
for ( int i = 0; i < count; i++ )
|
|
{
|
|
int entinfoIndex = m_simThinkList[i];
|
|
const CEntInfo *pInfo = gEntList.GetEntInfoPtrByIndex( entinfoIndex );
|
|
pList[i] = (CBaseEntity *)pInfo->m_pEntity;
|
|
Assert( gEntList.IsEntityPtr( pList[i] ) );
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
void EntityChanged( CBaseEntity *pEntity )
|
|
{
|
|
// might change after deletion, don't put back into the list
|
|
if ( pEntity->IsMarkedForDeletion() )
|
|
return;
|
|
|
|
const CBaseHandle &eh = pEntity->GetRefEHandle();
|
|
if ( !eh.IsValid() )
|
|
return;
|
|
|
|
int index = eh.GetEntryIndex();
|
|
// UNDONE: Maintain separate lists for "no think/no sim" and just "no sim"
|
|
// UNDONE: Keep "no sim" list sorted by thinktime
|
|
// UNDONE: Add query for "no sim" list that includes a time and just get ents that will think by that time
|
|
if ( pEntity->IsEFlagSet( EFL_NO_THINK_FUNCTION ) && pEntity->IsEFlagSet( EFL_NO_GAME_PHYSICS_SIMULATION ) )
|
|
{
|
|
Assert( !pEntity->IsPlayer() );
|
|
RemoveEntinfoIndex( index );
|
|
}
|
|
else
|
|
{
|
|
// already in the list? (had think or sim last time, now has both - or had both last time, now just one)
|
|
if ( m_entinfoIndex[index] == 0xFFFF )
|
|
{
|
|
MEM_ALLOC_CREDIT();
|
|
m_entinfoIndex[index] = m_simThinkList.AddToTail( (unsigned short)index );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ListSort()
|
|
{
|
|
int i;
|
|
int count = m_simThinkList.Count();
|
|
if ( !count )
|
|
return;
|
|
|
|
// sort by think time (lowest first)
|
|
m_simThinkList.Sort( CompareEntityThinkTimes );
|
|
|
|
// now remap the entindex map
|
|
for ( i = 0; i < count; i++ )
|
|
{
|
|
m_entinfoIndex[m_simThinkList[i]] = i;
|
|
}
|
|
}
|
|
private:
|
|
unsigned short m_entinfoIndex[NUM_ENT_ENTRIES];
|
|
CUtlVector<unsigned short> m_simThinkList;
|
|
};
|
|
|
|
CSimThinkManager g_SimThinkManager;
|
|
|
|
int SimThink_ListCount()
|
|
{
|
|
return g_SimThinkManager.ListCount();
|
|
}
|
|
|
|
int SimThink_ListCopy( CBaseEntity *pList[], int listMax )
|
|
{
|
|
return g_SimThinkManager.ListCopy( pList, listMax );
|
|
}
|
|
|
|
void SimThink_EntityChanged( CBaseEntity *pEntity )
|
|
{
|
|
g_SimThinkManager.EntityChanged( pEntity );
|
|
}
|
|
|
|
void SimThink_SortThinkList()
|
|
{
|
|
g_SimThinkManager.ListSort();
|
|
}
|
|
|
|
// This manages a list of entities queued up to receive PostClientMessages callbacks
|
|
class CPostClientMessageManager
|
|
{
|
|
public:
|
|
void LevelShutdownPostEntity()
|
|
{
|
|
m_list.Purge();
|
|
}
|
|
void AddEntity( CBaseEntity *pEntity )
|
|
{
|
|
MEM_ALLOC_CREDIT();
|
|
m_list.AddToTail( (unsigned short)pEntity->GetRefEHandle().GetEntryIndex() );
|
|
}
|
|
void PostClientMessagesSent()
|
|
{
|
|
for ( int i = m_list.Count()-1; i >= 0; --i )
|
|
{
|
|
CBaseEntity *pEntity = (CBaseEntity *)gEntList.GetEntInfoPtrByIndex( m_list[i] )->m_pEntity;
|
|
|
|
if ( pEntity )
|
|
{
|
|
pEntity->PostClientMessagesSent();
|
|
}
|
|
}
|
|
m_list.RemoveAll();
|
|
}
|
|
private:
|
|
// UNDONE: Need to use ehandles instead?
|
|
CUtlVector<unsigned short> m_list;
|
|
};
|
|
|
|
static CPostClientMessageManager g_PostClientManager;
|
|
|
|
static CBaseEntityClassList *s_pClassLists = NULL;
|
|
CBaseEntityClassList::CBaseEntityClassList()
|
|
{
|
|
m_pNextClassList = s_pClassLists;
|
|
s_pClassLists = this;
|
|
}
|
|
CBaseEntityClassList::~CBaseEntityClassList()
|
|
{
|
|
}
|
|
|
|
CGlobalEntityList::CGlobalEntityList()
|
|
{
|
|
m_iHighestEnt = m_iNumEnts = m_iNumEdicts = 0;
|
|
m_bClearingEntities = false;
|
|
}
|
|
|
|
|
|
// removes the entity from the global list
|
|
// only called from with the CBaseEntity destructor
|
|
static bool g_fInCleanupDelete;
|
|
|
|
|
|
// mark an entity as deleted
|
|
void CGlobalEntityList::AddToDeleteList( IServerNetworkable *ent )
|
|
{
|
|
if ( ent && ent->GetEntityHandle()->GetRefEHandle() != INVALID_EHANDLE_INDEX )
|
|
{
|
|
g_DeleteList.AddToTail( ent );
|
|
}
|
|
}
|
|
|
|
extern bool g_bDisableEhandleAccess;
|
|
// call this before and after each frame to delete all of the marked entities.
|
|
void CGlobalEntityList::CleanupDeleteList( void )
|
|
{
|
|
VPROF( "CGlobalEntityList::CleanupDeleteList" );
|
|
g_fInCleanupDelete = true;
|
|
|
|
// clean up the vphysics delete list as well
|
|
if ( physenv )
|
|
{
|
|
physenv->CleanupDeleteList();
|
|
}
|
|
g_bDisableEhandleAccess = true;
|
|
for ( int i = 0; i < g_DeleteList.Count(); i++ )
|
|
{
|
|
g_DeleteList[i]->Release();
|
|
}
|
|
g_bDisableEhandleAccess = false;
|
|
g_DeleteList.RemoveAll();
|
|
|
|
g_fInCleanupDelete = false;
|
|
}
|
|
|
|
int CGlobalEntityList::ResetDeleteList( void )
|
|
{
|
|
int result = g_DeleteList.Count();
|
|
g_DeleteList.RemoveAll();
|
|
return result;
|
|
}
|
|
|
|
|
|
// add a class that gets notified of entity events
|
|
void CGlobalEntityList::AddListenerEntity( IEntityListener *pListener )
|
|
{
|
|
if ( m_entityListeners.Find( pListener ) >= 0 )
|
|
{
|
|
AssertMsg( 0, "Can't add listeners multiple times\n" );
|
|
return;
|
|
}
|
|
m_entityListeners.AddToTail( pListener );
|
|
}
|
|
|
|
void CGlobalEntityList::RemoveListenerEntity( IEntityListener *pListener )
|
|
{
|
|
m_entityListeners.FindAndRemove( pListener );
|
|
}
|
|
|
|
void CGlobalEntityList::Clear( void )
|
|
{
|
|
m_bClearingEntities = true;
|
|
|
|
// Add all remaining entities in the game to the delete list and call appropriate UpdateOnRemove
|
|
CBaseHandle hCur = FirstHandle();
|
|
while ( hCur != InvalidHandle() )
|
|
{
|
|
IServerNetworkable *ent = GetServerNetworkable( hCur );
|
|
if ( ent )
|
|
{
|
|
MDLCACHE_CRITICAL_SECTION();
|
|
// Force UpdateOnRemove to be called
|
|
UTIL_Remove( ent );
|
|
}
|
|
hCur = NextHandle( hCur );
|
|
}
|
|
|
|
CleanupDeleteList();
|
|
// free the memory
|
|
g_DeleteList.Purge();
|
|
|
|
CBaseEntity::m_nDebugPlayer = -1;
|
|
CBaseEntity::m_bInDebugSelect = false;
|
|
m_iHighestEnt = 0;
|
|
m_iNumEnts = 0;
|
|
|
|
m_bClearingEntities = false;
|
|
}
|
|
|
|
|
|
int CGlobalEntityList::NumberOfEntities( void )
|
|
{
|
|
return m_iNumEnts;
|
|
}
|
|
|
|
int CGlobalEntityList::NumberOfEdicts( void )
|
|
{
|
|
return m_iNumEdicts;
|
|
}
|
|
|
|
CBaseEntity *CGlobalEntityList::NextEnt( CBaseEntity *pCurrentEnt )
|
|
{
|
|
if ( !pCurrentEnt )
|
|
{
|
|
const CEntInfo *pInfo = FirstEntInfo();
|
|
if ( !pInfo )
|
|
return NULL;
|
|
|
|
return (CBaseEntity *)pInfo->m_pEntity;
|
|
}
|
|
|
|
// Run through the list until we get a CBaseEntity.
|
|
const CEntInfo *pList = GetEntInfoPtr( pCurrentEnt->GetRefEHandle() );
|
|
if ( pList )
|
|
pList = NextEntInfo(pList);
|
|
|
|
while ( pList )
|
|
{
|
|
#if 0
|
|
if ( pList->m_pEntity )
|
|
{
|
|
IServerUnknown *pUnk = static_cast<IServerUnknown*>(const_cast<IHandleEntity*>(pList->m_pEntity));
|
|
CBaseEntity *pRet = pUnk->GetBaseEntity();
|
|
if ( pRet )
|
|
return pRet;
|
|
}
|
|
#else
|
|
return (CBaseEntity *)pList->m_pEntity;
|
|
#endif
|
|
pList = pList->m_pNext;
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
void CGlobalEntityList::ReportEntityFlagsChanged( CBaseEntity *pEntity, unsigned int flagsOld, unsigned int flagsNow )
|
|
{
|
|
if ( pEntity->IsMarkedForDeletion() )
|
|
return;
|
|
// UNDONE: Move this into IEntityListener instead?
|
|
unsigned int flagsChanged = flagsOld ^ flagsNow;
|
|
if ( flagsChanged & FL_AIMTARGET )
|
|
{
|
|
unsigned int flagsAdded = flagsNow & flagsChanged;
|
|
unsigned int flagsRemoved = flagsOld & flagsChanged;
|
|
|
|
if ( flagsAdded & FL_AIMTARGET )
|
|
{
|
|
g_AimManager.AddEntity( pEntity );
|
|
}
|
|
if ( flagsRemoved & FL_AIMTARGET )
|
|
{
|
|
g_AimManager.RemoveEntity( pEntity );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CGlobalEntityList::AddPostClientMessageEntity( CBaseEntity *pEntity )
|
|
{
|
|
g_PostClientManager.AddEntity( pEntity );
|
|
}
|
|
void CGlobalEntityList::PostClientMessagesSent()
|
|
{
|
|
g_PostClientManager.PostClientMessagesSent();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Used to confirm a pointer is a pointer to an entity, useful for
|
|
// asserts.
|
|
//-----------------------------------------------------------------------------
|
|
bool CGlobalEntityList::IsEntityPtr( void *pTest )
|
|
{
|
|
if ( pTest )
|
|
{
|
|
const CEntInfo *pInfo = FirstEntInfo();
|
|
for ( ;pInfo; pInfo = pInfo->m_pNext )
|
|
{
|
|
if ( pTest == (void *)pInfo->m_pEntity )
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Iterates the entities with a given classname.
|
|
// Input : pStartEntity - Last entity found, NULL to start a new iteration.
|
|
// szName - Classname to search for.
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CGlobalEntityList::FindEntityByClassname( CBaseEntity *pStartEntity, const char *szName )
|
|
{
|
|
const CEntInfo *pInfo = pStartEntity ? GetEntInfoPtr( pStartEntity->GetRefEHandle() )->m_pNext : FirstEntInfo();
|
|
|
|
for ( ;pInfo; pInfo = pInfo->m_pNext )
|
|
{
|
|
CBaseEntity *pEntity = (CBaseEntity *)pInfo->m_pEntity;
|
|
if ( !pEntity )
|
|
{
|
|
DevWarning( "NULL entity in global entity list!\n" );
|
|
continue;
|
|
}
|
|
|
|
if ( pEntity->ClassMatches(szName) )
|
|
return pEntity;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Finds an entity given a procedural name.
|
|
// Input : szName - The procedural name to search for, should start with '!'.
|
|
// pSearchingEntity -
|
|
// pActivator - The activator entity if this was called from an input
|
|
// or Use handler.
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CGlobalEntityList::FindEntityProcedural( const char *szName, CBaseEntity *pSearchingEntity, CBaseEntity *pActivator, CBaseEntity *pCaller )
|
|
{
|
|
//
|
|
// Check for the name escape character.
|
|
//
|
|
if ( szName[0] == '!' )
|
|
{
|
|
const char *pName = szName + 1;
|
|
|
|
//
|
|
// It is a procedural name, look for the ones we understand.
|
|
//
|
|
if ( FStrEq( pName, "player" ) )
|
|
{
|
|
return (CBaseEntity *)UTIL_PlayerByIndex( 1 );
|
|
}
|
|
else if ( FStrEq( pName, "pvsplayer" ) )
|
|
{
|
|
if ( pSearchingEntity )
|
|
{
|
|
return CBaseEntity::Instance( UTIL_FindClientInPVS( pSearchingEntity->edict() ) );
|
|
}
|
|
else if ( pActivator )
|
|
{
|
|
// FIXME: error condition?
|
|
return CBaseEntity::Instance( UTIL_FindClientInPVS( pActivator->edict() ) );
|
|
}
|
|
else
|
|
{
|
|
// FIXME: error condition?
|
|
return (CBaseEntity *)UTIL_PlayerByIndex( 1 );
|
|
}
|
|
|
|
}
|
|
else if ( FStrEq( pName, "activator" ) )
|
|
{
|
|
return pActivator;
|
|
}
|
|
else if ( FStrEq( pName, "caller" ) )
|
|
{
|
|
return pCaller;
|
|
}
|
|
else if ( FStrEq( pName, "picker" ) )
|
|
{
|
|
return FindPickerEntity( UTIL_PlayerByIndex(1) );
|
|
}
|
|
else if ( FStrEq( pName, "self" ) )
|
|
{
|
|
return pSearchingEntity;
|
|
}
|
|
else
|
|
{
|
|
Warning( "Invalid entity search name %s\n", szName );
|
|
Assert(0);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Iterates the entities with a given name.
|
|
// Input : pStartEntity - Last entity found, NULL to start a new iteration.
|
|
// szName - Name to search for.
|
|
// pActivator - Activator entity if this was called from an input
|
|
// handler or Use handler.
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CGlobalEntityList::FindEntityByName( CBaseEntity *pStartEntity, const char *szName, CBaseEntity *pSearchingEntity, CBaseEntity *pActivator, CBaseEntity *pCaller, IEntityFindFilter *pFilter )
|
|
{
|
|
if ( !szName || szName[0] == 0 )
|
|
return NULL;
|
|
|
|
if ( szName[0] == '!' )
|
|
{
|
|
//
|
|
// Avoid an infinite loop, only find one match per procedural search!
|
|
//
|
|
if (pStartEntity == NULL)
|
|
return FindEntityProcedural( szName, pSearchingEntity, pActivator, pCaller );
|
|
|
|
return NULL;
|
|
}
|
|
|
|
const CEntInfo *pInfo = pStartEntity ? GetEntInfoPtr( pStartEntity->GetRefEHandle() )->m_pNext : FirstEntInfo();
|
|
|
|
for ( ;pInfo; pInfo = pInfo->m_pNext )
|
|
{
|
|
CBaseEntity *ent = (CBaseEntity *)pInfo->m_pEntity;
|
|
if ( !ent )
|
|
{
|
|
DevWarning( "NULL entity in global entity list!\n" );
|
|
continue;
|
|
}
|
|
|
|
if ( !ent->m_iName )
|
|
continue;
|
|
|
|
if ( ent->NameMatches( szName ) )
|
|
{
|
|
if ( pFilter && !pFilter->ShouldFindEntity(ent) )
|
|
continue;
|
|
|
|
return ent;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : pStartEntity -
|
|
// szModelName -
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CGlobalEntityList::FindEntityByModel( CBaseEntity *pStartEntity, const char *szModelName )
|
|
{
|
|
const CEntInfo *pInfo = pStartEntity ? GetEntInfoPtr( pStartEntity->GetRefEHandle() )->m_pNext : FirstEntInfo();
|
|
|
|
for ( ;pInfo; pInfo = pInfo->m_pNext )
|
|
{
|
|
CBaseEntity *ent = (CBaseEntity *)pInfo->m_pEntity;
|
|
if ( !ent )
|
|
{
|
|
DevWarning( "NULL entity in global entity list!\n" );
|
|
continue;
|
|
}
|
|
|
|
if ( !ent->edict() || !ent->GetModelName() )
|
|
continue;
|
|
|
|
if ( FStrEq( STRING(ent->GetModelName()), szModelName ) )
|
|
return ent;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Iterates the entities with a given target.
|
|
// Input : pStartEntity -
|
|
// szName -
|
|
//-----------------------------------------------------------------------------
|
|
// FIXME: obsolete, remove
|
|
CBaseEntity *CGlobalEntityList::FindEntityByTarget( CBaseEntity *pStartEntity, const char *szName )
|
|
{
|
|
const CEntInfo *pInfo = pStartEntity ? GetEntInfoPtr( pStartEntity->GetRefEHandle() )->m_pNext : FirstEntInfo();
|
|
|
|
for ( ;pInfo; pInfo = pInfo->m_pNext )
|
|
{
|
|
CBaseEntity *ent = (CBaseEntity *)pInfo->m_pEntity;
|
|
if ( !ent )
|
|
{
|
|
DevWarning( "NULL entity in global entity list!\n" );
|
|
continue;
|
|
}
|
|
|
|
if ( !ent->m_target )
|
|
continue;
|
|
|
|
if ( FStrEq( STRING(ent->m_target), szName ) )
|
|
return ent;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Used to iterate all the entities within a sphere.
|
|
// Input : pStartEntity -
|
|
// vecCenter -
|
|
// flRadius -
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CGlobalEntityList::FindEntityInSphere( CBaseEntity *pStartEntity, const Vector &vecCenter, float flRadius )
|
|
{
|
|
const CEntInfo *pInfo = pStartEntity ? GetEntInfoPtr( pStartEntity->GetRefEHandle() )->m_pNext : FirstEntInfo();
|
|
|
|
for ( ;pInfo; pInfo = pInfo->m_pNext )
|
|
{
|
|
CBaseEntity *ent = (CBaseEntity *)pInfo->m_pEntity;
|
|
if ( !ent )
|
|
{
|
|
DevWarning( "NULL entity in global entity list!\n" );
|
|
continue;
|
|
}
|
|
|
|
if ( !ent->edict() )
|
|
continue;
|
|
|
|
Vector vecRelativeCenter;
|
|
ent->CollisionProp()->WorldToCollisionSpace( vecCenter, &vecRelativeCenter );
|
|
if ( !IsBoxIntersectingSphere( ent->CollisionProp()->OBBMins(), ent->CollisionProp()->OBBMaxs(), vecRelativeCenter, flRadius ) )
|
|
continue;
|
|
|
|
return ent;
|
|
}
|
|
|
|
// nothing found
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Finds the nearest entity by name within a radius
|
|
// Input : szName - Entity name to search for.
|
|
// vecSrc - Center of search radius.
|
|
// flRadius - Search radius for classname search, 0 to search everywhere.
|
|
// pSearchingEntity - The entity that is doing the search.
|
|
// pActivator - The activator entity if this was called from an input
|
|
// or Use handler, NULL otherwise.
|
|
// Output : Returns a pointer to the found entity, NULL if none.
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CGlobalEntityList::FindEntityByNameNearest( const char *szName, const Vector &vecSrc, float flRadius, CBaseEntity *pSearchingEntity, CBaseEntity *pActivator, CBaseEntity *pCaller )
|
|
{
|
|
CBaseEntity *pEntity = NULL;
|
|
|
|
//
|
|
// Check for matching class names within the search radius.
|
|
//
|
|
float flMaxDist2 = flRadius * flRadius;
|
|
if (flMaxDist2 == 0)
|
|
{
|
|
flMaxDist2 = MAX_TRACE_LENGTH * MAX_TRACE_LENGTH;
|
|
}
|
|
|
|
CBaseEntity *pSearch = NULL;
|
|
while ((pSearch = gEntList.FindEntityByName( pSearch, szName, pSearchingEntity, pActivator, pCaller )) != NULL)
|
|
{
|
|
if ( !pSearch->edict() )
|
|
continue;
|
|
|
|
float flDist2 = (pSearch->GetAbsOrigin() - vecSrc).LengthSqr();
|
|
|
|
if (flMaxDist2 > flDist2)
|
|
{
|
|
pEntity = pSearch;
|
|
flMaxDist2 = flDist2;
|
|
}
|
|
}
|
|
|
|
return pEntity;
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Finds the first entity by name within a radius
|
|
// Input : pStartEntity - The entity to start from when doing the search.
|
|
// szName - Entity name to search for.
|
|
// vecSrc - Center of search radius.
|
|
// flRadius - Search radius for classname search, 0 to search everywhere.
|
|
// pSearchingEntity - The entity that is doing the search.
|
|
// pActivator - The activator entity if this was called from an input
|
|
// or Use handler, NULL otherwise.
|
|
// Output : Returns a pointer to the found entity, NULL if none.
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CGlobalEntityList::FindEntityByNameWithin( CBaseEntity *pStartEntity, const char *szName, const Vector &vecSrc, float flRadius, CBaseEntity *pSearchingEntity, CBaseEntity *pActivator, CBaseEntity *pCaller )
|
|
{
|
|
//
|
|
// Check for matching class names within the search radius.
|
|
//
|
|
CBaseEntity *pEntity = pStartEntity;
|
|
float flMaxDist2 = flRadius * flRadius;
|
|
if (flMaxDist2 == 0)
|
|
{
|
|
return gEntList.FindEntityByName( pEntity, szName, pSearchingEntity, pActivator, pCaller );
|
|
}
|
|
|
|
while ((pEntity = gEntList.FindEntityByName( pEntity, szName, pSearchingEntity, pActivator, pCaller )) != NULL)
|
|
{
|
|
if ( !pEntity->edict() )
|
|
continue;
|
|
|
|
float flDist2 = (pEntity->GetAbsOrigin() - vecSrc).LengthSqr();
|
|
|
|
if (flMaxDist2 > flDist2)
|
|
{
|
|
return pEntity;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Finds the nearest entity by class name withing given search radius.
|
|
// Input : szName - Entity name to search for. Treated as a target name first,
|
|
// then as an entity class name, ie "info_target".
|
|
// vecSrc - Center of search radius.
|
|
// flRadius - Search radius for classname search, 0 to search everywhere.
|
|
// Output : Returns a pointer to the found entity, NULL if none.
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CGlobalEntityList::FindEntityByClassnameNearest( const char *szName, const Vector &vecSrc, float flRadius )
|
|
{
|
|
CBaseEntity *pEntity = NULL;
|
|
|
|
//
|
|
// Check for matching class names within the search radius.
|
|
//
|
|
float flMaxDist2 = flRadius * flRadius;
|
|
if (flMaxDist2 == 0)
|
|
{
|
|
flMaxDist2 = MAX_TRACE_LENGTH * MAX_TRACE_LENGTH;
|
|
}
|
|
|
|
CBaseEntity *pSearch = NULL;
|
|
while ((pSearch = gEntList.FindEntityByClassname( pSearch, szName )) != NULL)
|
|
{
|
|
if ( !pSearch->edict() )
|
|
continue;
|
|
|
|
float flDist2 = (pSearch->GetAbsOrigin() - vecSrc).LengthSqr();
|
|
|
|
if (flMaxDist2 > flDist2)
|
|
{
|
|
pEntity = pSearch;
|
|
flMaxDist2 = flDist2;
|
|
}
|
|
}
|
|
|
|
return pEntity;
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Finds the first entity within radius distance by class name.
|
|
// Input : pStartEntity - The entity to start from when doing the search.
|
|
// szName - Entity class name, ie "info_target".
|
|
// vecSrc - Center of search radius.
|
|
// flRadius - Search radius for classname search, 0 to search everywhere.
|
|
// Output : Returns a pointer to the found entity, NULL if none.
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CGlobalEntityList::FindEntityByClassnameWithin( CBaseEntity *pStartEntity, const char *szName, const Vector &vecSrc, float flRadius )
|
|
{
|
|
//
|
|
// Check for matching class names within the search radius.
|
|
//
|
|
CBaseEntity *pEntity = pStartEntity;
|
|
float flMaxDist2 = flRadius * flRadius;
|
|
if (flMaxDist2 == 0)
|
|
{
|
|
return gEntList.FindEntityByClassname( pEntity, szName );
|
|
}
|
|
|
|
while ((pEntity = gEntList.FindEntityByClassname( pEntity, szName )) != NULL)
|
|
{
|
|
if ( !pEntity->edict() )
|
|
continue;
|
|
|
|
float flDist2 = (pEntity->GetAbsOrigin() - vecSrc).LengthSqr();
|
|
|
|
if (flMaxDist2 > flDist2)
|
|
{
|
|
return pEntity;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Finds an entity by target name or class name.
|
|
// Input : pStartEntity - The entity to start from when doing the search.
|
|
// szName - Entity name to search for. Treated as a target name first,
|
|
// then as an entity class name, ie "info_target".
|
|
// vecSrc - Center of search radius.
|
|
// flRadius - Search radius for classname search, 0 to search everywhere.
|
|
// pSearchingEntity - The entity that is doing the search.
|
|
// pActivator - The activator entity if this was called from an input
|
|
// or Use handler, NULL otherwise.
|
|
// Output : Returns a pointer to the found entity, NULL if none.
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CGlobalEntityList::FindEntityGeneric( CBaseEntity *pStartEntity, const char *szName, CBaseEntity *pSearchingEntity, CBaseEntity *pActivator, CBaseEntity *pCaller )
|
|
{
|
|
CBaseEntity *pEntity = NULL;
|
|
|
|
pEntity = gEntList.FindEntityByName( pStartEntity, szName, pSearchingEntity, pActivator, pCaller );
|
|
if (!pEntity)
|
|
{
|
|
pEntity = gEntList.FindEntityByClassname( pStartEntity, szName );
|
|
}
|
|
|
|
return pEntity;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Finds the first entity by target name or class name within a radius
|
|
// Input : pStartEntity - The entity to start from when doing the search.
|
|
// szName - Entity name to search for. Treated as a target name first,
|
|
// then as an entity class name, ie "info_target".
|
|
// vecSrc - Center of search radius.
|
|
// flRadius - Search radius for classname search, 0 to search everywhere.
|
|
// pSearchingEntity - The entity that is doing the search.
|
|
// pActivator - The activator entity if this was called from an input
|
|
// or Use handler, NULL otherwise.
|
|
// Output : Returns a pointer to the found entity, NULL if none.
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CGlobalEntityList::FindEntityGenericWithin( CBaseEntity *pStartEntity, const char *szName, const Vector &vecSrc, float flRadius, CBaseEntity *pSearchingEntity, CBaseEntity *pActivator, CBaseEntity *pCaller )
|
|
{
|
|
CBaseEntity *pEntity = NULL;
|
|
|
|
pEntity = gEntList.FindEntityByNameWithin( pStartEntity, szName, vecSrc, flRadius, pSearchingEntity, pActivator, pCaller );
|
|
if (!pEntity)
|
|
{
|
|
pEntity = gEntList.FindEntityByClassnameWithin( pStartEntity, szName, vecSrc, flRadius );
|
|
}
|
|
|
|
return pEntity;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Finds the nearest entity by target name or class name within a radius.
|
|
// Input : pStartEntity - The entity to start from when doing the search.
|
|
// szName - Entity name to search for. Treated as a target name first,
|
|
// then as an entity class name, ie "info_target".
|
|
// vecSrc - Center of search radius.
|
|
// flRadius - Search radius for classname search, 0 to search everywhere.
|
|
// pSearchingEntity - The entity that is doing the search.
|
|
// pActivator - The activator entity if this was called from an input
|
|
// or Use handler, NULL otherwise.
|
|
// Output : Returns a pointer to the found entity, NULL if none.
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CGlobalEntityList::FindEntityGenericNearest( const char *szName, const Vector &vecSrc, float flRadius, CBaseEntity *pSearchingEntity, CBaseEntity *pActivator, CBaseEntity *pCaller )
|
|
{
|
|
CBaseEntity *pEntity = NULL;
|
|
|
|
pEntity = gEntList.FindEntityByNameNearest( szName, vecSrc, flRadius, pSearchingEntity, pActivator, pCaller );
|
|
if (!pEntity)
|
|
{
|
|
pEntity = gEntList.FindEntityByClassnameNearest( szName, vecSrc, flRadius );
|
|
}
|
|
|
|
return pEntity;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find the nearest entity along the facing direction from the given origin
|
|
// within the angular threshold (ignores worldspawn) with the
|
|
// given classname.
|
|
// Input : origin -
|
|
// facing -
|
|
// threshold -
|
|
// classname -
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CGlobalEntityList::FindEntityClassNearestFacing( const Vector &origin, const Vector &facing, float threshold, char *classname)
|
|
{
|
|
float bestDot = threshold;
|
|
CBaseEntity *best_ent = NULL;
|
|
|
|
const CEntInfo *pInfo = FirstEntInfo();
|
|
|
|
for ( ;pInfo; pInfo = pInfo->m_pNext )
|
|
{
|
|
CBaseEntity *ent = (CBaseEntity *)pInfo->m_pEntity;
|
|
if ( !ent )
|
|
{
|
|
DevWarning( "NULL entity in global entity list!\n" );
|
|
continue;
|
|
}
|
|
|
|
// FIXME: why is this skipping pointsize entities?
|
|
if (ent->IsPointSized() )
|
|
continue;
|
|
|
|
// Make vector to entity
|
|
Vector to_ent = (ent->GetAbsOrigin() - origin);
|
|
|
|
VectorNormalize( to_ent );
|
|
float dot = DotProduct (facing , to_ent );
|
|
if (dot > bestDot)
|
|
{
|
|
if (FClassnameIs(ent,classname))
|
|
{
|
|
// Ignore if worldspawn
|
|
if (!FClassnameIs( ent, "worldspawn" ) && !FClassnameIs( ent, "soundent"))
|
|
{
|
|
bestDot = dot;
|
|
best_ent = ent;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return best_ent;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find the nearest entity along the facing direction from the given origin
|
|
// within the angular threshold (ignores worldspawn)
|
|
// Input : origin -
|
|
// facing -
|
|
// threshold -
|
|
//-----------------------------------------------------------------------------
|
|
CBaseEntity *CGlobalEntityList::FindEntityNearestFacing( const Vector &origin, const Vector &facing, float threshold)
|
|
{
|
|
float bestDot = threshold;
|
|
CBaseEntity *best_ent = NULL;
|
|
|
|
const CEntInfo *pInfo = FirstEntInfo();
|
|
|
|
for ( ;pInfo; pInfo = pInfo->m_pNext )
|
|
{
|
|
CBaseEntity *ent = (CBaseEntity *)pInfo->m_pEntity;
|
|
if ( !ent )
|
|
{
|
|
DevWarning( "NULL entity in global entity list!\n" );
|
|
continue;
|
|
}
|
|
|
|
// Ignore logical entities
|
|
if (!ent->edict())
|
|
continue;
|
|
|
|
// Make vector to entity
|
|
Vector to_ent = ent->WorldSpaceCenter() - origin;
|
|
VectorNormalize(to_ent);
|
|
|
|
float dot = DotProduct( facing, to_ent );
|
|
if (dot <= bestDot)
|
|
continue;
|
|
|
|
// Ignore if worldspawn
|
|
if (!FStrEq( STRING(ent->m_iClassname), "worldspawn") && !FStrEq( STRING(ent->m_iClassname), "soundent"))
|
|
{
|
|
bestDot = dot;
|
|
best_ent = ent;
|
|
}
|
|
}
|
|
return best_ent;
|
|
}
|
|
|
|
|
|
void CGlobalEntityList::OnAddEntity( IHandleEntity *pEnt, CBaseHandle handle )
|
|
{
|
|
int i = handle.GetEntryIndex();
|
|
|
|
// record current list details
|
|
m_iNumEnts++;
|
|
if ( i > m_iHighestEnt )
|
|
m_iHighestEnt = i;
|
|
|
|
// If it's a CBaseEntity, notify the listeners.
|
|
CBaseEntity *pBaseEnt = static_cast<IServerUnknown*>(pEnt)->GetBaseEntity();
|
|
if ( pBaseEnt->edict() )
|
|
m_iNumEdicts++;
|
|
|
|
// NOTE: Must be a CBaseEntity on server
|
|
Assert( pBaseEnt );
|
|
//DevMsg(2,"Created %s\n", pBaseEnt->GetClassname() );
|
|
for ( i = m_entityListeners.Count()-1; i >= 0; i-- )
|
|
{
|
|
m_entityListeners[i]->OnEntityCreated( pBaseEnt );
|
|
}
|
|
}
|
|
|
|
|
|
void CGlobalEntityList::OnRemoveEntity( IHandleEntity *pEnt, CBaseHandle handle )
|
|
{
|
|
#ifdef DEBUG
|
|
if ( !g_fInCleanupDelete )
|
|
{
|
|
int i;
|
|
for ( i = 0; i < g_DeleteList.Count(); i++ )
|
|
{
|
|
if ( g_DeleteList[i]->GetEntityHandle() == pEnt )
|
|
{
|
|
g_DeleteList.FastRemove( i );
|
|
Msg( "ERROR: Entity being destroyed but previously threaded on g_DeleteList\n" );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
CBaseEntity *pBaseEnt = static_cast<IServerUnknown*>(pEnt)->GetBaseEntity();
|
|
if ( pBaseEnt->edict() )
|
|
m_iNumEdicts--;
|
|
|
|
m_iNumEnts--;
|
|
}
|
|
|
|
void CGlobalEntityList::NotifyCreateEntity( CBaseEntity *pEnt )
|
|
{
|
|
if ( !pEnt )
|
|
return;
|
|
|
|
//DevMsg(2,"Deleted %s\n", pBaseEnt->GetClassname() );
|
|
for ( int i = m_entityListeners.Count()-1; i >= 0; i-- )
|
|
{
|
|
m_entityListeners[i]->OnEntityCreated( pEnt );
|
|
}
|
|
}
|
|
|
|
void CGlobalEntityList::NotifySpawn( CBaseEntity *pEnt )
|
|
{
|
|
if ( !pEnt )
|
|
return;
|
|
|
|
//DevMsg(2,"Deleted %s\n", pBaseEnt->GetClassname() );
|
|
for ( int i = m_entityListeners.Count()-1; i >= 0; i-- )
|
|
{
|
|
m_entityListeners[i]->OnEntitySpawned( pEnt );
|
|
}
|
|
}
|
|
|
|
// NOTE: This doesn't happen in OnRemoveEntity() specifically because
|
|
// listeners may want to reference the object as it's being deleted
|
|
// OnRemoveEntity isn't called until the destructor and all data is invalid.
|
|
void CGlobalEntityList::NotifyRemoveEntity( CBaseHandle hEnt )
|
|
{
|
|
CBaseEntity *pBaseEnt = GetBaseEntity( hEnt );
|
|
if ( !pBaseEnt )
|
|
return;
|
|
|
|
//DevMsg(2,"Deleted %s\n", pBaseEnt->GetClassname() );
|
|
for ( int i = m_entityListeners.Count()-1; i >= 0; i-- )
|
|
{
|
|
m_entityListeners[i]->OnEntityDeleted( pBaseEnt );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// NOTIFY LIST
|
|
//
|
|
// Allows entities to get events fired when another entity changes
|
|
//-----------------------------------------------------------------------------
|
|
struct entitynotify_t
|
|
{
|
|
CBaseEntity *pNotify;
|
|
CBaseEntity *pWatched;
|
|
};
|
|
class CNotifyList : public INotify, public IEntityListener
|
|
{
|
|
public:
|
|
// INotify
|
|
void AddEntity( CBaseEntity *pNotify, CBaseEntity *pWatched );
|
|
void RemoveEntity( CBaseEntity *pNotify, CBaseEntity *pWatched );
|
|
void ReportNamedEvent( CBaseEntity *pEntity, const char *pEventName );
|
|
void ClearEntity( CBaseEntity *pNotify );
|
|
void ReportSystemEvent( CBaseEntity *pEntity, notify_system_event_t eventType, const notify_system_event_params_t ¶ms );
|
|
|
|
// IEntityListener
|
|
virtual void OnEntityCreated( CBaseEntity *pEntity );
|
|
virtual void OnEntityDeleted( CBaseEntity *pEntity );
|
|
|
|
// Called from CEntityListSystem
|
|
void LevelInitPreEntity();
|
|
void LevelShutdownPreEntity();
|
|
|
|
private:
|
|
CUtlVector<entitynotify_t> m_notifyList;
|
|
};
|
|
|
|
void CNotifyList::AddEntity( CBaseEntity *pNotify, CBaseEntity *pWatched )
|
|
{
|
|
// OPTIMIZE: Also flag pNotify for faster "RemoveAllNotify" ?
|
|
pWatched->AddEFlags( EFL_NOTIFY );
|
|
int index = m_notifyList.AddToTail();
|
|
entitynotify_t ¬ify = m_notifyList[index];
|
|
notify.pNotify = pNotify;
|
|
notify.pWatched = pWatched;
|
|
}
|
|
|
|
// Remove noitfication for an entity
|
|
void CNotifyList::RemoveEntity( CBaseEntity *pNotify, CBaseEntity *pWatched )
|
|
{
|
|
for ( int i = m_notifyList.Count(); --i >= 0; )
|
|
{
|
|
if ( m_notifyList[i].pNotify == pNotify && m_notifyList[i].pWatched == pWatched)
|
|
{
|
|
m_notifyList.FastRemove(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CNotifyList::ReportNamedEvent( CBaseEntity *pEntity, const char *pInputName )
|
|
{
|
|
variant_t emptyVariant;
|
|
|
|
if ( !pEntity->IsEFlagSet(EFL_NOTIFY) )
|
|
return;
|
|
|
|
for ( int i = 0; i < m_notifyList.Count(); i++ )
|
|
{
|
|
if ( m_notifyList[i].pWatched == pEntity )
|
|
{
|
|
m_notifyList[i].pNotify->AcceptInput( pInputName, pEntity, pEntity, emptyVariant, 0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CNotifyList::LevelInitPreEntity()
|
|
{
|
|
gEntList.AddListenerEntity( this );
|
|
}
|
|
|
|
void CNotifyList::LevelShutdownPreEntity( void )
|
|
{
|
|
gEntList.RemoveListenerEntity( this );
|
|
m_notifyList.Purge();
|
|
}
|
|
|
|
void CNotifyList::OnEntityCreated( CBaseEntity *pEntity )
|
|
{
|
|
}
|
|
|
|
void CNotifyList::OnEntityDeleted( CBaseEntity *pEntity )
|
|
{
|
|
ReportDestroyEvent( pEntity );
|
|
ClearEntity( pEntity );
|
|
}
|
|
|
|
|
|
// UNDONE: Slow linear search?
|
|
void CNotifyList::ClearEntity( CBaseEntity *pNotify )
|
|
{
|
|
for ( int i = m_notifyList.Count(); --i >= 0; )
|
|
{
|
|
if ( m_notifyList[i].pNotify == pNotify || m_notifyList[i].pWatched == pNotify)
|
|
{
|
|
m_notifyList.FastRemove(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CNotifyList::ReportSystemEvent( CBaseEntity *pEntity, notify_system_event_t eventType, const notify_system_event_params_t ¶ms )
|
|
{
|
|
if ( !pEntity->IsEFlagSet(EFL_NOTIFY) )
|
|
return;
|
|
|
|
for ( int i = 0; i < m_notifyList.Count(); i++ )
|
|
{
|
|
if ( m_notifyList[i].pWatched == pEntity )
|
|
{
|
|
m_notifyList[i].pNotify->NotifySystemEvent( pEntity, eventType, params );
|
|
}
|
|
}
|
|
}
|
|
|
|
static CNotifyList g_NotifyList;
|
|
INotify *g_pNotify = &g_NotifyList;
|
|
|
|
class CEntityTouchManager : public IEntityListener
|
|
{
|
|
public:
|
|
// called by CEntityListSystem
|
|
void LevelInitPreEntity()
|
|
{
|
|
gEntList.AddListenerEntity( this );
|
|
Clear();
|
|
}
|
|
void LevelShutdownPostEntity()
|
|
{
|
|
gEntList.RemoveListenerEntity( this );
|
|
Clear();
|
|
}
|
|
void FrameUpdatePostEntityThink();
|
|
|
|
void Clear()
|
|
{
|
|
m_updateList.Purge();
|
|
}
|
|
|
|
// IEntityListener
|
|
virtual void OnEntityCreated( CBaseEntity *pEntity ) {}
|
|
virtual void OnEntityDeleted( CBaseEntity *pEntity )
|
|
{
|
|
if ( !pEntity->GetCheckUntouch() )
|
|
return;
|
|
int index = m_updateList.Find( pEntity );
|
|
if ( m_updateList.IsValidIndex(index) )
|
|
{
|
|
m_updateList.FastRemove( index );
|
|
}
|
|
}
|
|
void AddEntity( CBaseEntity *pEntity )
|
|
{
|
|
if ( pEntity->IsMarkedForDeletion() )
|
|
return;
|
|
m_updateList.AddToTail( pEntity );
|
|
}
|
|
|
|
private:
|
|
CUtlVector<CBaseEntity *> m_updateList;
|
|
};
|
|
|
|
static CEntityTouchManager g_TouchManager;
|
|
|
|
void EntityTouch_Add( CBaseEntity *pEntity )
|
|
{
|
|
g_TouchManager.AddEntity( pEntity );
|
|
}
|
|
|
|
|
|
void CEntityTouchManager::FrameUpdatePostEntityThink()
|
|
{
|
|
VPROF( "CEntityTouchManager::FrameUpdatePostEntityThink" );
|
|
// Loop through all entities again, checking their untouch if flagged to do so
|
|
|
|
int count = m_updateList.Count();
|
|
if ( count )
|
|
{
|
|
// copy off the list
|
|
CBaseEntity **ents = (CBaseEntity **)stackalloc( sizeof(CBaseEntity *) * count );
|
|
memcpy( ents, m_updateList.Base(), sizeof(CBaseEntity *) * count );
|
|
// clear it
|
|
m_updateList.RemoveAll();
|
|
|
|
// now update those ents
|
|
for ( int i = 0; i < count; i++ )
|
|
{
|
|
//Assert( ents[i]->GetCheckUntouch() );
|
|
if ( ents[i]->GetCheckUntouch() )
|
|
{
|
|
ents[i]->PhysicsCheckForEntityUntouch();
|
|
}
|
|
}
|
|
stackfree( ents );
|
|
}
|
|
}
|
|
|
|
class CRespawnEntitiesFilter : public IMapEntityFilter
|
|
{
|
|
public:
|
|
virtual bool ShouldCreateEntity( const char *pClassname )
|
|
{
|
|
// Create everything but the world
|
|
return Q_stricmp( pClassname, "worldspawn" ) != 0;
|
|
}
|
|
|
|
virtual CBaseEntity* CreateNextEntity( const char *pClassname )
|
|
{
|
|
return CreateEntityByName( pClassname );
|
|
}
|
|
};
|
|
|
|
// One hook to rule them all...
|
|
// Since most of the little list managers in here only need one or two of the game
|
|
// system callbacks, this hook is a game system that passes them the appropriate callbacks
|
|
class CEntityListSystem : public CAutoGameSystemPerFrame
|
|
{
|
|
public:
|
|
CEntityListSystem( char const *name ) : CAutoGameSystemPerFrame( name )
|
|
{
|
|
m_bRespawnAllEntities = false;
|
|
}
|
|
void LevelInitPreEntity()
|
|
{
|
|
g_NotifyList.LevelInitPreEntity();
|
|
g_TouchManager.LevelInitPreEntity();
|
|
g_AimManager.LevelInitPreEntity();
|
|
g_SimThinkManager.LevelInitPreEntity();
|
|
}
|
|
void LevelShutdownPreEntity()
|
|
{
|
|
g_NotifyList.LevelShutdownPreEntity();
|
|
}
|
|
void LevelShutdownPostEntity()
|
|
{
|
|
g_TouchManager.LevelShutdownPostEntity();
|
|
g_AimManager.LevelShutdownPostEntity();
|
|
g_PostClientManager.LevelShutdownPostEntity();
|
|
g_SimThinkManager.LevelShutdownPostEntity();
|
|
|
|
CBaseEntityClassList *pClassList = s_pClassLists;
|
|
while ( pClassList )
|
|
{
|
|
pClassList->LevelShutdownPostEntity();
|
|
pClassList = pClassList->m_pNextClassList;
|
|
}
|
|
}
|
|
|
|
void FrameUpdatePostEntityThink()
|
|
{
|
|
g_TouchManager.FrameUpdatePostEntityThink();
|
|
|
|
if ( m_bRespawnAllEntities )
|
|
{
|
|
m_bRespawnAllEntities = false;
|
|
|
|
// Don't change globalstate owing to deletion here
|
|
GlobalEntity_EnableStateUpdates( false );
|
|
|
|
// Remove all entities
|
|
int nPlayerIndex = -1;
|
|
CBaseEntity *pEnt = gEntList.FirstEnt();
|
|
while ( pEnt )
|
|
{
|
|
CBaseEntity *pNextEnt = gEntList.NextEnt( pEnt );
|
|
if ( pEnt->IsPlayer() )
|
|
{
|
|
nPlayerIndex = pEnt->entindex();
|
|
}
|
|
if ( !pEnt->IsEFlagSet( EFL_KEEP_ON_RECREATE_ENTITIES ) )
|
|
{
|
|
UTIL_Remove( pEnt );
|
|
}
|
|
pEnt = pNextEnt;
|
|
}
|
|
|
|
gEntList.CleanupDeleteList();
|
|
|
|
GlobalEntity_EnableStateUpdates( true );
|
|
|
|
// Allows us to immediately re-use the edict indices we just freed to avoid edict overflow
|
|
engine->AllowImmediateEdictReuse();
|
|
|
|
// Reset node counter used during load
|
|
CNodeEnt::m_nNodeCount = 0;
|
|
|
|
CRespawnEntitiesFilter filter;
|
|
MapEntity_ParseAllEntities( engine->GetMapEntitiesString(), &filter, true );
|
|
|
|
// Allocate a CBasePlayer for pev, and call spawn
|
|
if ( nPlayerIndex >= 0 )
|
|
{
|
|
edict_t *pEdict = engine->PEntityOfEntIndex( nPlayerIndex );
|
|
ClientPutInServer( pEdict, "unnamed" );
|
|
ClientActive( pEdict, false );
|
|
|
|
CBasePlayer *pPlayer = ( CBasePlayer * )CBaseEntity::Instance( pEdict );
|
|
SceneManager_ClientActive( pPlayer );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool m_bRespawnAllEntities;
|
|
};
|
|
|
|
static CEntityListSystem g_EntityListSystem( "CEntityListSystem" );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Respawns all entities in the level
|
|
//-----------------------------------------------------------------------------
|
|
void RespawnEntities()
|
|
{
|
|
g_EntityListSystem.m_bRespawnAllEntities = true;
|
|
}
|
|
|
|
static ConCommand restart_entities( "respawn_entities", RespawnEntities, "Respawn all the entities in the map." );
|
|
|
|
class CSortedEntityList
|
|
{
|
|
public:
|
|
CSortedEntityList() : m_sortedList(), m_emptyCount(0) {}
|
|
|
|
typedef CBaseEntity *ENTITYPTR;
|
|
class CEntityReportLess
|
|
{
|
|
public:
|
|
bool Less( const ENTITYPTR &src1, const ENTITYPTR &src2, void *pCtx )
|
|
{
|
|
if ( stricmp( src1->GetClassname(), src2->GetClassname() ) < 0 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
void AddEntityToList( CBaseEntity *pEntity )
|
|
{
|
|
if ( !pEntity )
|
|
{
|
|
m_emptyCount++;
|
|
}
|
|
else
|
|
{
|
|
m_sortedList.Insert( pEntity );
|
|
}
|
|
}
|
|
void ReportEntityList()
|
|
{
|
|
const char *pLastClass = "";
|
|
int count = 0;
|
|
int edicts = 0;
|
|
for ( int i = 0; i < m_sortedList.Count(); i++ )
|
|
{
|
|
CBaseEntity *pEntity = m_sortedList[i];
|
|
if ( !pEntity )
|
|
continue;
|
|
|
|
if ( pEntity->edict() )
|
|
edicts++;
|
|
|
|
const char *pClassname = pEntity->GetClassname();
|
|
if ( !FStrEq( pClassname, pLastClass ) )
|
|
{
|
|
if ( count )
|
|
{
|
|
Msg("Class: %s (%d)\n", pLastClass, count );
|
|
}
|
|
|
|
pLastClass = pClassname;
|
|
count = 1;
|
|
}
|
|
else
|
|
count++;
|
|
}
|
|
if ( pLastClass[0] != 0 && count )
|
|
{
|
|
Msg("Class: %s (%d)\n", pLastClass, count );
|
|
}
|
|
if ( m_sortedList.Count() )
|
|
{
|
|
Msg("Total %d entities (%d empty, %d edicts)\n", m_sortedList.Count(), m_emptyCount, edicts );
|
|
}
|
|
}
|
|
private:
|
|
CUtlSortVector< CBaseEntity *, CEntityReportLess > m_sortedList;
|
|
int m_emptyCount;
|
|
};
|
|
|
|
|
|
|
|
CON_COMMAND(report_entities, "Lists all entities")
|
|
{
|
|
CSortedEntityList list;
|
|
CBaseEntity *pEntity = gEntList.FirstEnt();
|
|
while ( pEntity )
|
|
{
|
|
list.AddEntityToList( pEntity );
|
|
pEntity = gEntList.NextEnt( pEntity );
|
|
}
|
|
list.ReportEntityList();
|
|
}
|
|
|
|
|
|
CON_COMMAND(report_touchlinks, "Lists all touchlinks")
|
|
{
|
|
CSortedEntityList list;
|
|
CBaseEntity *pEntity = gEntList.FirstEnt();
|
|
while ( pEntity )
|
|
{
|
|
touchlink_t *root = ( touchlink_t * )pEntity->GetDataObject( TOUCHLINK );
|
|
if ( root )
|
|
{
|
|
touchlink_t *link = root->nextLink;
|
|
while ( link != root )
|
|
{
|
|
list.AddEntityToList( link->entityTouched );
|
|
link = link->nextLink;
|
|
}
|
|
}
|
|
pEntity = gEntList.NextEnt( pEntity );
|
|
}
|
|
list.ReportEntityList();
|
|
}
|
|
|
|
CON_COMMAND(report_simthinklist, "Lists all simulating/thinking entities")
|
|
{
|
|
CBaseEntity *pTmp[NUM_ENT_ENTRIES];
|
|
int count = SimThink_ListCopy( pTmp, ARRAYSIZE(pTmp) );
|
|
|
|
CSortedEntityList list;
|
|
for ( int i = 0; i < count; i++ )
|
|
{
|
|
if ( !pTmp[i] )
|
|
continue;
|
|
|
|
list.AddEntityToList( pTmp[i] );
|
|
}
|
|
list.ReportEntityList();
|
|
}
|
|
|