static cell_t smn_KvGotoNextKey(IPluginContext *pCtx, const cell_t *params)
{
Handle_t hndl = static_cast<Handle_t>(params[1]);
HandleError herr;
HandleSecurity sec;
KeyValueStack *pStk;
sec.pOwner = NULL;
sec.pIdentity = g_pCoreIdent;
if ((herr=handlesys->ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
!= HandleError_None)
{
return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
}
KeyValues *pSubKey = pStk->pCurRoot.front();
if (params[2])
{
pSubKey = pSubKey->GetNextTrueSubKey();
} else {
pSubKey = pSubKey->GetNextKey();
}
if (!pSubKey)
{
return 0;
}
pStk->pCurRoot.pop();
pStk->pCurRoot.push(pSubKey);
return 1;
}
void CCompiledKeyValuesWriter::BuildKVData_R( KeyValues *kv, int parent )
{
// Add self
KVInfo_t info;
info.key = m_StringTable.AddString( kv->GetName() );
info.value = m_StringTable.AddString( kv->GetString() );
info.SetSubTree( kv->GetFirstSubKey() != NULL ? true : false );
info.SetParent( parent );
int newParent = m_Data.AddToTail( info );
// Then add children
for ( KeyValues *sub = kv->GetFirstSubKey(); sub; sub = sub->GetNextKey() )
{
BuildKVData_R( sub, newParent );
}
// Then add peers
if ( parent == -1 )
{
if ( kv->GetNextKey() )
{
BuildKVData_R( kv->GetNextKey(), parent );
}
}
}
void CRoomTemplate::LoadFromKeyValues( const char *pRoomName, KeyValues *pKeyValues )
{
m_nTilesX = pKeyValues->GetInt( "TilesX", 1 );
m_nTilesY = pKeyValues->GetInt( "TilesY", 1 );
SetSpawnWeight( pKeyValues->GetInt( "SpawnWeight", MIN_SPAWN_WEIGHT ) );
SetFullName( pRoomName );
Q_strncpy( m_Description, pKeyValues->GetString( "RoomTemplateDescription", "" ), m_nMaxDescriptionLength );
Q_strncpy( m_Soundscape, pKeyValues->GetString( "Soundscape", "" ), m_nMaxSoundscapeLength );
SetTileType( pKeyValues->GetInt( "TileType", ASW_TILETYPE_UNKNOWN ) );
m_Tags.RemoveAll();
// search through all the exit subsections
KeyValues *pkvSubSection = pKeyValues->GetFirstSubKey();
bool bClearedExits = false;
while ( pkvSubSection )
{
// mission details
if ( Q_stricmp(pkvSubSection->GetName(), "EXIT")==0 )
{
if ( !bClearedExits )
{
// if we haven't cleared previous exits yet then do so now
m_Exits.PurgeAndDeleteElements();
bClearedExits = true;
}
CRoomTemplateExit *pExit = new CRoomTemplateExit();
pExit->m_iXPos = pkvSubSection->GetInt("XPos");
pExit->m_iYPos = pkvSubSection->GetInt("YPos");
pExit->m_ExitDirection = (ExitDirection_t) pkvSubSection->GetInt("ExitDirection");
pExit->m_iZChange = pkvSubSection->GetInt("ZChange");
Q_strncpy( pExit->m_szExitTag, pkvSubSection->GetString( "ExitTag" ), sizeof( pExit->m_szExitTag ) );
pExit->m_bChokepointGrowSource = !!pkvSubSection->GetInt("ChokeGrow", 0);
// discard exits outside the room bounds
if ( pExit->m_iXPos < 0 || pExit->m_iYPos < 0 || pExit->m_iXPos >= m_nTilesX || pExit->m_iYPos >= m_nTilesY )
{
delete pExit;
}
else
{
m_Exits.AddToTail(pExit);
}
}
else if ( Q_stricmp(pkvSubSection->GetName(), "Tags")==0 && TagList() )
{
for ( KeyValues *sub = pkvSubSection->GetFirstSubKey(); sub != NULL; sub = sub->GetNextKey() )
{
if ( !Q_stricmp( sub->GetName(), "tag" ) )
{
AddTag( sub->GetString() );
}
}
}
pkvSubSection = pkvSubSection->GetNextKey();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseModelPanel::ParseModelResInfo( KeyValues *inResourceData )
{
m_bForcePos = ( inResourceData->GetInt( "force_pos", 0 ) == 1 );
m_BMPResData.m_pszModelName = ReadAndAllocStringValue( inResourceData, "modelname" );
m_BMPResData.m_pszModelName_HWM = ReadAndAllocStringValue( inResourceData, "modelname_hwm" );
m_BMPResData.m_pszVCD = ReadAndAllocStringValue( inResourceData, "vcd" );
m_BMPResData.m_angModelPoseRot.Init( inResourceData->GetFloat( "angles_x", 0.0f ), inResourceData->GetFloat( "angles_y", 0.0f ), inResourceData->GetFloat( "angles_z", 0.0f ) );
m_BMPResData.m_vecOriginOffset.Init( inResourceData->GetFloat( "origin_x", 110.0 ), inResourceData->GetFloat( "origin_y", 5.0 ), inResourceData->GetFloat( "origin_z", 5.0 ) );
m_BMPResData.m_vecFramedOriginOffset.Init( inResourceData->GetFloat( "frame_origin_x", 110.0 ), inResourceData->GetFloat( "frame_origin_y", 5.0 ), inResourceData->GetFloat( "frame_origin_z", 5.0 ) );
m_BMPResData.m_vecViewportOffset.Init();
m_BMPResData.m_nSkin = inResourceData->GetInt( "skin", -1 );
m_BMPResData.m_bUseSpotlight = ( inResourceData->GetInt( "spotlight", 0 ) == 1 );
m_angPlayer = m_BMPResData.m_angModelPoseRot;
m_vecPlayerPos = m_BMPResData.m_vecOriginOffset;
for ( KeyValues *pData = inResourceData->GetFirstSubKey(); pData != NULL; pData = pData->GetNextKey() )
{
if ( !Q_stricmp( pData->GetName(), "animation" ) )
{
ParseModelAnimInfo( pData );
}
else if ( !Q_stricmp( pData->GetName(), "attached_model" ) )
{
ParseModelAttachInfo( pData );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Loads the surface properties database into the physics DLL
//-----------------------------------------------------------------------------
void LoadSurfaceProperties( void )
{
CreateInterfaceFn physicsFactory = GetPhysicsFactory();
if ( !physicsFactory )
return;
physprops = (IPhysicsSurfaceProps *)physicsFactory( VPHYSICS_SURFACEPROPS_INTERFACE_VERSION, NULL );
const char *SURFACEPROP_MANIFEST_FILE = "scripts/surfaceproperties_manifest.txt";
KeyValues *manifest = new KeyValues( SURFACEPROP_MANIFEST_FILE );
if ( manifest->LoadFromFile( g_pFileSystem, SURFACEPROP_MANIFEST_FILE, "GAME" ) )
{
for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL; sub = sub->GetNextKey() )
{
if ( !Q_stricmp( sub->GetName(), "file" ) )
{
// Add
LoadSurfacePropFile( sub->GetString() );
continue;
}
}
}
manifest->deleteThis();
}
void C_SoundscapeSystem::AddSoundScapeFile( const char *filename )
{
KeyValues *script = new KeyValues( filename );
#ifndef _XBOX
if ( script->LoadFromFile( filesystem, filename ) )
#else
if ( filesystem->LoadKeyValues( *script, IFileSystem::TYPE_SOUNDSCAPE, filename, "GAME" ) )
#endif
{
// parse out all of the top level sections and save their names
KeyValues *pKeys = script;
while ( pKeys )
{
// save pointers to all sections in the root
// each one is a soundscape
if ( pKeys->GetFirstSubKey() )
{
m_soundscapes.AddToTail( pKeys );
}
pKeys = pKeys->GetNextKey();
}
// Keep pointer around so we can delete it at exit
m_SoundscapeScripts.AddToTail( script );
}
else
{
script->deleteThis();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBaseObject::AddAndParseBuildPoint( int iAttachmentNumber, KeyValues *pkvBuildPoint )
{
int iPoint = AddBuildPoint( iAttachmentNumber );
m_BuildPoints[iPoint].m_bPutInAttachmentSpace = (pkvBuildPoint->GetInt( "PutInAttachmentSpace", 0 ) != 0);
// Now see if we've got a set of valid objects specified
KeyValues *pkvValidObjects = pkvBuildPoint->FindKey( "valid_objects" );
if ( pkvValidObjects )
{
KeyValues *pkvObject = pkvValidObjects->GetFirstSubKey();
while ( pkvObject )
{
const char *pSpecifiedObject = pkvObject->GetName();
int iLenObjName = Q_strlen( pSpecifiedObject );
// Find the object index for the name
for ( int i = 0; i < OBJ_LAST; i++ )
{
if ( !Q_strncasecmp( GetObjectInfo( i )->m_pClassName, pSpecifiedObject, iLenObjName) )
{
AddValidObjectToBuildPoint( iPoint, i );
break;
}
}
pkvObject = pkvObject->GetNextKey();
}
}
}
// fills in the target list panel with buttons for each of the entries in the desired list
bool SwarmopediaTopics::SetupList(SwarmopediaPanel *pPanel, const char *szDesiredList)
{
// look through our KeyValues for the desired list
KeyValues *pkvList = GetSubkeyForList(szDesiredList);
if (!pkvList)
{
Msg("Swarmopedia error: Couldn't find list %s\n", szDesiredList);
return false;
}
// now go through every LISTENTRY in the subkey we found, adding it to the list panel
int iPlayerUnlockLevel = 999; // todo: have this check a convar that measures how far through the jacob campaign the player has got
while ( pkvList )
{
if (Q_stricmp(pkvList->GetName(), "LISTENTRY")==0)
{
const char *szEntryName = pkvList->GetString("Name");
const char *szArticleTarget = pkvList->GetString("ArticleTarget");
const char *szListTarget = pkvList->GetString("ListTarget");
int iEntryUnlockLevel = pkvList->GetInt("UnlockLevel");
int iSectionHeader = pkvList->GetInt("SectionHeader");
if (iEntryUnlockLevel == 0 || iEntryUnlockLevel < iPlayerUnlockLevel)
{
pPanel->AddListEntry(szEntryName, szArticleTarget, szListTarget, iSectionHeader);
}
}
pkvList = pkvList->GetNextKey();
}
return true;
}
bool VMFExporter::ProcessGenericRecursive( KeyValues *pKey )
{
const char *szKey = pKey->GetName();
const char *szValue = pKey->GetString();
if ( !Q_stricmp( szKey, "startposition" ) )
{
Vector Origin;
int nRead = sscanf(szValue, "[%f %f %f]", &Origin[0], &Origin[1], &Origin[2]);
if (nRead != 3)
return false;
// move the points to where our room is
Origin += GetCurrentRoomOffset();
char buffer[256];
Q_snprintf(buffer, sizeof(buffer), "[%f %f %f]", Origin[0], Origin[1], Origin[2]);
pKey->SetStringValue( buffer );
}
if ( pKey->GetFirstSubKey() ) // if this keyvalues entry has subkeys, then process them
{
for ( KeyValues *pKeys = pKey->GetFirstSubKey(); pKeys; pKeys = pKeys->GetNextKey() )
{
if ( !ProcessGenericRecursive( pKeys ) )
return false;
}
}
return true;
}
//------------------------------------------------------------------------------
// Purpose:
//------------------------------------------------------------------------------
bool CNPC_Furniture::CreateVPhysics( void )
{
#ifndef HL2_DLL
return false;
#endif
if ( !m_BoneFollowerManager.GetNumBoneFollowers() )
{
KeyValues *modelKeyValues = new KeyValues("");
if ( modelKeyValues->LoadFromBuffer( modelinfo->GetModelName( GetModel() ), modelinfo->GetModelKeyValueText( GetModel() ) ) )
{
// Do we have a bone follower section?
KeyValues *pkvBoneFollowers = modelKeyValues->FindKey("bone_followers");
if ( pkvBoneFollowers )
{
// Loop through the list and create the bone followers
KeyValues *pBone = pkvBoneFollowers->GetFirstSubKey();
while ( pBone )
{
// Add it to the list
const char *pBoneName = pBone->GetString();
m_BoneFollowerManager.AddBoneFollower( this, pBoneName );
pBone = pBone->GetNextKey();
}
}
}
modelKeyValues->deleteThis();
}
return true;
}
void PrecacheFileWeaponInfoDatabase( IFileSystem *filesystem, const unsigned char *pICEKey )
{
if ( m_WeaponInfoDatabase.Count() )
return;
KeyValues *manifest = new KeyValues( "weaponscripts" );
if ( manifest->LoadFromFile( filesystem, "scripts/weapon_manifest.txt", "GAME" ) )
{
for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL ; sub = sub->GetNextKey() )
{
if ( !Q_stricmp( sub->GetName(), "file" ) )
{
char fileBase[512];
Q_FileBase( sub->GetString(), fileBase, sizeof(fileBase) );
WEAPON_FILE_INFO_HANDLE tmp;
#ifdef CLIENT_DLL
if ( ReadWeaponDataFromFileForSlot( filesystem, fileBase, &tmp, pICEKey ) )
{
gWR.LoadWeaponSprites( tmp );
}
#else
ReadWeaponDataFromFileForSlot( filesystem, fileBase, &tmp, pICEKey );
#endif
}
else
{
Error( "Expecting 'file', got %s\n", sub->GetName() );
}
}
}
manifest->deleteThis();
}
void VMFExporter::LoadUniqueKeyList()
{
m_UniqueKeys.RemoveAll();
m_NodeIDKeys.RemoveAll();
// Open the manifest file, and read the particles specified inside it
KeyValues *manifest = new KeyValues( UNIQUE_KEYS_FILE );
if ( manifest->LoadFromFile( g_pFullFileSystem, UNIQUE_KEYS_FILE, "GAME" ) )
{
for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL; sub = sub->GetNextKey() )
{
if ( !Q_stricmp( sub->GetName(), "key" ) )
{
m_UniqueKeys.AddToTail( sub->GetString() );
continue;
}
if ( !Q_stricmp( sub->GetName(), "NodeID" ) )
{
m_NodeIDKeys.AddToTail( sub->GetString() );
continue;
}
Warning( "VMFExporter::LoadUniqueKeyList: Manifest '%s' with bogus file type '%s', expecting 'key' or 'NodeID'\n", UNIQUE_KEYS_FILE, sub->GetName() );
}
}
else
{
Warning( "VMFExporter: Unable to load manifest file '%s'\n", UNIQUE_KEYS_FILE );
}
manifest->deleteThis();
}
void CASW_Holdout_Wave::LoadFromKeyValues( int nWaveNumber, KeyValues *pKeys )
{
m_Entries.PurgeAndDeleteElements();
m_nTotalAliens = 0;
m_nWaveNumber = nWaveNumber;
m_iszWaveName = AllocPooledString( pKeys->GetString( "Name", "Unknown" ) );
m_nEnvironmentModifiers = pKeys->GetInt( "EnvironmentModifiers" ); // TODO: Turn this into a string parser for the bit flag names
m_bWaveHasResupply = pKeys->GetBool( "Resupply", false );
for ( KeyValues *pKey = pKeys->GetFirstSubKey(); pKey; pKey = pKey->GetNextKey() )
{
if ( !Q_stricmp( pKey->GetName(), "ENTRY" ) )
{
if ( asw_holdout_debug.GetBool() )
{
Msg( " Loading a wave entry\n" );
}
CASW_Holdout_Wave_Entry *pEntry = new CASW_Holdout_Wave_Entry();
pEntry->LoadFromKeyValues( pKey );
m_Entries.AddToTail( pEntry );
m_nTotalAliens += pEntry->GetQuantity();
}
}
}
void PhysParseSurfaceData( IPhysicsSurfaceProps *pProps, IFileSystem *pFileSystem )
{
KeyValues *manifest = new KeyValues( SURFACEPROP_MANIFEST_FILE );
if ( manifest->LoadFromFile( pFileSystem, SURFACEPROP_MANIFEST_FILE, "GAME" ) )
{
for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL; sub = sub->GetNextKey() )
{
if ( !Q_stricmp( sub->GetName(), "file" ) )
{
// Add
AddSurfacepropFile( sub->GetString(), pProps, pFileSystem );
continue;
}
Warning( "surfaceprops::Init: Manifest '%s' with bogus file type '%s', expecting 'file'\n",
SURFACEPROP_MANIFEST_FILE, sub->GetName() );
}
}
else
{
Error( "Unable to load manifest file '%s'\n", SURFACEPROP_MANIFEST_FILE );
}
manifest->deleteThis();
}
//-----------------------------------------------------------------------------
// Purpose: sets up the button/command bindings
//-----------------------------------------------------------------------------
void CControllerMap::ApplySettings( KeyValues *inResourceData )
{
BaseClass::ApplySettings( inResourceData );
// loop through all the data adding items to the menu
for (KeyValues *dat = inResourceData->GetFirstSubKey(); dat != NULL; dat = dat->GetNextKey())
{
if ( !Q_stricmp( dat->GetName(), "button" ) )
{
const char *buttonName = dat->GetString( "name", "" );
int keycode = StringToButtonCode( buttonName );
if ( keycode != -1 )
{
button_t b;
b.cmd = CUtlSymbol( dat->GetString( "command", "" ) );
// text and icon are optional - their existence means this button
// should be displayed in the footer panel.
const char *helpText = dat->GetString( "text", NULL );
if ( helpText )
{
b.text = CUtlSymbol( helpText );
b.icon = CUtlSymbol( dat->GetString( "icon", NULL ) );
}
m_buttonMap.Insert( keycode, b );
}
}
}
}
bool VMFExporter::AddRoomTemplateSolids( const CRoomTemplate *pRoomTemplate )
{
// open its vmf file
char roomvmfname[MAX_PATH];
Q_snprintf(roomvmfname, sizeof(roomvmfname), "tilegen/roomtemplates/%s/%s.vmf",
pRoomTemplate->m_pLevelTheme->m_szName,
pRoomTemplate->GetFullName() );
m_pTemplateKeys = new KeyValues( "RoomTemplateVMF" );
m_pTemplateKeys->LoadFromFile( g_pFullFileSystem, roomvmfname, "GAME" );
// look for world key
for ( KeyValues *pKeys = m_pTemplateKeys; pKeys; pKeys = pKeys->GetNextKey() )
{
if ( !Q_stricmp( pKeys->GetName(), "world" ) ) // find the world key in our room template
{
if ( !ProcessWorld( pKeys ) ) // fix up solid positions
{
Q_snprintf( m_szLastExporterError, sizeof(m_szLastExporterError), "Failed to copy world from room %s\n", pRoomTemplate->GetFullName() );
return false;
}
for ( KeyValues *pSubKey = pKeys->GetFirstSubKey(); pSubKey; pSubKey = pSubKey->GetNextKey() ) // convert each solid to a func_detail entity
{
if ( !Q_stricmp( pSubKey->GetName(), "solid" ) )
{
if ( IsDisplacementBrush( pSubKey ) )
{
// add to world section
m_pExportWorldKeys->AddSubKey( pSubKey->MakeCopy() );
}
else
{
// put into entity section as a func_detail
KeyValues *pFuncDetail = new KeyValues( "entity" );
pFuncDetail->SetInt( "id", ++m_iEntityCount );
pFuncDetail->SetString( "classname", "func_detail" );
pFuncDetail->AddSubKey( pSubKey->MakeCopy() );
m_pExportKeys->AddSubKey( pFuncDetail );
}
}
}
}
}
m_pTemplateKeys->deleteThis();
m_pTemplateKeys = NULL;
return true;
}
void BuildGroup::ProcessConditionalKeys( KeyValues *pData, KeyValues *pConditions )
{
// for each condition, look for it in keys
// if its a positive condition, promote all of its children, replacing values
if ( pData )
{
KeyValues *pSubKey = pData->GetFirstSubKey();
if ( !pSubKey )
{
// not a block
return;
}
for ( ; pSubKey != nullptr; pSubKey = pSubKey->GetNextKey() )
{
// recursively descend each sub block
ProcessConditionalKeys( pSubKey, pConditions );
KeyValues *pCondition = pConditions->GetFirstSubKey();
for ( ; pCondition != nullptr; pCondition = pCondition->GetNextKey() )
{
// if we match any conditions in this sub block, copy up
KeyValues *pConditionBlock = pSubKey->FindKey( pCondition->GetName() );
if ( pConditionBlock )
{
KeyValues *pOverridingKey;
for ( pOverridingKey = pConditionBlock->GetFirstSubKey(); pOverridingKey != nullptr; pOverridingKey = pOverridingKey->GetNextKey() )
{
KeyValues *pExistingKey = pSubKey->FindKey( pOverridingKey->GetName() );
if ( pExistingKey )
{
pExistingKey->SetStringValue( pOverridingKey->GetString() );
}
else
{
KeyValues *copy = pOverridingKey->MakeCopy();
pSubKey->AddSubKey( copy );
}
}
}
}
}
}
}
virtual void FrameUpdatePostEntityThink( void )
{
// Wait until we're all spawned in
if ( gpGlobals->curtime < 5 )
return;
if ( m_bIssuedNextMapCommand )
return;
if ( !m_bParsedMapFile )
{
m_bParsedMapFile = true;
// See if we've got a camera file to import cameras from
char szFullName[512];
Q_snprintf(szFullName,sizeof(szFullName), "maps/%s.txt", STRING( gpGlobals->mapname ));
KeyValues *pkvMapCameras = new KeyValues( "MapCameras" );
if ( pkvMapCameras->LoadFromFile( filesystem, szFullName, "MOD" ) )
{
Warning( "Devshots: Loading point_devshot_camera positions from %s. \n", szFullName );
// Get each camera, and add it to our list
KeyValues *pkvCamera = pkvMapCameras->GetFirstSubKey();
while ( pkvCamera )
{
// Get camera name
const char *pCameraName = pkvCamera->GetName();
// Make a camera, and move it to the position specified
CPointDevShotCamera *pCamera = (CPointDevShotCamera*)CreateEntityByName( "point_devshot_camera" );
Assert( pCamera );
pCamera->KeyValue( "cameraname", pCameraName );
pCamera->KeyValue( "origin", pkvCamera->GetString( "origin", "0 0 0" ) );
pCamera->KeyValue( "angles", pkvCamera->GetString( "angles", "0 0 0" ) );
pCamera->KeyValue( "FOV", pkvCamera->GetString( "FOV", "75" ) );
DispatchSpawn( pCamera );
pCamera->Activate();
// Move to next camera
pkvCamera = pkvCamera->GetNextKey();
}
}
if ( !g_iDevShotCameraCount )
{
Warning( "Devshots: No point_devshot_camera in %s. Moving to next map.\n", STRING( gpGlobals->mapname ) );
CBasePlayer *pPlayer = UTIL_GetLocalPlayerOrListenServerHost();
if ( pPlayer )
{
engine->ClientCommand( pPlayer->edict(), "devshots_nextmap" );
m_bIssuedNextMapCommand = true;
return;
}
}
}
}
void KeyValues::AddSubKey(KeyValues *pSubkey)
{
Assert(pSubkey->m_pPeer == NULL);
if (m_pSub == NULL)
{
m_pSub = pSubkey;
}
else
{
KeyValues *pTempDat = m_pSub;
while (pTempDat->GetNextKey() != NULL)
pTempDat = pTempDat->GetNextKey();
pTempDat->SetNextKey(pSubkey);
}
}
void PrecacheFileWeaponInfoDatabase( IFileSystem *filesystem, const unsigned char *pICEKey )
{
if ( m_WeaponInfoDatabase.Count() )
return;
#if !defined( _XBOX )
FileFindHandle_t findHandle;
const char *pFilename = filesystem->FindFirstEx( "scripts/weapon_*.txt", IsXbox() ? "XGAME" : "GAME", &findHandle );
while ( pFilename != NULL )
{
char fileBase[512];
Q_FileBase( pFilename, fileBase, sizeof(fileBase) );
WEAPON_FILE_INFO_HANDLE tmp;
#ifdef CLIENT_DLL
if ( ReadWeaponDataFromFileForSlot( filesystem, fileBase, &tmp, pICEKey ) )
{
gWR.LoadWeaponSprites( tmp );
}
#else
ReadWeaponDataFromFileForSlot( filesystem, fileBase, &tmp, pICEKey );
#endif
pFilename = filesystem->FindNext( findHandle );
}
filesystem->FindClose( findHandle );
#else
#define WEAPON_SCRIPT_MANIFEST_FILE "scripts/_weapon_manifest.txt"
// Use a manifest file on the xbox
KeyValues *manifest = new KeyValues( "weaponscripts" );
if ( manifest->LoadFromFile( filesystem, WEAPON_SCRIPT_MANIFEST_FILE, "XGAME" ) )
{
for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL ; sub = sub->GetNextKey() )
{
if ( !Q_stricmp( sub->GetName(), "file" ) )
{
char fileBase[512];
Q_FileBase( sub->GetString(), fileBase, sizeof(fileBase) );
WEAPON_FILE_INFO_HANDLE tmp;
#ifdef CLIENT_DLL
if ( ReadWeaponDataFromFileForSlot( filesystem, fileBase, &tmp, pICEKey ) )
{
gWR.LoadWeaponSprites( tmp );
}
#else
ReadWeaponDataFromFileForSlot( filesystem, fileBase, &tmp, pICEKey );
#endif
}
else
{
Error( "Expecting 'file', got %s\n", sub->GetName() );
}
}
}
manifest->deleteThis();
#endif
}
void KeyValues::AppendIncludedKeys(CUtlVector<KeyValues *> &includedKeys)
{
int includeCount = includedKeys.Count();
for (int i = 0; i < includeCount; i++)
{
KeyValues *kv = includedKeys[i];
Assert(kv);
KeyValues *insertSpot = this;
while (insertSpot->GetNextKey())
{
insertSpot = insertSpot->GetNextKey();
}
insertSpot->SetNextKey(kv);
}
}
bool VMFExporter::ProcessConnections( KeyValues *pConnections )
{
for ( KeyValues *pKeys = pConnections->GetFirstSubKey(); pKeys; pKeys = pKeys->GetNextKey() )
{
if ( !ProcessConnectionsKey( pKeys ) )
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: create the Border objects from the scheme data
//-----------------------------------------------------------------------------
void CScheme::LoadBorders()
{
m_pkvBorders = m_pData->FindKey("Borders", true);
{for ( KeyValues *kv = m_pkvBorders->GetFirstSubKey(); kv != NULL; kv = kv->GetNextKey())
{
if (kv->GetDataType() == KeyValues::TYPE_STRING)
{
// it's referencing another border, ignore for now
}
else
{
int i = m_BorderList.AddToTail();
Border *border = new Border();
border->SetName(kv->GetName());
border->ApplySchemeSettings(this, kv);
m_BorderList[i].border = border;
m_BorderList[i].bSharedBorder = false;
m_BorderList[i].borderSymbol = kv->GetNameSymbol();
}
}}
// iterate again to get the border references
for ( KeyValues *kv = m_pkvBorders->GetFirstSubKey(); kv != NULL; kv = kv->GetNextKey())
{
if (kv->GetDataType() == KeyValues::TYPE_STRING)
{
// it's referencing another border, find it
Border *border = (Border *)GetBorder(kv->GetString());
// const char *str = kv->GetName();
Assert(border);
// add an entry that just references the existing border
int i = m_BorderList.AddToTail();
m_BorderList[i].border = border;
m_BorderList[i].bSharedBorder = true;
m_BorderList[i].borderSymbol = kv->GetNameSymbol();
}
}
m_pBaseBorder = GetBorder("BaseBorder");
}
const char* CASW_Mission_Chooser_Source_Local::GetPrettySavedCampaignName(const char *szSaveName)
{
static char szPrettyName[256];
szPrettyName[0] = '\0';
char stripped[MAX_PATH];
V_StripExtension( szSaveName, stripped, MAX_PATH );
char tempfile[MAX_PATH];
Q_snprintf( tempfile, sizeof( tempfile ), "save/%s.campaignsave", stripped );
KeyValues *pSaveKeyValues = new KeyValues( szSaveName );
if (pSaveKeyValues->LoadFromFile(g_pFullFileSystem, tempfile))
{
const char *szCampaignName = pSaveKeyValues->GetString("CampaignName");
const char *szPrettyCampaignName = szCampaignName;
if (szCampaignName && Q_strlen(szCampaignName) > 0)
{
szPrettyCampaignName = GetPrettyCampaignName(szCampaignName);
}
const char *szDate = pSaveKeyValues->GetString("DateTime");
char namebuffer[256];
namebuffer[0] = '\0';
int namepos = 0;
KeyValues *pkvSubSection = pSaveKeyValues->GetFirstSubKey();
while ( pkvSubSection && namepos < 253)
{
if (Q_stricmp(pkvSubSection->GetName(), "PLAYER")==0)
{
const char *pName = pkvSubSection->GetString("PlayerName");
if (pName && pName[0] != '\0')
{
if (namepos != 0)
{
namebuffer[namepos] = ' '; namepos++;
}
int namelength = Q_strlen(pName);
for (int charcopy=0; charcopy<namelength && namepos<253; charcopy++)
{
namebuffer[namepos] = pName[charcopy];
namepos++;
}
namebuffer[namepos] = '\0';
}
}
pkvSubSection = pkvSubSection->GetNextKey();
}
Q_snprintf(szPrettyName, sizeof(szPrettyName),
"%s (%s) (%s)",
szPrettyCampaignName, szDate, namebuffer);
}
pSaveKeyValues->deleteThis();
return szPrettyName;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFIntroMenu::LoadCaptions( void )
{
bool bSuccess = false;
// clear any current captions
m_Captions.PurgeAndDeleteElements();
m_iCurrentCaption = 0;
if ( m_pCaptionLabel )
{
KeyValues *kvCaptions = NULL;
char strFullpath[MAX_PATH];
Q_strncpy( strFullpath, TFGameRules()->GetVideoFileForMap( false ), MAX_PATH ); // Assume we must play out of the media directory
Q_strncat( strFullpath, ".res", MAX_PATH ); // Assume we're a .res extension type
if ( g_pFullFileSystem->FileExists( strFullpath ) )
{
kvCaptions = new KeyValues( strFullpath );
if ( kvCaptions )
{
if ( kvCaptions->LoadFromFile( g_pFullFileSystem, strFullpath ) )
{
for ( KeyValues *pData = kvCaptions->GetFirstSubKey(); pData != NULL; pData = pData->GetNextKey() )
{
CVideoCaption *pCaption = new CVideoCaption;
if ( pCaption )
{
pCaption->m_pszString = ReadAndAllocStringValue( pData, "string" );
pCaption->m_flStartTime = pData->GetFloat( "start", 0.0 );
pCaption->m_flDisplayTime = pData->GetFloat( "length", 3.0 );
m_Captions.AddToTail( pCaption );
// we have at least one caption to show
bSuccess = true;
}
}
}
kvCaptions->deleteThis();
}
}
}
if ( bSuccess )
{
// sort the captions so we show them in the correct order (they're not necessarily in order in the .res file)
m_Captions.Sort( CaptionsSort );
}
return bSuccess;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CSoundEmitterSystemBase::BaseInit()
{
if ( m_SoundKeyValues.Count() > 0 )
{
BaseShutdown();
}
KeyValues *manifest = new KeyValues( MANIFEST_FILE );
if ( manifest->LoadFromFile( filesystem, MANIFEST_FILE, "GAME" ) )
{
for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL; sub = sub->GetNextKey() )
{
if ( !Q_stricmp( sub->GetName(), "precache_file" ) )
{
// Add and always precache
AddSoundsFromFile( sub->GetString(), true );
continue;
}
else if ( !Q_stricmp( sub->GetName(), "declare_file" ) )
{
// Add but don't precache
AddSoundsFromFile( sub->GetString(), false );
continue;
}
Warning( "CSoundEmitterSystemBase::BaseInit: Manifest '%s' with bogus file type '%s', expecting 'declare_file' or 'precache_file'\n",
MANIFEST_FILE, sub->GetName() );
}
}
else
{
Error( "Unable to load manifest file '%s'\n", MANIFEST_FILE );
}
// Only print total once, on server
#if !defined( CLIENT_DLL )
int missing = CheckForMissingWavFiles( false );
if ( missing > 0 )
{
DevMsg( 1, "CSoundEmitterSystem: Registered %i sounds ( %i missing .wav files referenced )\n",
m_Sounds.Count(), missing );
}
else
{
DevMsg( 1, "CSoundEmitterSystem: Registered %i sounds\n",
m_Sounds.Count() );
}
#endif
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *filename -
//-----------------------------------------------------------------------------
void CSoundEmitterSystemBase::AddSoundsFromFile( const char *filename, bool precachealways )
{
CSoundScriptFile sf;
Assert( Q_strlen( filename ) < sizeof( sf.filename ) );
Q_strncpy( sf.filename, filename, sizeof( sf.filename ) );
sf.dirty = false;
sf.precachealways = precachealways;
int scriptindex = m_SoundKeyValues.AddToTail( sf );
// Open the soundscape data file, and abort if we can't
KeyValues *kv = new KeyValues( filename );
if ( kv->LoadFromFile( filesystem, filename, "GAME" ) )
{
// parse out all of the top level sections and save their names
KeyValues *pKeys = kv;
while ( pKeys )
{
if ( pKeys->GetFirstSubKey() )
{
CSoundEntry entry;
entry.m_bRemoved = false;
entry.m_nScriptFileIndex = scriptindex;
entry.m_bPrecacheAlways = precachealways;
int lookup = m_Sounds.Find( pKeys->GetName() );
if ( lookup != m_Sounds.InvalidIndex() )
{
DevMsg( "CSoundEmitterSystem::AddSoundsFromFile(%s): Entry %s duplicated, skipping\n", filename, pKeys->GetName() );
}
else
{
InitSoundInternalParameters( pKeys->GetName(), pKeys, entry.m_SoundParams );
m_Sounds.Insert( pKeys->GetName(), entry );
}
}
pKeys = pKeys->GetNextKey();
}
}
else
{
Msg( "CSoundEmitterSystem::AddSoundsFromFile: No such file %s\n", filename );
// Discard
m_SoundKeyValues.Remove( scriptindex );
kv->deleteThis();
return;
}
Assert( scriptindex >= 0 );
}
void CGECharacterDataParser::Parse( KeyValues *pKeyValuesData, const char *szFileWithoutEXT )
{
CGECharData *pChar = g_GECharacters.Add( szFileWithoutEXT );
Q_strncpy( pChar->szPrintName, pKeyValuesData->GetString("printname", "#GE_UNNAMED"), MAX_CHAR_IDENT );
Q_strncpy( pChar->szShortName, pKeyValuesData->GetString("shortname", "#GE_UNNAMED"), MAX_CHAR_NAME );
Q_strncpy( pChar->szBio, pKeyValuesData->GetString("bio", "" ), MAX_CHAR_BIO );
// Load our weight
pChar->iWeight = pKeyValuesData->GetInt( "weight" );
// Affiliate them with a team
const char *team = pKeyValuesData->GetString( "team", "unassigned" );
if ( !Q_stricmp(team, "mi6") )
pChar->iTeam = TEAM_MI6;
else if ( !Q_stricmp(team, "janus") )
pChar->iTeam = TEAM_JANUS;
else
pChar->iTeam = TEAM_UNASSIGNED;
const char *gender = pKeyValuesData->GetString( "gender", "m" );
if ( gender[0] == 'f' )
pChar->iGender = CHAR_GENDER_FEMALE;
else
pChar->iGender = CHAR_GENDER_MALE;
// Load our skins in
KeyValues *pSkinValues = pKeyValuesData->FindKey( "skins" );
if ( pSkinValues )
{
KeyValues *pSkinData = pSkinValues->GetFirstSubKey();
for( int i=0; i < MAX_CHAR_SKINS; i++ )
{
if( pSkinData == NULL )
break;
GECharSkin *skin = new GECharSkin;
Q_strncpy( skin->szIdent, pSkinData->GetName(), MAX_CHAR_IDENT );
Q_strncpy( skin->szPreviewImg, pSkinData->GetString("previewimg", "unknown" ), MAX_CHAR_NAME );
Q_strncpy( skin->szModel, pSkinData->GetString("model", "" ), MAX_MODEL_PATH );
Q_strncpy( skin->szHatModel, pSkinData->GetString("hatmodel", "" ), MAX_MODEL_PATH );
skin->iViewSkin = pSkinData->GetInt( "viewmodelskin", 0 );
skin->iWorldSkin = pSkinData->GetInt( "worldmodelskin", 0 );
// TODO: We need to error check this input....
pChar->m_pSkins.AddToTail( skin );
pSkinData = pSkinData->GetNextKey();
}
}
}
bool VMFExporter::IsDisplacementBrush( KeyValues *pSolidKeys )
{
// go through each side
for ( KeyValues *pKeys = pSolidKeys->GetFirstSubKey(); pKeys; pKeys = pKeys->GetNextKey() )
{
if ( !Q_stricmp( pKeys->GetName(), "side" ) && pKeys->FindKey( "dispinfo" ) )
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Clear out the stats + their history
//-----------------------------------------------------------------------------
void CPropData::ParsePropDataFile( void )
{
m_pKVPropData = new KeyValues( "PropDatafile" );
if ( !m_pKVPropData->LoadFromFile( filesystem, "scripts/propdata.txt" ) )
{
m_pKVPropData->deleteThis();
m_pKVPropData = NULL;
return;
}
m_bPropDataLoaded = true;
// Now try and parse out the breakable section
KeyValues *pBreakableSection = m_pKVPropData->FindKey( "BreakableModels" );
if ( pBreakableSection )
{
KeyValues *pChunkSection = pBreakableSection->GetFirstSubKey();
while ( pChunkSection )
{
// Create a new chunk section and add it to our list
int index = m_BreakableChunks.AddToTail();
propdata_breakablechunk_t *pBreakableChunk = &m_BreakableChunks[index];
pBreakableChunk->iszChunkType = AllocPooledString( pChunkSection->GetName() );
// Read in all the model names
KeyValues *pModelName = pChunkSection->GetFirstSubKey();
while ( pModelName )
{
const char *pModel = pModelName->GetName();
string_t pooledName = AllocPooledString( pModel );
pBreakableChunk->iszChunkModels.AddToTail( pooledName );
CBaseEntity::PrecacheModel( STRING( pooledName ) );
pModelName = pModelName->GetNextKey();
}
pChunkSection = pChunkSection->GetNextKey();
}
}
}
