//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: // // $NoKeywords: $ // //=============================================================================// /* Entity Data Descriptions Each entity has an array which defines it's data in way that is useful for entity communication, parsing initial values from the map, and save/restore. each entity has to have the following line in it's class declaration: DECLARE_DATADESC(); this line defines that it has an m_DataDesc[] array, and declares functions through which various subsystems can iterate the data. In it's implementation, each entity has to have: typedescription_t CBaseEntity::m_DataDesc[] = { ... } in which all it's data is defined (see below), followed by: which implements the functions necessary for iterating through an entities data desc. There are several types of data: FIELD : this is a variable which gets saved & loaded from disk KEY : this variable can be read in from the map file GLOBAL : a global field is actually local; it is saved/restored, but is actually unique to the entity on each level. CUSTOM : the save/restore parsing functions are described by the user. ARRAY : an array of values OUTPUT : a variable or event that can be connected to other entities (see below) INPUTFUNC : maps a string input to a function pointer. Outputs connected to this input will call the notify function when fired. INPUT : maps a string input to a member variable. Outputs connected to this input will update the input data value when fired. INPUTNOTIFY : maps a string input to a member variable/function pointer combo. Outputs connected to this input will update the data value and call the notify function when fired. some of these can overlap. all the data descriptions usable are: DEFINE_FIELD( name, fieldtype ) DEFINE_KEYFIELD( name, fieldtype, mapname ) DEFINE_KEYFIELD_NOTSAVED( name, fieldtype, mapname ) DEFINE_ARRAY( name, fieldtype, count ) DEFINE_GLOBAL_FIELD(name, fieldtype ) DEFINE_CUSTOM_FIELD(name, datafuncs, mapname ) DEFINE_GLOBAL_KEYFIELD(name, fieldtype, mapname ) where: type is the name of the class (eg. CBaseEntity) name is the name of the variable in the class (eg. m_iHealth) fieldtype is the type of data (FIELD_STRING, FIELD_INTEGER, etc) mapname is the string by which this variable is associated with map file data count is the number of items in the array datafuncs is a struct containing function pointers for a custom-defined save/restore/parse OUTPUTS: DEFINE_OUTPUT( outputvar, outputname ) This maps the string 'outputname' to the COutput-derived member variable outputvar. In the VMF file these outputs can be hooked up to inputs (see above). Whenever the internal state of an entity changes it will often fire off outputs so that map makers can hook up behaviors. e.g. A door entity would have OnDoorOpen, OnDoorClose, OnTouched, etc outputs. */ #include "cbase.h" #include "entitylist.h" #include "mapentities_shared.h" #include "isaverestore.h" #include "eventqueue.h" #include "entityinput.h" #include "entityoutput.h" #include "mempool.h" #include "tier1/strtools.h" #include "datacache/imdlcache.h" #include "env_debughistory.h" #include "tier0/vprof.h" // memdbgon must be the last include file in a .cpp file!!! #include "tier0/memdbgon.h" extern ISaveRestoreOps *variantFuncs; // function pointer set for save/restoring variants BEGIN_SIMPLE_DATADESC( CEventAction ) DEFINE_FIELD( m_iTarget, FIELD_STRING ), DEFINE_FIELD( m_iTargetInput, FIELD_STRING ), DEFINE_FIELD( m_iParameter, FIELD_STRING ), DEFINE_FIELD( m_flDelay, FIELD_FLOAT ), DEFINE_FIELD( m_nTimesToFire, FIELD_INTEGER ), DEFINE_FIELD( m_iIDStamp, FIELD_INTEGER ), // This is dealt with by the Restore method // DEFINE_FIELD( m_pNext, CEventAction ), END_DATADESC() // ID Stamp used to uniquely identify every output int CEventAction::s_iNextIDStamp = 0; //----------------------------------------------------------------------------- // Purpose: Creates an event action and assigns it an unique ID stamp. // Input : ActionData - the map file data block descibing the event action. //----------------------------------------------------------------------------- CEventAction::CEventAction( const char *ActionData ) { m_pNext = NULL; m_iIDStamp = ++s_iNextIDStamp; m_flDelay = 0; m_iTarget = NULL_STRING; m_iParameter = NULL_STRING; m_iTargetInput = NULL_STRING; m_nTimesToFire = EVENT_FIRE_ALWAYS; if (ActionData == NULL) return; char szToken[256]; // // Parse the target name. // const char *psz = nexttoken(szToken, ActionData, ','); if (szToken[0] != '\0') { m_iTarget = AllocPooledString(szToken); } // // Parse the input name. // psz = nexttoken(szToken, psz, ','); if (szToken[0] != '\0') { m_iTargetInput = AllocPooledString(szToken); } else { m_iTargetInput = AllocPooledString("Use"); } // // Parse the parameter override. // psz = nexttoken(szToken, psz, ','); if (szToken[0] != '\0') { m_iParameter = AllocPooledString(szToken); } // // Parse the delay. // psz = nexttoken(szToken, psz, ','); if (szToken[0] != '\0') { m_flDelay = atof(szToken); } // // Parse the number of times to fire. // nexttoken(szToken, psz, ','); if (szToken[0] != '\0') { m_nTimesToFire = atoi(szToken); if (m_nTimesToFire == 0) { m_nTimesToFire = EVENT_FIRE_ALWAYS; } } } // this memory pool stores blocks around the size of CEventAction/inputitem_t structs // can be used for other blocks; will error if to big a block is tried to be allocated CUtlMemoryPool g_EntityListPool( MAX(sizeof(CEventAction),sizeof(CMultiInputVar::inputitem_t)), 512, CUtlMemoryPool::GROW_FAST, "g_EntityListPool" ); #include "tier0/memdbgoff.h" void *CEventAction::operator new( size_t stAllocateBlock ) { return g_EntityListPool.Alloc( stAllocateBlock ); } void *CEventAction::operator new( size_t stAllocateBlock, int nBlockUse, const char *pFileName, int nLine ) { return g_EntityListPool.Alloc( stAllocateBlock ); } void CEventAction::operator delete( void *pMem ) { g_EntityListPool.Free( pMem ); } #include "tier0/memdbgon.h" //----------------------------------------------------------------------------- // Purpose: Returns the highest-valued delay in our list of event actions. //----------------------------------------------------------------------------- float CBaseEntityOutput::GetMaxDelay(void) { float flMaxDelay = 0; CEventAction *ev = m_ActionList; while (ev != NULL) { if (ev->m_flDelay > flMaxDelay) { flMaxDelay = ev->m_flDelay; } ev = ev->m_pNext; } return(flMaxDelay); } //----------------------------------------------------------------------------- // Purpose: Destructor. //----------------------------------------------------------------------------- CBaseEntityOutput::~CBaseEntityOutput() { CEventAction *ev = m_ActionList; while (ev != NULL) { CEventAction *pNext = ev->m_pNext; delete ev; ev = pNext; } } //----------------------------------------------------------------------------- // Purpose: Fires the event, causing a sequence of action to occur in other ents. // Input : pActivator - Entity that initiated this sequence of actions. // pCaller - Entity that is actually causing the event. //----------------------------------------------------------------------------- void CBaseEntityOutput::FireOutput(variant_t Value, CBaseEntity *pActivator, CBaseEntity *pCaller, float fDelay) { // // Iterate through all eventactions and fire them off. // CEventAction *ev = m_ActionList; CEventAction *prev = NULL; while (ev != NULL) { if (ev->m_iParameter == NULL_STRING) { // // Post the event with the default parameter. // g_EventQueue.AddEvent( STRING(ev->m_iTarget), STRING(ev->m_iTargetInput), Value, ev->m_flDelay + fDelay, pActivator, pCaller, ev->m_iIDStamp ); } else { // // Post the event with a parameter override. // variant_t ValueOverride; ValueOverride.SetString( ev->m_iParameter ); g_EventQueue.AddEvent( STRING(ev->m_iTarget), STRING(ev->m_iTargetInput), ValueOverride, ev->m_flDelay, pActivator, pCaller, ev->m_iIDStamp ); } if ( ev->m_flDelay ) { char szBuffer[256]; Q_snprintf( szBuffer, sizeof(szBuffer), "(%0.2f) output: (%s,%s) -> (%s,%s,%.1f)(%s)\n", #ifdef TF_DLL engine->GetServerTime(), #else gpGlobals->curtime, #endif pCaller ? STRING(pCaller->m_iClassname) : "NULL", pCaller ? STRING(pCaller->GetEntityName()) : "NULL", STRING(ev->m_iTarget), STRING(ev->m_iTargetInput), ev->m_flDelay, STRING(ev->m_iParameter) ); DevMsg( 2, "%s", szBuffer ); ADD_DEBUG_HISTORY( HISTORY_ENTITY_IO, szBuffer ); } else { char szBuffer[256]; Q_snprintf( szBuffer, sizeof(szBuffer), "(%0.2f) output: (%s,%s) -> (%s,%s)(%s)\n", #ifdef TF_DLL engine->GetServerTime(), #else gpGlobals->curtime, #endif pCaller ? STRING(pCaller->m_iClassname) : "NULL", pCaller ? STRING(pCaller->GetEntityName()) : "NULL", STRING(ev->m_iTarget), STRING(ev->m_iTargetInput), STRING(ev->m_iParameter) ); DevMsg( 2, "%s", szBuffer ); ADD_DEBUG_HISTORY( HISTORY_ENTITY_IO, szBuffer ); } if ( pCaller && pCaller->m_debugOverlays & OVERLAY_MESSAGE_BIT) { pCaller->DrawOutputOverlay(ev); } // // Remove the event action from the list if it was set to be fired a finite // number of times (and has been). // bool bRemove = false; if (ev->m_nTimesToFire != EVENT_FIRE_ALWAYS) { ev->m_nTimesToFire--; if (ev->m_nTimesToFire == 0) { char szBuffer[256]; Q_snprintf( szBuffer, sizeof(szBuffer), "Removing from action list: (%s,%s) -> (%s,%s)\n", pCaller ? STRING(pCaller->m_iClassname) : "NULL", pCaller ? STRING(pCaller->GetEntityName()) : "NULL", STRING(ev->m_iTarget), STRING(ev->m_iTargetInput)); DevMsg( 2, "%s", szBuffer ); ADD_DEBUG_HISTORY( HISTORY_ENTITY_IO, szBuffer ); bRemove = true; } } if (!bRemove) { prev = ev; ev = ev->m_pNext; } else { if (prev != NULL) { prev->m_pNext = ev->m_pNext; } else { m_ActionList = ev->m_pNext; } CEventAction *next = ev->m_pNext; delete ev; ev = next; } } } //----------------------------------------------------------------------------- // Purpose: Parameterless firing of an event // Input : pActivator - // pCaller - //----------------------------------------------------------------------------- void COutputEvent::FireOutput(CBaseEntity *pActivator, CBaseEntity *pCaller, float fDelay) { variant_t Val; Val.Set( FIELD_VOID, NULL ); CBaseEntityOutput::FireOutput(Val, pActivator, pCaller, fDelay); } void CBaseEntityOutput::ParseEventAction( const char *EventData ) { AddEventAction( new CEventAction( EventData ) ); } void CBaseEntityOutput::AddEventAction( CEventAction *pEventAction ) { pEventAction->m_pNext = m_ActionList; m_ActionList = pEventAction; } // save data description for the event queue BEGIN_SIMPLE_DATADESC( CBaseEntityOutput ) DEFINE_CUSTOM_FIELD( m_Value, variantFuncs ), // This is saved manually by CBaseEntityOutput::Save // DEFINE_FIELD( m_ActionList, CEventAction ), END_DATADESC() int CBaseEntityOutput::Save( ISave &save ) { // save that value out to disk, so we know how many to restore if ( !save.WriteFields( "Value", this, NULL, m_DataMap.dataDesc, m_DataMap.dataNumFields ) ) return 0; for ( CEventAction *ev = m_ActionList; ev != NULL; ev = ev->m_pNext ) { if ( !save.WriteFields( "EntityOutput", ev, NULL, ev->m_DataMap.dataDesc, ev->m_DataMap.dataNumFields ) ) return 0; } return 1; } int CBaseEntityOutput::Restore( IRestore &restore, int elementCount ) { // load the number of items saved if ( !restore.ReadFields( "Value", this, NULL, m_DataMap.dataDesc, m_DataMap.dataNumFields ) ) return 0; m_ActionList = NULL; // read in all the fields CEventAction *lastEv = NULL; for ( int i = 0; i < elementCount; i++ ) { CEventAction *ev = new CEventAction(NULL); if ( !restore.ReadFields( "EntityOutput", ev, NULL, ev->m_DataMap.dataDesc, ev->m_DataMap.dataNumFields ) ) return 0; // add it to the list in the same order it was saved in if ( lastEv ) { lastEv->m_pNext = ev; } else { m_ActionList = ev; } ev->m_pNext = NULL; lastEv = ev; } return 1; } int CBaseEntityOutput::NumberOfElements( void ) { int count = 0; for ( CEventAction *ev = m_ActionList; ev != NULL; ev = ev->m_pNext ) { count++; } return count; } /// Delete every single action in the action list. void CBaseEntityOutput::DeleteAllElements( void ) { // walk front to back, deleting as we go. We needn't fix up pointers because // EVERYTHING will die. CEventAction *pNext = m_ActionList; // wipe out the head m_ActionList = NULL; while (pNext) { register CEventAction *strikeThis = pNext; pNext = pNext->m_pNext; delete strikeThis; } } /// EVENTS save/restore parsing wrapper class CEventsSaveDataOps : public ISaveRestoreOps { virtual void Save( const SaveRestoreFieldInfo_t &fieldInfo, ISave *pSave ) { AssertMsg( fieldInfo.pTypeDesc->fieldSize == 1, "CEventsSaveDataOps does not support arrays"); CBaseEntityOutput *ev = (CBaseEntityOutput*)fieldInfo.pField; const int fieldSize = fieldInfo.pTypeDesc->fieldSize; for ( int i = 0; i < fieldSize; i++, ev++ ) { // save out the number of fields int numElements = ev->NumberOfElements(); pSave->WriteInt( &numElements, 1 ); // save the event data ev->Save( *pSave ); } } virtual void Restore( const SaveRestoreFieldInfo_t &fieldInfo, IRestore *pRestore ) { AssertMsg( fieldInfo.pTypeDesc->fieldSize == 1, "CEventsSaveDataOps does not support arrays"); CBaseEntityOutput *ev = (CBaseEntityOutput*)fieldInfo.pField; const int fieldSize = fieldInfo.pTypeDesc->fieldSize; for ( int i = 0; i < fieldSize; i++, ev++ ) { int nElements = pRestore->ReadInt(); Assert( nElements < 100 ); ev->Restore( *pRestore, nElements ); } } virtual bool IsEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) { AssertMsg( fieldInfo.pTypeDesc->fieldSize == 1, "CEventsSaveDataOps does not support arrays"); // check all the elements of the array (usually only 1) CBaseEntityOutput *ev = (CBaseEntityOutput*)fieldInfo.pField; const int fieldSize = fieldInfo.pTypeDesc->fieldSize; for ( int i = 0; i < fieldSize; i++, ev++ ) { // It's not empty if it has events or if it has a non-void variant value if (( ev->NumberOfElements() != 0 ) || ( ev->ValueFieldType() != FIELD_VOID )) return 0; } // variant has no data return 1; } virtual void MakeEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) { // Don't no how to. This is okay, since objects of this type // are always born clean before restore, and not reused } virtual bool Parse( const SaveRestoreFieldInfo_t &fieldInfo, char const* szValue ) { CBaseEntityOutput *ev = (CBaseEntityOutput*)fieldInfo.pField; ev->ParseEventAction( szValue ); return true; } }; CEventsSaveDataOps g_EventsSaveDataOps; ISaveRestoreOps *eventFuncs = &g_EventsSaveDataOps; //----------------------------------------------------------------------------- // CMultiInputVar implementation // // Purpose: holds a list of inputs and their ID tags // used for entities that hold inputs from a set of other entities //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- // Purpose: destructor, frees the data list //----------------------------------------------------------------------------- CMultiInputVar::~CMultiInputVar() { if ( m_InputList ) { while ( m_InputList->next != NULL ) { inputitem_t *input = m_InputList->next; m_InputList->next = input->next; delete input; } delete m_InputList; } } //----------------------------------------------------------------------------- // Purpose: Updates the data set with a new value // Input : newVal - the new value to add to or update in the list // outputID - the source of the value //----------------------------------------------------------------------------- void CMultiInputVar::AddValue( variant_t newVal, int outputID ) { // see if it's already in the list inputitem_t *inp; for ( inp = m_InputList; inp != NULL; inp = inp->next ) { // already in list, so just update this link if ( inp->outputID == outputID ) { inp->value = newVal; return; } } // add to start of list inp = new inputitem_t; inp->value = newVal; inp->outputID = outputID; if ( !m_InputList ) { m_InputList = inp; inp->next = NULL; } else { inp->next = m_InputList; m_InputList = inp; } } #include "tier0/memdbgoff.h" //----------------------------------------------------------------------------- // Purpose: allocates memory from the entitylist pool //----------------------------------------------------------------------------- void *CMultiInputVar::inputitem_t::operator new( size_t stAllocateBlock ) { return g_EntityListPool.Alloc( stAllocateBlock ); } void *CMultiInputVar::inputitem_t::operator new( size_t stAllocateBlock, int nBlockUse, const char *pFileName, int nLine ) { return g_EntityListPool.Alloc( stAllocateBlock ); } //----------------------------------------------------------------------------- // Purpose: frees memory from the entitylist pool //----------------------------------------------------------------------------- void CMultiInputVar::inputitem_t::operator delete( void *pMem ) { g_EntityListPool.Free( pMem ); } #include "tier0/memdbgon.h" //----------------------------------------------------------------------------- // CEventQueue implementation // // Purpose: holds and executes a global prioritized queue of entity actions //----------------------------------------------------------------------------- DEFINE_FIXEDSIZE_ALLOCATOR( EventQueuePrioritizedEvent_t, 128, CUtlMemoryPool::GROW_SLOW ); CEventQueue g_EventQueue; CEventQueue::CEventQueue() { m_Events.m_flFireTime = -FLT_MAX; m_Events.m_pNext = NULL; Init(); } CEventQueue::~CEventQueue() { Clear(); } // Robin: Left here for backwards compatability. class CEventQueueSaveLoadProxy : public CLogicalEntity { DECLARE_CLASS( CEventQueueSaveLoadProxy, CLogicalEntity ); int Save( ISave &save ) { if ( !BaseClass::Save(save) ) return 0; // save out the message queue return g_EventQueue.Save( save ); } int Restore( IRestore &restore ) { if ( !BaseClass::Restore(restore) ) return 0; // restore the event queue int iReturn = g_EventQueue.Restore( restore ); // Now remove myself, because the CEventQueue_SaveRestoreBlockHandler // will handle future saves. UTIL_Remove( this ); return iReturn; } }; LINK_ENTITY_TO_CLASS(event_queue_saveload_proxy, CEventQueueSaveLoadProxy); //----------------------------------------------------------------------------- // EVENT QUEUE SAVE / RESTORE //----------------------------------------------------------------------------- static short EVENTQUEUE_SAVE_RESTORE_VERSION = 1; class CEventQueue_SaveRestoreBlockHandler : public CDefSaveRestoreBlockHandler { public: const char *GetBlockName() { return "EventQueue"; } //--------------------------------- void Save( ISave *pSave ) { g_EventQueue.Save( *pSave ); } //--------------------------------- void WriteSaveHeaders( ISave *pSave ) { pSave->WriteShort( &EVENTQUEUE_SAVE_RESTORE_VERSION ); } //--------------------------------- void ReadRestoreHeaders( IRestore *pRestore ) { // No reason why any future version shouldn't try to retain backward compatability. The default here is to not do so. short version; pRestore->ReadShort( &version ); m_fDoLoad = ( version == EVENTQUEUE_SAVE_RESTORE_VERSION ); } //--------------------------------- void Restore( IRestore *pRestore, bool createPlayers ) { if ( m_fDoLoad ) { g_EventQueue.Restore( *pRestore ); } } private: bool m_fDoLoad; }; //----------------------------------------------------------------------------- CEventQueue_SaveRestoreBlockHandler g_EventQueue_SaveRestoreBlockHandler; //------------------------------------- ISaveRestoreBlockHandler *GetEventQueueSaveRestoreBlockHandler() { return &g_EventQueue_SaveRestoreBlockHandler; } void CEventQueue::Init( void ) { Clear(); } void CEventQueue::Clear( void ) { // delete all the events in the queue EventQueuePrioritizedEvent_t *pe = m_Events.m_pNext; while ( pe != NULL ) { EventQueuePrioritizedEvent_t *next = pe->m_pNext; delete pe; pe = next; } m_Events.m_pNext = NULL; } void CEventQueue::Dump( void ) { EventQueuePrioritizedEvent_t *pe = m_Events.m_pNext; Msg("Dumping event queue. Current time is: %.2f\n", #ifdef TF_DLL engine->GetServerTime() #else gpGlobals->curtime #endif ); while ( pe != NULL ) { EventQueuePrioritizedEvent_t *next = pe->m_pNext; Msg(" (%.2f) Target: '%s', Input: '%s', Parameter '%s'. Activator: '%s', Caller '%s'. \n", pe->m_flFireTime, STRING(pe->m_iTarget), STRING(pe->m_iTargetInput), pe->m_VariantValue.String(), pe->m_pActivator ? pe->m_pActivator->GetDebugName() : "None", pe->m_pCaller ? pe->m_pCaller->GetDebugName() : "None" ); pe = next; } Msg("Finished dump.\n"); } //----------------------------------------------------------------------------- // Purpose: adds the action into the correct spot in the priority queue, targeting entity via string name //----------------------------------------------------------------------------- void CEventQueue::AddEvent( const char *target, const char *targetInput, variant_t Value, float fireDelay, CBaseEntity *pActivator, CBaseEntity *pCaller, int outputID ) { // build the new event EventQueuePrioritizedEvent_t *newEvent = new EventQueuePrioritizedEvent_t; #ifdef TF_DLL newEvent->m_flFireTime = engine->GetServerTime() + fireDelay; // priority key in the priority queue #else newEvent->m_flFireTime = gpGlobals->curtime + fireDelay; // priority key in the priority queue #endif newEvent->m_iTarget = MAKE_STRING( target ); newEvent->m_pEntTarget = NULL; newEvent->m_iTargetInput = MAKE_STRING( targetInput ); newEvent->m_pActivator = pActivator; newEvent->m_pCaller = pCaller; newEvent->m_VariantValue = Value; newEvent->m_iOutputID = outputID; AddEvent( newEvent ); } //----------------------------------------------------------------------------- // Purpose: adds the action into the correct spot in the priority queue, targeting entity via pointer //----------------------------------------------------------------------------- void CEventQueue::AddEvent( CBaseEntity *target, const char *targetInput, variant_t Value, float fireDelay, CBaseEntity *pActivator, CBaseEntity *pCaller, int outputID ) { // build the new event EventQueuePrioritizedEvent_t *newEvent = new EventQueuePrioritizedEvent_t; #ifdef TF_DLL newEvent->m_flFireTime = engine->GetServerTime() + fireDelay; // primary priority key in the priority queue #else newEvent->m_flFireTime = gpGlobals->curtime + fireDelay; // primary priority key in the priority queue #endif newEvent->m_iTarget = NULL_STRING; newEvent->m_pEntTarget = target; newEvent->m_iTargetInput = MAKE_STRING( targetInput ); newEvent->m_pActivator = pActivator; newEvent->m_pCaller = pCaller; newEvent->m_VariantValue = Value; newEvent->m_iOutputID = outputID; AddEvent( newEvent ); } void CEventQueue::AddEvent( CBaseEntity *target, const char *action, float fireDelay, CBaseEntity *pActivator, CBaseEntity *pCaller, int outputID ) { variant_t Value; Value.Set( FIELD_VOID, NULL ); AddEvent( target, action, Value, fireDelay, pActivator, pCaller, outputID ); } //----------------------------------------------------------------------------- // Purpose: private function, adds an event into the list // Input : *newEvent - the (already built) event to add //----------------------------------------------------------------------------- void CEventQueue::AddEvent( EventQueuePrioritizedEvent_t *newEvent ) { // loop through the actions looking for a place to insert EventQueuePrioritizedEvent_t *pe; for ( pe = &m_Events; pe->m_pNext != NULL; pe = pe->m_pNext ) { if ( pe->m_pNext->m_flFireTime > newEvent->m_flFireTime ) { break; } } Assert( pe ); // insert newEvent->m_pNext = pe->m_pNext; newEvent->m_pPrev = pe; pe->m_pNext = newEvent; if ( newEvent->m_pNext ) { newEvent->m_pNext->m_pPrev = newEvent; } } void CEventQueue::RemoveEvent( EventQueuePrioritizedEvent_t *pe ) { Assert( pe->m_pPrev ); pe->m_pPrev->m_pNext = pe->m_pNext; if ( pe->m_pNext ) { pe->m_pNext->m_pPrev = pe->m_pPrev; } } //----------------------------------------------------------------------------- // Purpose: fires off any events in the queue who's fire time is (or before) the present time //----------------------------------------------------------------------------- void CEventQueue::ServiceEvents( void ) { if (!CBaseEntity::Debug_ShouldStep()) { return; } EventQueuePrioritizedEvent_t *pe = m_Events.m_pNext; #ifdef TF_DLL while ( pe != NULL && pe->m_flFireTime <= engine->GetServerTime() ) #else while ( pe != NULL && pe->m_flFireTime <= gpGlobals->curtime ) #endif { MDLCACHE_CRITICAL_SECTION(); bool targetFound = false; // find the targets if ( pe->m_iTarget != NULL_STRING ) { // In the context the event, the searching entity is also the caller CBaseEntity *pSearchingEntity = pe->m_pCaller; CBaseEntity *target = NULL; while ( 1 ) { target = gEntList.FindEntityByName( target, pe->m_iTarget, pSearchingEntity, pe->m_pActivator, pe->m_pCaller ); if ( !target ) break; // pump the action into the target target->AcceptInput( STRING(pe->m_iTargetInput), pe->m_pActivator, pe->m_pCaller, pe->m_VariantValue, pe->m_iOutputID ); targetFound = true; } } // direct pointer if ( pe->m_pEntTarget != NULL ) { pe->m_pEntTarget->AcceptInput( STRING(pe->m_iTargetInput), pe->m_pActivator, pe->m_pCaller, pe->m_VariantValue, pe->m_iOutputID ); targetFound = true; } if ( !targetFound ) { // See if we can find a target if we treat the target as a classname if ( pe->m_iTarget != NULL_STRING ) { CBaseEntity *target = NULL; while ( 1 ) { target = gEntList.FindEntityByClassname( target, STRING(pe->m_iTarget) ); if ( !target ) break; // pump the action into the target target->AcceptInput( STRING(pe->m_iTargetInput), pe->m_pActivator, pe->m_pCaller, pe->m_VariantValue, pe->m_iOutputID ); targetFound = true; } } } if ( !targetFound ) { const char *pClass ="", *pName = ""; // might be NULL if ( pe->m_pCaller ) { pClass = STRING(pe->m_pCaller->m_iClassname); pName = STRING(pe->m_pCaller->GetEntityName()); } char szBuffer[256]; Q_snprintf( szBuffer, sizeof(szBuffer), "unhandled input: (%s) -> (%s), from (%s,%s); target entity not found\n", STRING(pe->m_iTargetInput), STRING(pe->m_iTarget), pClass, pName ); DevMsg( 2, "%s", szBuffer ); ADD_DEBUG_HISTORY( HISTORY_ENTITY_IO, szBuffer ); } // remove the event from the list (remembering that the queue may have been added to) RemoveEvent( pe ); delete pe; // // If we are in debug mode, exit the loop if we have fired the correct number of events. // if (CBaseEntity::Debug_IsPaused()) { if (!CBaseEntity::Debug_Step()) { break; } } // restart the list (to catch any new items have probably been added to the queue) pe = m_Events.m_pNext; } } //----------------------------------------------------------------------------- // Purpose: Dumps the contents of the Entity I/O event queue to the console. //----------------------------------------------------------------------------- void CC_DumpEventQueue() { if ( !UTIL_IsCommandIssuedByServerAdmin() ) return; g_EventQueue.Dump(); } static ConCommand dumpeventqueue( "dumpeventqueue", CC_DumpEventQueue, "Dump the contents of the Entity I/O event queue to the console." ); //----------------------------------------------------------------------------- // Purpose: Removes all pending events from the I/O queue that were added by the // given caller. // // TODO: This is only as reliable as callers are in passing the correct // caller pointer when they fire the outputs. Make more foolproof. //----------------------------------------------------------------------------- void CEventQueue::CancelEvents( CBaseEntity *pCaller ) { if (!pCaller) return; EventQueuePrioritizedEvent_t *pCur = m_Events.m_pNext; while (pCur != NULL) { bool bDelete = false; if (pCur->m_pCaller == pCaller) { // Pointers match; make sure everything else matches. if (!stricmp(STRING(pCur->m_pCaller->GetEntityName()), STRING(pCaller->GetEntityName())) && !stricmp(pCur->m_pCaller->GetClassname(), pCaller->GetClassname())) { // Found a matching event; delete it from the queue. bDelete = true; } } EventQueuePrioritizedEvent_t *pCurSave = pCur; pCur = pCur->m_pNext; if (bDelete) { RemoveEvent( pCurSave ); delete pCurSave; } } } //----------------------------------------------------------------------------- // Purpose: Removes all pending events of the specified type from the I/O queue of the specified target // // TODO: This is only as reliable as callers are in passing the correct // caller pointer when they fire the outputs. Make more foolproof. //----------------------------------------------------------------------------- void CEventQueue::CancelEventOn( CBaseEntity *pTarget, const char *sInputName ) { if (!pTarget) return; EventQueuePrioritizedEvent_t *pCur = m_Events.m_pNext; while (pCur != NULL) { bool bDelete = false; if (pCur->m_pEntTarget == pTarget) { if ( !Q_strncmp( STRING(pCur->m_iTargetInput), sInputName, strlen(sInputName) ) ) { // Found a matching event; delete it from the queue. bDelete = true; } } EventQueuePrioritizedEvent_t *pCurSave = pCur; pCur = pCur->m_pNext; if (bDelete) { RemoveEvent( pCurSave ); delete pCurSave; } } } //----------------------------------------------------------------------------- // Purpose: Return true if the target has any pending inputs. // Input : *pTarget - // *sInputName - NULL for any input, or a specified one //----------------------------------------------------------------------------- bool CEventQueue::HasEventPending( CBaseEntity *pTarget, const char *sInputName ) { if (!pTarget) return false; EventQueuePrioritizedEvent_t *pCur = m_Events.m_pNext; while (pCur != NULL) { if (pCur->m_pEntTarget == pTarget) { if ( !sInputName ) return true; if ( !Q_strncmp( STRING(pCur->m_iTargetInput), sInputName, strlen(sInputName) ) ) return true; } pCur = pCur->m_pNext; } return false; } void ServiceEventQueue( void ) { VPROF("ServiceEventQueue()"); g_EventQueue.ServiceEvents(); } // save data description for the event queue BEGIN_SIMPLE_DATADESC( CEventQueue ) // These are saved explicitly in CEventQueue::Save below // DEFINE_FIELD( m_Events, EventQueuePrioritizedEvent_t ), DEFINE_FIELD( m_iListCount, FIELD_INTEGER ), // this value is only used during save/restore END_DATADESC() // save data for a single event in the queue BEGIN_SIMPLE_DATADESC( EventQueuePrioritizedEvent_t ) DEFINE_FIELD( m_flFireTime, FIELD_TIME ), DEFINE_FIELD( m_iTarget, FIELD_STRING ), DEFINE_FIELD( m_iTargetInput, FIELD_STRING ), DEFINE_FIELD( m_pActivator, FIELD_EHANDLE ), DEFINE_FIELD( m_pCaller, FIELD_EHANDLE ), DEFINE_FIELD( m_pEntTarget, FIELD_EHANDLE ), DEFINE_FIELD( m_iOutputID, FIELD_INTEGER ), DEFINE_CUSTOM_FIELD( m_VariantValue, variantFuncs ), // DEFINE_FIELD( m_pNext, FIELD_??? ), // DEFINE_FIELD( m_pPrev, FIELD_??? ), END_DATADESC() int CEventQueue::Save( ISave &save ) { // count the number of items in the queue EventQueuePrioritizedEvent_t *pe; m_iListCount = 0; for ( pe = m_Events.m_pNext; pe != NULL; pe = pe->m_pNext ) { m_iListCount++; } // save that value out to disk, so we know how many to restore if ( !save.WriteFields( "EventQueue", this, NULL, m_DataMap.dataDesc, m_DataMap.dataNumFields ) ) return 0; // cycle through all the events, saving them all for ( pe = m_Events.m_pNext; pe != NULL; pe = pe->m_pNext ) { if ( !save.WriteFields( "PEvent", pe, NULL, pe->m_DataMap.dataDesc, pe->m_DataMap.dataNumFields ) ) return 0; } return 1; } int CEventQueue::Restore( IRestore &restore ) { // clear the event queue Clear(); // rebuild the event queue by restoring all the queue items EventQueuePrioritizedEvent_t tmpEvent; // load the number of items saved if ( !restore.ReadFields( "EventQueue", this, NULL, m_DataMap.dataDesc, m_DataMap.dataNumFields ) ) return 0; for ( int i = 0; i < m_iListCount; i++ ) { if ( !restore.ReadFields( "PEvent", &tmpEvent, NULL, tmpEvent.m_DataMap.dataDesc, tmpEvent.m_DataMap.dataNumFields ) ) return 0; // add the restored event into the list if ( tmpEvent.m_pEntTarget ) { AddEvent( tmpEvent.m_pEntTarget, STRING(tmpEvent.m_iTargetInput), tmpEvent.m_VariantValue, #ifdef TF_DLL tmpEvent.m_flFireTime - engine->GetServerTime(), #else tmpEvent.m_flFireTime - gpGlobals->curtime, #endif tmpEvent.m_pActivator, tmpEvent.m_pCaller, tmpEvent.m_iOutputID ); } else { AddEvent( STRING(tmpEvent.m_iTarget), STRING(tmpEvent.m_iTargetInput), tmpEvent.m_VariantValue, #ifdef TF_DLL tmpEvent.m_flFireTime - engine->GetServerTime(), #else tmpEvent.m_flFireTime - gpGlobals->curtime, #endif tmpEvent.m_pActivator, tmpEvent.m_pCaller, tmpEvent.m_iOutputID ); } } return 1; } ////////////////////////// variant_t implementation ////////////////////////// // BUGBUG: Add support for function pointer save/restore to variants // BUGBUG: Must pass datamap_t to read/write fields void variant_t::Set( fieldtype_t ftype, void *data ) { fieldType = ftype; switch ( ftype ) { case FIELD_BOOLEAN: bVal = *((bool *)data); break; case FIELD_CHARACTER: iVal = *((char *)data); break; case FIELD_SHORT: iVal = *((short *)data); break; case FIELD_INTEGER: iVal = *((int *)data); break; case FIELD_STRING: iszVal = *((string_t *)data); break; case FIELD_FLOAT: flVal = *((float *)data); break; case FIELD_COLOR32: rgbaVal = *((color32 *)data); break; case FIELD_VECTOR: case FIELD_POSITION_VECTOR: { vecVal[0] = ((float *)data)[0]; vecVal[1] = ((float *)data)[1]; vecVal[2] = ((float *)data)[2]; break; } case FIELD_EHANDLE: eVal = *((EHANDLE *)data); break; case FIELD_CLASSPTR: eVal = *((CBaseEntity **)data); break; case FIELD_VOID: default: iVal = 0; fieldType = FIELD_VOID; break; } } //----------------------------------------------------------------------------- // Purpose: Copies the value in the variant into a block of memory // Input : *data - the block to write into //----------------------------------------------------------------------------- void variant_t::SetOther( void *data ) { switch ( fieldType ) { case FIELD_BOOLEAN: *((bool *)data) = bVal != 0; break; case FIELD_CHARACTER: *((char *)data) = iVal; break; case FIELD_SHORT: *((short *)data) = iVal; break; case FIELD_INTEGER: *((int *)data) = iVal; break; case FIELD_STRING: *((string_t *)data) = iszVal; break; case FIELD_FLOAT: *((float *)data) = flVal; break; case FIELD_COLOR32: *((color32 *)data) = rgbaVal; break; case FIELD_VECTOR: case FIELD_POSITION_VECTOR: { ((float *)data)[0] = vecVal[0]; ((float *)data)[1] = vecVal[1]; ((float *)data)[2] = vecVal[2]; break; } case FIELD_EHANDLE: *((EHANDLE *)data) = eVal; break; case FIELD_CLASSPTR: *((CBaseEntity **)data) = eVal; break; } } //----------------------------------------------------------------------------- // Purpose: Converts the variant to a new type. This function defines which I/O // types can be automatically converted between. Connections that require // an unsupported conversion will cause an error message at runtime. // Input : newType - the type to convert to // Output : Returns true on success, false if the conversion is not legal //----------------------------------------------------------------------------- bool variant_t::Convert( fieldtype_t newType ) { if ( newType == fieldType ) { return true; } // // Converting to a null value is easy. // if ( newType == FIELD_VOID ) { Set( FIELD_VOID, NULL ); return true; } // // FIELD_INPUT accepts the variant type directly. // if ( newType == FIELD_INPUT ) { return true; } switch ( fieldType ) { case FIELD_INTEGER: { switch ( newType ) { case FIELD_FLOAT: { SetFloat( (float) iVal ); return true; } case FIELD_BOOLEAN: { SetBool( iVal != 0 ); return true; } } break; } case FIELD_FLOAT: { switch ( newType ) { case FIELD_INTEGER: { SetInt( (int) flVal ); return true; } case FIELD_BOOLEAN: { SetBool( flVal != 0 ); return true; } } break; } // // Everyone must convert from FIELD_STRING if possible, since // parameter overrides are always passed as strings. // case FIELD_STRING: { switch ( newType ) { case FIELD_INTEGER: { if (iszVal != NULL_STRING) { SetInt(atoi(STRING(iszVal))); } else { SetInt(0); } return true; } case FIELD_FLOAT: { if (iszVal != NULL_STRING) { SetFloat(atof(STRING(iszVal))); } else { SetFloat(0); } return true; } case FIELD_BOOLEAN: { if (iszVal != NULL_STRING) { SetBool( atoi(STRING(iszVal)) != 0 ); } else { SetBool(false); } return true; } case FIELD_VECTOR: { Vector tmpVec = vec3_origin; if (sscanf(STRING(iszVal), "[%f %f %f]", &tmpVec[0], &tmpVec[1], &tmpVec[2]) == 0) { // Try sucking out 3 floats with no []s sscanf(STRING(iszVal), "%f %f %f", &tmpVec[0], &tmpVec[1], &tmpVec[2]); } SetVector3D( tmpVec ); return true; } case FIELD_COLOR32: { int nRed = 0; int nGreen = 0; int nBlue = 0; int nAlpha = 255; sscanf(STRING(iszVal), "%d %d %d %d", &nRed, &nGreen, &nBlue, &nAlpha); SetColor32( nRed, nGreen, nBlue, nAlpha ); return true; } case FIELD_EHANDLE: { // convert the string to an entity by locating it by classname CBaseEntity *ent = NULL; if ( iszVal != NULL_STRING ) { // FIXME: do we need to pass an activator in here? ent = gEntList.FindEntityByName( NULL, iszVal ); } SetEntity( ent ); return true; } } break; } case FIELD_EHANDLE: { switch ( newType ) { case FIELD_STRING: { // take the entities targetname as the string string_t iszStr = NULL_STRING; if ( eVal != NULL ) { SetString( eVal->GetEntityName() ); } return true; } } break; } } // invalid conversion return false; } //----------------------------------------------------------------------------- // Purpose: All types must be able to display as strings for debugging purposes. // Output : Returns a pointer to the string that represents this value. // // NOTE: The returned pointer should not be stored by the caller as // subsequent calls to this function will overwrite the contents // of the buffer! //----------------------------------------------------------------------------- const char *variant_t::ToString( void ) const { COMPILE_TIME_ASSERT( sizeof(string_t) == sizeof(intp) ); static char szBuf[512]; switch (fieldType) { case FIELD_STRING: { return(STRING(iszVal)); } case FIELD_BOOLEAN: { if (bVal == 0) { Q_strncpy(szBuf, "false",sizeof(szBuf)); } else { Q_strncpy(szBuf, "true",sizeof(szBuf)); } return(szBuf); } case FIELD_INTEGER: { Q_snprintf( szBuf, sizeof( szBuf ), "%i", iVal ); return(szBuf); } case FIELD_FLOAT: { Q_snprintf(szBuf,sizeof(szBuf), "%g", flVal); return(szBuf); } case FIELD_COLOR32: { Q_snprintf(szBuf,sizeof(szBuf), "%d %d %d %d", (int)rgbaVal.r, (int)rgbaVal.g, (int)rgbaVal.b, (int)rgbaVal.a); return(szBuf); } case FIELD_VECTOR: { Q_snprintf(szBuf,sizeof(szBuf), "[%g %g %g]", (double)vecVal[0], (double)vecVal[1], (double)vecVal[2]); return(szBuf); } case FIELD_VOID: { szBuf[0] = '\0'; return(szBuf); } case FIELD_EHANDLE: { const char *pszName = (Entity()) ? STRING(Entity()->GetEntityName()) : "<>"; Q_strncpy( szBuf, pszName, 512 ); return (szBuf); } } return("No conversion to string"); } #define classNameTypedef variant_t // to satisfy DEFINE... macros typedescription_t variant_t::m_SaveBool[] = { DEFINE_FIELD( bVal, FIELD_BOOLEAN ), }; typedescription_t variant_t::m_SaveInt[] = { DEFINE_FIELD( iVal, FIELD_INTEGER ), }; typedescription_t variant_t::m_SaveFloat[] = { DEFINE_FIELD( flVal, FIELD_FLOAT ), }; typedescription_t variant_t::m_SaveEHandle[] = { DEFINE_FIELD( eVal, FIELD_EHANDLE ), }; typedescription_t variant_t::m_SaveString[] = { DEFINE_FIELD( iszVal, FIELD_STRING ), }; typedescription_t variant_t::m_SaveColor[] = { DEFINE_FIELD( rgbaVal, FIELD_COLOR32 ), }; #undef classNameTypedef // // Struct for saving and restoring vector variants, since they are // stored as float[3] and we want to take advantage of position vector // fixup across level transitions. // #define classNameTypedef variant_savevector_t // to satisfy DEFINE... macros struct variant_savevector_t { Vector vecSave; }; typedescription_t variant_t::m_SaveVector[] = { // Just here to shut up ClassCheck // DEFINE_ARRAY( vecVal, FIELD_FLOAT, 3 ), DEFINE_FIELD( vecSave, FIELD_VECTOR ), }; typedescription_t variant_t::m_SavePositionVector[] = { DEFINE_FIELD( vecSave, FIELD_POSITION_VECTOR ), }; #undef classNameTypedef #define classNameTypedef variant_savevmatrix_t // to satisfy DEFINE... macros struct variant_savevmatrix_t { VMatrix matSave; }; typedescription_t variant_t::m_SaveVMatrix[] = { DEFINE_FIELD( matSave, FIELD_VMATRIX ), }; typedescription_t variant_t::m_SaveVMatrixWorldspace[] = { DEFINE_FIELD( matSave, FIELD_VMATRIX_WORLDSPACE ), }; #undef classNameTypedef #define classNameTypedef variant_savevmatrix3x4_t // to satisfy DEFINE... macros struct variant_savevmatrix3x4_t { matrix3x4_t matSave; }; typedescription_t variant_t::m_SaveMatrix3x4Worldspace[] = { DEFINE_FIELD( matSave, FIELD_MATRIX3X4_WORLDSPACE ), }; #undef classNameTypedef class CVariantSaveDataOps : public CDefSaveRestoreOps { // saves the entire array of variables virtual void Save( const SaveRestoreFieldInfo_t &fieldInfo, ISave *pSave ) { variant_t *var = (variant_t*)fieldInfo.pField; int type = var->FieldType(); pSave->WriteInt( &type, 1 ); switch ( var->FieldType() ) { case FIELD_VOID: break; case FIELD_BOOLEAN: pSave->WriteFields( fieldInfo.pTypeDesc->fieldName, var, NULL, variant_t::m_SaveBool, 1 ); break; case FIELD_INTEGER: pSave->WriteFields( fieldInfo.pTypeDesc->fieldName, var, NULL, variant_t::m_SaveInt, 1 ); break; case FIELD_FLOAT: pSave->WriteFields( fieldInfo.pTypeDesc->fieldName, var, NULL, variant_t::m_SaveFloat, 1 ); break; case FIELD_EHANDLE: pSave->WriteFields( fieldInfo.pTypeDesc->fieldName, var, NULL, variant_t::m_SaveEHandle, 1 ); break; case FIELD_STRING: pSave->WriteFields( fieldInfo.pTypeDesc->fieldName, var, NULL, variant_t::m_SaveString, 1 ); break; case FIELD_COLOR32: pSave->WriteFields( fieldInfo.pTypeDesc->fieldName, var, NULL, variant_t::m_SaveColor, 1 ); break; case FIELD_VECTOR: { variant_savevector_t Temp; var->Vector3D(Temp.vecSave); pSave->WriteFields( fieldInfo.pTypeDesc->fieldName, &Temp, NULL, variant_t::m_SaveVector, 1 ); break; } case FIELD_POSITION_VECTOR: { variant_savevector_t Temp; var->Vector3D(Temp.vecSave); pSave->WriteFields( fieldInfo.pTypeDesc->fieldName, &Temp, NULL, variant_t::m_SavePositionVector, 1 ); break; } default: Warning( "Bad type %d in saved variant_t\n", var->FieldType() ); Assert(0); } } // restores a single instance of the variable virtual void Restore( const SaveRestoreFieldInfo_t &fieldInfo, IRestore *pRestore ) { variant_t *var = (variant_t*)fieldInfo.pField; *var = variant_t(); var->fieldType = (_fieldtypes)pRestore->ReadInt(); switch ( var->fieldType ) { case FIELD_VOID: break; case FIELD_BOOLEAN: pRestore->ReadFields( fieldInfo.pTypeDesc->fieldName, var, NULL, variant_t::m_SaveBool, 1 ); break; case FIELD_INTEGER: pRestore->ReadFields( fieldInfo.pTypeDesc->fieldName, var, NULL, variant_t::m_SaveInt, 1 ); break; case FIELD_FLOAT: pRestore->ReadFields( fieldInfo.pTypeDesc->fieldName, var, NULL, variant_t::m_SaveFloat, 1 ); break; case FIELD_EHANDLE: pRestore->ReadFields( fieldInfo.pTypeDesc->fieldName, var, NULL, variant_t::m_SaveEHandle, 1 ); break; case FIELD_STRING: pRestore->ReadFields( fieldInfo.pTypeDesc->fieldName, var, NULL, variant_t::m_SaveString, 1 ); break; case FIELD_COLOR32: pRestore->ReadFields( fieldInfo.pTypeDesc->fieldName, var, NULL, variant_t::m_SaveColor, 1 ); break; case FIELD_VECTOR: { variant_savevector_t Temp; pRestore->ReadFields( fieldInfo.pTypeDesc->fieldName, &Temp, NULL, variant_t::m_SaveVector, 1 ); var->SetVector3D(Temp.vecSave); break; } case FIELD_POSITION_VECTOR: { variant_savevector_t Temp; pRestore->ReadFields( fieldInfo.pTypeDesc->fieldName, &Temp, NULL, variant_t::m_SavePositionVector, 1 ); var->SetPositionVector3D(Temp.vecSave); break; } default: Warning( "Bad type %d in saved variant_t\n", var->FieldType() ); Assert(0); break; } } virtual bool IsEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) { // check all the elements of the array (usually only 1) variant_t *var = (variant_t*)fieldInfo.pField; for ( int i = 0; i < fieldInfo.pTypeDesc->fieldSize; i++, var++ ) { if ( var->FieldType() != FIELD_VOID ) return 0; } // variant has no data return 1; } virtual void MakeEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) { // Don't no how to. This is okay, since objects of this type // are always born clean before restore, and not reused } }; CVariantSaveDataOps g_VariantSaveDataOps; ISaveRestoreOps *variantFuncs = &g_VariantSaveDataOps; /////////////////////// entitylist ///////////////////// CUtlMemoryPool g_EntListMemPool( sizeof(entitem_t), 256, CUtlMemoryPool::GROW_NONE, "g_EntListMemPool" ); #include "tier0/memdbgoff.h" void *entitem_t::operator new( size_t stAllocateBlock ) { return g_EntListMemPool.Alloc( stAllocateBlock ); } void *entitem_t::operator new( size_t stAllocateBlock, int nBlockUse, const char *pFileName, int nLine ) { return g_EntListMemPool.Alloc( stAllocateBlock ); } void entitem_t::operator delete( void *pMem ) { g_EntListMemPool.Free( pMem ); } #include "tier0/memdbgon.h" CEntityList::CEntityList() { m_pItemList = NULL; m_iNumItems = 0; } CEntityList::~CEntityList() { // remove all items from the list entitem_t *next, *e = m_pItemList; while ( e != NULL ) { next = e->pNext; delete e; e = next; } m_pItemList = NULL; } void CEntityList::AddEntity( CBaseEntity *pEnt ) { // check if it's already in the list; if not, add it entitem_t *e = m_pItemList; while ( e != NULL ) { if ( e->hEnt == pEnt ) { // it's already in the list return; } if ( e->pNext == NULL ) { // we've hit the end of the list, so tack it on e->pNext = new entitem_t; e->pNext->hEnt = pEnt; e->pNext->pNext = NULL; m_iNumItems++; return; } e = e->pNext; } // empty list m_pItemList = new entitem_t; m_pItemList->hEnt = pEnt; m_pItemList->pNext = NULL; m_iNumItems = 1; } void CEntityList::DeleteEntity( CBaseEntity *pEnt ) { // find the entry in the list and delete it entitem_t *prev = NULL, *e = m_pItemList; while ( e != NULL ) { // delete the link if it's the matching entity OR if the link is NULL if ( e->hEnt == pEnt || e->hEnt == NULL ) { if ( prev ) { prev->pNext = e->pNext; } else { m_pItemList = e->pNext; } delete e; m_iNumItems--; // REVISIT: Is this correct? Is this just here to clean out dead EHANDLEs? // restart the loop e = m_pItemList; prev = NULL; continue; } prev = e; e = e->pNext; } }