//
// This method starts the parser that will either load one file
// or many based on pszFilePath.
// Input: pszFilePath - FS path to KeyValue file(s) for parsing.
// extentions are defined using .X
//
void CScriptParser::InitParser( const char *pszPath, bool bAllowNonEncryptedSearch /*=true*/, bool bAllowEncryptedSearch /*=true*/ )
{
// If you hit this assert, check to see where your instancing
// CScriptParser, make sure it isn't before the filesystem inits
Assert( filesystem );
Assert( pszPath );
// Have we already been parsed?
// TODO: Maybe just issue a DevWarning here instead of bailing
if( m_bParsed )
return;
// Copy the file path to tweak the extensions and fix it up
char szFilePath[FILE_PATH_MAX_LENGTH];
V_FixupPathName( szFilePath, FILE_PATH_MAX_LENGTH, pszPath );
//Search for unencrypted files
if( bAllowNonEncryptedSearch )
{
Q_SetExtension( szFilePath, GetNonEncryptedEXT(), FILE_PATH_MAX_LENGTH );
SearchForFiles( szFilePath );
}
//Search for encrypted files
if( bAllowEncryptedSearch )
{
Q_SetExtension( szFilePath, GetEncryptedEXT(), FILE_PATH_MAX_LENGTH );
SearchForFiles( szFilePath );
}
m_bParsed = true;
}
CChoreoScene *C_SceneEntity::LoadScene( const char *filename )
{
char loadfile[ 512 ];
Q_strncpy( loadfile, filename, sizeof( loadfile ) );
Q_SetExtension( loadfile, ".vcd", sizeof( loadfile ) );
Q_FixSlashes( loadfile );
char *buffer = NULL;
size_t bufsize = scenefilecache->GetSceneBufferSize( loadfile );
if ( bufsize <= 0 )
return NULL;
buffer = new char[ bufsize ];
if ( !scenefilecache->GetSceneData( filename, (byte *)buffer, bufsize ) )
{
delete[] buffer;
return NULL;
}
g_TokenProcessor.SetBuffer( buffer );
CChoreoScene *scene = ChoreoLoadScene( loadfile, this, &g_TokenProcessor, Scene_Printf );
delete[] buffer;
return scene;
}
//-----------------------------------------------------------------------------
// The application object
//-----------------------------------------------------------------------------
void CSFMGenApp::GenerateSFMFiles( SFMGenInfo_t& info )
{
char pRelativeModelPath[MAX_PATH];
Q_ComposeFileName( "models", info.m_pModelName, pRelativeModelPath, sizeof(pRelativeModelPath) );
Q_SetExtension( pRelativeModelPath, ".mdl", sizeof(pRelativeModelPath) );
MDLHandle_t hMDL = g_pMDLCache->FindMDL( pRelativeModelPath );
if ( hMDL == MDLHANDLE_INVALID )
{
Warning( "sfmgen: Model %s doesn't exist!\n", pRelativeModelPath );
return;
}
studiohdr_t *pStudioHdr = g_pMDLCache->GetStudioHdr( hMDL );
if ( !pStudioHdr || g_pMDLCache->IsErrorModel( hMDL ) )
{
Warning( "sfmgen: Model %s doesn't exist!\n", pRelativeModelPath );
return;
}
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
if ( !g_pFullFileSystem->ReadFile( info.m_pCSVFile, NULL, buf ) )
{
Warning( "sfmgen: Unable to load file %s\n", info.m_pCSVFile );
return;
}
CUtlVector< SFMInfo_t > infoList;
ParseCSVFile( buf, infoList, 1 );
int nCount = infoList.Count();
if ( nCount == 0 )
{
Warning( "sfmgen: no files to create!\n" );
return;
}
UniqueifyNames( infoList );
// Construct full path to the output directories
char pFullPath[MAX_PATH];
char pFullFacPathBuf[MAX_PATH];
const char *pExportFacPath = NULL;
ComputeFullPath( info.m_pOutputDirectory, pFullPath, sizeof(pFullPath) );
if ( info.m_pExportFacDirectory )
{
ComputeFullPath( info.m_pExportFacDirectory, pFullFacPathBuf, sizeof(pFullFacPathBuf) );
pExportFacPath = pFullFacPathBuf;
}
for ( int i = 0; i < nCount; ++i )
{
GenerateSFMFile( info, infoList[i], pStudioHdr, pFullPath, pExportFacPath );
}
}
void CASW_Mission_Chooser_Source_Local::OnSaveDeleted(const char *szSaveName)
{
char fixedname[ 256 ];
Q_strncpy( fixedname, szSaveName, sizeof( fixedname ) );
Q_SetExtension( fixedname, ".campaignsave", sizeof( fixedname ) );
// check if this save is in the list of summaries, if so, remove it
for (int i=0;i<m_SavedCampaignList.Count();i++)
{
if (!Q_stricmp(m_SavedCampaignList[i].m_szSaveName, fixedname))
{
m_SavedCampaignList.Remove(i);
return;
}
}
}
bool HasMultipleBones( const char *pFilename )
{
char outName[1024];
studiohdr_t hdr;
Q_strncpy( outName, pFilename, sizeof(outName) );
Q_SetExtension( outName, ".mdl", sizeof(outName) );
FileHandle_t fp = g_pFileSystem->Open( outName, "rb", TOOLS_READ_PATH_ID );
if ( fp == FILESYSTEM_INVALID_HANDLE )
return false;
g_pFileSystem->Read( &hdr, sizeof(hdr), fp );
g_pFileSystem->Close( fp );
if ( hdr.numbones > 1 )
return true;
return false;
}
// schedules a map to be compiled
void CASW_Map_Builder::ScheduleMapBuild(const char* pszMap, const float fTime)
{
if ( m_iBuildStage != STAGE_NONE )
{
Log_Warning( LOG_TilegenGeneral, "Map builder is currently busy, ignoring request to schedule map build for map '%s'", pszMap );
return;
}
Q_strncpy( m_szLayoutName, Q_UnqualifiedFileName( pszMap ), _countof( m_szLayoutName ) );
Q_SetExtension( m_szLayoutName, "layout", _countof( m_szLayoutName ) );
m_flStartProcessingTime = fTime;
m_bStartedGeneration = false;
m_iBuildStage = STAGE_MAP_BUILD_SCHEDULED;
m_flProgress = 0.0f;
Q_snprintf( m_szStatusMessage, sizeof( m_szStatusMessage ), "Generating map..." );
}
CChoreoScene *C_SceneEntity::LoadScene( const char *filename )
{
char loadfile[ 512 ];
Q_strncpy( loadfile, filename, sizeof( loadfile ) );
Q_SetExtension( loadfile, ".vcd", sizeof( loadfile ) );
Q_FixSlashes( loadfile );
char *pBuffer = NULL;
size_t bufsize = scenefilecache->GetSceneBufferSize( loadfile );
if ( bufsize <= 0 )
return NULL;
pBuffer = new char[ bufsize ];
if ( !scenefilecache->GetSceneData( filename, (byte *)pBuffer, bufsize ) )
{
delete[] pBuffer;
return NULL;
}
CChoreoScene *pScene;
if ( IsBufferBinaryVCD( pBuffer, bufsize ) )
{
pScene = new CChoreoScene( this );
CUtlBuffer buf( pBuffer, bufsize, CUtlBuffer::READ_ONLY );
if ( !pScene->RestoreFromBinaryBuffer( buf, loadfile, &g_ChoreoStringPool ) )
{
Warning( "Unable to restore binary scene '%s'\n", loadfile );
delete pScene;
pScene = NULL;
}
else
{
pScene->SetPrintFunc( Scene_Printf );
pScene->SetEventCallbackInterface( this );
}
}
else
{
g_TokenProcessor.SetBuffer( pBuffer );
pScene = ChoreoLoadScene( loadfile, this, &g_TokenProcessor, Scene_Printf );
}
delete[] pBuffer;
return pScene;
}
bool LoadStudioCollisionModel( char const* pModelName, CUtlBuffer& buf )
{
char tmp[1024];
Q_strncpy( tmp, pModelName, sizeof( tmp ) );
Q_SetExtension( tmp, ".phy", sizeof( tmp ) );
// No luck, gotta build it
if (!LoadFile( tmp, buf ))
{
// this is not an error, the model simply has no PHY file
return false;
}
phyheader_t *header = (phyheader_t *)buf.PeekGet();
if ( header->size != sizeof(*header) || header->solidCount <= 0 )
return false;
return true;
}
// schedules a map to be randomly generated
void CASW_Map_Builder::ScheduleMapGeneration( const char* pszMap, const float fTime, KeyValues *pMissionSettings, KeyValues *pMissionDefinition )
{
if ( m_iBuildStage != STAGE_NONE )
{
Log_Warning( LOG_TilegenGeneral, "Map builder is currently busy, ignoring request to schedule map generation for map '%s'", pszMap );
return;
}
Q_strncpy( m_szLayoutName, Q_UnqualifiedFileName( pszMap ), _countof( m_szLayoutName ) );
Q_SetExtension( m_szLayoutName, "layout", _countof( m_szLayoutName ) );
m_pMissionSettings = pMissionSettings;
m_pMissionDefinition = pMissionDefinition;
m_flStartProcessingTime = fTime;
m_iBuildStage = STAGE_GENERATE;
m_bStartedGeneration = false;
m_nLevelGenerationRetryCount = 0;
m_flProgress = 0.0f;
Q_snprintf( m_szStatusMessage, sizeof( m_szStatusMessage ), "Generating map..." );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEnvBeam::Precache( void )
{
if ( !Q_stristr( STRING(m_iszSpriteName), ".vmt" ) )
{
// HACK/YWB: This was almost always the laserbeam.spr, so alloc'ing the name a second time with the proper extension isn't going to
// kill us on memrory.
//Warning( "Level Design Error: %s (%i:%s) Sprite name (%s) missing .vmt extension!\n",
// STRING( m_iClassname ), entindex(), GetEntityName(), STRING(m_iszSpriteName) );
char fixedname[ 512 ];
Q_strncpy( fixedname, STRING( m_iszSpriteName ), sizeof( fixedname ) );
Q_SetExtension( fixedname, ".vmt", sizeof( fixedname ) );
m_iszSpriteName = AllocPooledString( fixedname );
}
g_iszPhysicsPropClassname = AllocPooledString( "prop_physics" );
m_spriteTexture = PrecacheModel( STRING(m_iszSpriteName) );
BaseClass::Precache();
}
//-----------------------------------------------------------------------------
// Creates a single sfm file
//-----------------------------------------------------------------------------
void CSFMGenApp::GenerateSFMFile( const SFMGenInfo_t& sfmGenInfo, const SFMInfo_t &info,
studiohdr_t *pStudioHdr, const char *pOutputDirectory, const char *pExportFacPath )
{
CSFMSession session;
session.Init();
char pAnimationSetName[256];
Q_FileBase( pStudioHdr->name, pAnimationSetName, sizeof(pAnimationSetName) );
// Set the file id( necessary for phoneme extraction)
DmFileId_t fileid = g_pDataModel->FindOrCreateFileId( pAnimationSetName );
session.Root()->SetFileId( fileid, TD_DEEP );
g_pModelPresetGroupMgr->AssociatePresetsWithFile( fileid );
// Get the shot.
CDmeFilmClip *pMovie = session.Root()->GetValueElement<CDmeFilmClip>( "activeClip" );
CDmeFilmClip* pShot = CastElement< CDmeFilmClip >( pMovie->GetFilmTrack()->GetClip( 0 ) );
// Create a camera for the shot
DmeCameraParams_t cameraParams( pAnimationSetName, vec3_origin, QAngle( 0, 180, 0 ) );
cameraParams.origin.x = pStudioHdr->hull_max.x + 20;
cameraParams.origin.z = Lerp( 0.95f, pStudioHdr->hull_min.z, pStudioHdr->hull_max.z );
cameraParams.fov = 75.0f;
CDmeCamera* pCamera = session.CreateCamera( cameraParams );
pShot->SetCamera( pCamera );
// Create a game model for the studio hdr
CDmeGameModel *pGameModel = session.CreateEditorGameModel( pStudioHdr, vec3_origin, Quaternion( 0, 0, 0, 1 ) );
// Create a scene for the shot
CDmeDag *pScene = session.FindOrCreateScene( pShot, pAnimationSetName );
pScene->AddChild( pGameModel );
// Create a sound clip
CDmeGameSound *pGameSound;
CDmeSoundClip *pSoundClip = CreateSoundClip( pMovie, pAnimationSetName, info.m_GameSound, pStudioHdr, &pGameSound );
pShot->SetDuration( pSoundClip->GetDuration() );
pMovie->SetDuration( pSoundClip->GetDuration() );
// Create an animation set
CDmeAnimationSet *pAnimationSet = CreateAnimationSet( pMovie, pShot, pGameModel, pAnimationSetName, 0, false );
// Extract phonemes
if ( pSoundClip )
{
CExtractInfo extractInfo;
extractInfo.m_pClip = pSoundClip;
extractInfo.m_pSound = pGameSound;
extractInfo.m_sHintText = info.m_Text;
extractInfo.m_bUseSentence = sfmGenInfo.m_bUsePhonemesInWavs;
ExtractDesc_t extractDesc;
extractDesc.m_nExtractType = EXTRACT_WIPE_CLIP;
extractDesc.m_pMovie = pMovie;
extractDesc.m_pShot = pShot;
extractDesc.m_pSet = pAnimationSet;
extractDesc.m_flSampleRateHz = sfmGenInfo.m_flSampleRateHz;
extractDesc.m_flSampleFilterSize = sfmGenInfo.m_flSampleFilterSize;
extractDesc.m_WorkList.AddToTail( extractInfo );
BuildFacialControlList( pShot, pAnimationSet, extractDesc.m_ControlList );
sfm_phonemeextractor->Extract( SPEECH_API_LIPSINC, extractDesc, sfmGenInfo.m_bWritePhonemesInWavs );
CExtractInfo &results = extractDesc.m_WorkList[ 0 ];
CDmElement *pExtractionSettings = pGameSound->FindOrAddPhonemeExtractionSettings();
pExtractionSettings->SetValue< float >( "duration", results.m_flDuration );
// Store off phonemes
if ( !pExtractionSettings->HasAttribute( "results" ) )
{
pExtractionSettings->AddAttribute( "results", AT_ELEMENT_ARRAY );
}
CDmrElementArray< CDmElement > resultsArray( pExtractionSettings, "results" );
resultsArray.RemoveAll();
for ( int i = 0; i < results.m_ApplyTags.Count(); ++i )
{
CBasePhonemeTag *tag = results.m_ApplyTags[ i ];
CDmElement *tagElement = CreateElement< CDmElement >( ConvertPhoneme( tag->GetPhonemeCode() ), pGameSound->GetFileId() );
tagElement->SetValue< float >( "start", tag->GetStartTime() );
tagElement->SetValue< float >( "end", tag->GetEndTime() );
resultsArray.AddToTail( tagElement );
}
if ( pExportFacPath )
{
char pFACFileName[MAX_PATH];
Q_ComposeFileName( pExportFacPath, info.m_DMXFileName, pFACFileName, sizeof(pFACFileName) );
Q_SetExtension( pFACFileName, ".dmx", sizeof(pFACFileName) );
ExportFacialAnimation( pFACFileName, pMovie, pShot, pAnimationSet );
}
}
SaveSFMFile( session.Root(), pOutputDirectory, info.m_DMXFileName );
session.Shutdown();
}
// saves current save data to a keyvalues file
bool CASW_Campaign_Save::SaveGameToFile(const char *szFileName)
{
// make sure the path and extension are correct
char szFullFileName[256];
char tempbuffer[256];
if (szFileName==NULL)
{
if (m_CurrentSaveFileName == NULL_STRING)
{
Msg("Error: Couldn't save game to file as we have no name already and you didn't supply one.\n");
return false;
}
Q_snprintf(szFullFileName, sizeof(szFullFileName), "%s", STRING(m_CurrentSaveFileName));
}
else
{
Q_snprintf(tempbuffer, sizeof(tempbuffer), "%s", szFileName);
Q_SetExtension( tempbuffer, ".campaignsave", sizeof(tempbuffer) );
const char *pszNoPathName = Q_UnqualifiedFileName(tempbuffer);
Q_snprintf(szFullFileName, sizeof(szFullFileName), "save/%s", pszNoPathName);
}
// before saving, check if this is actually a completed campaign
if (ASWGameRules())
{
int iLeft = ASWGameRules()->CampaignMissionsLeft();
if (iLeft <= 0)
{
Msg("Deleting completed campaign %s", szFullFileName);
filesystem->RemoveFile( szFullFileName, "GAME" );
// notify the local mission source that a save has been deleted
if (missionchooser && missionchooser->LocalMissionSource())
{
const char *pszNoPathName = Q_UnqualifiedFileName(szFullFileName);
missionchooser->LocalMissionSource()->NotifySaveDeleted(pszNoPathName);
}
return true;
}
}
// we don't want completed campaigns lingering on disk
KeyValues *pSaveKeyValues = new KeyValues( "CAMPAIGNSAVE" );
pSaveKeyValues->SetInt("Version", m_iVersion);
pSaveKeyValues->SetInt("SkillLevel", m_iLowestSkillLevelPlayed);
pSaveKeyValues->SetString("CampaignName", m_CampaignName.Get());
pSaveKeyValues->SetInt("CurrentPosition", m_iCurrentPosition);
pSaveKeyValues->SetInt("NumMissionsComplete", m_iNumMissionsComplete);
pSaveKeyValues->SetInt("InitialNumMissionsComplete", m_iInitialNumMissionsComplete);
pSaveKeyValues->SetInt("Multiplayer", m_bMultiplayerGame ? 1 : 0);
pSaveKeyValues->SetInt( "NumDeaths", m_iNumDeaths );
pSaveKeyValues->SetBool( "FixedSkillPoints", m_bFixedSkillPoints );
// update date
int year, month, dayOfWeek, day, hour, minute, second;
missionchooser->GetCurrentTimeAndDate(&year, &month, &dayOfWeek, &day, &hour, &minute, &second);
//year = month = dayOfWeek = day = hour = minute = second = 0;
Q_snprintf(m_DateTime.GetForModify(), 255, "%02d/%02d/%d %02d:%02d", month, day, year, hour, minute);
pSaveKeyValues->SetString("DateTime", m_DateTime.Get());
// write out each mission's status
KeyValues *pSubSection;
for (int i=0; i<ASW_MAX_MISSIONS_PER_CAMPAIGN; i++)
{
pSubSection = new KeyValues("MISSION");
pSubSection->SetInt("MissionID", i);
pSubSection->SetInt("MissionComplete", m_MissionComplete[i]);
pSubSection->SetInt("NumRetries", m_NumRetries[i]);
pSaveKeyValues->AddSubKey(pSubSection);
}
// write out each marine's stats
for (int MarineID=0; MarineID<ASW_NUM_MARINE_PROFILES; MarineID++)
{
pSubSection = new KeyValues("MARINE");
pSubSection->SetInt("MarineID", MarineID);
pSubSection->SetInt("SkillSlot0", m_iMarineSkill[MarineID][ASW_SKILL_SLOT_0]);
pSubSection->SetInt("SkillSlot1", m_iMarineSkill[MarineID][ASW_SKILL_SLOT_1]);
pSubSection->SetInt("SkillSlot2", m_iMarineSkill[MarineID][ASW_SKILL_SLOT_2]);
pSubSection->SetInt("SkillSlot3", m_iMarineSkill[MarineID][ASW_SKILL_SLOT_3]);
pSubSection->SetInt("SkillSlot4", m_iMarineSkill[MarineID][ASW_SKILL_SLOT_4]);
pSubSection->SetInt("SkillSlotSpare", m_iMarineSkill[MarineID][ASW_SKILL_SLOT_SPARE]);
pSubSection->SetInt("UndoSkillSlot0", m_iPreviousMarineSkill[MarineID][ASW_SKILL_SLOT_0]);
pSubSection->SetInt("UndoSkillSlot1", m_iPreviousMarineSkill[MarineID][ASW_SKILL_SLOT_1]);
pSubSection->SetInt("UndoSkillSlot2", m_iPreviousMarineSkill[MarineID][ASW_SKILL_SLOT_2]);
pSubSection->SetInt("UndoSkillSlot3", m_iPreviousMarineSkill[MarineID][ASW_SKILL_SLOT_3]);
pSubSection->SetInt("UndoSkillSlot4", m_iPreviousMarineSkill[MarineID][ASW_SKILL_SLOT_4]);
pSubSection->SetInt("UndoSkillSlotSpare", m_iPreviousMarineSkill[MarineID][ASW_SKILL_SLOT_SPARE]);
pSubSection->SetInt("ParasitesKilled", m_iParasitesKilled[MarineID]);
pSubSection->SetString("MissionsCompleted", STRING(m_MissionsCompleteNames[MarineID]));
pSubSection->SetString("Medals", STRING(m_Medals[MarineID]));
int iWound = IsMarineWounded(MarineID) ? 1 : 0;
pSubSection->SetInt("Wounded", iWound);
int iDead = IsMarineAlive(MarineID) ? 0 : 1;
pSubSection->SetInt("Dead", iDead);
pSaveKeyValues->AddSubKey(pSubSection);
}
// check for any new players to add to our list
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CASW_Player* pPlayer = dynamic_cast<CASW_Player*>(UTIL_PlayerByIndex(i));
if ( pPlayer )
{
// first check his network ID
const char *pszNetworkID = pPlayer->GetASWNetworkID();
// check if it's in our list
bool bFound = false;
for (int k=0;k<m_PlayerIDs.Count();k++)
{
const char *p = STRING(m_PlayerIDs[k]);
if (!Q_strcmp(p, pszNetworkID))
bFound = true;
}
if (!bFound)
{
// add it to the list
string_t stringID = AllocPooledString(pszNetworkID);
m_PlayerIDs.AddToTail(stringID);
}
// then check player name
const char *pszPlayerName = pPlayer->GetPlayerName();
bFound = false;
for (int k=0;k<m_PlayerNames.Count();k++)
{
const char *p = STRING(m_PlayerNames[k]);
if (!Q_strcmp(p, pszPlayerName))
bFound = true;
}
if (!bFound)
{
// add it to the list
string_t stringName = AllocPooledString(pszPlayerName);
m_PlayerNames.AddToTail(stringName);
}
}
}
pSaveKeyValues->SetInt("NumPlayers", m_PlayerNames.Count());
// write out player names
for (int i=0; i<m_PlayerNames.Count(); i++)
{
pSubSection = new KeyValues("PLAYER");
pSubSection->SetString("PlayerName", STRING(m_PlayerNames[i]));
pSaveKeyValues->AddSubKey(pSubSection);
}
// write out player IDs
for (int i=0; i<m_PlayerIDs.Count(); i++)
{
pSubSection = new KeyValues("DATA");
pSubSection->SetString("DataBlock", STRING(m_PlayerIDs[i]));
pSaveKeyValues->AddSubKey(pSubSection);
}
// write out last commanders section
pSubSection = new KeyValues("COMM");
for (int i=0;i<ASW_NUM_MARINE_PROFILES;i++)
{
char buffer[16];
Q_snprintf(buffer, sizeof(buffer), "Comm%d", i);
pSubSection->SetString(buffer, STRING(m_LastCommanders[i]));
Q_snprintf(buffer, sizeof(buffer), "Slot%d", i);
pSubSection->SetInt( buffer, m_LastMarineResourceSlot[i] );
//Ch1ckensCoop: Record which marine was primary for reservations.
Q_snprintf(buffer, sizeof(buffer), "Primary%d", i);
pSubSection->SetBool( buffer, m_LastPrimaryMarines[i] );
}
pSaveKeyValues->AddSubKey(pSubSection);
if (pSaveKeyValues->SaveToFile(filesystem, szFullFileName))
{
if (missionchooser && missionchooser->LocalMissionSource())
{
const char *pszNoPathName = Q_UnqualifiedFileName(szFullFileName);
missionchooser->LocalMissionSource()->OnSaveUpdated(pszNoPathName);
}
return true;
}
return false;
}
void WritePHXFile( const char *pName, const phyfile_t &file )
{
if ( file.header.size != sizeof(file.header) || file.collide.solidCount <= 0 )
return;
CUtlBuffer out;
char outName[1024];
Q_snprintf( outName, sizeof(outName), "%s", pName );
Q_SetExtension( outName, ".phx", sizeof(outName) );
simplifyparams_t params;
params.Defaults();
params.tolerance = (file.collide.solidCount > 1) ? 4.0f : 2.0f;
// single solids constraint to AABB for placement help
params.addAABBToSimplifiedHull = (file.collide.solidCount == 1) ? true : false;
params.mergeConvexElements = true;
params.mergeConvexTolerance = 0.025f;
Q_FixSlashes(outName);
Q_strlower(outName);
char *pSearch = Q_strstr( outName,"models\\" );
if ( pSearch )
{
char keyname[1024];
pSearch += strlen("models\\");
Q_StripExtension( pSearch, keyname, sizeof(keyname) );
OverrideDefaultsForModel( keyname, params );
}
out.Put( &file.header, sizeof(file.header) );
int outSize = 0;
bool bStoreSolidNames = file.collide.solidCount > 1 ? true : false;
bStoreSolidNames = bStoreSolidNames || HasMultipleBones(outName);
vcollide_t *pNewCollide = ConvertVCollideToPHX( &file.collide, params, &outSize, false, bStoreSolidNames);
g_TotalOut += file.fileSize;
for ( int i = 0; i < pNewCollide->solidCount; i++ )
{
int collideSize = physcollision->CollideSize( pNewCollide->solids[i] );
out.PutInt( collideSize );
char *pMem = new char[collideSize];
physcollision->CollideWrite( pMem, pNewCollide->solids[i] );
out.Put( pMem, collideSize );
delete[] pMem;
}
if (!g_bQuiet)
{
Msg("%s Compressed %d (%d text) to %d (%d text)\n", outName, file.fileSize, file.collide.descSize, out.TellPut(), pNewCollide->descSize );
}
out.Put( pNewCollide->pKeyValues, pNewCollide->descSize );
g_TotalCompress += out.TellPut();
#if 0
//Msg("OLD:\n-----------------------------------\n%s\n", file.collide.pKeyValues );
CPackedPhysicsDescription *pPacked = physcollision->CreatePackedDesc( pNewCollide->pKeyValues, pNewCollide->descSize );
Msg("NEW:\n-----------------------------------\n" );
for ( int i = 0; i < pPacked->m_solidCount; i++ )
{
solid_t solid;
pPacked->GetSolid( &solid, i );
Msg("index %d\n", solid.index );
Msg("name %s\n", solid.name );
Msg("mass %.2f\n", solid.params.mass );
Msg("surfaceprop %s\n", solid.surfaceprop);
Msg("damping %.2f\n", solid.params.damping );
Msg("rotdamping %.2f\n", solid.params.rotdamping );
Msg("drag %.2f\n", solid.params.dragCoefficient );
Msg("inertia %.2f\n", solid.params.inertia );
Msg("volume %.2f\n", solid.params.volume );
}
#endif
DestroyPHX( pNewCollide );
if ( !g_pFullFileSystem->WriteFile( outName, NULL, out ) )
Warning("Can't write file: %s\n", outName );
}
//-----------------------------------------------------------------------------
// Saves/loads from file
//-----------------------------------------------------------------------------
bool CVcdBlockDoc::LoadFromFile( const char *pFileName )
{
Assert( !m_hVMFRoot.Get() );
Assert( !m_hEditRoot.Get() );
CAppDisableUndoScopeGuard guard( "CVcdBlockDoc::LoadFromFile", NOTIFY_CHANGE_OTHER );
SetDirty( false );
if ( !pFileName[0] )
return false;
// Construct VMF file name from the BSP
const char *pGame = Q_stristr( pFileName, "\\game\\" );
if ( !pGame )
{
pGame = Q_stristr( pFileName, "\\content\\" );
if ( !pGame )
return false;
}
// Compute the map name
const char *pMaps = Q_stristr( pFileName, "\\maps\\" );
if ( !pMaps )
return false;
// Build map name
char mapname[ 256 ];
Q_StripExtension( pFileName, mapname, sizeof(mapname) );
char *pszFileName = (char*)Q_UnqualifiedFileName(mapname);
int nLen = (int)( (size_t)pGame - (size_t)pFileName ) + 1;
Q_strncpy( m_pVMFFileName, pFileName, nLen );
Q_strncat( m_pVMFFileName, "\\content\\", sizeof(m_pVMFFileName) );
Q_strncat( m_pVMFFileName, pGame + 6, sizeof(m_pVMFFileName) );
Q_SetExtension( m_pVMFFileName, ".vmf", sizeof(m_pVMFFileName) );
// Make sure new entities start with ids at 0
CDmeVMFEntity::SetNextEntityId( 0 );
// Build the Edit file name
Q_StripExtension( m_pVMFFileName, m_pEditFileName, sizeof(m_pEditFileName) );
Q_strncat( m_pEditFileName, ".vle", sizeof( m_pEditFileName ) );
// Store the BSP file name
Q_strncpy( m_pBSPFileName, pFileName, sizeof( m_pBSPFileName ) );
// Set the txt file name.
// If we loaded a .bsp, clear out what we're doing
// load the Edits file into memory, assign it as our "root"
CDmElement *pEdit = NULL;
if ( !V_stricmp( Q_GetFileExtension( pFileName ), "vle" ) )
{
if ( g_pDataModel->RestoreFromFile( m_pEditFileName, NULL, "vmf", &pEdit ) != DMFILEID_INVALID )
{
// If we successfully read the file in, ask it for the max hammer id
//int nMaxHammerId = pVMF->GetAttributeValue<int>( "maxHammerId" );
//CDmeVMFEntity::SetNextEntityId( nMaxHammerId + 1 );
m_hEditRoot = pEdit;
SetDirty( false );
}
}
if (pEdit == NULL)
{
if ( g_pFileSystem->FileExists( m_pEditFileName ) )
{
char pBuf[1024];
Q_snprintf( pBuf, sizeof(pBuf), "File %s already exists!\n", m_pEditFileName );
m_pEditFileName[0] = 0;
vgui::MessageBox *pMessageBox = new vgui::MessageBox( "Unable to overwrite file!\n", pBuf, g_pVcdBlockTool );
pMessageBox->DoModal( );
return false;
}
DmFileId_t fileid = g_pDataModel->FindOrCreateFileId( m_pEditFileName );
m_hEditRoot = CreateElement<CDmElement>( "root", fileid );
m_hEditRoot->AddAttribute( "entities", AT_ELEMENT_ARRAY );
g_pDataModel->SetFileRoot( fileid, m_hEditRoot );
SetDirty( true );
}
guard.Release();
// tell the engine to actually load the map
char cmd[ 256 ];
Q_snprintf( cmd, sizeof( cmd ), "disconnect; map %s\n", pszFileName );
enginetools->Command( cmd );
enginetools->Execute( );
return true;
}
virtual int Run()
{
while ( true )
{
WaitForCall();
if ( GetCallParam() == MBC_SHUTDOWN )
{
// exit cleanly
return 0;
}
else
{
#ifdef SUPPORT_VBSP_2
char filename[MAX_PATH];
// Safe to access m_szVBSP2MapName because it will not be changed by the main thread while this is happening.
Q_snprintf( filename, sizeof( filename ), "maps\\%s", m_pMapBuilder->m_szVBSP2MapName );
CSimpleMapFile *pSimpleMapFile;
m_pMapBuilder->m_nVBSP2Progress = g_ProgressAmounts[1];
CSimpleMapFile::LoadFromFile( g_pFullFileSystem, filename, &pSimpleMapFile );
m_pMapBuilder->m_nVBSP2Progress = g_ProgressAmounts[2];
pSimpleMapFile->ResolveInstances( CSimpleMapFile::CONVERT_STRUCTURAL_TO_DETAIL, FixupInstance, m_pMapBuilder );
m_pMapBuilder->m_nVBSP2Progress = g_ProgressAmounts[3];
// mess with the pSimpleMapFile here
/*
CMapLayout *pLayout = m_pMapBuilder->GetCurrentlyBuildingMapLayout();
// find the alien floor texture
int iBrushes = pSimpleMapFile->GetBrushCount();
const MapBrush_t *pBrushes = pSimpleMapFile->GetBrushes();
const MapBrushSide_t *pBrushSides = pSimpleMapFile->GetBrushSides();
MapTextureInfo_t *pTextureInfos = pSimpleMapFile->GetTextureInfos();
MapTextureData_t *pTextureDatas = pSimpleMapFile->GetTextureData();
const MapTextureInfo_t *pAlienFloorTextureInfo = NULL; // a texture info that's using the alien floor material
for ( int i = 0; i < iBrushes; i++ )
{
for ( int side = pBrushes[i].m_nFirstSideIndex; side < pBrushes[i].m_nFirstSideIndex + pBrushes[i].m_nNumSides; side++ )
{
const MapTextureInfo_t *pTextureInfo = &pTextureInfos[ pBrushSides[ side ].m_nTextureInfoIndex ];
const MapTextureData_t *pTextureData = &pTextureDatas[ pTextureInfo->m_nTextureDataIndex ];
if ( !Q_stricmp( pTextureData->m_MaterialName, asw_alien_floor_texture.GetString() ) )
{
pAlienFloorTextureInfo = pTextureInfo;
break;
}
}
}
if ( pAlienFloorTextureInfo )
{
// now find all sides using the regular floor texture
for ( int i = 0; i < iBrushes; i++ )
{
// is this brush in an encounter room? - just check the center for now
Vector vecCenter = ( pBrushes[i].m_vMinBounds + pBrushes[i].m_vMaxBounds ) * 0.5f;
CRoom *pRoom = pLayout->GetRoom( vecCenter );
if ( !pRoom || !pRoom->HasAlienEncounter() )
continue;
for ( int side = pBrushes[i].m_nFirstSideIndex; side < pBrushes[i].m_nFirstSideIndex + pBrushes[i].m_nNumSides; side++ )
{
MapTextureInfo_t *pTextureInfo = &pTextureInfos[ pBrushSides[ side ].m_nTextureInfoIndex ];
MapTextureData_t *pTextureData = &pTextureDatas[ pTextureInfo->m_nTextureDataIndex ];
if ( !Q_stricmp( pTextureData->m_MaterialName, asw_regular_floor_texture.GetString() ) )
{
// switch regular floor over to using the new texture index
pTextureInfo->m_nTextureDataIndex = pAlienFloorTextureInfo->m_nTextureDataIndex;
}
}
}
}
else
{
Warning( "Couldn't find alien floor texture in map\n" );
}
*/
// re-resolve if necessary
//pSimpleMapFile->ResolveInstances( CSimpleMapFile::CONVERT_STRUCTURAL_TO_DETAIL, NULL, NULL );
char bspFilename[MAX_PATH];
Q_strncpy( bspFilename, filename, MAX_PATH );
Q_SetExtension( bspFilename, ".bsp", MAX_PATH );
CUtlStreamBuffer outputBSPFile( bspFilename, NULL );
CSimpleBSPFile *pBSPFile = new CSimpleBSPFile();
pBSPFile->CreateFromMapFile( pSimpleMapFile );
m_pMapBuilder->m_nVBSP2Progress = g_ProgressAmounts[4];
SaveToFile( &outputBSPFile, pBSPFile );
outputBSPFile.Close();
delete pBSPFile;
delete pSimpleMapFile;
// Commit all reads/writes before ending task
ThreadMemoryBarrier();
m_pMapBuilder->m_nVBSP2Progress = g_ProgressAmounts[5];
Reply( 0 );
#else
return 0;
#endif
}
}
return 0;
}
// Builds a map from a .layout file
void CASW_Map_Builder::BuildMap()
{
char layoutFilename[MAX_PATH];
char vmfFilename[MAX_PATH];
Q_snprintf( layoutFilename, MAX_PATH, "maps\\%s", m_szLayoutName );
Q_strncpy( vmfFilename, m_szLayoutName, MAX_PATH );
Q_SetExtension( vmfFilename, "vmf", MAX_PATH );
Log_Msg( LOG_TilegenGeneral, "Building map from layout: %s, emitting map file: %s\n", layoutFilename, vmfFilename );
// Make sure our themes are loaded
CLevelTheme::LoadLevelThemes();
// Load the .layout from disk
// @TODO: keep this in memory and avoid the round-trip
delete m_pBuildingMapLayout;
m_pBuildingMapLayout = new CMapLayout();
if ( !m_pBuildingMapLayout->LoadMapLayout( layoutFilename ) )
{
Log_Warning(LOG_TilegenGeneral, "Couldn't find layoutfile: [%s]", layoutFilename);
m_iBuildStage = MapBuildStage::STAGE_NONE;
delete m_pBuildingMapLayout;
m_pBuildingMapLayout = NULL;
return;
}
// Export it to VMF
bool bSuccess = false;
{
VMFExporter exporter;
bSuccess = exporter.ExportVMF(m_pBuildingMapLayout, m_szLayoutName);
}
if ( !bSuccess )
{
Log_Warning( LOG_TilegenGeneral, "Failed to create VMF from layout '%s'.\n", m_szLayoutName );
delete m_pBuildingMapLayout;
m_pBuildingMapLayout = NULL;
}
if ( asw_vbsp2.GetInt() )
{
m_iBuildStage = STAGE_VBSP2;
m_nVBSP2Progress = 0;
Q_strncpy( m_szVBSP2MapName, vmfFilename, MAX_PATH );
// Guarantee all reads/writes committed before kicking off the thread. Probably unnecessary in practice due to lag between operations, but whatever...
ThreadMemoryBarrier();
// Call with a 0 ms timeout to return immediately
m_pWorkerThread->CallWorker( MBC_PROCESS_MAP, 0 );
}
else
{
// Building map layout is ignored in VBSP1 codepath
delete m_pBuildingMapLayout;
m_pBuildingMapLayout = NULL;
m_iBuildStage = STAGE_VBSP;
char buffer[512];
Q_snprintf( buffer, sizeof(buffer), "-game ..\\ %s %s", m_pMapBuilderOptions->GetString( "vbsp", "" ), vmfFilename );
Execute( "bin/vbsp.exe", buffer );
m_iCurrentBuildSearch = 0;
m_iOutputBufferPos = 0;
Q_memset( &m_szOutputBuffer, 0, sizeof( m_szOutputBuffer ) );
}
}
//-----------------------------------------------------------------------------
// Load the VMF file, merge in all the edits, write it back out
//-----------------------------------------------------------------------------
bool CVcdBlockDoc::CopyEditsToVMF( )
{
const CDmrElementArray<CDmElement> entityList = GetEntityList();
CDmElement *pVMF = NULL;
DmFileId_t fileid = g_pDataModel->FindOrCreateFileId( m_pVMFFileName );
if ( g_pDataModel->RestoreFromFile( m_pVMFFileName, NULL, "vmf", &pVMF ) == DMFILEID_INVALID )
{
// needs some kind of error message
return false;
}
CDmrElementArray<CDmElement> vmfEntities( pVMF, "entities" );
int nVMFCount = vmfEntities.Count();
for (int i = 0; i < nVMFCount; i++)
{
CDmElement *pVMFEntity = vmfEntities[i];
char classname[256];
pVMFEntity->GetValueAsString( "classname", classname, sizeof( classname ) );
if ( Q_stricmp( "info_target", classname ) )
continue;
int nHammerID = atoi( pVMFEntity->GetName() );
// find a match.
int nCount = entityList.Count();
for (int j = 0; j < nCount; j++)
{
CDmeVMFEntity *pEntity = CastElement<CDmeVMFEntity>( entityList[j] );
if ( pEntity->IsDirty() && pEntity->GetEntityId() == nHammerID)
{
char text[256];
pEntity->GetValueAsString( "targetname", text, sizeof( text ) );
pVMFEntity->SetValueFromString( "targetname", text );
pEntity->GetValueAsString( "origin", text, sizeof( text ) );
pVMFEntity->SetValueFromString( "origin", text );
pEntity->GetValueAsString( "angles", text, sizeof( text ) );
pVMFEntity->SetValueFromString( "angles", text );
pEntity->MarkDirty(false);
}
}
}
// add the new entities
int nCount = entityList.Count();
for (int j = 0; j < nCount; j++)
{
CDmeVMFEntity *pEntity = CastElement<CDmeVMFEntity>( entityList[j] );
if ( pEntity->IsDirty())
{
CDmElement *pVMFEntity = CreateElement<CDmElement>( pEntity->GetName(), fileid );
char text[256];
pEntity->GetValueAsString( "classname", text, sizeof( text ) );
pVMFEntity->SetValue( "classname", text );
pEntity->GetValueAsString( "targetname", text, sizeof( text ) );
pVMFEntity->SetValue( "targetname", text );
pEntity->GetValueAsString( "origin", text, sizeof( text ) );
pVMFEntity->SetValue( "origin", text );
pEntity->GetValueAsString( "angles", text, sizeof( text ) );
pVMFEntity->SetValue( "angles", text );
vmfEntities.AddToTail( pVMFEntity );
pEntity->MarkDirty(false);
}
}
// currently, don't overwrite the vmf, not sure if this is serializing correctly yet
char tmpname[ 256 ];
Q_StripExtension( m_pVMFFileName, tmpname, sizeof(tmpname) );
Q_SetExtension( tmpname, ".vme", sizeof(tmpname) );
if (!g_pDataModel->SaveToFile( tmpname, NULL, "keyvalues", "vmf", pVMF ))
{
// needs some kind of error message
return false;
}
/*
// If we successfully read the file in, ask it for the max hammer id
int nMaxHammerId = pVMF->GetAttributeValue<int>( "maxHammerId" );
CDmeVMFEntity::SetNextEntityId( nMaxHammerId + 1 );
m_hVMFRoot = pVMF;
*/
return true;
}
bool CEngineSprite::Init( const char *pName )
{
m_hAVIMaterial = AVIMATERIAL_INVALID;
m_hBIKMaterial = BIKMATERIAL_INVALID;
m_width = m_height = m_numFrames = 1;
const char *pExt = Q_GetFileExtension( pName );
bool bIsAVI = pExt && !Q_stricmp( pExt, "avi" );
#if !defined( _X360 ) || defined( BINK_ENABLED_FOR_X360 )
bool bIsBIK = pExt && !Q_stricmp( pExt, "bik" );
#endif
if ( bIsAVI && IsPC() )
{
m_hAVIMaterial = avi->CreateAVIMaterial( pName, pName, "GAME" );
if ( m_hAVIMaterial == AVIMATERIAL_INVALID )
return false;
IMaterial *pMaterial = avi->GetMaterial( m_hAVIMaterial );
avi->GetFrameSize( m_hAVIMaterial, &m_width, &m_height );
m_numFrames = avi->GetFrameCount( m_hAVIMaterial );
for ( int i = 0; i < kRenderModeCount; ++i )
{
m_material[i] = pMaterial;
pMaterial->IncrementReferenceCount();
}
}
#if !defined( _X360 ) || defined( BINK_ENABLED_FOR_X360 )
else if ( bIsBIK )
{
m_hBIKMaterial = bik->CreateMaterial( pName, pName, "GAME" );
if ( m_hBIKMaterial == BIKMATERIAL_INVALID )
return false;
IMaterial *pMaterial = bik->GetMaterial( m_hBIKMaterial );
bik->GetFrameSize( m_hBIKMaterial, &m_width, &m_height );
m_numFrames = bik->GetFrameCount( m_hBIKMaterial );
for ( int i = 0; i < kRenderModeCount; ++i )
{
m_material[i] = pMaterial;
pMaterial->IncrementReferenceCount();
}
}
#endif
else
{
char pTemp[MAX_PATH];
char pMaterialName[MAX_PATH];
char pMaterialPath[MAX_PATH];
Q_StripExtension( pName, pTemp, sizeof(pTemp) );
Q_strlower( pTemp );
Q_FixSlashes( pTemp, '/' );
// Check to see if this is a UNC-specified material name
bool bIsUNC = pTemp[0] == '/' && pTemp[1] == '/' && pTemp[2] != '/';
if ( !bIsUNC )
{
Q_strncpy( pMaterialName, "materials/", sizeof(pMaterialName) );
Q_strncat( pMaterialName, pTemp, sizeof(pMaterialName), COPY_ALL_CHARACTERS );
}
else
{
Q_strncpy( pMaterialName, pTemp, sizeof(pMaterialName) );
}
Q_strncpy( pMaterialPath, pMaterialName, sizeof(pMaterialPath) );
Q_SetExtension( pMaterialPath, ".vmt", sizeof(pMaterialPath) );
for ( int i = 0; i < kRenderModeCount; ++i )
{
m_material[i] = NULL;
}
KeyValues *kv = new KeyValues( "vmt" );
if ( !kv->LoadFromFile( g_pFullFileSystem, pMaterialPath, "GAME" ) )
{
Warning( "Unable to load sprite material %s!\n", pMaterialPath );
return false;
}
for ( int i = 0; i < kRenderModeCount; ++i )
{
if ( i == kRenderNone || i == kRenderEnvironmental )
{
continue;
}
// strip possible materials/
Q_snprintf( pMaterialPath, sizeof(pMaterialPath), "%s_rendermode_%d", pMaterialName + ( bIsUNC ? 0 : 10 ), i );
KeyValues *pMaterialKV = kv->MakeCopy();
pMaterialKV->SetInt( "$spriteRenderMode", i );
m_material[i] = g_pMaterialSystem->FindProceduralMaterial( pMaterialPath, TEXTURE_GROUP_CLIENT_EFFECTS, pMaterialKV );
m_material[i]->IncrementReferenceCount();
}
kv->deleteThis();
m_width = m_material[0]->GetMappingWidth();
m_height = m_material[0]->GetMappingHeight();
m_numFrames = m_material[0]->GetNumAnimationFrames();
}
for ( int i = 0; i < kRenderModeCount; ++i )
{
if ( i == kRenderNone || i == kRenderEnvironmental )
continue;
if ( !m_material[i] )
return false;
}
IMaterialVar *orientationVar = m_material[0]->FindVarFast( "$spriteorientation", &spriteOrientationCache );
m_orientation = orientationVar ? orientationVar->GetIntValue() : C_SpriteRenderer::SPR_VP_PARALLEL_UPRIGHT;
IMaterialVar *originVar = m_material[0]->FindVarFast( "$spriteorigin", &spriteOriginCache );
Vector origin, originVarValue;
if( !originVar || ( originVar->GetType() != MATERIAL_VAR_TYPE_VECTOR ) )
{
origin[0] = -m_width * 0.5f;
origin[1] = m_height * 0.5f;
}
else
{
originVar->GetVecValue( &originVarValue[0], 3 );
origin[0] = -m_width * originVarValue[0];
origin[1] = m_height * originVarValue[1];
}
up = origin[1];
down = origin[1] - m_height;
left = origin[0];
right = m_width + origin[0];
return true;
}
bool CEngineSprite::Init( const char *pName )
{
m_VideoMaterial = NULL;
for ( int i = 0; i < kRenderModeCount; ++i )
{
m_material[ i ] = NULL;
}
m_width = m_height = m_numFrames = 1;
Assert( g_pVideo != NULL );
if ( g_pVideo != NULL && g_pVideo->LocateVideoSystemForPlayingFile( pName ) != VideoSystem::NONE )
{
m_VideoMaterial = g_pVideo->CreateVideoMaterial( pName, pName, "GAME", VideoPlaybackFlags::DEFAULT_MATERIAL_OPTIONS, VideoSystem::DETERMINE_FROM_FILE_EXTENSION, false );
if ( m_VideoMaterial == NULL )
return false;
IMaterial *pMaterial = m_VideoMaterial->GetMaterial();
m_VideoMaterial->GetVideoImageSize( &m_width, &m_height );
m_numFrames = m_VideoMaterial->GetFrameCount();
for ( int i = 0; i < kRenderModeCount; ++i )
{
m_material[i] = pMaterial;
pMaterial->IncrementReferenceCount();
}
}
else
{
char pTemp[MAX_PATH];
char pMaterialName[MAX_PATH];
char pMaterialPath[MAX_PATH];
Q_StripExtension( pName, pTemp, sizeof(pTemp) );
Q_strlower( pTemp );
Q_FixSlashes( pTemp, '/' );
// Check to see if this is a UNC-specified material name
bool bIsUNC = pTemp[0] == '/' && pTemp[1] == '/' && pTemp[2] != '/';
if ( !bIsUNC )
{
Q_strncpy( pMaterialName, "materials/", sizeof(pMaterialName) );
Q_strncat( pMaterialName, pTemp, sizeof(pMaterialName), COPY_ALL_CHARACTERS );
}
else
{
Q_strncpy( pMaterialName, pTemp, sizeof(pMaterialName) );
}
Q_strncpy( pMaterialPath, pMaterialName, sizeof(pMaterialPath) );
Q_SetExtension( pMaterialPath, ".vmt", sizeof(pMaterialPath) );
KeyValues *kv = new KeyValues( "vmt" );
if ( !kv->LoadFromFile( g_pFullFileSystem, pMaterialPath, "GAME" ) )
{
Warning( "Unable to load sprite material %s!\n", pMaterialPath );
return false;
}
for ( int i = 0; i < kRenderModeCount; ++i )
{
if ( i == kRenderNone || i == kRenderEnvironmental )
{
m_material[i] = NULL;
continue;
}
Q_snprintf( pMaterialPath, sizeof(pMaterialPath), "%s_rendermode_%d", pMaterialName, i );
KeyValues *pMaterialKV = kv->MakeCopy();
pMaterialKV->SetInt( "$spriteRenderMode", i );
m_material[i] = g_pMaterialSystem->FindProceduralMaterial( pMaterialPath, TEXTURE_GROUP_CLIENT_EFFECTS, pMaterialKV );
m_material[ i ]->IncrementReferenceCount();
}
kv->deleteThis();
m_width = m_material[0]->GetMappingWidth();
m_height = m_material[0]->GetMappingHeight();
m_numFrames = m_material[0]->GetNumAnimationFrames();
}
for ( int i = 0; i < kRenderModeCount; ++i )
{
if ( i == kRenderNone || i == kRenderEnvironmental )
continue;
if ( !m_material[i] )
return false;
}
IMaterialVar *orientationVar = m_material[0]->FindVarFast( "$spriteorientation", &spriteOrientationCache );
m_orientation = orientationVar ? orientationVar->GetIntValue() : C_SpriteRenderer::SPR_VP_PARALLEL_UPRIGHT;
IMaterialVar *originVar = m_material[0]->FindVarFast( "$spriteorigin", &spriteOriginCache );
Vector origin, originVarValue;
if( !originVar || ( originVar->GetType() != MATERIAL_VAR_TYPE_VECTOR ) )
{
origin[0] = -m_width * 0.5f;
origin[1] = m_height * 0.5f;
}
else
{
originVar->GetVecValue( &originVarValue[0], 3 );
origin[0] = -m_width * originVarValue[0];
origin[1] = m_height * originVarValue[1];
}
up = origin[1];
down = origin[1] - m_height;
left = origin[0];
right = m_width + origin[0];
return true;
}
// reads in current save data from a keyvalues file
bool CASW_Campaign_Save::LoadGameFromFile(const char *szFileName)
{
// make sure the path and extension are correct
char szFullFileName[256];
char tempbuffer[256];
Q_snprintf(tempbuffer, sizeof(tempbuffer), "%s", szFileName);
Q_SetExtension( tempbuffer, ".campaignsave", sizeof(tempbuffer) );
const char *pszNoPathName = Q_UnqualifiedFileName(tempbuffer);
Q_snprintf(szFullFileName, sizeof(szFullFileName), "save/%s", pszNoPathName);
KeyValues *pSaveKeyValues = new KeyValues( szFileName );
if (pSaveKeyValues->LoadFromFile(filesystem, szFullFileName))
{
m_CurrentSaveFileName = AllocPooledString(szFullFileName);
m_iVersion = pSaveKeyValues->GetInt("Version");
m_iLowestSkillLevelPlayed = pSaveKeyValues->GetInt("SkillLevel");
Q_strncpy( m_CampaignName.GetForModify(), pSaveKeyValues->GetString("CampaignName"), 255 );
m_iCurrentPosition = pSaveKeyValues->GetInt("CurrentPosition");
m_iNumMissionsComplete = pSaveKeyValues->GetInt("NumMissionsComplete");
m_iInitialNumMissionsComplete = pSaveKeyValues->GetInt("InitialNumMissionsComplete");
m_bMultiplayerGame = pSaveKeyValues->GetInt("Multiplayer") != 0;
Q_strncpy( m_DateTime.GetForModify(), pSaveKeyValues->GetString("DateTime"), 255 );
m_iNumDeaths = pSaveKeyValues->GetInt("NumDeaths");
m_bFixedSkillPoints = !asw_custom_skill_points.GetBool(); //pSaveKeyValues->GetBool( "FixedSkillPoints", true );
m_iNumPlayers = pSaveKeyValues->GetInt("NumPlayers");
m_PlayerNames.Purge();
m_PlayerIDs.Purge();
// go through each sub section, adding the relevant details
KeyValues *pkvSubSection = pSaveKeyValues->GetFirstSubKey();
while ( pkvSubSection )
{
// mission details
if (Q_stricmp(pkvSubSection->GetName(), "MISSION")==0)
{
int MissionID = pkvSubSection->GetInt("MissionID");
if (MissionID >=0 && MissionID < ASW_MAX_MISSIONS_PER_CAMPAIGN)
{
m_MissionComplete.Set(MissionID, pkvSubSection->GetInt("MissionComplete"));
m_NumRetries.Set(MissionID, pkvSubSection->GetInt("NumRetries"));
}
}
// marine details
if (Q_stricmp(pkvSubSection->GetName(), "MARINE")==0)
{
int MarineID = pkvSubSection->GetInt("MarineID");
if (MarineID >=0 && MarineID < ASW_NUM_MARINE_PROFILES)
{
m_iMarineSkill[MarineID][ASW_SKILL_SLOT_0] = pkvSubSection->GetInt("SkillSlot0");
m_iMarineSkill[MarineID][ASW_SKILL_SLOT_1] = pkvSubSection->GetInt("SkillSlot1");
m_iMarineSkill[MarineID][ASW_SKILL_SLOT_2] = pkvSubSection->GetInt("SkillSlot2");
m_iMarineSkill[MarineID][ASW_SKILL_SLOT_3] = pkvSubSection->GetInt("SkillSlot3");
m_iMarineSkill[MarineID][ASW_SKILL_SLOT_4] = pkvSubSection->GetInt("SkillSlot4");
m_iMarineSkill[MarineID][ASW_SKILL_SLOT_SPARE] = pkvSubSection->GetInt("SkillSlotSpare");
m_iPreviousMarineSkill[MarineID][ASW_SKILL_SLOT_0] = pkvSubSection->GetInt("UndoSkillSlot0");
m_iPreviousMarineSkill[MarineID][ASW_SKILL_SLOT_1] = pkvSubSection->GetInt("UndoSkillSlot1");
m_iPreviousMarineSkill[MarineID][ASW_SKILL_SLOT_2] = pkvSubSection->GetInt("UndoSkillSlot2");
m_iPreviousMarineSkill[MarineID][ASW_SKILL_SLOT_3] = pkvSubSection->GetInt("UndoSkillSlot3");
m_iPreviousMarineSkill[MarineID][ASW_SKILL_SLOT_4] = pkvSubSection->GetInt("UndoSkillSlot4");
m_iPreviousMarineSkill[MarineID][ASW_SKILL_SLOT_SPARE] = pkvSubSection->GetInt("UndoSkillSlotSpare");
m_iParasitesKilled[MarineID] = pkvSubSection->GetInt("ParasitesKilled");
m_MissionsCompleteNames.Set(MarineID, AllocPooledString(pkvSubSection->GetString("MissionsCompleted")));
m_Medals.Set(MarineID, AllocPooledString(pkvSubSection->GetString("Medals")));
m_bMarineWounded.Set(MarineID, (pkvSubSection->GetInt("Wounded") == 1));
m_bMarineDead.Set(MarineID, (pkvSubSection->GetInt("Dead") == 1));
//Ch1ckensCoop: Hack to give marines skill points for the first mission in a campaign. I'm too lazy to edit missionchooser.
if (m_iCurrentPosition == 1)
{
m_iMarineSkill[MarineID][ASW_SKILL_SLOT_SPARE] = sk_asw_points_per_mission.GetInt();
m_iPreviousMarineSkill[MarineID][ASW_SKILL_SLOT_SPARE] = sk_asw_points_per_mission.GetInt();
}
}
}
// player name
if (Q_stricmp(pkvSubSection->GetName(), "PLAYER")==0)
{
string_t stringName = AllocPooledString(pkvSubSection->GetString("PlayerName"));
m_PlayerNames.AddToTail(stringName);
}
// player ID
if (Q_stricmp(pkvSubSection->GetName(), "DATA")==0)
{
string_t stringID = AllocPooledString(pkvSubSection->GetString("DataBlock"));
m_PlayerIDs.AddToTail(stringID);
}
// last commanders
if (Q_stricmp(pkvSubSection->GetName(), "COMM")==0)
{
for (int i=0;i<ASW_NUM_MARINE_PROFILES;i++)
{
char buffer[16];
Q_snprintf(buffer, sizeof(buffer), "Comm%d", i);
string_t stringID = AllocPooledString(pkvSubSection->GetString(buffer));
m_LastCommanders[i] = stringID;
Q_snprintf(buffer, sizeof(buffer), "Slot%d", i);
m_LastMarineResourceSlot[i] = pkvSubSection->GetInt(buffer);
//Ch1ckensCoop: Remember primary marines for each player, so we can handle reservations properly.
Q_snprintf(buffer, sizeof(buffer), "Primary%d", i);
m_LastPrimaryMarines[i] = pkvSubSection->GetBool(buffer);
}
}
pkvSubSection = pkvSubSection->GetNextKey();
}
return true;
}
Msg("Failed to load KeyValues from file %s\n", szFullFileName);
return false;
}
bool VMFExporter::ExportVMF( CMapLayout* pLayout, const char *mapname, bool bPopupWarnings )
{
m_bPopupWarnings = bPopupWarnings;
Init();
m_pMapLayout = pLayout;
if ( pLayout->m_PlacedRooms.Count() <= 0 )
{
Q_snprintf( m_szLastExporterError, sizeof(m_szLastExporterError), "Failed to export: No rooms placed in the map layout!\n" );
return false;
}
// see if we have a start room
bool bHasStartRoom = false;
for ( int i = 0 ; i < pLayout->m_PlacedRooms.Count() ; i++ )
{
if ( pLayout->m_PlacedRooms[i]->m_pRoomTemplate->IsStartRoom() )
{
int half_map_size = MAP_LAYOUT_TILES_WIDE * 0.5f; // shift back so the middle of our grid is the origin
m_vecStartRoomOrigin.x = ( pLayout->m_PlacedRooms[i]->m_iPosX - half_map_size ) * ASW_TILE_SIZE;
m_vecStartRoomOrigin.y = ( pLayout->m_PlacedRooms[i]->m_iPosY - half_map_size ) * ASW_TILE_SIZE;
bHasStartRoom = true;
break;
}
}
LoadUniqueKeyList();
m_iNextNodeID = 0;
m_pExportKeys = new KeyValues( "ExportKeys" );
m_pExportKeys->AddSubKey( GetVersionInfo() );
m_pExportKeys->AddSubKey( GetDefaultVisGroups() );
m_pExportKeys->AddSubKey( GetViewSettings() );
m_pExportWorldKeys = GetDefaultWorldChunk();
if ( !m_pExportWorldKeys )
{
Q_snprintf( m_szLastExporterError, sizeof(m_szLastExporterError), "Failed to save world chunk start\n");
return false;
}
m_pExportKeys->AddSubKey( m_pExportWorldKeys );
// save out the big cube the whole level sits in
if ( !AddLevelContainer() )
{
Q_snprintf( m_szLastExporterError, sizeof(m_szLastExporterError), "Failed to save level container\n");
return false;
}
if ( tilegen_use_instancing.GetBool() )
{
int nLogicalRooms = m_pMapLayout->m_LogicalRooms.Count();
int nPlacedRooms = m_pMapLayout->m_PlacedRooms.Count();
m_pRoom = NULL;
for ( int i = 0; i < nLogicalRooms; ++ i )
{
AddRoomInstance( m_pMapLayout->m_LogicalRooms[i] );
}
for ( int i = 0; i < nPlacedRooms; ++ i )
{
m_pRoom = m_pMapLayout->m_PlacedRooms[i];
AddRoomInstance( m_pRoom->m_pRoomTemplate, i );
}
}
else
{
// write out logical room solids
int iLogicalRooms = m_pMapLayout->m_LogicalRooms.Count();
m_pRoom = NULL;
for ( int i = 0 ; i < iLogicalRooms ; i++ )
{
// start logical room IDs at 5000 (assumes we'll never place 5000 real rooms)
m_iCurrentRoom = 5000 + i;
CRoomTemplate *pRoomTemplate = m_pMapLayout->m_LogicalRooms[i];
if ( !pRoomTemplate )
continue;
if ( !AddRoomTemplateSolids( pRoomTemplate ) )
return false;
}
// go through each CRoom and write out its world solids
int iRooms = m_pMapLayout->m_PlacedRooms.Count();
for ( m_iCurrentRoom = 0 ; m_iCurrentRoom<iRooms ; m_iCurrentRoom++)
{
m_pRoom = m_pMapLayout->m_PlacedRooms[m_iCurrentRoom];
if (!m_pRoom)
continue;
const CRoomTemplate *pRoomTemplate = m_pRoom->m_pRoomTemplate;
if (!pRoomTemplate)
continue;
if ( !AddRoomTemplateSolids( pRoomTemplate ) )
return false;
}
// write out logical room entities
m_pRoom = NULL;
for ( int i = 0 ; i < iLogicalRooms ; i++ )
{
// start logical room IDs at 5000 (assumes we'll never place 5000 real rooms)
m_iCurrentRoom = 5000 + i;
CRoomTemplate *pRoomTemplate = m_pMapLayout->m_LogicalRooms[i];
if ( !pRoomTemplate )
continue;
if ( !AddRoomTemplateEntities( pRoomTemplate ) )
return false;
}
// go through each CRoom and add its entities
for ( m_iCurrentRoom = 0 ; m_iCurrentRoom<iRooms ; m_iCurrentRoom++)
{
m_pRoom = m_pMapLayout->m_PlacedRooms[m_iCurrentRoom];
if (!m_pRoom)
continue;
const CRoomTemplate *pRoomTemplate = m_pRoom->m_pRoomTemplate;
if (!pRoomTemplate)
continue;
if ( !AddRoomTemplateEntities( pRoomTemplate ) )
return false;
}
}
// add some player starts to the map in the tile the user selected
if ( !bHasStartRoom )
{
m_pExportKeys->AddSubKey( GetPlayerStarts() );
}
m_pExportKeys->AddSubKey( GetGameRulesProxy() );
m_pExportKeys->AddSubKey( GetDefaultCamera() );
// save out the export keys
char filename[512];
Q_snprintf( filename, sizeof(filename), "maps\\%s", mapname );
Q_SetExtension( filename, "vmf", sizeof( filename ) );
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
for ( KeyValues *pKey = m_pExportKeys->GetFirstSubKey(); pKey; pKey = pKey->GetNextKey() )
{
pKey->RecursiveSaveToFile( buf, 0 );
}
if ( !g_pFullFileSystem->WriteFile( filename, "GAME", buf ) )
{
Msg( "Failed to SaveToFile %s\n", filename );
return false;
}
// save the map layout there (so the game can get information about rooms during play)
Q_snprintf( filename, sizeof( filename ), "maps\\%s", mapname );
Q_SetExtension( filename, "layout", sizeof( filename ) );
if ( !m_pMapLayout->SaveMapLayout( filename ) )
{
Q_snprintf( m_szLastExporterError, sizeof(m_szLastExporterError), "Failed to save .layout file\n");
return false;
}
return true;
}
bool CASW_Mission_Chooser_Source_Local::ASW_Campaign_CreateNewSaveGame(char *szFileName, int iFileNameMaxLen, const char *szCampaignName, bool bMultiplayerGame, const char *szStartingMission) // szFileName arg is the desired filename or NULL for an autogenerated one. Function sets szFileName with the filename used.
{
if (!szFileName)
return false;
char stripped[MAX_PATH];
V_StripExtension( szCampaignName, stripped, MAX_PATH );
char szStartingMissionStripped[64];
if ( szStartingMission )
{
V_StripExtension( szStartingMission, szStartingMissionStripped, sizeof( szStartingMissionStripped ) );
}
else
{
szStartingMissionStripped[0] = 0;
}
// check the campaign file exists
char campbuffer[MAX_PATH];
Q_snprintf(campbuffer, sizeof(campbuffer), "resource/campaigns/%s.txt", stripped);
if (!g_pFullFileSystem->FileExists(campbuffer))
{
Msg("No such campaign: %s\n", campbuffer);
return false;
}
// Get the current time and date as a string
char szDateTime[256];
int year, month, dayOfWeek, day, hour, minute, second;
ASW_System_GetCurrentTimeAndDate(&year, &month, &dayOfWeek, &day, &hour, &minute, &second);
Q_snprintf(szDateTime, sizeof(szDateTime), "%02d/%02d/%02d %02d:%02d", month, day, year, hour, minute);
if (szFileName[0] == '\0')
{
// autogenerate a filename based on the current time and date
Q_snprintf(szFileName, iFileNameMaxLen, "%s_save_%02d_%02d_%02d_%02d_%02d_%02d", stripped, year, month, day, hour, minute, second);
}
// make sure the path and extension are correct
Q_SetExtension( szFileName, ".campaignsave", iFileNameMaxLen );
char tempbuffer[256];
Q_snprintf(tempbuffer, sizeof(tempbuffer), "%s", szFileName);
const char *pszNoPathName = Q_UnqualifiedFileName(tempbuffer);
Msg("Unqualified = %s\n", pszNoPathName);
char szFullFileName[256];
Q_snprintf(szFullFileName, sizeof(szFullFileName), "save/%s", pszNoPathName);
Msg("Creating new save with filename: %s\n", szFullFileName);
KeyValues *pSaveKeyValues = new KeyValues( pszNoPathName );
int nMissionsComplete = 0;
if ( szStartingMission && szStartingMission[0] )
{
KeyValues *pCampaignDetails = GetCampaignDetails( stripped );
if ( pCampaignDetails )
{
int nMissionSections = 0;
for ( KeyValues *pMission = pCampaignDetails->GetFirstSubKey(); pMission; pMission = pMission->GetNextKey() )
{
if ( !Q_stricmp( pMission->GetName(), "MISSION" ) )
{
if ( !Q_stricmp( pMission->GetString( "MapName", "" ), szStartingMissionStripped ) )
{
nMissionsComplete = nMissionSections - 1; // skip first dummy mission
break;
}
nMissionSections++;
}
}
}
}
pSaveKeyValues->SetInt("Version", ASW_CURRENT_SAVE_VERSION);
pSaveKeyValues->SetString("CampaignName", stripped);
pSaveKeyValues->SetInt("CurrentPosition", nMissionsComplete + 1); // position squad on the first uncompleted mission
pSaveKeyValues->SetInt("NumMissionsComplete", nMissionsComplete);
pSaveKeyValues->SetInt("InitialNumMissionsComplete", nMissionsComplete);
pSaveKeyValues->SetInt("Multiplayer", bMultiplayerGame ? 1 : 0);
pSaveKeyValues->SetString("DateTime", szDateTime);
pSaveKeyValues->SetInt("NumPlayers", 0);
// write out each mission's status
KeyValues *pSubSection;
for (int i=0; i<ASW_MAX_MISSIONS_PER_CAMPAIGN; i++)
{
pSubSection = new KeyValues("MISSION");
pSubSection->SetInt("MissionID", i);
bool bComplete = ( i != 0 ) && ( i <= nMissionsComplete );
pSubSection->SetInt("MissionComplete", bComplete ? 1 : 0 );
pSaveKeyValues->AddSubKey(pSubSection);
}
const int nInitialSkillPoints = 0;
// write out each marine's stats
for (int i=0; i<ASW_NUM_MARINE_PROFILES; i++)
{
pSubSection = new KeyValues("MARINE");
pSubSection->SetInt("MarineID", i);
pSubSection->SetInt("SkillSlot0", 0);
pSubSection->SetInt("SkillSlot1", 0);
pSubSection->SetInt("SkillSlot2", 0);
pSubSection->SetInt("SkillSlot3", 0);
pSubSection->SetInt("SkillSlot4", 0);
pSubSection->SetInt("SkillSlotSpare", nInitialSkillPoints + nMissionsComplete * ASW_SKILL_POINTS_PER_MISSION );
pSubSection->SetInt("UndoSkillSlot0", 0);
pSubSection->SetInt("UndoSkillSlot1", 0);
pSubSection->SetInt("UndoSkillSlot2", 0);
pSubSection->SetInt("UndoSkillSlot3", 0);
pSubSection->SetInt("UndoSkillSlot4", 0);
pSubSection->SetInt("UndoSkillSlotSpare", nInitialSkillPoints + nMissionsComplete * ASW_SKILL_POINTS_PER_MISSION );
pSubSection->SetString("MissionsCompleted", "");
pSubSection->SetString("Medals", "");
pSubSection->SetInt("Wounded", 0);
pSubSection->SetInt("Dead", 0);
pSubSection->SetInt("ParasitesKilled", 0);
pSaveKeyValues->AddSubKey(pSubSection);
}
// players section is empty at first
// Create the save sub-directory
if (!g_pFullFileSystem->IsDirectory( "save", "MOD" ))
{
g_pFullFileSystem->CreateDirHierarchy( "save", "MOD" );
}
// save it
if (pSaveKeyValues->SaveToFile(g_pFullFileSystem, szFullFileName))
{
// make sure our save summary list adds this to it, if needed
Msg("New save created: %s\n", szFullFileName);
NotifyNewSave(pszNoPathName);
return true;
}
Msg("Save to file failed. Filename=%s\n", szFullFileName);
return false;
}
