//-----------------------------------------------------------------------------
// Purpose: Static method
// Input : *event -
// soundlist -
//-----------------------------------------------------------------------------
void CSceneCache::PrecacheSceneEvent( CChoreoEvent *event, CUtlVector< unsigned short >& soundlist )
{
if ( !event || event->GetType() != CChoreoEvent::SPEAK )
return;
int idx = soundemitterbase->GetSoundIndex( event->GetParameters() );
if ( idx != -1 )
{
MEM_ALLOC_CREDIT();
Assert( idx <= 65535 );
soundlist.AddToTail( (unsigned short)idx );
}
if ( event->GetCloseCaptionType() == CChoreoEvent::CC_MASTER )
{
char tok[ CChoreoEvent::MAX_CCTOKEN_STRING ];
if ( event->GetPlaybackCloseCaptionToken( tok, sizeof( tok ) ) )
{
int idx = soundemitterbase->GetSoundIndex( tok );
if ( idx != -1 && soundlist.Find( idx ) == soundlist.InvalidIndex() )
{
MEM_ALLOC_CREDIT();
Assert( idx <= 65535 );
soundlist.AddToTail( (unsigned short)idx );
}
}
}
}
//-----------------------------------------------------------------------------
// Level init, shutdown
//-----------------------------------------------------------------------------
void CClientLeafSystem::LevelInitPreEntity()
{
MEM_ALLOC_CREDIT();
m_Renderables.EnsureCapacity( 1024 );
m_RenderablesInLeaf.EnsureCapacity( 1024 );
m_ShadowsInLeaf.EnsureCapacity( 256 );
m_ShadowsOnRenderable.EnsureCapacity( 256 );
m_DirtyRenderables.EnsureCapacity( 256 );
// Add all the leaves we'll need
int leafCount = engine->LevelLeafCount();
m_Leaf.EnsureCapacity( leafCount );
ClientLeaf_t newLeaf;
newLeaf.m_FirstElement = m_RenderablesInLeaf.InvalidIndex();
newLeaf.m_FirstShadow = m_ShadowsInLeaf.InvalidIndex();
newLeaf.m_FirstDetailProp = 0;
newLeaf.m_DetailPropCount = 0;
newLeaf.m_DetailPropRenderFrame = -1;
while ( --leafCount >= 0 )
{
m_Leaf.AddToTail( newLeaf );
}
}
void virtualmodel_t::AppendModels( int group, const studiohdr_t *pStudioHdr )
{
AUTO_LOCK_( CThreadTerminalMutex<CThreadFastMutex>, m_Lock );
// build a search table if necesary
CModelLookupContext ctx(group, pStudioHdr);
AppendSequences( group, pStudioHdr );
AppendAnimations( group, pStudioHdr );
AppendBonemap( group, pStudioHdr );
AppendAttachments( group, pStudioHdr );
AppendPoseParameters( group, pStudioHdr );
AppendNodes( group, pStudioHdr );
AppendIKLocks( group, pStudioHdr );
struct HandleAndHeader_t
{
void *handle;
const studiohdr_t *pHdr;
};
HandleAndHeader_t list[64];
// determine quantity of valid include models in one pass only
// temporarily cache results off, otherwise FindModel() causes ref counting problems
int j;
int nValidIncludes = 0;
for (j = 0; j < pStudioHdr->numincludemodels; j++)
{
// find model (increases ref count)
void *tmp = NULL;
const studiohdr_t *pTmpHdr = pStudioHdr->FindModel( &tmp, pStudioHdr->pModelGroup( j )->pszName() );
if ( pTmpHdr )
{
if ( nValidIncludes >= ARRAYSIZE( list ) )
{
// would cause stack overflow
Assert( 0 );
break;
}
list[nValidIncludes].handle = tmp;
list[nValidIncludes].pHdr = pTmpHdr;
nValidIncludes++;
}
}
if ( nValidIncludes )
{
m_group.EnsureCapacity( m_group.Count() + nValidIncludes );
for (j = 0; j < nValidIncludes; j++)
{
MEM_ALLOC_CREDIT();
int group = m_group.AddToTail();
m_group[group].cache = list[j].handle;
AppendModels( group, list[j].pHdr );
}
}
UpdateAutoplaySequences( pStudioHdr );
}
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 Draw_DecalSetName( int decal, char *name )
{
while ( decal >= g_DecalLookup.Count() )
{
MEM_ALLOC_CREDIT();
int idx = g_DecalLookup.AddToTail();
g_DecalLookup[idx] = g_DecalDictionary.InvalidIndex();
}
FileNameHandle_t fnHandle = g_pFileSystem->FindOrAddFileName( name );
int lookup = g_DecalDictionary.Find( fnHandle );
if ( lookup == g_DecalDictionary.InvalidIndex() )
{
DecalEntry entry;
#ifdef _DEBUG
int len = strlen(name) + 1;
entry.m_pDebugName = new char[len];
memcpy( entry.m_pDebugName, name, len );
#endif
entry.material = GL_LoadMaterial( name, TEXTURE_GROUP_DECAL );
entry.index = decal;
lookup = g_DecalDictionary.Insert( fnHandle, entry );
}
else
{
g_DecalDictionary[lookup].index = decal;
}
g_DecalLookup[decal] = lookup;
}
void CGameUI2::Initialize(CreateInterfaceFn appFactory)
{
MEM_ALLOC_CREDIT();
ConnectTier1Libraries(&appFactory, 1);
ConnectTier2Libraries(&appFactory, 1);
ConVar_Register(FCVAR_CLIENTDLL);
ConnectTier3Libraries(&appFactory, 1);
engine = static_cast<IVEngineClient*>(appFactory(VENGINE_CLIENT_INTERFACE_VERSION, nullptr));
enginesound = static_cast<IEngineSound*>(appFactory(IENGINESOUND_CLIENT_INTERFACE_VERSION, nullptr));
enginevgui = static_cast<IEngineVGui*>(appFactory(VENGINE_VGUI_VERSION, nullptr));
soundemitterbase = static_cast<ISoundEmitterSystemBase*>(appFactory(SOUNDEMITTERSYSTEM_INTERFACE_VERSION, nullptr));
render = static_cast<IVRenderView*>(appFactory(VENGINE_RENDERVIEW_INTERFACE_VERSION, nullptr));
CreateInterfaceFn gameUIFactory = g_GameUI.GetFactory();
if (gameUIFactory)
gameui = static_cast<IGameUI*>(gameUIFactory(GAMEUI_INTERFACE_VERSION, nullptr));
if (!enginesound || !enginevgui || !engine || !soundemitterbase || !render || !gameui)
Error("CGameUI2::Initialize() failed to get necessary interfaces.\n");
if (!CommandLine()->FindParm("-shaderedit"))
{
GetBasePanel()->Create();
if (GetBasePanel())
gameui->SetMainMenuOverride(GetBasePanel()->GetMainMenu()->GetVPanel());
}
}
void PhysicsLevelInit( void )
{
physenv = physics->CreateEnvironment();
assert( physenv );
#ifdef PORTAL
physenv_main = physenv;
#endif
{
MEM_ALLOC_CREDIT();
g_EntityCollisionHash = physics->CreateObjectPairHash();
}
// TODO: need to get the right factory function here
//physenv->SetDebugOverlay( appSystemFactory );
physenv->SetGravity( Vector(0, 0, -sv_gravity.GetFloat() ) );
physenv->SetAlternateGravity( Vector(0, 0, -cl_ragdoll_gravity.GetFloat() ) );
// NOTE: Always run client physics at a rate >= 45Hz - helps keep ragdolls stable
const float defaultPhysicsTick = 1.0f / 60.0f; // 60Hz to stay in sync with x360 framerate of 30Hz
physenv->SetSimulationTimestep( defaultPhysicsTick );
physenv->SetCollisionEventHandler( &g_Collisions );
physenv->SetCollisionSolver( &g_Collisions );
C_World *pWorld = GetClientWorldEntity();
g_PhysWorldObject = PhysCreateWorld_Shared( pWorld, modelinfo->GetVCollide(1), g_PhysDefaultObjectParams );
staticpropmgr->CreateVPhysicsRepresentations( physenv, &g_SolidSetup, pWorld );
}
void PhysicsLevelInit( void )
{
physenv = physics->CreateEnvironment();
assert( physenv );
#ifdef PORTAL
physenv_main = physenv;
#endif
{
MEM_ALLOC_CREDIT();
g_EntityCollisionHash = physics->CreateObjectPairHash();
}
// TODO: need to get the right factory function here
//physenv->SetDebugOverlay( appSystemFactory );
physenv->SetGravity( Vector(0, 0, -sv_gravity.GetFloat() ) );
// 15 ms per tick
// NOTE: Always run client physics at this rate - helps keep ragdolls stable
physenv->SetSimulationTimestep( IsXbox() ? DEFAULT_XBOX_CLIENT_VPHYSICS_TICK : DEFAULT_TICK_INTERVAL );
physenv->SetCollisionEventHandler( &g_Collisions );
physenv->SetCollisionSolver( &g_Collisions );
g_PhysWorldObject = PhysCreateWorld_Shared( GetClientWorldEntity(), modelinfo->GetVCollide(1), g_PhysDefaultObjectParams );
staticpropmgr->CreateVPhysicsRepresentations( physenv, &g_SolidSetup, NULL );
}
void virtualmodel_t::AppendAnimations( int group, const studiohdr_t *pStudioHdr )
{
AUTO_LOCK_( CThreadTerminalMutex<CThreadFastMutex>, m_Lock );
int numCheck = m_anim.Count();
CUtlVector< virtualgeneric_t > anim;
anim = m_anim;
MEM_ALLOC_CREDIT();
int j, k;
m_group[ group ].masterAnim.SetCount( pStudioHdr->numlocalanim );
for (j = 0; j < pStudioHdr->numlocalanim; j++)
{
char *s1 = pStudioHdr->pLocalAnimdesc( j )->pszName();
if ( HasLookupTable() )
{
k = numCheck;
short index = GetAnimTable()->Find( s1 );
if ( index != GetAnimTable()->InvalidIndex() )
{
k = GetAnimTable()->Element(index);
}
}
else
{
for (k = 0; k < numCheck; k++)
{
char *s2 = m_group[ anim[k].group ].GetStudioHdr()->pLocalAnimdesc( anim[k].index )->pszName();
if (stricmp( s1, s2 ) == 0)
{
break;
}
}
}
// no duplication
if (k == numCheck)
{
virtualgeneric_t tmp;
tmp.group = group;
tmp.index = j;
k = anim.AddToTail( tmp );
}
m_group[ group ].masterAnim[ j ] = k;
}
if ( HasLookupTable() )
{
for ( j = numCheck; j < anim.Count(); j++ )
{
const char *s1 = m_group[ anim[j].group ].GetStudioHdr()->pLocalAnimdesc( anim[j].index )->pszName();
GetAnimTable()->Insert( s1, j );
}
}
m_anim = anim;
}
void CBaseGameStats_Driver::PossibleMapChange( void )
{
#ifdef GAME_DLL
//detect and copy map changes
if ( Q_stricmp( m_PrevMapName.String(), STRING( gpGlobals->mapname ) ) )
{
MEM_ALLOC_CREDIT();
CUtlString PrevMapBackup = m_PrevMapName;
m_PrevMapName = STRING( gpGlobals->mapname );
gamestats->Event_MapChange( PrevMapBackup.String(), STRING( gpGlobals->mapname ) );
if ( gamestats->UseOldFormat() )
{
if( gamestats->AutoSave_OnMapChange() )
gamestats->SaveToFileNOW();
if( gamestats->AutoUpload_OnMapChange() )
gamestats->UploadStatsFileNOW();
}
}
#endif
}
static void SortSpawnListByHierarchy( int nEntities, HierarchicalSpawn_t *pSpawnList )
{
MEM_ALLOC_CREDIT();
g_pClassnameSpawnPriority = new CStringRegistry;
// this will cause the entities to be spawned in the indicated order
// Highest string ID spawns first. String ID is spawn priority.
// by default, anything not in this list has priority -1
g_pClassnameSpawnPriority->AddString( "func_wall", 10 );
g_pClassnameSpawnPriority->AddString( "scripted_sequence", 9 );
g_pClassnameSpawnPriority->AddString( "phys_hinge", 8 );
g_pClassnameSpawnPriority->AddString( "phys_ballsocket", 8 );
g_pClassnameSpawnPriority->AddString( "phys_slideconstraint", 8 );
g_pClassnameSpawnPriority->AddString( "phys_constraint", 8 );
g_pClassnameSpawnPriority->AddString( "phys_pulleyconstraint", 8 );
g_pClassnameSpawnPriority->AddString( "phys_lengthconstraint", 8 );
g_pClassnameSpawnPriority->AddString( "phys_ragdollconstraint", 8 );
g_pClassnameSpawnPriority->AddString( "info_mass_center", 8 ); // spawn these before physbox/prop_physics
g_pClassnameSpawnPriority->AddString( "trigger_vphysics_motion", 8 ); // spawn these before physbox/prop_physics
g_pClassnameSpawnPriority->AddString( "prop_physics", 7 );
g_pClassnameSpawnPriority->AddString( "prop_ragdoll", 7 );
// Sort the entities (other than the world) by hierarchy depth, in order to spawn them in
// that order. This insures that each entity's parent spawns before it does so that
// it can properly set up anything that relies on hierarchy.
#ifdef _WIN32
qsort(&pSpawnList[0], nEntities, sizeof(pSpawnList[0]), (int (__cdecl *)(const void *, const void *))CompareSpawnOrder);
#elif POSIX
qsort(&pSpawnList[0], nEntities, sizeof(pSpawnList[0]), (int (*)(const void *, const void *))CompareSpawnOrder);
#endif
delete g_pClassnameSpawnPriority;
g_pClassnameSpawnPriority = NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Add an activity to the activity string registry and increment
// the acitivty counter
//-----------------------------------------------------------------------------
void CAI_BaseNPC::AddActivityToSR(const char *actName, int actID)
{
Assert( m_pActivitySR );
if ( !m_pActivitySR )
return;
// technically order isn't dependent, but it's too damn easy to forget to add new ACT_'s to all three lists.
// NOTE: This assertion generally means that the activity enums are out of order or that new enums were not added to all
// relevant tables. Make sure that you have included all new enums in:
// game_shared/ai_activity.h
// game_shared/activitylist.cpp
// dlls/ai_activity.cpp
MEM_ALLOC_CREDIT();
static int lastActID = -2;
Assert( actID >= LAST_SHARED_ACTIVITY || actID == lastActID + 1 || actID == ACT_INVALID );
lastActID = actID;
if ( m_pActivitySR->GetStringID( actName ) != -1 )
{
printf( "Duplicate\n" );
}
m_pActivitySR->AddString(actName, actID);
m_iNumActivities++;
}
void CUtlBinaryBlock::SetLength( int nLength )
{
MEM_ALLOC_CREDIT();
Assert( !m_Memory.IsReadOnly() );
m_nActualLength = nLength;
if ( nLength > m_Memory.NumAllocated() )
{
int nOverFlow = nLength - m_Memory.NumAllocated();
m_Memory.Grow( nOverFlow );
// If the reallocation failed, clamp length
if ( nLength > m_Memory.NumAllocated() )
{
m_nActualLength = m_Memory.NumAllocated();
}
}
#ifdef _DEBUG
if ( m_Memory.NumAllocated() > m_nActualLength )
{
memset( ( ( char * )m_Memory.Base() ) + m_nActualLength, 0xEB, m_Memory.NumAllocated() - m_nActualLength );
}
#endif
}
//-----------------------------------------------------------------------------
// Base class, containing simple memory management
//-----------------------------------------------------------------------------
CUtlBinaryBlock::CUtlBinaryBlock( int growSize, int initSize )
{
MEM_ALLOC_CREDIT();
m_Memory.Init( growSize, initSize );
m_nActualLength = 0;
}
void ClearKeyValuesCache()
{
MEM_ALLOC_CREDIT();
for ( int i=g_KeyValuesCache.First(); i != g_KeyValuesCache.InvalidIndex(); i=g_KeyValuesCache.Next( i ) )
{
g_KeyValuesCache[i]->deleteThis();
}
g_KeyValuesCache.Purge();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ReloadParticleEffectsInList( IFileList *pFilesToReload )
{
MEM_ALLOC_CREDIT();
CUtlVector<CUtlString> files;
GetParticleManifest( files );
// CAB 2/17/11 Reload all the particles regardless (Fixes filename change exploits).
bool bReloadAll = true;
//int nCount = files.Count();
//for ( int i = 0; i < nCount; ++i )
//{
// // Skip the precache marker
// const char *pFile = files[i];
// if ( pFile[0] == '!' )
// {
// pFile++;
// }
// char szDX80Filename[MAX_PATH];
// V_strncpy( szDX80Filename, pFile, sizeof( szDX80Filename ) );
// V_StripExtension( pFile, szDX80Filename, sizeof( szDX80Filename ) );
// V_strncat( szDX80Filename, "_dx80.", sizeof( szDX80Filename ) );
// V_strncat( szDX80Filename, V_GetFileExtension( pFile ), sizeof( szDX80Filename ) );
// if ( pFilesToReload->IsFileInList( pFile ) || pFilesToReload->IsFileInList( szDX80Filename ) )
// {
// Msg( "Reloading all particle files due to pure settings.\n" );
// bReloadAll = true;
// break;
// }
//}
// Then check to see if we need to reload the map's particles
const char *pszMapName = NULL;
#ifdef CLIENT_DLL
pszMapName = engine->GetLevelName();
#else
pszMapName = STRING( gpGlobals->mapname );
#endif
if ( pszMapName && pszMapName[0] )
{
char mapname[MAX_MAP_NAME];
Q_FileBase( pszMapName, mapname, sizeof( mapname ) );
Q_strlower( mapname );
ParseParticleEffectsMap( mapname, true, pFilesToReload );
}
if ( bReloadAll )
{
ParseParticleEffects( true, true );
}
g_pParticleSystemMgr->DecommitTempMemory();
}
void CGameUI::SendConnectedToGameMessage()
{
MEM_ALLOC_CREDIT();
KeyValues *kv = new KeyValues( "ConnectedToGame" );
kv->SetInt( "ip", m_iGameIP );
kv->SetInt( "connectionport", m_iGameConnectionPort );
kv->SetInt( "queryport", m_iGameQueryPort );
g_VModuleLoader.PostMessageToAllModules( kv );
}
//-----------------------------------------------------------------------------
// Purpose: Static method
// Input : sounds -
// *soundname -
//-----------------------------------------------------------------------------
void CModelSoundsCache::FindOrAddScriptSound( CUtlVector< unsigned short >& sounds, char const *soundname )
{
int soundindex = soundemitterbase->GetSoundIndex( soundname );
if ( soundindex != -1 )
{
// Only add it once per model...
if ( sounds.Find( soundindex ) == sounds.InvalidIndex() )
{
MEM_ALLOC_CREDIT();
sounds.AddToTail( soundindex );
}
}
}
void virtualmodel_t::AppendPoseParameters( int group, const studiohdr_t *pStudioHdr )
{
AUTO_LOCK_( CThreadTerminalMutex<CThreadFastMutex>, m_Lock );
int numCheck = m_pose.Count();
CUtlVector< virtualgeneric_t > pose;
pose = m_pose;
MEM_ALLOC_CREDIT();
int j, k;
m_group[ group ].masterPose.SetCount( pStudioHdr->numlocalposeparameters );
for (j = 0; j < pStudioHdr->numlocalposeparameters; j++)
{
char *s1 = pStudioHdr->pLocalPoseParameter( j )->pszName();
for (k = 0; k < numCheck; k++)
{
char *s2 = m_group[ pose[k].group ].GetStudioHdr()->pLocalPoseParameter( pose[k].index )->pszName();
if (stricmp( s1, s2 ) == 0)
{
break;
}
}
if (k == numCheck)
{
// no duplication
virtualgeneric_t tmp;
tmp.group = group;
tmp.index = j;
k = pose.AddToTail( tmp );
}
else
{
// duplicate, reset start and end to fit full dynamic range
mstudioposeparamdesc_t *pPose1 = pStudioHdr->pLocalPoseParameter( j );
mstudioposeparamdesc_t *pPose2 = m_group[ pose[k].group ].GetStudioHdr()->pLocalPoseParameter( pose[k].index );
float start = min( pPose2->end, min( pPose1->end, min( pPose2->start, pPose1->start ) ) );
float end = max( pPose2->end, max( pPose1->end, max( pPose2->start, pPose1->start ) ) );
pPose2->start = start;
pPose2->end = end;
}
m_group[ group ].masterPose[ j ] = k;
}
m_pose = pose;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CGameUI::SetProgressLevelName( const char *levelName )
{
MEM_ALLOC_CREDIT();
if ( g_hLoadingBackgroundDialog )
{
KeyValues *pKV = new KeyValues( "ProgressLevelName" );
pKV->SetString( "levelName", levelName );
vgui::ivgui()->PostMessage( g_hLoadingBackgroundDialog, pKV, NULL );
}
if ( g_hLoadingDialog.Get() )
{
// TODO: g_hLoadingDialog->SetLevelName( levelName );
}
}
//-----------------------------------------------------------------------------
// Loads up a file containing metaclass definitions
//-----------------------------------------------------------------------------
void CPanelMetaClassMgrImp::LoadMetaClassDefinitionFile( const char *pFileName )
{
MEM_ALLOC_CREDIT();
// Blat out previous metaclass definitions read in from this file...
int i = m_MetaClassKeyValues.Find( pFileName );
if (i != m_MetaClassKeyValues.InvalidIndex() )
{
// Blow away the previous keyvalues from that file
unsigned short j = m_MetaClassDict.First();
while ( j != m_MetaClassDict.InvalidIndex() )
{
unsigned short next = m_MetaClassDict.Next(j);
if ( m_MetaClassDict[j].m_KeyValueIndex == i)
{
m_MetaClassDict.RemoveAt(j);
}
j = next;
}
m_MetaClassKeyValues[i]->deleteThis();
m_MetaClassKeyValues.RemoveAt(i);
}
// Create a new keyvalues entry
KeyValues* pKeyValues = new KeyValues(pFileName);
int idx = m_MetaClassKeyValues.Insert( pFileName, pKeyValues );
// Read in all metaclass definitions...
// Load the file
if ( !pKeyValues->LoadFromFile( filesystem, pFileName ) )
{
Warning( "Couldn't find metaclass definition file %s\n", pFileName );
pKeyValues->deleteThis();
m_MetaClassKeyValues.RemoveAt(idx);
return;
}
else
{
// Go ahead and parse the data now
if ( !ParseMetaClassList( pFileName, pKeyValues, idx ) )
{
Warning( "Detected one or more errors parsing %s\n", pFileName );
}
}
}
KeyValues* CacheKeyValuesForFile( const char *pFilename )
{
MEM_ALLOC_CREDIT();
int i = g_KeyValuesCache.Find( pFilename );
if ( i == g_KeyValuesCache.InvalidIndex() )
{
KeyValues *rDat = new KeyValues( pFilename );
rDat->LoadFromFile( filesystem, pFilename, NULL );
g_KeyValuesCache.Insert( pFilename, rDat );
return rDat;
}
else
{
return g_KeyValuesCache[i];
}
}
void CAI_GlobalNamespace::AddSymbol( const char *pszSymbol, int symbolID )
{
MEM_ALLOC_CREDIT();
AssertMsg( symbolID != -1, "Invalid symbol id passed to CAI_GlobalNamespace::AddSymbol()" );
if (symbolID == -1 )
return;
AssertMsg( AI_IdIsGlobal( symbolID ), ("Local symbol ID passed to CAI_GlobalNamespace::AddSymbol()") );
AssertMsg( !IdToSymbol( symbolID ) , ("Duplicate symbol ID passed to CAI_GlobalNamespace::AddSymbol()") );
AssertMsg( SymbolToId( pszSymbol ) == -1, ("Duplicate symbol passed to CAI_GlobalNamespace::AddSymbol()") );
m_pSymbols->AddString( pszSymbol, symbolID );
if ( m_NextGlobalBase < symbolID + 1 )
m_NextGlobalBase = symbolID + 1;
}
CCountedStringPool::CCountedStringPool()
{
MEM_ALLOC_CREDIT();
m_HashTable.EnsureCount(HASH_TABLE_SIZE);
for( int i = 0; i < m_HashTable.Count(); i++ )
{
m_HashTable[i] = INVALID_ELEMENT;
}
m_FreeListStart = INVALID_ELEMENT;
m_Elements.AddToTail();
m_Elements[0].pString = NULL;
m_Elements[0].nReferenceCount = 0;
m_Elements[0].nNextElement = INVALID_ELEMENT;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *criteria -
// "" -
// 1.0f -
//-----------------------------------------------------------------------------
void AI_CriteriaSet::AppendCriteria( const char *criteria, const char *value /*= ""*/, float weight /*= 1.0f*/ )
{
int idx = FindCriterionIndex( criteria );
if ( idx == -1 )
{
CritEntry_t entry;
entry.criterianame = criteria;
MEM_ALLOC_CREDIT();
idx = m_Lookup.Insert( entry );
}
CritEntry_t *entry = &m_Lookup[ idx ];
entry->SetValue( value );
entry->weight = weight;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ParseParticleEffects( bool bLoadSheets, bool bPrecache )
{
MEM_ALLOC_CREDIT();
g_pParticleSystemMgr->ShouldLoadSheets( bLoadSheets );
CUtlVector<CUtlString> files;
GetParticleManifest( files );
int nCount = files.Count();
for ( int i = 0; i < nCount; ++i )
{
g_pParticleSystemMgr->ReadParticleConfigFile( files[i], bPrecache, false );
}
g_pParticleSystemMgr->DecommitTempMemory();
}
// Assumed to be set up by calling code
bool AsyncCaption_t::LoadFromFile( const char *pRelativePath )
{
char pRelativePathFixed[MAX_PATH];
Q_strncpy( pRelativePathFixed, pRelativePath, sizeof(pRelativePathFixed) );
Q_FixSlashes( pRelativePathFixed );
Q_strlower( pRelativePathFixed );
pRelativePath = pRelativePathFixed;
if ( Q_IsAbsolutePath( pRelativePath ) )
{
Warning( "AsyncCaption_t::LoadFromFile: Fullpath encountered! %s\n", pRelativePath );
}
FileHandle_t fh = g_pFullFileSystem->Open( pRelativePath, "rb", "GAME" );
if ( FILESYSTEM_INVALID_HANDLE == fh )
return false;
MEM_ALLOC_CREDIT();
CUtlBuffer dirbuffer;
// Read the header
g_pFullFileSystem->Read( &m_Header, sizeof( m_Header ), fh );
if ( m_Header.magic != COMPILED_CAPTION_FILEID )
Error( "Invalid file id for %s\n", pRelativePath );
if ( m_Header.version != COMPILED_CAPTION_VERSION )
Error( "Invalid file version for %s\n", pRelativePath );
if ( m_Header.directorysize < 0 || m_Header.directorysize > 64 * 1024 )
Error( "Invalid directory size %d for %s\n", m_Header.directorysize, pRelativePath );
//if ( m_Header.blocksize != MAX_BLOCK_SIZE )
// Error( "Invalid block size %d, expecting %d for %s\n", m_Header.blocksize, MAX_BLOCK_SIZE, pchFullPath );
int directoryBytes = m_Header.directorysize * sizeof( CaptionLookup_t );
m_CaptionDirectory.EnsureCapacity( m_Header.directorysize );
dirbuffer.EnsureCapacity( directoryBytes );
g_pFullFileSystem->Read( dirbuffer.Base(), directoryBytes, fh );
g_pFullFileSystem->Close( fh );
m_CaptionDirectory.CopyArray( (const CaptionLookup_t *)dirbuffer.PeekGet(), m_Header.directorysize );
m_CaptionDirectory.RedoSort( true );
m_DataBaseFile = pRelativePath;
return true;
}
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();
if ( pEntity->IsEFlagSet( EFL_NO_THINK_FUNCTION ) && pEntity->IsEFlagSet( EFL_NO_GAME_PHYSICS_SIMULATION ) )
{
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();
m_simThinkList[m_entinfoIndex[index]].entEntry = (unsigned short)index;
m_simThinkList[m_entinfoIndex[index]].nextThinkTick = 0;
if ( pEntity->IsEFlagSet(EFL_NO_GAME_PHYSICS_SIMULATION) )
{
m_simThinkList[m_entinfoIndex[index]].nextThinkTick = pEntity->GetFirstThinkTick();
Assert(m_simThinkList[m_entinfoIndex[index]].nextThinkTick>=0);
}
}
else
{
// updating existing entry - if no sim, reset think time
if ( pEntity->IsEFlagSet(EFL_NO_GAME_PHYSICS_SIMULATION) )
{
m_simThinkList[m_entinfoIndex[index]].nextThinkTick = pEntity->GetFirstThinkTick();
Assert(m_simThinkList[m_entinfoIndex[index]].nextThinkTick>=0);
}
else
{
m_simThinkList[m_entinfoIndex[index]].nextThinkTick = 0;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: loads per-map manifest!
//-----------------------------------------------------------------------------
void ParseParticleEffectsMap( const char *pMapName, bool bLoadSheets )
{
MEM_ALLOC_CREDIT();
g_pParticleSystemMgr->ShouldLoadSheets( bLoadSheets );
CUtlVector<CUtlString> files;
const char *mapManifestFilename = NULL;
if ( pMapName && *pMapName )
{
#ifdef CLIENT_DLL
#define UTIL_VarArgs VarArgs //Tony; goddamnit.
#endif
mapManifestFilename = UTIL_VarArgs( "particles/particles_%s.txt", pMapName );
}
// Open the manifest file, and read the particles specified inside it
KeyValues *manifest = new KeyValues( mapManifestFilename );
if ( manifest->LoadFromFile( filesystem, mapManifestFilename, "GAME" ) )
{
for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL; sub = sub->GetNextKey() )
{
if ( !Q_stricmp( sub->GetName(), "file" ) )
{
files.AddToTail( sub->GetString() );
continue;
}
Warning( "CParticleMgr::LevelInit: Manifest '%s' with bogus file type '%s', expecting 'file'\n", mapManifestFilename, sub->GetName() );
}
}
else
//Tony; don't print a warning, and don't proceed any further if the file doesn't exist!
return;
int nCount = files.Count();
for ( int i = 0; i < nCount; ++i )
{
g_pParticleSystemMgr->ReadParticleConfigFile( files[i], true, true );
}
g_pParticleSystemMgr->DecommitTempMemory();
}
// add a new event to the database
eventlist_t *EventList_AddEventEntry( const char *pName, int iEventIndex, bool isPrivate, int iType )
{
MEM_ALLOC_CREDIT();
int index = g_EventList.AddToTail();
eventlist_t *pList = &g_EventList[index];
pList->eventIndex = iEventIndex;
pList->stringKey = g_EventStrings.AddString( pName, index );
pList->isPrivate = isPrivate;
pList->iType = iType;
// UNDONE: This implies that ALL shared activities are added before ANY custom activities
// UNDONE: Segment these instead? It's a 32-bit int, how many activities do we need?
if ( iEventIndex > g_HighestEvent )
{
g_HighestEvent = iEventIndex;
}
return pList;
}
