//-----------------------------------------------------------------------------
// Parse a single metaclass
//-----------------------------------------------------------------------------
bool CPanelMetaClassMgrImp::ParseSingleMetaClass( const char* pFileName,
const char* pMetaClassName, KeyValues* pMetaClassValues, int keyValueIndex )
{
// Complain about duplicately defined metaclass names...
if ( m_MetaClassDict.Find( pMetaClassName ) != m_MetaClassDict.InvalidIndex() )
{
Warning( "Meta class %s duplicately defined (file %s)\n", pMetaClassName, pFileName );
return false;
}
// find the type...
const char* pPanelType = pMetaClassValues->GetString( "type" );
if (!pPanelType || !pPanelType[0])
{
Warning( "Unable to find type of meta class %s in file %s\n", pMetaClassName, pFileName );
return false;
}
unsigned short i = m_PanelTypeDict.Find( pPanelType );
if (i == m_PanelTypeDict.InvalidIndex())
{
Warning( "Type %s of meta class %s undefined!\n", pPanelType, pMetaClassName );
stackfree(pLwrMetaClass);
return false;
}
// Add it to the metaclass dictionary
MetaClassDict_t element;
element.m_TypeIndex = i;
element.m_KeyValueIndex = keyValueIndex;
element.m_pKeyValues = pMetaClassValues;
m_MetaClassDict.Insert( pMetaClassName, element );
return true;
}
PyEntityFactory* CClassMap::PyGetFactory( const char *classname )
{
int index = m_ClassDict.Find( classname );
if( index == m_ClassDict.InvalidIndex() )
return NULL;
return m_ClassDict[index].pyfactory;
}
//-----------------------------------------------------------------------------
// Create, destroy panel...
//-----------------------------------------------------------------------------
vgui::Panel *CPanelMetaClassMgrImp::CreatePanelMetaClass( const char* pMetaClassName,
int sortorder, void *pInitData, vgui::Panel *pParent, const char *pChainName )
{
// Search for the metaclass name
int i = m_MetaClassDict.Find( pMetaClassName );
if (i == m_MetaClassDict.InvalidIndex())
return NULL;
// Now that we've got the metaclass, we can figure out what kind of
// panel to instantiate...
MetaClassDict_t &metaClass = m_MetaClassDict[i];
IPanelFactory* pFactory = m_PanelTypeDict[metaClass.m_TypeIndex];
// Set up the key values for use in initialization
if (pChainName)
{
KeyValueChainRecursive( metaClass.m_pKeyValues, pChainName );
}
// Create and initialize the panel
vgui::Panel *pPanel = pFactory->Create( pMetaClassName, metaClass.m_pKeyValues, pInitData, pParent );
if ( pPanel )
{
pPanel->SetZPos( sortorder );
}
return pPanel;
}
void RegisterScriptedWeapon( const char *className )
{
#ifdef CLIENT_DLL
if ( GetClassMap().FindFactory( className ) )
{
return;
}
GetClassMap().Add( className, "CHL2MPScriptedWeapon", sizeof( CHL2MPScriptedWeapon ),
&CCHL2MPScriptedWeaponFactory, true );
#else
if ( EntityFactoryDictionary()->FindFactory( className ) )
{
return;
}
unsigned short lookup = m_WeaponFactoryDatabase.Find( className );
if ( lookup != m_WeaponFactoryDatabase.InvalidIndex() )
{
return;
}
// Andrew; This fixes months worth of pain and anguish.
CEntityFactory<CHL2MPScriptedWeapon> *pFactory = new CEntityFactory<CHL2MPScriptedWeapon>( className );
lookup = m_WeaponFactoryDatabase.Insert( className, pFactory );
Assert( lookup != m_WeaponFactoryDatabase.InvalidIndex() );
#endif
// BUGBUG: When attempting to precache weapons registered during runtime,
// they don't appear as valid registered entities.
// static CPrecacheRegister precache_weapon_(&CPrecacheRegister::PrecacheFn_Other, className);
}
char* AllocateUniqueDataTableName( bool bSendTable, const char *pFormat, ... )
{
// Setup the string.
va_list marker;
va_start( marker, pFormat );
char *pRet = AllocateStringHelper2( pFormat, marker );
va_end( marker );
// Make sure it's unique.
#ifdef _DEBUG
// Have to allocate them here because if they're declared as straight global variables,
// their constructors won't have been called yet by the time we get in here.
if ( !g_STDict )
{
g_STDict = new CUtlDict<int,int>;
g_RTDict = new CUtlDict<int,int>;
}
CUtlDict<int,int> *pDict = bSendTable ? g_STDict : g_RTDict;
if ( pDict->Find( pRet ) != pDict->InvalidIndex() )
{
// If it hits this, then they have 2 utlvectors in different data tables with the same name and the
// same size limit. The names of
Assert( false );
}
pDict->Insert( pRet, 0 );
#endif
return pRet;
}
//-----------------------------------------------------------------------------
// Finds a widget factory by name
//-----------------------------------------------------------------------------
IAttributeWidgetFactory *CAttributeWidgetFactoryList::FindWidgetFactory( const char *pWidgetName )
{
unsigned short i = m_Factories.Find( pWidgetName );
if ( i != m_Factories.InvalidIndex() )
return m_Factories[i];
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Find a free PyServerClass and claim it
// Send a message to the clients to claim a client class and set it to
// the right type.
//-----------------------------------------------------------------------------
NetworkedClass::NetworkedClass(
const char *pNetworkName, boost::python::object cls_type,
const char *pClientModuleName )
{
m_pClientClass = NULL;
m_pNetworkName = strdup( pNetworkName );
m_pyClass = cls_type;
unsigned short lookup = m_NetworkClassDatabase.Find( m_pNetworkName );
if ( lookup != m_NetworkClassDatabase.InvalidIndex() )
{
Warning("NetworkedClass: %s already added, replacing contents...\n", pNetworkName);
m_pClientClass = m_NetworkClassDatabase[lookup]->m_pClientClass;
m_NetworkClassDatabase[lookup] = this;
if( m_pClientClass )
{
AttachClientClass( m_pClientClass );
}
}
else
{
// New entry, add to database and find if there is an existing ClientClass
m_NetworkClassDatabase.Insert( m_pNetworkName, this );
m_pClientClass = FindPyClientClassToNetworkClass( m_pNetworkName );
}
}
void RegisterScriptedEntity( const char *className )
{
#ifdef CLIENT_DLL
if ( GetClassMap().FindFactory( className ) )
{
return;
}
GetClassMap().Add( className, "CBaseScripted", sizeof( CBaseScripted ),
&CCBaseScriptedFactory, true );
#else
if ( EntityFactoryDictionary()->FindFactory( className ) )
{
return;
}
unsigned short lookup = m_EntityFactoryDatabase.Find( className );
if ( lookup != m_EntityFactoryDatabase.InvalidIndex() )
{
return;
}
CEntityFactory<CBaseScripted> *pFactory = new CEntityFactory<CBaseScripted>( className );
lookup = m_EntityFactoryDatabase.Insert( className, pFactory );
Assert( lookup != m_EntityFactoryDatabase.InvalidIndex() );
#endif
}
bool AddModelNameFromSource( CUtlDict< ModelFile, int >& models, char const *filename, char const *modelname, int offset )
{
int idx = models.Find( modelname );
if ( idx != models.InvalidIndex() )
{
char shortname[ MAX_PATH ];
char shortname2[ MAX_PATH ];
strcpy( shortname, &filename[ offset ] );
strcpy( shortname2, &models[ idx ].qcfile[ offset ] );
vprint( 0, "multiple .qc's build %s\n %s\n %s\n",
modelname,
shortname,
shortname2 );
return false;
}
ModelFile mf;
strcpy( mf.qcfile, filename );
_strlwr( mf.qcfile );
mf.version = 0;
models.Insert( modelname, mf );
return true;
}
void DiscoverMacroTextures()
{
CUtlDict<int,int> tempDict;
g_FaceMacroTextureInfos.SetSize( numfaces );
for ( int iFace=0; iFace < numfaces; iFace++ )
{
texinfo_t *pTexInfo = &texinfo[dfaces[iFace].texinfo];
if ( pTexInfo->texdata < 0 )
continue;
dtexdata_t *pTexData = &dtexdata[pTexInfo->texdata];
const char *pMaterialName = &g_TexDataStringData[ g_TexDataStringTable[pTexData->nameStringTableID] ];
MaterialSystemMaterial_t hMaterial = FindMaterial( pMaterialName, NULL, false );
const char *pMacroTextureName = GetMaterialVar( hMaterial, "$macro_texture" );
if ( pMacroTextureName )
{
if ( tempDict.Find( pMacroTextureName ) == tempDict.InvalidIndex() )
{
Msg( "-- DiscoverMacroTextures: %s\n", pMacroTextureName );
tempDict.Insert( pMacroTextureName, 0 );
}
int stringID = TexDataStringTable_AddOrFindString( pMacroTextureName );
g_FaceMacroTextureInfos[iFace].m_MacroTextureNameID = (unsigned short)stringID;
}
else
{
g_FaceMacroTextureInfos[iFace].m_MacroTextureNameID = 0xFFFF;
}
}
}
// called from cl_parse.cpp
// find the server side decal id given it's name.
// used for save/restore
int Draw_DecalIndexFromName( char *name )
{
int lookup = g_DecalDictionary.Find( name );
if ( lookup == g_DecalDictionary.InvalidIndex() )
return 0;
return g_DecalDictionary[ lookup ].index;
}
CMacroTextureData* FindMacroTexture( const char *pFilename )
{
int index = g_MacroTextureLookup.Find( pFilename );
if ( g_MacroTextureLookup.IsValidIndex( index ) )
return g_MacroTextureLookup[index];
else
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Find but don't add mapping
//-----------------------------------------------------------------------------
PanelAnimationMap *CPanelAnimationDictionary::FindPanelAnimationMap( char const *className )
{
int lookup = m_AnimationMaps.Find( StripNamespace( className ) );
if ( lookup != m_AnimationMaps.InvalidIndex() )
{
return m_AnimationMaps[ lookup ].map;
}
return NULL;
}
ITextureInternal *CTextureManager::FindTexture( const char *pTextureName )
{
if ( !pTextureName || pTextureName[0] == 0 )
return NULL;
char szCleanName[MAX_PATH];
NormalizeTextureName( pTextureName, szCleanName, sizeof( szCleanName ) );
int i = m_TextureList.Find( szCleanName );
if ( i != m_TextureList.InvalidIndex() )
{
return m_TextureList[i];
}
i = m_TextureAliases.Find( szCleanName );
if ( i != m_TextureAliases.InvalidIndex() )
{
return FindTexture( m_TextureAliases[i] );
}
// Special handling: lightmaps
if ( char const *szLightMapNum = StringAfterPrefix( szCleanName, "[lightmap" ) )
{
int iLightMapNum = atoi( szLightMapNum );
extern CMaterialSystem g_MaterialSystem;
CMatLightmaps *plm = g_MaterialSystem.GetLightmaps();
if ( iLightMapNum >= 0 &&
iLightMapNum < plm->GetNumLightmapPages() )
{
ShaderAPITextureHandle_t hTex = plm->GetLightmapPageTextureHandle( iLightMapNum );
if ( hTex != INVALID_SHADERAPI_TEXTURE_HANDLE )
{
// Establish the lookup linking in the dictionary
ITextureInternal *pTxInt = ITextureInternal::CreateReferenceTextureFromHandle( pTextureName, TEXTURE_GROUP_LIGHTMAP, hTex );
m_TextureList.Insert( pTextureName, pTxInt );
return pTxInt;
}
}
}
return NULL;
}
const char *CClassMap::Lookup( const char *classname )
{
unsigned short index;
static classentry_t lookup;
index = m_ClassDict.Find( classname );
if ( index == m_ClassDict.InvalidIndex() )
return NULL;
lookup = m_ClassDict.Element( index );
return lookup.GetMapName();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : gamematerial -
// Output : char const
//-----------------------------------------------------------------------------
char const *CDecalEmitterSystem::ImpactDecalForGameMaterial( int gamematerial )
{
char gm[ 2 ];
gm[0] = (char)gamematerial;
gm[1] = 0;
int idx = m_GameMaterialTranslation.Find( gm );
if ( idx == m_GameMaterialTranslation.InvalidIndex() )
return NULL;
return m_Decals.GetElementName( m_GameMaterialTranslation.Element(idx) );
}
int CMapEntities::FindNamedEntity( char const *name )
{
char lowername[ 128 ];
strcpy( lowername, name );
_strlwr( lowername );
int index = m_Entities.Find( lowername );
if ( index == m_Entities.InvalidIndex() )
return -1;
return index;
}
// Message handler for PyNetworkCls
void __MsgFunc_PyNetworkCls( bf_read &msg )
{
char clientClass[PYNETCLS_BUFSIZE];
char networkName[PYNETCLS_BUFSIZE];
int iType = msg.ReadByte();
msg.ReadString(clientClass, PYNETCLS_BUFSIZE);
msg.ReadString(networkName, PYNETCLS_BUFSIZE);
DbgStrPyMsg( "__MsgFunc_PyNetworkCls: Registering Python network class message %d %s %s\n", iType, clientClass, networkName );
// Get module path
const char *pch = Q_strrchr( networkName, '.' );
if( !pch )
{
Warning( "Invalid python class name %s\n", networkName );
return;
}
int n = pch - networkName + 1;
char modulePath[PYNETCLS_BUFSIZE];
Q_strncpy( modulePath, networkName, n );
// Make sure the client class is imported
SrcPySystem()->Import( modulePath );
// Read which client class we are modifying
PyClientClassBase *p = FindPyClientClass( clientClass );
if( !p )
{
Warning( "__MsgFunc_PyNetworkCls: Invalid networked class %s\n", clientClass );
return;
}
// Set type
p->SetType( iType );
SetupClientClassRecv( p, iType );
// Read network class name
Q_strncpy( p->m_strPyNetworkedClassName, networkName, PYNETCLS_BUFSIZE );
// Attach if a network class exists
unsigned short lookup = m_NetworkClassDatabase.Find( networkName );
if ( lookup != m_NetworkClassDatabase.InvalidIndex() )
{
m_NetworkClassDatabase.Element(lookup)->AttachClientClass( p );
}
else
{
Warning( "__MsgFunc_PyNetworkCls: Invalid networked class %s\n", networkName );
}
}
void CTextureManager::RemoveTextureAlias( const char *pAlias )
{
if ( pAlias == NULL )
return;
char szCleanName[MAX_PATH];
int index = m_TextureAliases.Find( NormalizeTextureName( pAlias, szCleanName, sizeof( szCleanName ) ) );
if ( index == m_TextureAliases.InvalidIndex() )
return; //not found
delete []m_TextureAliases[index];
m_TextureAliases.RemoveAt( index );
}
void CorrelateWavsAndVCDs( CUtlVector< CUtlSymbol >& vcdfiles, CUtlVector< CUtlSymbol >& wavfiles )
{
CUtlDict< VCDList, int > database;
int i;
int c = vcdfiles.Count();
for ( i = 0; i < c; i++ )
{
CUtlSymbol& vcdname = vcdfiles[ i ];
// Load the .vcd and update the database
ProcessVCD( database, vcdname );
}
if ( vcdonly )
return;
vprint( 0, "Found %i wav files in %i vcds\n",
database.Count(), vcdfiles.Count() );
// Now look for any wavfiles that weren't in the database
int ecount = 0;
c = wavfiles.Count();
for ( i = 0; i < c; i++ )
{
CUtlSymbol& wavename = wavfiles[ i ];
int idx = database.Find( g_Analysis.symbols.String( wavename ) );
if ( idx != database.InvalidIndex() )
{
VCDList *listentry = &database[ idx ];
int vcdcount = listentry->vcds.Count();
if ( vcdcount >= 2 && verbose )
{
vprint( 0, " wave '%s' used by multiple .vcds:\n", g_Analysis.symbols.String( wavename ) );
int j;
for ( j = 0; j < vcdcount; j++ )
{
vprint( 1, "%i -- '%s'\n", j+1, g_Analysis.symbols.String( listentry->vcds[ j ] ) );
}
}
continue;
}
vprint( 0, "%i -- '%s' not referenced by .vcd\n",
++ecount, g_Analysis.symbols.String( wavename ) );
}
vprint( 0, "\nSummary: found %i/%i (%.2f percent) .wav errors\n", ecount, c, 100.0 * ecount / max( c, 1 ) );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *name -
// Output : FileItemInfo_t
//-----------------------------------------------------------------------------
static ITEM_FILE_INFO_HANDLE FindItemInfo( const char *name )
{
// Complain about duplicately defined metaclass names...
unsigned short lookup = m_ItemInfoDatabase.Find( name );
if ( lookup != m_ItemInfoDatabase.InvalidIndex() )
{
return lookup;
}
FileItemInfo_t *insert = new FileItemInfo_t; // BOXBOX was CreateWeaponInfo();
lookup = m_ItemInfoDatabase.Insert( name, insert );
Assert( lookup != m_ItemInfoDatabase.InvalidIndex() );
return lookup;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *name -
// Output : FilePlayerClassInfo_t
//-----------------------------------------------------------------------------
static PLAYERCLASS_FILE_INFO_HANDLE FindPlayerClassInfoSlot( const char *name )
{
// Complain about duplicately defined metaclass names...
unsigned short lookup = m_PlayerClassInfoDatabase.Find( name );
if ( lookup != m_PlayerClassInfoDatabase.InvalidIndex() )
{
return lookup;
}
FilePlayerClassInfo_t *insert = CreatePlayerClassInfo();
lookup = m_PlayerClassInfoDatabase.Insert( name, insert );
Assert( lookup != m_PlayerClassInfoDatabase.InvalidIndex() );
return lookup;
}
//-----------------------------------------------------------------------------
// 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];
}
}
// Message handler for PyNetworkCls
void __MsgFunc_PyNetworkCls( bf_read &msg )
{
int iClassID;
char networkName[PYNETCLS_BUFSIZE];
iClassID = msg.ReadWord();
msg.ReadString( networkName, PYNETCLS_BUFSIZE );
DbgStrPyMsg( "__MsgFunc_PyNetworkCls: Registering Python network class message %d %s\n", iClassID, networkName );
// Get module path
const char *pch = V_strrchr( networkName, '.' );
if( !pch )
{
Warning( "Invalid python class name %s\n", networkName );
return;
}
int n = pch - networkName + 1;
char modulePath[PYNETCLS_BUFSIZE];
V_strncpy( modulePath, networkName, n );
// Make sure the client class is imported
SrcPySystem()->Import( modulePath );
// Read which client class we are modifying
PyClientClassBase *p = FindPyClientClassByID( iClassID );
if( !p )
{
Warning( "__MsgFunc_PyNetworkCls: Invalid networked class %d\n", iClassID );
return;
}
// Read network class name
V_strncpy( p->m_strPyNetworkedClassName, networkName, sizeof( p->m_strPyNetworkedClassName ) );
// Attach if a network class exists
unsigned short lookup = m_NetworkClassDatabase.Find( networkName );
if ( lookup != m_NetworkClassDatabase.InvalidIndex() )
{
m_NetworkClassDatabase.Element(lookup)->AttachClientClass( p );
}
else
{
Warning( "__MsgFunc_PyNetworkCls: Invalid networked class %s\n", networkName );
}
}
NetworkedClass::~NetworkedClass()
{
if( m_pServerClass )
{
m_pServerClass->m_bFree = true;
m_pServerClass->SetupServerClass(PN_NONE);
unsigned short lookup = m_ServerClassInfoDatabase.Find( m_pNetworkName );
if ( lookup != m_ServerClassInfoDatabase.InvalidIndex() )
{
m_ServerClassInfoDatabase.Remove( m_pNetworkName );
}
}
free( (void *)m_pNetworkName );
m_pNetworkName = NULL;
}
void RegisterScriptedTrigger( const char *className )
{
if ( EntityFactoryDictionary()->FindFactory( className ) )
{
return;
}
unsigned short lookup = m_TriggerFactoryDatabase.Find( className );
if ( lookup != m_TriggerFactoryDatabase.InvalidIndex() )
{
return;
}
CEntityFactory<CBaseScriptedTrigger> *pFactory = new CEntityFactory<CBaseScriptedTrigger>( className );
lookup = m_TriggerFactoryDatabase.Insert( className, pFactory );
Assert( lookup != m_TriggerFactoryDatabase.InvalidIndex() );
}
/**
* Try to look up named sequences in a CUtlDict cache before falling back to the normal LookupSequence. It's
* best to avoid the normal LookupSequence when your models have 750+ sequences...
*/
int CCSPlayerAnimState::CalcSequenceIndex( const char *pBaseName, ... )
{
VPROF( "CCSPlayerAnimState::CalcSequenceIndex" );
CheckCachedSequenceValidity();
char szFullName[512];
va_list marker;
va_start( marker, pBaseName );
Q_vsnprintf( szFullName, sizeof( szFullName ), pBaseName, marker );
va_end( marker );
int iSequence = m_namedSequence.Find( szFullName );
if ( iSequence == m_namedSequence.InvalidIndex() )
{
iSequence = GetOuter()->LookupSequence( szFullName );
m_namedSequence.Insert( szFullName, iSequence );
}
else
{
iSequence = m_namedSequence[iSequence];
}
#if defined(CLIENT_DLL) && defined(_DEBUG)
int realSequence = GetOuter()->LookupSequence( szFullName );
Assert( realSequence == iSequence );
#endif
// Show warnings if we can't find anything here.
if ( iSequence == -1 )
{
static CUtlDict<int,int> dict;
if ( dict.Find( szFullName ) == -1 )
{
dict.Insert( szFullName, 0 );
Warning( "CalcSequenceIndex: can't find '%s'.\n", szFullName );
}
iSequence = 0;
}
return iSequence;
}
void CClassMap::Add( const char *mapname, const char *classname, int size, DISPATCHFUNCTION factory = 0 )
{
const char *map = Lookup( classname );
if ( map && !Q_strcasecmp( mapname, map ) )
return;
if ( map )
{
int index = m_ClassDict.Find( classname );
Assert( index != m_ClassDict.InvalidIndex() );
m_ClassDict.RemoveAt( index );
}
classentry_t element;
element.SetMapName( mapname );
element.factory = factory;
element.size = size;
m_ClassDict.Insert( classname, element );
}
void CGECreateServer::AddWeaponSet( const char *group, KeyValues *set )
{
int grpIdx = m_WeaponSets.Find( group );
if ( grpIdx == m_WeaponSets.InvalidIndex() )
grpIdx = m_WeaponSets.Insert( group, new CUtlDict<char*, int>() );
char *name = new char[32];
Q_strncpy( name, set->GetString("print_name", "Unnamed"), 32 );
int setIdx = m_WeaponSets[grpIdx]->Find( set->GetName() );
if ( setIdx != m_WeaponSets[grpIdx]->InvalidIndex() )
{
// Replace the existing set with this one
delete [] m_WeaponSets[grpIdx]->Element(setIdx);
m_WeaponSets[grpIdx]->RemoveAt(grpIdx);
}
// Insert the set
m_WeaponSets[grpIdx]->Insert( set->GetName(), name );
}
