d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
551 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 29985681a1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '29985681a1'
${ noResults }
source-engine/hammer/gameconfig.cpp

622 lines
17 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "stdafx.h"
#include <direct.h>
#include <io.h>
#include <WorldSize.h>
#include "Gameconfig.h"
#include "GlobalFunctions.h"
#include "fgdlib/HelperInfo.h"
#include "hammer.h"
#include "KeyValues.h"
#include "MapDoc.h"
#include "MapDoc.h"
#include "MapEntity.h"
#include "MapInstance.h"
#include "MapWorld.h"
#include "filesystem_tools.h"
#include "TextureSystem.h"
#include "tier1/strtools.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#pragma warning(disable:4244)
const int MAX_ERRORS = 5;
GameData *pGD;
CGameConfig g_DefaultGameConfig;
CGameConfig *g_pGameConfig = &g_DefaultGameConfig;
float g_MAX_MAP_COORD = 4096;
float g_MIN_MAP_COORD = -4096;
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CGameConfig *CGameConfig::GetActiveGame(void)
{
return g_pGameConfig;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pGame -
//-----------------------------------------------------------------------------
void CGameConfig::SetActiveGame(CGameConfig *pGame)
{
if (pGame != NULL)
{
g_pGameConfig = pGame;
pGD = &pGame->GD;
if (pGame->mapformat == mfHalfLife)
{
g_MAX_MAP_COORD = 4096;
g_MIN_MAP_COORD = -4096;
}
else
{
g_MAX_MAP_COORD = pGD->GetMaxMapCoord();
g_MIN_MAP_COORD = pGD->GetMinMapCoord();
}
}
else
{
g_pGameConfig = &g_DefaultGameConfig;
pGD = NULL;
g_MAX_MAP_COORD = 4096;
g_MIN_MAP_COORD = -4096;
}
}
//-----------------------------------------------------------------------------
// Purpose: Constructor. Maintains a static counter uniquely identifying each
// game configuration.
//-----------------------------------------------------------------------------
CGameConfig::CGameConfig(void)
{
nGDFiles = 0;
textureformat = tfNone;
m_fDefaultTextureScale = DEFAULT_TEXTURE_SCALE;
m_nDefaultLightmapScale = DEFAULT_LIGHTMAP_SCALE;
m_MaterialExcludeCount = 0;
memset(szName, 0, sizeof(szName));
memset(szExecutable, 0, sizeof(szExecutable));
memset(szDefaultPoint, 0, sizeof(szDefaultPoint));
memset(szDefaultSolid, 0, sizeof(szDefaultSolid));
memset(szBSP, 0, sizeof(szBSP));
memset(szLIGHT, 0, sizeof(szLIGHT));
memset(szVIS, 0, sizeof(szVIS));
memset(szMapDir, 0, sizeof(szMapDir));
memset(m_szGameExeDir, 0, sizeof(m_szGameExeDir));
memset(szBSPDir, 0, sizeof(szBSPDir));
memset(m_szModDir, 0, sizeof(m_szModDir));
strcpy(m_szCordonTexture, "BLACK");
m_szSteamDir[0] = '\0';
m_szSteamAppID[0] = '\0';
static DWORD __dwID = 0;
dwID = __dwID++;
}
//-----------------------------------------------------------------------------
// Purpose: Imports an old binary GameCfg.wc file.
// Input : file -
// fVersion -
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
BOOL CGameConfig::Import(std::fstream& file, float fVersion)
{
file.read(szName, sizeof szName);
file.read((char*)&nGDFiles, sizeof nGDFiles);
file.read((char*)&textureformat, sizeof textureformat);
if (fVersion >= 1.1f)
{
file.read((char*)&mapformat, sizeof mapformat);
}
else
{
mapformat = mfQuake;
}
//
// If reading an old (pre 1.4) format file, skip past the obselete palette
// file path.
//
if (fVersion < 1.4f)
{
char szPalette[128];
file.read(szPalette, sizeof szPalette);
}
file.read(szExecutable, sizeof szExecutable);
file.read(szDefaultSolid, sizeof szDefaultSolid);
file.read(szDefaultPoint, sizeof szDefaultPoint);
if (fVersion >= 1.2f)
{
file.read(szBSP, sizeof szBSP);
file.read(szLIGHT, sizeof szLIGHT);
file.read(szVIS, sizeof szVIS);
file.read(m_szGameExeDir, sizeof m_szGameExeDir);
file.read(szMapDir, sizeof szMapDir);
}
if (fVersion >= 1.3f)
{
file.read(szBSPDir, sizeof(szBSPDir));
}
if (fVersion >= 1.4f)
{
// CSG setting is gone now.
char szTempCSG[128];
file.read(szTempCSG, sizeof(szTempCSG));
file.read(m_szModDir, sizeof(m_szModDir));
// gamedir is gone now.
char tempGameDir[128];
file.read(tempGameDir, sizeof(tempGameDir));
}
// read game data files
char szBuf[128];
for(int i = 0; i < nGDFiles; i++)
{
file.read(szBuf, sizeof szBuf);
GDFiles.Add(CString(szBuf));
}
LoadGDFiles();
return TRUE;
}
//-----------------------------------------------------------------------------
// Purpose: Loads this game configuration from a keyvalue block.
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CGameConfig::Load(KeyValues *pkv)
{
char szKey[MAX_PATH];
// We should at least be able to get the game name and the game dir.
Q_strncpy(szName, pkv->GetName(), sizeof(szName));
Q_strncpy(m_szModDir, pkv->GetString("GameDir"), sizeof(m_szModDir));
// Try to get the Hammer settings.
KeyValues *pkvHammer = pkv->FindKey("Hammer");
if (!pkvHammer)
return true;
//
// Load the game data filenames from the "GameData0..GameDataN" keys.
//
nGDFiles = 0;
bool bAdded = true;
do
{
sprintf(szKey, "GameData%d", nGDFiles);
const char *pszGameData = pkvHammer->GetString(szKey);
if (pszGameData[0] != '\0')
{
GDFiles.Add(pszGameData);
nGDFiles++;
}
else
{
bAdded = false;
}
} while (bAdded);
textureformat = (TEXTUREFORMAT)pkvHammer->GetInt("TextureFormat", tfVMT);
mapformat = (MAPFORMAT)pkvHammer->GetInt("MapFormat", mfHalfLife2);
m_fDefaultTextureScale = pkvHammer->GetFloat("DefaultTextureScale", DEFAULT_TEXTURE_SCALE);
if (m_fDefaultTextureScale == 0)
{
m_fDefaultTextureScale = DEFAULT_TEXTURE_SCALE;
}
m_nDefaultLightmapScale = pkvHammer->GetInt("DefaultLightmapScale", DEFAULT_LIGHTMAP_SCALE);
Q_strncpy(szExecutable, pkvHammer->GetString("GameExe"), sizeof(szExecutable));
Q_strncpy(szDefaultSolid, pkvHammer->GetString("DefaultSolidEntity"), sizeof(szDefaultSolid));
Q_strncpy(szDefaultPoint, pkvHammer->GetString("DefaultPointEntity"), sizeof(szDefaultPoint));
Q_strncpy(szBSP, pkvHammer->GetString("BSP"), sizeof(szBSP));
Q_strncpy(szVIS, pkvHammer->GetString("Vis"), sizeof(szVIS));
Q_strncpy(szLIGHT, pkvHammer->GetString("Light"), sizeof(szLIGHT));
Q_strncpy(m_szGameExeDir, pkvHammer->GetString("GameExeDir"), sizeof(m_szGameExeDir));
Q_strncpy(szMapDir, pkvHammer->GetString("MapDir"), sizeof(szMapDir));
Q_strncpy(szBSPDir, pkvHammer->GetString("BSPDir"), sizeof(szBSPDir));
SetCordonTexture( pkvHammer->GetString("CordonTexture", "BLACK") );
char szExcludeDir[MAX_PATH];
m_MaterialExcludeCount = pkvHammer->GetInt( "MaterialExcludeCount" );
for ( int i = 0; i < m_MaterialExcludeCount; i++ )
{
sprintf( szExcludeDir, "-MaterialExcludeDir%d", i );
int index = m_MaterialExclusions.AddToTail();
Q_strncpy( m_MaterialExclusions[index].szDirectory, pkvHammer->GetString( szExcludeDir ), sizeof( m_MaterialExclusions[index].szDirectory ) );
Q_StripTrailingSlash( m_MaterialExclusions[index].szDirectory );
m_MaterialExclusions[index].bUserGenerated = true;
}
LoadGDFiles();
return(true);
}
//-----------------------------------------------------------------------------
// Purpose: Saves this config's data into a keyvalues object.
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CGameConfig::Save(KeyValues *pkv)
{
pkv->SetName(szName);
pkv->SetString("GameDir", m_szModDir);
// Try to get the Hammer settings.
KeyValues *pkvHammer = pkv->FindKey("Hammer");
if (pkvHammer)
{
pkv->RemoveSubKey(pkvHammer);
pkvHammer->deleteThis();
}
pkvHammer = pkv->CreateNewKey();
if (!pkvHammer)
return false;
pkvHammer->SetName("Hammer");
//
// Load the game data filenames from the "GameData0..GameDataN" keys.
//
for (int i = 0; i < nGDFiles; i++)
{
char szKey[MAX_PATH];
sprintf(szKey, "GameData%d", i);
pkvHammer->SetString(szKey, GDFiles.GetAt(i));
}
pkvHammer->SetInt("TextureFormat", textureformat);
pkvHammer->SetInt("MapFormat", mapformat);
pkvHammer->SetFloat("DefaultTextureScale", m_fDefaultTextureScale);
pkvHammer->SetInt("DefaultLightmapScale", m_nDefaultLightmapScale);
pkvHammer->SetString("GameExe", szExecutable);
pkvHammer->SetString("DefaultSolidEntity", szDefaultSolid);
pkvHammer->SetString("DefaultPointEntity", szDefaultPoint);
pkvHammer->SetString("BSP", szBSP);
pkvHammer->SetString("Vis", szVIS);
pkvHammer->SetString("Light", szLIGHT);
pkvHammer->SetString("GameExeDir", m_szGameExeDir);
pkvHammer->SetString("MapDir", szMapDir);
pkvHammer->SetString("BSPDir", szBSPDir);
pkvHammer->SetString("CordonTexture", m_szCordonTexture);
char szExcludeDir[MAX_PATH];
pkvHammer->SetInt("MaterialExcludeCount", m_MaterialExcludeCount);
for (int i = 0; i < m_MaterialExcludeCount; i++)
{
sprintf(szExcludeDir, "-MaterialExcludeDir%d", i );
pkvHammer->SetString(szExcludeDir, m_MaterialExclusions[i].szDirectory);
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : file -
//-----------------------------------------------------------------------------
void CGameConfig::Save(std::fstream &file)
{
file.write(szName, sizeof szName);
file.write((char*)&nGDFiles, sizeof nGDFiles);
file.write((char*)&textureformat, sizeof textureformat);
file.write((char*)&mapformat, sizeof mapformat);
file.write(szExecutable, sizeof szExecutable);
file.write(szDefaultSolid, sizeof szDefaultSolid);
file.write(szDefaultPoint, sizeof szDefaultPoint);
// 1.2
file.write(szBSP, sizeof szBSP);
file.write(szLIGHT, sizeof szLIGHT);
file.write(szVIS, sizeof szVIS);
file.write(m_szGameExeDir, sizeof(m_szGameExeDir));
file.write(szMapDir, sizeof szMapDir);
// 1.3
file.write(szBSPDir, sizeof szBSPDir);
// 1.4
char tempCSG[128] = "";
file.write(tempCSG, sizeof(tempCSG));
file.write(m_szModDir, sizeof(m_szModDir));
char tempGameDir[128] = "";
file.write(tempGameDir, sizeof(tempGameDir));
// write game data files
char szBuf[128];
for(int i = 0; i < nGDFiles; i++)
{
strcpy(szBuf, GDFiles[i]);
file.write(szBuf, sizeof szBuf);
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pConfig -
//-----------------------------------------------------------------------------
void CGameConfig::CopyFrom(CGameConfig *pConfig)
{
nGDFiles = pConfig->nGDFiles;
GDFiles.RemoveAll();
GDFiles.Append(pConfig->GDFiles);
strcpy(szName, pConfig->szName);
strcpy(szExecutable, pConfig->szExecutable);
strcpy(szDefaultPoint, pConfig->szDefaultPoint);
strcpy(szDefaultSolid, pConfig->szDefaultSolid);
strcpy(szBSP, pConfig->szBSP);
strcpy(szLIGHT, pConfig->szLIGHT);
strcpy(szVIS, pConfig->szVIS);
strcpy(szMapDir, pConfig->szMapDir);
strcpy(m_szGameExeDir, pConfig->m_szGameExeDir);
strcpy(szBSPDir, pConfig->szBSPDir);
strcpy(m_szModDir, pConfig->m_szModDir);
pConfig->m_MaterialExcludeCount = m_MaterialExcludeCount;
for( int i = 0; i < m_MaterialExcludeCount; i++ )
{
strcpy( m_MaterialExclusions[i].szDirectory, pConfig->m_MaterialExclusions[i].szDirectory );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pEntity -
// pGD -
// Output : Returns TRUE to keep enumerating.
//-----------------------------------------------------------------------------
static BOOL UpdateClassPointer(CMapEntity *pEntity, GameData *pGDIn)
{
GDclass *pClass = pGDIn->ClassForName(pEntity->GetClassName());
pEntity->SetClass(pClass);
return(TRUE);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CGameConfig::LoadGDFiles(void)
{
GD.ClearData();
// Save the old working directory
char szOldDir[MAX_PATH];
_getcwd( szOldDir, sizeof(szOldDir) );
// Set our working directory properly
char szAppDir[MAX_PATH];
APP()->GetDirectory( DIR_PROGRAM, szAppDir );
_chdir( szAppDir );
for (int i = 0; i < nGDFiles; i++)
{
GD.Load(GDFiles[i]);
}
// Reset our old working directory
_chdir( szOldDir );
// All the class pointers have changed - now we have to
// reset all the class pointers in each map doc that
// uses this game.
for ( int i=0; i<CMapDoc::GetDocumentCount(); i++ )
{
CMapDoc *pDoc = CMapDoc::GetDocument(i);
if (pDoc->GetGame() == this)
{
CMapWorld *pWorld = pDoc->GetMapWorld();
pWorld->SetClass(GD.ClassForName(pWorld->GetClassName()));
pWorld->EnumChildren((ENUMMAPCHILDRENPROC)UpdateClassPointer, (DWORD)&GD, MAPCLASS_TYPE(CMapEntity));
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Searches for the given filename, starting in szStartDir and looking
// up the directory tree.
// Input: szFile - the name of the file to search for.
// szStartDir - the folder to start searching from, towards the root.
// szFoundPath - receives the full path of the FOLDER where szFile was found.
// Output : Returns true if the file was found, false if not. If the file was
// found the full path (not including the filename) is returned in szFoundPath.
//-----------------------------------------------------------------------------
bool FindFileInTree(const char *szFile, const char *szStartDir, char *szFoundPath)
{
if ((szFile == NULL) || (szStartDir == NULL) || (szFoundPath == NULL))
{
return false;
}
char szRoot[MAX_PATH];
strcpy(szRoot, szStartDir);
Q_AppendSlash(szRoot, sizeof(szRoot));
char szTemp[MAX_PATH];
do
{
strcpy(szTemp, szRoot);
strcat(szTemp, szFile);
if (!_access(szTemp, 0))
{
strcpy(szFoundPath, szRoot);
Q_StripTrailingSlash(szFoundPath);
return true;
}
} while (Q_StripLastDir(szRoot, sizeof(szRoot)));
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *szDir -
// *szSteamDir -
// *szSteamUserDir -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool FindSteamUserDir(const char *szAppDir, const char *szSteamDir, char *szSteamUserDir)
{
if ((szAppDir == NULL) || (szSteamDir == NULL) || (szSteamUserDir == NULL))
{
return false;
}
// If the szAppDir was run from within the steam tree, we should be able to find the steam user dir.
int nSteamDirLen = strlen(szSteamDir);
if (!Q_strnicmp(szAppDir, szSteamDir, nSteamDirLen ) && (szAppDir[nSteamDirLen] == '\\'))
{
strcpy(szSteamUserDir, szAppDir);
char *pszSlash = strchr(&szSteamUserDir[nSteamDirLen + 1], '\\');
if (pszSlash)
{
pszSlash++;
pszSlash = strchr(pszSlash, '\\');
if (pszSlash)
{
*pszSlash = '\0';
return true;
}
}
}
szSteamUserDir[0] = '\0';
return false;
}
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgoff.h"
//-----------------------------------------------------------------------------
// Purpose: Loads the settings from <mod dir>\gameinfo.txt into data members.
//-----------------------------------------------------------------------------
void CGameConfig::ParseGameInfo()
{
KeyValues *pkv = new KeyValues("gameinfo.txt");
if (!pkv->LoadFromFile(g_pFileSystem, "gameinfo.txt", "GAME"))
{
pkv->deleteThis();
return;
}
KeyValues *pKey = pkv->FindKey("FileSystem");
if (pKey)
{
V_strcpy_safe( m_szSteamAppID, pKey->GetString( "SteamAppId", "" ) );
}
const char *InstancePath = pkv->GetString( "InstancePath", NULL );
if ( InstancePath )
{
CMapInstance::SetInstancePath( InstancePath );
}
pkv->deleteThis();
char szAppDir[MAX_PATH];
APP()->GetDirectory(DIR_PROGRAM, szAppDir);
if (!FindFileInTree("steam.exe", szAppDir, m_szSteamDir))
{
// Couldn't find steam.exe in the hammer tree
m_szSteamDir[0] = '\0';
}
if (!FindSteamUserDir(szAppDir, m_szSteamDir, m_szSteamUserDir))
{
m_szSteamUserDir[0] = '\0';
}
}
//-----------------------------------------------------------------------------
// Accessor methods to get at the mod + the game (*not* full paths)
//-----------------------------------------------------------------------------
const char *CGameConfig::GetMod()
{
// Strip path from modDir
char szModPath[MAX_PATH];
static char szMod[MAX_PATH];
Q_strncpy( szModPath, m_szModDir, MAX_PATH );
Q_StripTrailingSlash( szModPath );
if ( !szModPath[0] )
{
Q_strcpy( szModPath, "hl2" );
}
Q_FileBase( szModPath, szMod, MAX_PATH );
return szMod;
}
const char *CGameConfig::GetGame()
{
return "hl2";
// // Strip path from modDir
// char szGamePath[MAX_PATH];
// static char szGame[MAX_PATH];
// Q_strncpy( szGamePath, m_szGameDir, MAX_PATH );
// Q_StripTrailingSlash( szGamePath );
// Q_FileBase( szGamePath, szGame, MAX_PATH );
// return szGame;
}