/* <4f169d> ../game_shared/bot/nav_file.cpp:811 */
void LoadLocationFile(const char *filename)
{
char locFilename[256];
Q_strcpy(locFilename, filename);
char *dot = Q_strchr(locFilename, '.');
if (dot)
{
Q_strcpy(dot, ".loc");
int locDataLength;
char *locDataFile = (char *)LOAD_FILE_FOR_ME(const_cast<char *>(locFilename), &locDataLength);
char *locData = locDataFile;
if (locData)
{
CONSOLE_ECHO("Loading legacy 'location file' '%s'\n", locFilename);
// read directory
locData = MP_COM_Parse(locData);
int dirSize = Q_atoi(MP_COM_GetToken());
if (dirSize)
{
std::vector<unsigned int> directory;
directory.reserve(dirSize);
for (int i = 0; i < dirSize; ++i)
{
locData = MP_COM_Parse(locData);
directory.push_back(TheBotPhrases->NameToID(MP_COM_GetToken()));
}
// read places for each nav area
unsigned int areaID, locDirIndex;
while (true)
{
locData = MP_COM_Parse(locData);
if (locData == NULL)
break;
areaID = Q_atoi(MP_COM_GetToken());
locData = MP_COM_Parse(locData);
locDirIndex = Q_atoi(MP_COM_GetToken());
CNavArea *area = TheNavAreaGrid.GetNavAreaByID(areaID);
unsigned int place = (locDirIndex > 0) ? directory[locDirIndex - 1] : UNDEFINED_PLACE;
if (area)
area->SetPlace(place);
}
}
FREE_FILE(locDataFile);
}
}
}
CHalfLifeMultiplay :: CHalfLifeMultiplay()
{
m_VoiceGameMgr.Init(&g_GameMgrHelper, gpGlobals->maxClients);
int length;
char * pFileList = (char*)LOAD_FILE_FOR_ME( "motd.txt", &length );
if ( pFileList )
g_bHaveMOTD = true;
else
g_bHaveMOTD = false;
RefreshSkillData();
m_flIntermissionEndTime = 0;
m_flGameEndTime = 0.0;
// 11/8/98
// Modified by YWB: Server .cfg file is now a cvar, so that
// server ops can run multiple game servers, with different server .cfg files,
// from a single installed directory.
// Mapcyclefile is already a cvar.
// 3/31/99
// Added lservercfg file cvar, since listen and dedicated servers should not
// share a single config file. (sjb)
if ( IS_DEDICATED_SERVER() )
{
// dedicated server
char *servercfgfile = (char *)CVAR_GET_STRING( "servercfgfile" );
if ( servercfgfile && servercfgfile[0] )
{
char szCommand[256];
ALERT( at_console, "Executing dedicated server config file\n" );
sprintf( szCommand, "exec %s\n", servercfgfile );
SERVER_COMMAND( szCommand );
}
}
else
{
// listen server
char *lservercfgfile = (char *)CVAR_GET_STRING( "lservercfgfile" );
if ( lservercfgfile && lservercfgfile[0] )
{
char szCommand[256];
ALERT( at_console, "Executing listen server config file\n" );
sprintf( szCommand, "exec %s\n", lservercfgfile );
SERVER_COMMAND( szCommand );
}
}
}
void GetMapNamesFromMapCycle(StringList& outMapNameList)
{
char* mapcfile = (char*)CVAR_GET_STRING( "mapcyclefile" );
ASSERT( mapcfile != NULL );
char szBuffer[ MAX_RULE_BUFFER ];
char szMap[ 32 ];
int length;
char *pFileList;
char *aFileList = pFileList = (char*)LOAD_FILE_FOR_ME( mapcfile, &length );
int hasbuffer;
mapcycle_item_s *newlist = NULL;
if ( pFileList && length )
{
// the first map name in the file becomes the default
while ( 1 )
{
hasbuffer = 0;
memset( szBuffer, 0, MAX_RULE_BUFFER );
pFileList = COM_Parse( pFileList );
if ( strlen( com_token ) <= 0 )
break;
strcpy( szMap, com_token );
// Any more tokens on this line?
if ( COM_TokenWaiting( pFileList ) )
{
pFileList = COM_Parse( pFileList );
if ( strlen( com_token ) > 0 )
{
hasbuffer = 1;
strcpy( szBuffer, com_token );
}
}
// Check map
if ( IS_MAP_VALID( szMap ) )
{
outMapNameList.push_back( szMap );
}
}
FREE_FILE( aFileList );
}
}
void CHalfLifeMultiplay :: SendMOTDToClient( edict_t *client )
{
// read from the MOTD.txt file
int length, char_count = 0;
char *pFileList;
char *aFileList = pFileList = (char*)LOAD_FILE_FOR_ME( (char *)CVAR_GET_STRING( "motdfile" ), &length );
// send the server name
MESSAGE_BEGIN( MSG_ONE, gmsgServerName, nullptr, client );
WRITE_STRING( CVAR_GET_STRING("hostname") );
MESSAGE_END();
// Send the message of the day
// read it chunk-by-chunk, and send it in parts
while ( pFileList && *pFileList && char_count < MAX_MOTD_LENGTH )
{
char chunk[MAX_MOTD_CHUNK+1];
if ( strlen( pFileList ) < MAX_MOTD_CHUNK )
{
strcpy( chunk, pFileList );
}
else
{
strncpy( chunk, pFileList, MAX_MOTD_CHUNK );
chunk[MAX_MOTD_CHUNK] = 0; // strncpy doesn't always append the null terminator
}
char_count += strlen( chunk );
if ( char_count < MAX_MOTD_LENGTH )
pFileList = aFileList + char_count;
else
*pFileList = 0;
MESSAGE_BEGIN( MSG_ONE, gmsgMOTD, nullptr, client );
WRITE_BYTE( *pFileList ? FALSE : TRUE ); // FALSE means there is still more message to come
WRITE_STRING( chunk );
MESSAGE_END();
}
FREE_FILE( aFileList );
}
void CHalfLifeMultiplay :: SendMOTDToClient( edict_t *client )
{
// read from the MOTD.txt file
int length, char_count = 0;
char *pFileList;
char *aFileList = pFileList = (char*)LOAD_FILE_FOR_ME( (char *)CVAR_GET_STRING( "motdfile" ), &length );
// send the server name
NetMsg_ServerName( &client->v, string( CVAR_GET_STRING( "hostname" ) ) );
// Send the message of the day
// read it chunk-by-chunk, and send it in parts
while ( pFileList && *pFileList && char_count < MAX_MOTD_LENGTH )
{
char chunk[MAX_MOTD_CHUNK+1];
if ( strlen( pFileList ) < MAX_MOTD_CHUNK )
{
strcpy( chunk, pFileList );
}
else
{
strncpy( chunk, pFileList, MAX_MOTD_CHUNK );
chunk[MAX_MOTD_CHUNK] = 0; // strncpy doesn't always append the null terminator
}
char_count += strlen( chunk );
if ( char_count < MAX_MOTD_LENGTH )
pFileList = aFileList + char_count;
else
*pFileList = 0;
NetMsg_MOTD( &client->v, *pFileList ? false : true, string( chunk ) );
}
FREE_FILE( aFileList );
}
// Load the bot profile database
void BotProfileManager::Init(const char *filename, unsigned int *checksum)
{
static const char *BotDifficultyName[] = { "EASY", "NORMAL", "HARD", "EXPERT", nullptr };
int dataLength;
char *dataPointer = (char *)LOAD_FILE_FOR_ME(const_cast<char *>(filename), &dataLength);
char *dataFile = dataPointer;
if (!dataFile)
{
if (AreBotsAllowed())
{
CONSOLE_ECHO("WARNING: Cannot access bot profile database '%s'\n", filename);
}
return;
}
// compute simple checksum
if (checksum)
{
*checksum = ComputeSimpleChecksum((const unsigned char *)dataPointer, dataLength);
}
// keep list of templates used for inheritance
BotProfileList templateList;
BotProfile defaultProfile;
// Parse the BotProfile.db into BotProfile instances
while (true)
{
dataFile = SharedParse(dataFile);
if (!dataFile)
break;
char *token = SharedGetToken();
bool isDefault = (!Q_stricmp(token, "Default"));
bool isTemplate = (!Q_stricmp(token, "Template"));
bool isCustomSkin = (!Q_stricmp(token, "Skin"));
if (isCustomSkin)
{
const int BufLen = 64;
char skinName[BufLen];
// get skin name
dataFile = SharedParse(dataFile);
if (!dataFile)
{
CONSOLE_ECHO("Error parsing %s - expected skin name\n", filename);
FREE_FILE(dataPointer);
return;
}
token = SharedGetToken();
Q_snprintf(skinName, BufLen, "%s", token);
// get attribute name
dataFile = SharedParse(dataFile);
if (!dataFile)
{
CONSOLE_ECHO("Error parsing %s - expected 'Model'\n", filename);
FREE_FILE(dataPointer);
return;
}
token = SharedGetToken();
if (Q_stricmp(token, "Model") != 0)
{
CONSOLE_ECHO("Error parsing %s - expected 'Model'\n", filename);
FREE_FILE(dataPointer);
return;
}
// eat '='
dataFile = SharedParse(dataFile);
if (!dataFile)
{
CONSOLE_ECHO("Error parsing %s - expected '='\n", filename);
FREE_FILE(dataPointer);
return;
}
token = SharedGetToken();
if (Q_strcmp(token, "=") != 0)
{
CONSOLE_ECHO("Error parsing %s - expected '='\n", filename);
FREE_FILE(dataPointer);
return;
}
// get attribute value
dataFile = SharedParse(dataFile);
if (!dataFile)
{
CONSOLE_ECHO("Error parsing %s - expected attribute value\n", filename);
FREE_FILE(dataPointer);
return;
}
token = SharedGetToken();
const char *decoratedName = GetDecoratedSkinName(skinName, filename);
bool skinExists = GetCustomSkinIndex(decoratedName) > 0;
if (m_nextSkin < NumCustomSkins && !skinExists)
{
// decorate the name
m_skins[m_nextSkin] = CloneString(decoratedName);
// construct the model filename
m_skinModelnames[m_nextSkin] = CloneString(token);
m_skinFilenames[m_nextSkin] = new char[Q_strlen(token) * 2 + Q_strlen("models/player//.mdl") + 1];
Q_sprintf(m_skinFilenames[m_nextSkin], "models/player/%s/%s.mdl", token, token);
m_nextSkin++;
}
// eat 'End'
dataFile = SharedParse(dataFile);
if (!dataFile)
{
CONSOLE_ECHO("Error parsing %s - expected 'End'\n", filename);
FREE_FILE(dataPointer);
return;
}
token = SharedGetToken();
if (Q_strcmp(token, "End") != 0)
{
CONSOLE_ECHO("Error parsing %s - expected 'End'\n", filename);
FREE_FILE(dataPointer);
return;
}
// it's just a custom skin - no need to do inheritance on a bot profile, etc.
continue;
}
// encountered a new profile
BotProfile *profile;
if (isDefault)
{
profile = &defaultProfile;
}
else
{
profile = new BotProfile;
// always inherit from Default
*profile = defaultProfile;
}
// do inheritance in order of appearance
if (!isTemplate && !isDefault)
{
const BotProfile *inherit = nullptr;
// template names are separated by "+"
while (true)
{
char *c = Q_strchr(token, '+');
if (c)
*c = '\0';
// find the given template name
for (auto templates : templateList)
{
if (!Q_stricmp(templates->GetName(), token))
{
inherit = templates;
break;
}
}
if (!inherit)
{
CONSOLE_ECHO("Error parsing '%s' - invalid template reference '%s'\n", filename, token);
FREE_FILE(dataPointer);
return;
}
// inherit the data
profile->Inherit(inherit, &defaultProfile);
if (c == nullptr)
break;
token = c + 1;
}
}
// get name of this profile
if (!isDefault)
{
dataFile = SharedParse(dataFile);
if (!dataFile)
{
CONSOLE_ECHO("Error parsing '%s' - expected name\n", filename);
FREE_FILE(dataPointer);
return;
}
profile->m_name = CloneString(SharedGetToken());
#ifdef REGAMEDLL_FIXES
if (RANDOM_LONG(0, 2) == 2)
#else
// HACK HACK
// Until we have a generalized means of storing bot preferences, we're going to hardcode the bot's
// preference towards silencers based on his name.
if (profile->m_name[0] % 2)
#endif
{
profile->m_prefersSilencer = true;
}
}
// read attributes for this profile
bool isFirstWeaponPref = true;
while (true)
{
// get next token
dataFile = SharedParse(dataFile);
if (!dataFile)
{
CONSOLE_ECHO("Error parsing %s - expected 'End'\n", filename);
FREE_FILE(dataPointer);
return;
}
token = SharedGetToken();
// check for End delimiter
if (!Q_stricmp(token, "End"))
break;
// found attribute name - keep it
char attributeName[64];
Q_strcpy(attributeName, token);
// eat '='
dataFile = SharedParse(dataFile);
if (!dataFile)
{
CONSOLE_ECHO("Error parsing %s - expected '='\n", filename);
FREE_FILE(dataPointer);
return;
}
token = SharedGetToken();
if (Q_strcmp(token, "=") != 0)
{
CONSOLE_ECHO("Error parsing %s - expected '='\n", filename);
FREE_FILE(dataPointer);
return;
}
// get attribute value
dataFile = SharedParse(dataFile);
if (!dataFile)
{
CONSOLE_ECHO("Error parsing %s - expected attribute value\n", filename);
FREE_FILE(dataPointer);
return;
}
token = SharedGetToken();
// store value in appropriate attribute
if (!Q_stricmp("Aggression", attributeName))
{
profile->m_aggression = Q_atof(token) / 100.0f;
}
else if (!Q_stricmp("Skill", attributeName))
{
profile->m_skill = Q_atof(token) / 100.0f;
}
else if (!Q_stricmp("Skin", attributeName))
{
profile->m_skin = Q_atoi(token);
if (profile->m_skin == 0)
{
// Q_atoi() failed - try to look up a custom skin by name
profile->m_skin = GetCustomSkinIndex(token, filename);
}
}
else if (!Q_stricmp("Teamwork", attributeName))
{
profile->m_teamwork = Q_atof(token) / 100.0f;
}
else if (!Q_stricmp("Cost", attributeName))
{
profile->m_cost = Q_atoi(token);
}
else if (!Q_stricmp("VoicePitch", attributeName))
{
profile->m_voicePitch = Q_atoi(token);
}
else if (!Q_stricmp("VoiceBank", attributeName))
{
profile->m_voiceBank = FindVoiceBankIndex(token);
}
else if (!Q_stricmp("WeaponPreference", attributeName))
{
// weapon preferences override parent prefs
if (isFirstWeaponPref)
{
isFirstWeaponPref = false;
profile->m_weaponPreferenceCount = 0;
}
if (!Q_stricmp(token, "none"))
{
profile->m_weaponPreferenceCount = 0;
}
else
{
if (profile->m_weaponPreferenceCount < BotProfile::MAX_WEAPON_PREFS)
{
profile->m_weaponPreference[profile->m_weaponPreferenceCount++] = AliasToWeaponID(token);
}
}
}
else if (!Q_stricmp("ReactionTime", attributeName))
{
profile->m_reactionTime = Q_atof(token);
#ifndef GAMEUI_EXPORTS
// subtract off latency due to "think" update rate.
// In GameUI, we don't really care.
profile->m_reactionTime -= g_flBotFullThinkInterval;
#endif
}
else if (!Q_stricmp("AttackDelay", attributeName))
{
profile->m_attackDelay = Q_atof(token);
}
else if (!Q_stricmp("Difficulty", attributeName))
{
// override inheritance
profile->m_difficultyFlags = 0;
// parse bit flags
while (true)
{
char *c = Q_strchr(token, '+');
if (c)
*c = '\0';
for (int i = 0; i < NUM_DIFFICULTY_LEVELS; i++)
{
if (!Q_stricmp(BotDifficultyName[i], token))
profile->m_difficultyFlags |= (1<<i);
}
if (c == nullptr)
break;
token = c + 1;
}
}
else if (!Q_stricmp("Team", attributeName))
{
if (!Q_stricmp(token, "T"))
{
profile->m_teams = BOT_TEAM_T;
}
else if (!Q_stricmp(token, "CT"))
{
profile->m_teams = BOT_TEAM_CT;
}
else
{
profile->m_teams = BOT_TEAM_ANY;
}
}
else
{
CONSOLE_ECHO("Error parsing %s - unknown attribute '%s'\n", filename, attributeName);
}
}
if (!isDefault)
{
if (isTemplate)
{
// add to template list
templateList.push_back(profile);
}
else
{
// add profile to the master list
m_profileList.push_back(profile);
}
}
}
FREE_FILE(dataPointer);
// free the templates
for (auto templates : templateList)
delete templates;
templateList.clear();
}
/*
==============
ReloadMapCycleFile
Parses mapcycle.txt file into mapcycle_t structure
==============
*/
int ReloadMapCycleFile( char *filename, mapcycle_t *cycle )
{
char szBuffer[ MAX_RULE_BUFFER ];
char szMap[ 32 ];
int length;
char *pFileList;
char *aFileList = pFileList = (char*)LOAD_FILE_FOR_ME( filename, &length );
int hasbuffer;
mapcycle_item_s *item, *newlist = NULL, *next;
if ( pFileList && length )
{
// the first map name in the file becomes the default
while ( 1 )
{
hasbuffer = 0;
memset( szBuffer, 0, MAX_RULE_BUFFER );
pFileList = COM_Parse( pFileList );
if ( strlen( com_token ) <= 0 )
break;
strcpy( szMap, com_token );
// Any more tokens on this line?
if ( COM_TokenWaiting( pFileList ) )
{
pFileList = COM_Parse( pFileList );
if ( strlen( com_token ) > 0 )
{
hasbuffer = 1;
strcpy( szBuffer, com_token );
}
}
// Check map
if ( IS_MAP_VALID( szMap ) )
{
// Create entry
char *s;
item = new mapcycle_item_s;
strcpy( item->mapname, szMap );
item->minplayers = 0;
item->maxplayers = 0;
memset( item->rulebuffer, 0, MAX_RULE_BUFFER );
if ( hasbuffer )
{
s = g_engfuncs.pfnInfoKeyValue( szBuffer, "minplayers" );
if ( s && s[0] )
{
item->minplayers = atoi( s );
item->minplayers = max( item->minplayers, 0 );
item->minplayers = min( item->minplayers, gpGlobals->maxClients );
}
s = g_engfuncs.pfnInfoKeyValue( szBuffer, "maxplayers" );
if ( s && s[0] )
{
item->maxplayers = atoi( s );
item->maxplayers = max( item->maxplayers, 0 );
item->maxplayers = min( item->maxplayers, gpGlobals->maxClients );
}
// Remove keys
//
g_engfuncs.pfnInfo_RemoveKey( szBuffer, "minplayers" );
g_engfuncs.pfnInfo_RemoveKey( szBuffer, "maxplayers" );
strcpy( item->rulebuffer, szBuffer );
}
item->next = cycle->items;
cycle->items = item;
}
else
{
ALERT( at_console, "Skipping %s from mapcycle, not a valid map\n", szMap );
}
}
FREE_FILE( aFileList );
}
// Fixup circular list pointer
item = cycle->items;
// Reverse it to get original order
while ( item )
{
next = item->next;
item->next = newlist;
newlist = item;
item = next;
}
cycle->items = newlist;
item = cycle->items;
// Didn't parse anything
if ( !item )
{
return 0;
}
while ( item->next )
{
item = item->next;
}
item->next = cycle->items;
cycle->next_item = item->next;
return 1;
}