void CASW_Mission_Chooser_Source_Local::AddToMapList(const char *szMapName)
{
MapListName item;
Q_snprintf(item.szMapName, sizeof(item.szMapName), "%s", szMapName);
m_Items.Insert( item );
// check if it has an overview txt
char stripped[MAX_PATH];
V_StripExtension( szMapName, stripped, MAX_PATH );
char tempfile[MAX_PATH];
Q_snprintf( tempfile, sizeof( tempfile ), "resource/overviews/%s.txt", stripped );
bool bHasOverviewOnHost = (g_pFullFileSystem->FileExists(tempfile));
//bool bNoOverview = false;
if ( !bHasOverviewOnHost )
{
// try to load it directly from the maps folder
Q_snprintf( tempfile, sizeof( tempfile ), "maps/%s.txt", stripped );
bHasOverviewOnHost = (g_pFullFileSystem->FileExists(tempfile));
}
// add it to our overview list if it has an overview
if (bHasOverviewOnHost)
{
m_OverviewItems.Insert( item );
}
}
int CASW_Mission_Chooser_Source_Local::GetNumMissionsCompleted(const char *szSaveName)
{
Msg("GetNumMissionsCompleted %s\n", szSaveName);
// check the save file exists
char stripped[MAX_PATH];
V_StripExtension( szSaveName, stripped, MAX_PATH );
Msg(" stripped = %s\n", stripped);
char tempfile[MAX_PATH];
Q_snprintf( tempfile, sizeof( tempfile ), "save/%s.campaignsave", stripped );
Msg(" tempfile = %s\n", tempfile);
Q_strlower( tempfile );
Msg(" tempfile lowered = %s\n", tempfile);
if (!g_pFullFileSystem->FileExists(tempfile))
{
Msg(" this save doesn't exist! returning -1 missions\n");
return -1;
}
KeyValues *pSaveKeyValues = new KeyValues( szSaveName );
if (pSaveKeyValues->LoadFromFile(g_pFullFileSystem, tempfile))
{
int iMissions = pSaveKeyValues->GetInt("NumMissionsComplete");
pSaveKeyValues->deleteThis();
Msg(" loaded keyvalues from file and it thinks num missions is %d\n", iMissions);
return iMissions;
}
Msg(" Couldn't load save keyvalues from file, returning -1\n");
if (pSaveKeyValues->LoadFromFile(g_pFullFileSystem, tempfile, "MOD"))
Msg(" but it loaded if we use the MOD path\n");
else if (pSaveKeyValues->LoadFromFile(g_pFullFileSystem, tempfile, "GAME"))
Msg(" but it loaded if we use the GAME path\n");
pSaveKeyValues->deleteThis();
return -1;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool VerifyHaveAddonVPK( const char *pFileList[], int iArraySize, const char *pMountID, KeyValues *pMountList = NULL )
{
char buf[_MAX_PATH];
char path[_MAX_PATH];
char addon_root[_MAX_PATH];
int i;
if( pMountList && pMountList->GetInt( pMountID, 0 ) == 0 )
{
MountMsg("failed (disabled in mount list)\n");
return false;
}
filesystem->RelativePathToFullPath("addons", "MOD", addon_root, _MAX_PATH);
for( i=0; i < iArraySize; i++ )
{
V_StripExtension(pFileList[i], buf, _MAX_PATH);
V_SetExtension(buf, ".vpk", _MAX_PATH);
Q_snprintf(path, _MAX_PATH, "%s/%s", addon_root, buf);
if( !filesystem->FileExists(path) )
{
return false;
}
}
return true;
}
bool CASW_Mission_Chooser_Source_Local::SavedCampaignExists(const char *szSaveName)
{
// check the save file exists
char stripped[MAX_PATH];
V_StripExtension( szSaveName, stripped, MAX_PATH );
char tempfile[MAX_PATH];
Q_snprintf( tempfile, sizeof( tempfile ), "save/%s.campaignsave", stripped );
return (g_pFullFileSystem->FileExists(tempfile));
}
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;
}
bool CASW_Mission_Chooser_Source_Local::CampaignExists(const char *szCampaignName)
{
if ( !szCampaignName )
return false;
// check the campaign txt exists
char stripped[MAX_PATH];
V_StripExtension( szCampaignName, stripped, MAX_PATH );
char tempfile[MAX_PATH];
Q_snprintf( tempfile, sizeof( tempfile ), "resource/campaigns/%s.txt", stripped );
return (g_pFullFileSystem->FileExists(tempfile));
}
const char* CASW_Mission_Chooser_Source_Local::GetCampaignSaveIntroMap(const char *szSaveName)
{
// check the save file exists
char stripped[MAX_PATH];
V_StripExtension( szSaveName, stripped, MAX_PATH );
char tempfile[MAX_PATH];
Q_snprintf( tempfile, sizeof( tempfile ), "save/%s.campaignsave", stripped );
if (!g_pFullFileSystem->FileExists(tempfile))
return ASW_DEFAULT_INTRO_MAP;
KeyValues *pSaveKeyValues = new KeyValues( szSaveName );
const char* pszCampaign = NULL;
if (pSaveKeyValues->LoadFromFile(g_pFullFileSystem, tempfile))
{
pszCampaign = pSaveKeyValues->GetString("CampaignName");
}
if (!pszCampaign)
{
pSaveKeyValues->deleteThis();
return ASW_DEFAULT_INTRO_MAP;
}
char ctempfile[MAX_PATH];
Q_snprintf( ctempfile, sizeof( ctempfile ), "resource/campaigns/%s.txt", pszCampaign );
if (!g_pFullFileSystem->FileExists(ctempfile)) /// check it exists
{
pSaveKeyValues->deleteThis();
return ASW_DEFAULT_INTRO_MAP;
}
// now read in the campaign txt and find the intro map name
KeyValues *pCampaignKeyValues = new KeyValues( pszCampaign );
if (pCampaignKeyValues->LoadFromFile(g_pFullFileSystem, ctempfile))
{
static char s_introname[128];
Q_strncpy( s_introname, pCampaignKeyValues->GetString("IntroMap"), 128 );
// check we actually got a valid intro map name string
if ( Q_strlen(s_introname) > 5 && !Q_strnicmp( s_introname, "intro", 5 ) )
{
pSaveKeyValues->deleteThis();
pCampaignKeyValues->deleteThis();
return s_introname;
}
}
pSaveKeyValues->deleteThis();
pCampaignKeyValues->deleteThis();
return ASW_DEFAULT_INTRO_MAP;
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void C_ColorCorrection::OnDataChanged(DataUpdateType_t updateType)
{
BaseClass::OnDataChanged( updateType );
if ( updateType == DATA_UPDATE_CREATED )
{
if ( m_CCHandle == INVALID_CLIENT_CCHANDLE )
{
// forming a unique name without extension
char cleanName[MAX_PATH];
V_StripExtension( m_netLookupFilename, cleanName, sizeof( cleanName ) );
char name[MAX_PATH];
Q_snprintf( name, MAX_PATH, "%s_%d", cleanName, entindex() );
m_CCHandle = g_pColorCorrectionMgr->AddColorCorrectionEntity( this, name, m_netLookupFilename );
}
}
}
const char* CASW_Mission_Chooser_Source_Local::GetPrettyCampaignName(const char *szCampaignName)
{
static char szPrettyName[64];
szPrettyName[0] = '\0';
char stripped[MAX_PATH];
V_StripExtension( szCampaignName, stripped, MAX_PATH );
char tempfile[MAX_PATH];
Q_snprintf( tempfile, sizeof( tempfile ), "resource/campaigns/%s.txt", stripped );
KeyValues *pCampaignKeyValues = new KeyValues( szCampaignName );
if (pCampaignKeyValues->LoadFromFile(g_pFullFileSystem, tempfile))
{
Q_snprintf(szPrettyName, sizeof(szPrettyName), "%s", pCampaignKeyValues->GetString("CampaignName"));
}
pCampaignKeyValues->deleteThis();
return szPrettyName;
}
bool CASW_Mission_Chooser_Source_Local::MissionExists(const char *szMapName, bool bRequireOverview)
{
if ( !szMapName )
return false;
// check it has an overview txt
char stripped[MAX_PATH];
V_StripExtension( szMapName, stripped, MAX_PATH );
char tempfile[MAX_PATH];
if (bRequireOverview)
{
Q_snprintf( tempfile, sizeof( tempfile ), "resource/overviews/%s.txt", stripped );
if (!g_pFullFileSystem->FileExists(tempfile))
return false;
}
// check the map exists
Q_snprintf( tempfile, sizeof( tempfile ), "maps/%s.bsp", stripped );
return (g_pFullFileSystem->FileExists(tempfile));
}
// a new save has been created, add it to our summary list
void CASW_Mission_Chooser_Source_Local::NotifyNewSave(const char *szSaveName)
{
// if we haven't started scanning for saves yet, don't worry about it
if (!m_bBuiltSavedCampaignList && !m_bBuildingSavedCampaignList)
return;
// make sure it has the campaignsave extension
char stripped[256];
V_StripExtension(szSaveName, stripped, sizeof(stripped));
char szWithExtension[256];
Q_snprintf(szWithExtension, sizeof(szWithExtension), "%s.campaignsave", stripped);
// check it's not already in the saved list
for (int i=0;i<m_SavedCampaignList.Count();i++)
{
if (!Q_strcmp(m_SavedCampaignList[i].m_szSaveName, szWithExtension))
return;
}
Msg("New save created, adding it to the list of saved campaigns: %s\n", szSaveName);
AddToSavedCampaignList(szWithExtension);
}
//------------------------------------------------------------------------------
// Purpose :
// Input :
// Output :
//------------------------------------------------------------------------------
void C_ColorCorrectionVolume::OnDataChanged(DataUpdateType_t updateType)
{
BaseClass::OnDataChanged( updateType );
if ( updateType == DATA_UPDATE_CREATED )
{
if ( m_CCHandle == INVALID_CLIENT_CCHANDLE )
{
// forming a unique name without extension
char cleanName[MAX_PATH];
V_StripExtension( m_lookupFilename, cleanName, sizeof( cleanName ) );
char name[MAX_PATH];
Q_snprintf( name, MAX_PATH, "%s_%d", cleanName, entindex() );
m_CCHandle = g_pColorCorrectionMgr->AddColorCorrectionVolume( this, name, m_lookupFilename );
SetSolid( SOLID_BSP );
SetSolidFlags( FSOLID_TRIGGER | FSOLID_NOT_SOLID );
}
}
}
// a new save has been created, add it to our summary list
void CASW_Mission_Chooser_Source_Local::NotifySaveDeleted(const char *szSaveName)
{
// if we haven't started scanning for saves yet, don't worry about it
if (!m_bBuiltSavedCampaignList && !m_bBuildingSavedCampaignList)
return;
// make sure it has the campaignsave extension
char stripped[256];
V_StripExtension(szSaveName, stripped, sizeof(stripped));
char szWithExtension[256];
Q_snprintf(szWithExtension, sizeof(szWithExtension), "%s.campaignsave", stripped);
// find it in the list
for (int i=0;i<m_SavedCampaignList.Count();i++)
{
if (!Q_strcmp(m_SavedCampaignList[i].m_szSaveName, szWithExtension))
{
m_SavedCampaignList.Remove(i);
return;
}
}
}
const char* CASW_Mission_Chooser_Source_Local::GetCampaignSaveIntroMap(const char *szSaveName)
{
// check the save file exists
char stripped[MAX_PATH];
V_StripExtension( szSaveName, stripped, MAX_PATH );
char tempfile[MAX_PATH];
Q_snprintf( tempfile, sizeof( tempfile ), "save/%s.campaignsave", stripped );
if (!g_pFullFileSystem->FileExists(tempfile))
return NULL;
KeyValues *pSaveKeyValues = new KeyValues( szSaveName );
KeyValues::AutoDelete saveKeyValuesAutoDelete( pSaveKeyValues );
const char* pszCampaign = NULL;
if (pSaveKeyValues->LoadFromFile(g_pFullFileSystem, tempfile))
pszCampaign = pSaveKeyValues->GetString("CampaignName");
if (!pszCampaign)
return NULL;
// now read in the campaign txt and find the intro map name
KeyValues *pCampaignKeyValues = GetCampaignDetails( pszCampaign );
if (pCampaignKeyValues)
{
KeyValues *pMission = pCampaignKeyValues->FindKey("MISSION");
Assert(pMission);
if (pMission)
{
pMission = pMission->GetNextKey();
Assert(pMission && !Q_stricmp(pMission->GetName(), "MISSION"));
if (pMission && !Q_stricmp(pMission->GetName(), "MISSION"))
{
Assert(pMission->GetString("MapName", NULL));
return pMission->GetString("MapName", NULL);
}
}
}
return NULL;
}
KeyValues *CASW_Mission_Chooser_Source_Local::GetCampaignDetails( const char *szCampaignName )
{
// see if we have this cached already
for ( int i = 0; i < m_CampaignDetails.Count(); i++ )
{
if ( !Q_stricmp( m_CampaignDetails[ i ]->szCampaignName, szCampaignName ) )
{
return m_CampaignDetails[ i ]->m_pCampaignKeys;
}
}
// strip off the extension
char stripped[MAX_PATH];
V_StripExtension( szCampaignName, stripped, MAX_PATH );
KeyValues *pCampaignKeys = new KeyValues( stripped );
char tempfile[MAX_PATH];
Q_snprintf( tempfile, sizeof( tempfile ), "resource/campaigns/%s.txt", stripped );
bool bNoOverview = false;
if ( !pCampaignKeys->LoadFromFile( g_pFullFileSystem, tempfile, "GAME" ) )
{
// try to load it directly from the maps folder
Q_snprintf( tempfile, sizeof( tempfile ), "maps/%s.txt", stripped );
if ( !pCampaignKeys->LoadFromFile( g_pFullFileSystem, tempfile, "GAME" ) )
{
bNoOverview = true;
}
}
CampaignDetails_t *pDetails = new CampaignDetails_t;
pDetails->m_pCampaignKeys = pCampaignKeys;
Q_snprintf( pDetails->szCampaignName, sizeof( pDetails->szCampaignName ), "%s", szCampaignName );
m_CampaignDetails.AddToTail( pDetails );
return pCampaignKeys;
}
void CASW_Mission_Chooser_Source_Local::OnSaveUpdated(const char *szSaveName)
{
// if we haven't started scanning for saves yet, don't worry about it
if (!m_bBuiltSavedCampaignList && !m_bBuildingSavedCampaignList)
return;
// make sure it has the campaignsave extension
char stripped[256];
V_StripExtension(szSaveName, stripped, sizeof(stripped));
char szWithExtension[256];
Q_snprintf(szWithExtension, sizeof(szWithExtension), "%s.campaignsave", stripped);
// check it's not already in the saved list
for (int i=0;i<m_SavedCampaignList.Count();i++)
{
if (!Q_strcmp(m_SavedCampaignList[i].m_szSaveName, szWithExtension))
{
m_SavedCampaignList.Remove(i);
break;
}
}
Msg("Updating save game summary %s\n", szSaveName);
AddToSavedCampaignList(szWithExtension);
}
//-----------------------------------------------------------------------------
// Generate a tree containing files from a reslist. Returns TRUE if successful.
//-----------------------------------------------------------------------------
bool LoadReslist( const char *pReslistName, CUtlRBTree< CUtlString, int > *pTree )
{
CUtlBuffer buffer;
if ( !scriptlib->ReadFileToBuffer( pReslistName, buffer, true ) )
{
return false;
}
char szBasename[MAX_PATH];
V_FileBase( pReslistName, szBasename, sizeof( szBasename ) );
characterset_t breakSet;
CharacterSetBuild( &breakSet, "" );
// parse reslist
char szToken[MAX_PATH];
char szBspName[MAX_PATH];
szBspName[0] = '\0';
for ( ;; )
{
int nTokenSize = buffer.ParseToken( &breakSet, szToken, sizeof( szToken ) );
if ( nTokenSize <= 0 )
{
break;
}
// reslists are pc built, filenames can be sloppy
V_strlower( szToken );
V_FixSlashes( szToken );
V_RemoveDotSlashes( szToken );
// can safely cull filetypes that are ignored by queued loader at runtime
bool bKeep = false;
const char *pExt = V_GetFileExtension( szToken );
if ( !pExt )
{
// unknown
continue;
}
else if ( !V_stricmp( pExt, "vmt" ) ||
!V_stricmp( pExt, "vhv" ) ||
!V_stricmp( pExt, "mdl" ) ||
!V_stricmp( pExt, "raw" ) ||
!V_stricmp( pExt, "wav" ) )
{
bKeep = true;
}
else if ( !V_stricmp( pExt, "mp3" ) )
{
// change to .wav
V_SetExtension( szToken, ".wav", sizeof( szToken ) );
bKeep = true;
}
else if ( !V_stricmp( pExt, "bsp" ) )
{
// reslists erroneously have multiple bsps
if ( !V_stristr( szToken, szBasename ) )
{
// wrong one, cull it
continue;
}
else
{
// right one, save it
strcpy( szBspName, szToken );
bKeep = true;
}
}
if ( bKeep )
{
FindOrAddFileToResourceList( szToken, pTree );
}
}
if ( !szBspName[0] )
{
// reslist is not bsp derived, nothing more to do
return true;
}
CUtlVector< CUtlString > bspList;
bool bOK = GetDependants_BSP( szBspName, &bspList );
if ( !bOK )
{
return false;
}
// add all the bsp dependants to the resource list
for ( int i=0; i<bspList.Count(); i++ )
{
FindOrAddFileToResourceList( bspList[i].String(), pTree );
}
// iterate all the models in the resource list, get all their dependents
CUtlVector< CUtlString > modelList;
for ( int i = pTree->FirstInorder(); i != pTree->InvalidIndex(); i = pTree->NextInorder( i ) )
{
const char *pExt = V_GetFileExtension( pTree->Element( i ).String() );
if ( !pExt || V_stricmp( pExt, "mdl" ) )
{
continue;
}
if ( !GetDependants_MDL( pTree->Element( i ).String(), &modelList ) )
{
return false;
}
}
// add all the model dependents to the resource list
for ( int i=0; i<modelList.Count(); i++ )
{
FindOrAddFileToResourceList( modelList[i].String(), pTree );
}
// check for optional commentary, include wav dependencies
char szCommentaryName[MAX_PATH];
V_ComposeFileName( g_szGamePath, szBspName, szCommentaryName, sizeof( szCommentaryName ) );
V_StripExtension( szCommentaryName, szCommentaryName, sizeof( szCommentaryName ) );
V_strncat( szCommentaryName, "_commentary.txt", sizeof( szCommentaryName ) );
CUtlBuffer commentaryBuffer;
if ( ReadFileToBuffer( szCommentaryName, commentaryBuffer, true, true ) )
{
// any single token may be quite large to due to text
char szCommentaryToken[8192];
for ( ;; )
{
int nTokenSize = commentaryBuffer.ParseToken( &breakSet, szCommentaryToken, sizeof( szCommentaryToken ) );
if ( nTokenSize < 0 )
{
break;
}
if ( nTokenSize > 0 && !V_stricmp( szCommentaryToken, "commentaryfile" ) )
{
// get the commentary file
nTokenSize = commentaryBuffer.ParseToken( &breakSet, szCommentaryToken, sizeof( szCommentaryToken ) );
if ( nTokenSize > 0 )
{
// skip past sound chars
char *pName = szCommentaryToken;
while ( *pName && IsSoundChar( *pName ) )
{
pName++;
}
char szWavFile[MAX_PATH];
V_snprintf( szWavFile, sizeof( szWavFile ), "sound/%s", pName );
FindOrAddFileToResourceList( szWavFile, pTree );
}
}
}
}
// check for optional blacklist
char szBlacklist[MAX_PATH];
V_ComposeFileName( g_szGamePath, "reslistfixes_xbox.xsc", szBlacklist, sizeof( szBlacklist ) );
CUtlBuffer blacklistBuffer;
if ( ReadFileToBuffer( szBlacklist, blacklistBuffer, true, true ) )
{
for ( ;; )
{
int nTokenSize = blacklistBuffer.ParseToken( &breakSet, szToken, sizeof( szToken ) );
if ( nTokenSize <= 0 )
{
break;
}
bool bAdd;
if ( !V_stricmp( szToken, "-" ) )
{
bAdd = false;
}
else if ( !V_stricmp( szToken, "+" ) )
{
bAdd = true;
}
else
{
// bad syntax, skip line
Msg( "Bad Syntax, expecting '+' or '-' as first token in reslist fixup file '%s'.\n", szBlacklist );
continue;
}
// get entry
nTokenSize = blacklistBuffer.ParseToken( &breakSet, szToken, sizeof( szToken ) );
if ( nTokenSize <= 0 )
{
break;
}
if ( bAdd )
{
FindOrAddFileToResourceList( szToken, pTree );
}
else
{
RemoveFileFromResourceList( szToken, pTree );
}
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Force extension...
// Input : *path -
// *extension -
// pathStringLength -
//-----------------------------------------------------------------------------
void V_SetExtension( char *path, const char *extension, int pathStringLength )
{
V_StripExtension( path, path, pathStringLength );
V_DefaultExtension( path, extension, pathStringLength );
}
//-----------------------------------------------------------------------------
// Rebuilds all of a MDL's components.
//-----------------------------------------------------------------------------
static bool GenerateModelFiles( const char *pMdlFilename )
{
CUtlBuffer tempBuffer;
int fileSize;
int paddedSize;
int swappedSize;
// .mdl
CUtlBuffer mdlBuffer;
if ( !scriptlib->ReadFileToBuffer( pMdlFilename, mdlBuffer ) )
{
return false;
}
if ( !Studio_ConvertStudioHdrToNewVersion( (studiohdr_t *)mdlBuffer.Base() ))
{
Msg("%s needs to be recompiled\n", pMdlFilename );
}
// .vtx
char szVtxFilename[MAX_PATH];
V_StripExtension( pMdlFilename, szVtxFilename, sizeof( szVtxFilename ) );
V_strncat( szVtxFilename, ".dx90.vtx", sizeof( szVtxFilename ) );
CUtlBuffer vtxBuffer;
bool bHasVtx = ReadFileToBuffer( szVtxFilename, vtxBuffer, false, true );
// .vvd
char szVvdFilename[MAX_PATH];
V_StripExtension( pMdlFilename, szVvdFilename, sizeof( szVvdFilename ) );
V_strncat( szVvdFilename, ".vvd", sizeof( szVvdFilename ) );
CUtlBuffer vvdBuffer;
bool bHasVvd = ReadFileToBuffer( szVvdFilename, vvdBuffer, false, true );
if ( bHasVtx != bHasVvd )
{
// paired resources, either mandates the other
return false;
}
// a .mdl file that has .vtx/.vvd gets re-processed to cull lod data
if ( bHasVtx && bHasVvd )
{
// cull lod if needed
IMdlStripInfo *pStripInfo = NULL;
bool bResult = mdllib->StripModelBuffers( mdlBuffer, vvdBuffer, vtxBuffer, &pStripInfo );
if ( !bResult )
{
return false;
}
if ( pStripInfo )
{
// .vsi
CUtlBuffer vsiBuffer;
pStripInfo->Serialize( vsiBuffer );
pStripInfo->DeleteThis();
// save strip info for later processing
char szVsiFilename[MAX_PATH];
V_StripExtension( pMdlFilename, szVsiFilename, sizeof( szVsiFilename ) );
V_strncat( szVsiFilename, ".vsi", sizeof( szVsiFilename ) );
WriteBufferToFile( szVsiFilename, vsiBuffer, false, WRITE_TO_DISK_ALWAYS );
}
}
// .ani processing may further update .mdl buffer
char szAniFilename[MAX_PATH];
V_StripExtension( pMdlFilename, szAniFilename, sizeof( szAniFilename ) );
V_strncat( szAniFilename, ".ani", sizeof( szAniFilename ) );
CUtlBuffer aniBuffer;
bool bHasAni = ReadFileToBuffer( szAniFilename, aniBuffer, false, true );
if ( bHasAni )
{
// Some vestigal .ani files exist in the tree, only process valid .ani
if ( ((studiohdr_t*)mdlBuffer.Base())->numanimblocks != 0 )
{
// .ani processing modifies .mdl buffer
fileSize = aniBuffer.TellPut();
paddedSize = fileSize + BYTESWAP_ALIGNMENT_PADDING;
aniBuffer.EnsureCapacity( paddedSize );
tempBuffer.EnsureCapacity( paddedSize );
V_StripExtension( pMdlFilename, szAniFilename, sizeof( szAniFilename ) );
V_strncat( szAniFilename, ".360.ani", sizeof( szAniFilename ) );
swappedSize = StudioByteSwap::ByteswapStudioFile( szAniFilename, tempBuffer.Base(), aniBuffer.PeekGet(), fileSize, (studiohdr_t*)mdlBuffer.Base(), CompressFunc );
if ( swappedSize > 0 )
{
// .ani buffer is replaced with swapped data
aniBuffer.Purge();
aniBuffer.Put( tempBuffer.Base(), swappedSize );
WriteBufferToFile( szAniFilename, aniBuffer, false, WRITE_TO_DISK_ALWAYS );
}
else
{
return false;
}
}
}
// .phy
char szPhyFilename[MAX_PATH];
V_StripExtension( pMdlFilename, szPhyFilename, sizeof( szPhyFilename ) );
V_strncat( szPhyFilename, ".phy", sizeof( szPhyFilename ) );
CUtlBuffer phyBuffer;
bool bHasPhy = ReadFileToBuffer( szPhyFilename, phyBuffer, false, true );
if ( bHasPhy )
{
fileSize = phyBuffer.TellPut();
paddedSize = fileSize + BYTESWAP_ALIGNMENT_PADDING;
phyBuffer.EnsureCapacity( paddedSize );
tempBuffer.EnsureCapacity( paddedSize );
V_StripExtension( pMdlFilename, szPhyFilename, sizeof( szPhyFilename ) );
V_strncat( szPhyFilename, ".360.phy", sizeof( szPhyFilename ) );
swappedSize = StudioByteSwap::ByteswapStudioFile( szPhyFilename, tempBuffer.Base(), phyBuffer.PeekGet(), fileSize, (studiohdr_t*)mdlBuffer.Base(), CompressFunc );
if ( swappedSize > 0 )
{
// .phy buffer is replaced with swapped data
phyBuffer.Purge();
phyBuffer.Put( tempBuffer.Base(), swappedSize );
WriteBufferToFile( szPhyFilename, phyBuffer, false, WRITE_TO_DISK_ALWAYS );
}
else
{
return false;
}
}
if ( bHasVtx )
{
fileSize = vtxBuffer.TellPut();
paddedSize = fileSize + BYTESWAP_ALIGNMENT_PADDING;
vtxBuffer.EnsureCapacity( paddedSize );
tempBuffer.EnsureCapacity( paddedSize );
V_StripExtension( pMdlFilename, szVtxFilename, sizeof( szVtxFilename ) );
V_strncat( szVtxFilename, ".dx90.360.vtx", sizeof( szVtxFilename ) );
swappedSize = StudioByteSwap::ByteswapStudioFile( szVtxFilename, tempBuffer.Base(), vtxBuffer.PeekGet(), fileSize, (studiohdr_t*)mdlBuffer.Base(), CompressFunc );
if ( swappedSize > 0 )
{
// .vtx buffer is replaced with swapped data
vtxBuffer.Purge();
vtxBuffer.Put( tempBuffer.Base(), swappedSize );
WriteBufferToFile( szVtxFilename, vtxBuffer, false, WRITE_TO_DISK_ALWAYS );
}
else
{
return false;
}
}
if ( bHasVvd )
{
fileSize = vvdBuffer.TellPut();
paddedSize = fileSize + BYTESWAP_ALIGNMENT_PADDING;
vvdBuffer.EnsureCapacity( paddedSize );
tempBuffer.EnsureCapacity( paddedSize );
V_StripExtension( pMdlFilename, szVvdFilename, sizeof( szVvdFilename ) );
V_strncat( szVvdFilename, ".360.vvd", sizeof( szVvdFilename ) );
swappedSize = StudioByteSwap::ByteswapStudioFile( szVvdFilename, tempBuffer.Base(), vvdBuffer.PeekGet(), fileSize, (studiohdr_t*)mdlBuffer.Base(), CompressFunc );
if ( swappedSize > 0 )
{
// .vvd buffer is replaced with swapped data
vvdBuffer.Purge();
vvdBuffer.Put( tempBuffer.Base(), swappedSize );
WriteBufferToFile( szVvdFilename, vvdBuffer, false, WRITE_TO_DISK_ALWAYS );
}
else
{
return false;
}
}
// swap and write final .mdl
fileSize = mdlBuffer.TellPut();
paddedSize = fileSize + BYTESWAP_ALIGNMENT_PADDING;
mdlBuffer.EnsureCapacity( paddedSize );
tempBuffer.EnsureCapacity( paddedSize );
char szMdlFilename[MAX_PATH];
V_StripExtension( pMdlFilename, szMdlFilename, sizeof( szMdlFilename ) );
V_strncat( szMdlFilename, ".360.mdl", sizeof( szMdlFilename ) );
swappedSize = StudioByteSwap::ByteswapStudioFile( szMdlFilename, tempBuffer.Base(), mdlBuffer.PeekGet(), fileSize, NULL, CompressFunc );
if ( swappedSize > 0 )
{
// .mdl buffer is replaced with swapped data
mdlBuffer.Purge();
mdlBuffer.Put( tempBuffer.Base(), swappedSize );
WriteBufferToFile( szMdlFilename, mdlBuffer, false, WRITE_TO_DISK_ALWAYS );
}
else
{
return false;
}
return true;
}
bool CDynPatcher::LoadLib(const char *LibName, bool ForceLoad)
{
if(!LibName)
return false;
DynMsg("Loading library:%s%s",LibName,ForceLoad?" (Force)":"");
if(DllHandler)
{
DynErr(false,"Library \"%s\" already loaded",szLibName);
return false;
}
szLibName = new char[strlen(LibName) + 1];
//#ifdef _WIN32
strcpy(szLibName, LibName);
#ifdef LINUX
int Len=strlen(LibName) + 1;
V_StripExtension(LibName,szLibName,Len);
V_SetExtension( szLibName, ".so", Len);
#endif
const char *LibFileName = CSectionData::GetFileName(szLibName);
DynMsg("LibName=\"%s\"; LibFileName=\"%s\"",szLibName,LibFileName);
#ifdef _WIN32
DllHandler=GetModuleHandleA(LibFileName);
//DynMsg("GetModuleHandleA(%s)=0x%p",LibFileName,DllHandler);
if(DllHandler)
{
bSelfLoaded=false;
return true;
}
else if(ForceLoad)
{
//DynMsg("Force loading!");
DllHandler=LoadLibraryA(szLibName);
//DynMsg("LoadLibraryA(%s)=0x%p",LibName,DllHandler);
if(DllHandler)
{
bSelfLoaded=true;
return true;
}
}
#else
DllBase=LocateLib(LibFileName);
DynMsg("LocateLib(%s)=0x%p",LibFileName,DllBase);
if(DllBase)
{
DllHandler=dlopen(szLibName,RTLD_NOW);
DynMsg("dlopen(%s)=0x%p",szLibName,DllHandler);
dlclose(DllHandler);
DynMsg("DllHandler aftrer dlclose=0x%p",DllHandler);
if(DllHandler)
{
bSelfLoaded=false;
return true;
}
else
{
DllBase=0;
return false;
}
}
else if(ForceLoad)
{
DynMsg("Force loading!");
DllHandler=dlopen(szLibName, RTLD_NOW);
DynMsg("dlopen(%s)=0x%p",szLibName,DllHandler);
if(!DllHandler)
{
return false;
}
DllBase=LocateLib(LibFileName);
DynMsg("LocateLib(%s)=0x%p",LibFileName,DllBase);
if(!DllBase)
{
dlclose(DllHandler);
DllHandler=NULL;
return false;
}
bSelfLoaded=true;
return true;
}
#endif
return false;
}
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;
}
CUtlString CUtlString::StripExtension() const
{
char szTemp[MAX_PATH];
V_StripExtension( String(), szTemp, sizeof( szTemp ) );
return CUtlString( szTemp );
}
