1dot13/source
1
0
Fork 0
mirror of https://github.com/1dot13/source.git synced 2026-08-26 14:30:26 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
89671c218b35a95af90428d6d3e23b752f575c90
source/Strategic/XML_SectorNames.cpp
T
Marco Antonio J. CostamajcostaClaude Opus 5
 00fb898600 Delete builddefines.h 
Nothing was left in it but the include of profiler.h, and 132 translation units
were including it for that alone. Fifteen files were leaning on profiler.h to
drag in <set>, <vector> and <ostream> for them; those now include what they use.

This is the commit that moves line numbers. Removing an include line shifts
__LINE__ by one for everything below it, and __LINE__ is an immediate operand in
every Assert() and DebugMsg() call, so the four game executables differ from
their predecessors by roughly a thousand 32-bit constants each. Every one of
those is accounted for: each is a single immediate that moved by -1 where the
builddefines.h include went away, or +1 where a <set>/<vector> include was
added. Nothing else in .text, .rdata or .data moves, no object file's section
sizes change, and symbolize_crash and Ja2Export stay bit-identical.

The one non-immediate difference is that the 24 Editor translation units of the
non-editor apps stop emitting __Avx2WmemEnabledWeakValue, a 4-byte weak COMDAT
they only ever instantiated through profiler.h's <vector>. It is a UCRT weak
default that other translation units still provide.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-22 01:07:26 -03:00

477 lines
17 KiB
C++
Raw Blame History

#include <stdio.h>
#include "XML.h"
#include "expat.h"
#include "string.h"
#include "Campaign Types.h"
#include "FileMan.h"
#include "MemMan.h"
#include "Debug Control.h"
#include "mapscreen.h"
#define MAX_CHAR_DATA_LENGTH 500
// Four different sector names, used at different times.
extern CHAR16 gzSectorNames[256][4][MAX_SECTOR_NAME_LENGTH];
// Flugente: external sector data
extern SECTOR_EXT_DATA SectorExternalData[256][4];
// moved to lua
//extern CHAR16 gzSectorUndergroundNames1[256][4][MAX_SECTOR_NAME_LENGTH];
//extern CHAR16 gzSectorUndergroundNames2[256][4][MAX_SECTOR_NAME_LENGTH];
//extern CHAR16 gzSectorUndergroundNames3[256][4][MAX_SECTOR_NAME_LENGTH];
typedef struct
{
PARSE_STAGE curElement;
CHAR8 szCharData[MAX_CHAR_DATA_LENGTH+1];
UINT8 sCurSectorX;
UINT8 sCurSectorY;
CHAR16 szCurUnexploredName[MAX_SECTOR_NAME_LENGTH];
CHAR16 szCurDetailedUnexploredName[MAX_SECTOR_NAME_LENGTH];
CHAR16 szCurExploredName[MAX_SECTOR_NAME_LENGTH];
CHAR16 szCurDetailedExploredName[MAX_SECTOR_NAME_LENGTH];
SECTOR_EXT_DATA sectordata;
UINT8 curSupplyType;
UINT32 currentDepth;
UINT32 maxReadDepth;
} SectorNameParseData;
// for compliation reasons, this may not be a part of SectorNameParseData
std::vector<UINT16> prisonroomvector;
BOOLEAN SectorName_TextOnly;
INT8 Sector_Level;
static void XMLCALL
SectorNameStartElementHandle(void *userData, const XML_Char *name, const char **atts)
{
SectorNameParseData * pData = (SectorNameParseData *) userData;
if(pData->currentDepth <= pData->maxReadDepth) //are we reading this element?
{
if(strcmp(name, "SECTOR_NAMES") == 0 && pData->curElement == ELEMENT_NONE)
{
pData->curElement = ELEMENT_LIST;
pData->maxReadDepth++; //we are not skipping this element
// Initiate gzSectorNames Array by setting first character to 0.
for (UINT16 x = 0; x < 256; x++)
{
if (Sector_Level == 0 )
{
gzSectorNames[x][0][0]=0;
gzSectorNames[x][1][0]=0;
gzSectorNames[x][2][0]=0;
gzSectorNames[x][3][0]=0;
}
}
}
else if(strcmp(name, "SECTOR") == 0 && pData->curElement == ELEMENT_LIST)
{
pData->curElement = ELEMENT;
pData->maxReadDepth++; //we are not skipping this element
}
else if(pData->curElement == ELEMENT &&
(strcmp(name, "SectorGrid") == 0 ||
strcmp(name, "szUnexploredName") == 0 ||
strcmp(name, "szDetailedUnexploredName") == 0 ||
strcmp(name, "szExploredName") == 0 ||
strcmp(name, "szDetailedExploredName") == 0 ||
strcmp(name, "sWaterType") == 0 ||
strcmp(name, "usNaturalDirt") == 0 ||
strcmp(name, "usCurfewValue") == 0 ||
strcmp(name, "sRadioScanModifier") == 0 ||
strcmp(name, "usPrisonRoomNumber" ) == 0 ||
strcmp(name, "usCivilianPopulation" ) == 0 ||
strcmp(name, "rainchance" ) == 0 ||
strcmp(name, "sandstormchance") == 0 ||
strcmp(name, "snowchance" ) == 0 ||
strcmp(name, "snakechance" ) == 0 ||
strcmp(name, "numsnakes" ) == 0 ||
strcmp(name, "maxworkers" ) == 0 ||
strcmp(name, "wealth" ) == 0 ||
strcmp(name, "bloodcatraidpossible" ) == 0 ||
strcmp(name, "zombieraidpossible" ) == 0 ||
strcmp(name, "banditraidpossible" ) == 0 ))
{
pData->curElement = ELEMENT_PROPERTY;
pData->maxReadDepth++; //we are not skipping this element
}
pData->szCharData[0] = '\0';
}
pData->currentDepth++;
}
static void XMLCALL
SectorNameCharacterDataHandle(void *userData, const XML_Char *str, int len)
{
SectorNameParseData * pData = (SectorNameParseData *) userData;
if(pData->currentDepth <= pData->maxReadDepth && strlen(pData->szCharData) < MAX_CHAR_DATA_LENGTH)
strncat(pData->szCharData,str,__min((unsigned int)len,MAX_CHAR_DATA_LENGTH-strlen(pData->szCharData)));
}
static void XMLCALL
SectorNameEndElementHandle(void *userData, const XML_Char *name)
{
SectorNameParseData * pData = (SectorNameParseData *)userData;
if(pData->currentDepth <= pData->maxReadDepth) //we're at the end of an element that we've been reading
{
if(strcmp(name, "SECTOR_NAMES") == 0)
{
pData->curElement = ELEMENT_NONE;
}
else if(strcmp(name, "SECTOR") == 0)
{
pData->curElement = ELEMENT_LIST;
UINT8 ubSectorId = SECTOR(pData->sCurSectorX, pData->sCurSectorY);
if (ubSectorId >= 0 && ubSectorId < 256)
{
if (!SectorName_TextOnly)
{
if (Sector_Level == 0 )
{
wcscpy(gzSectorNames[ubSectorId][0], pData->szCurUnexploredName);
wcscpy(gzSectorNames[ubSectorId][1], pData->szCurDetailedUnexploredName);
wcscpy(gzSectorNames[ubSectorId][2], pData->szCurExploredName);
wcscpy(gzSectorNames[ubSectorId][3], pData->szCurDetailedExploredName);
}
// moved to lua
//else if (Sector_Level == 1 )
//{
// wcscpy(gzSectorUndergroundNames1[ubSectorId][0], pData->szCurUnexploredName);
// wcscpy(gzSectorUndergroundNames1[ubSectorId][1], pData->szCurDetailedUnexploredName);
// wcscpy(gzSectorUndergroundNames1[ubSectorId][2], pData->szCurExploredName);
// wcscpy(gzSectorUndergroundNames1[ubSectorId][3], pData->szCurDetailedExploredName);
//}
//else if (Sector_Level == 2 )
//{
// wcscpy(gzSectorUndergroundNames2[ubSectorId][0], pData->szCurUnexploredName);
// wcscpy(gzSectorUndergroundNames2[ubSectorId][1], pData->szCurDetailedUnexploredName);
// wcscpy(gzSectorUndergroundNames2[ubSectorId][2], pData->szCurExploredName);
// wcscpy(gzSectorUndergroundNames2[ubSectorId][3], pData->szCurDetailedExploredName);
//}
//else if (Sector_Level == 3 )
//{
// wcscpy(gzSectorUndergroundNames3[ubSectorId][0], pData->szCurUnexploredName);
// wcscpy(gzSectorUndergroundNames3[ubSectorId][1], pData->szCurDetailedUnexploredName);
// wcscpy(gzSectorUndergroundNames3[ubSectorId][2], pData->szCurExploredName);
// wcscpy(gzSectorUndergroundNames3[ubSectorId][3], pData->szCurDetailedExploredName);
//}
SectorExternalData[ubSectorId][0].usWaterType = pData->sectordata.usWaterType;
SectorExternalData[ubSectorId][1].usWaterType = pData->sectordata.usWaterType;
SectorExternalData[ubSectorId][2].usWaterType = pData->sectordata.usWaterType;
SectorExternalData[ubSectorId][3].usWaterType = pData->sectordata.usWaterType;
SectorExternalData[ubSectorId][0].usNaturalDirt = pData->sectordata.usNaturalDirt;
SectorExternalData[ubSectorId][1].usNaturalDirt = pData->sectordata.usNaturalDirt;
SectorExternalData[ubSectorId][2].usNaturalDirt = pData->sectordata.usNaturalDirt;
SectorExternalData[ubSectorId][3].usNaturalDirt = pData->sectordata.usNaturalDirt;
SectorExternalData[ubSectorId][0].usCurfewValue = pData->sectordata.usCurfewValue;
SectorExternalData[ubSectorId][1].usCurfewValue = pData->sectordata.usCurfewValue;
SectorExternalData[ubSectorId][2].usCurfewValue = pData->sectordata.usCurfewValue;
SectorExternalData[ubSectorId][3].usCurfewValue = pData->sectordata.usCurfewValue;
INT8 radioscanmod = max( -3, pData->sectordata.sRadioScanModifier );
radioscanmod = min( 3, pData->sectordata.sRadioScanModifier );
SectorExternalData[ubSectorId][0].sRadioScanModifier = radioscanmod;
SectorExternalData[ubSectorId][1].sRadioScanModifier = radioscanmod;
SectorExternalData[ubSectorId][2].sRadioScanModifier = radioscanmod;
SectorExternalData[ubSectorId][3].sRadioScanModifier = radioscanmod;
SectorExternalData[ubSectorId][0].usCivilianPopulation = pData->sectordata.usCivilianPopulation;
SectorExternalData[ubSectorId][1].usCivilianPopulation = pData->sectordata.usCivilianPopulation;
SectorExternalData[ubSectorId][2].usCivilianPopulation = pData->sectordata.usCivilianPopulation;
SectorExternalData[ubSectorId][3].usCivilianPopulation = pData->sectordata.usCivilianPopulation;
SectorExternalData[ubSectorId][0].rainchance = pData->sectordata.rainchance;
SectorExternalData[ubSectorId][1].rainchance = 0;
SectorExternalData[ubSectorId][2].rainchance = 0;
SectorExternalData[ubSectorId][3].rainchance = 0;
SectorExternalData[ubSectorId][0].sandstormchance = pData->sectordata.sandstormchance;
SectorExternalData[ubSectorId][1].sandstormchance = 0;
SectorExternalData[ubSectorId][2].sandstormchance = 0;
SectorExternalData[ubSectorId][3].sandstormchance = 0;
SectorExternalData[ubSectorId][0].snowchance = pData->sectordata.snowchance;
SectorExternalData[ubSectorId][1].snowchance = 0;
SectorExternalData[ubSectorId][2].snowchance = 0;
SectorExternalData[ubSectorId][3].snowchance = 0;
SectorExternalData[ubSectorId][0].snakechance = pData->sectordata.snakechance;
SectorExternalData[ubSectorId][1].snakechance = 0;
SectorExternalData[ubSectorId][2].snakechance = 0;
SectorExternalData[ubSectorId][3].snakechance = 0;
SectorExternalData[ubSectorId][0].numsnakes = pData->sectordata.numsnakes;
SectorExternalData[ubSectorId][1].numsnakes = 0;
SectorExternalData[ubSectorId][2].numsnakes = 0;
SectorExternalData[ubSectorId][3].numsnakes = 0;
SectorExternalData[ubSectorId][0].maxworkers = pData->sectordata.maxworkers;
SectorExternalData[ubSectorId][1].maxworkers = 0;
SectorExternalData[ubSectorId][2].maxworkers = 0;
SectorExternalData[ubSectorId][3].maxworkers = 0;
SectorExternalData[ubSectorId][0].wealth = pData->sectordata.wealth;
SectorExternalData[ubSectorId][1].wealth = 0;
SectorExternalData[ubSectorId][2].wealth = 0;
SectorExternalData[ubSectorId][3].wealth = 0;
SectorExternalData[ubSectorId][0].usSectorFlagMask = pData->sectordata.usSectorFlagMask;
SectorExternalData[ubSectorId][1].usSectorFlagMask = 0;
SectorExternalData[ubSectorId][2].usSectorFlagMask = 0;
SectorExternalData[ubSectorId][3].usSectorFlagMask = 0;
if ( !prisonroomvector.empty( ) )
{
std::vector<UINT16>::iterator itend = prisonroomvector.end( );
std::vector<UINT16>::iterator it = prisonroomvector.begin( );
for ( ; it != itend; ++it )
{
SectorExternalData[ubSectorId][0].prisonroomvector.push_back( (*it) );
}
}
prisonroomvector.clear( );
// clean up values afterwards
pData->sectordata.usWaterType = 0;
pData->sectordata.usNaturalDirt = 100;
pData->sectordata.usCurfewValue = 0;
pData->sectordata.sRadioScanModifier = 0;
pData->sectordata.usCivilianPopulation = 0;
pData->sectordata.rainchance = 0;
pData->sectordata.sandstormchance = 0;
pData->sectordata.snowchance = 0;
pData->sectordata.snakechance = 0;
pData->sectordata.numsnakes = 0;
pData->sectordata.maxworkers = 0;
pData->sectordata.wealth = 0;
pData->sectordata.usSectorFlagMask = 0;
}
else
{
if (Sector_Level == 0 )
{
wcscpy(gzSectorNames[ubSectorId][0], pData->szCurUnexploredName);
wcscpy(gzSectorNames[ubSectorId][1], pData->szCurDetailedUnexploredName);
wcscpy(gzSectorNames[ubSectorId][2], pData->szCurExploredName);
wcscpy(gzSectorNames[ubSectorId][3], pData->szCurDetailedExploredName);
}
}
}
}
else if(strcmp(name, "SectorGrid") == 0 )
{
UINT8 x, y;
pData->curElement = ELEMENT;
y = (UINT8)pData->szCharData[0] & 0x1F;
x = (UINT8)atol(&pData->szCharData[1]);
if ( x > 0 && x <= 16 && y > 0 && y <= 16 )
{
pData->sCurSectorX = x;
pData->sCurSectorY = y;
}
}
else if(strcmp(name, "szUnexploredName") == 0 )
{
pData->curElement = ELEMENT;
MultiByteToWideChar( CP_UTF8, 0, pData->szCharData, -1, pData->szCurUnexploredName, sizeof(pData->szCurUnexploredName)/sizeof(pData->szCurUnexploredName[0]) );
pData->szCurUnexploredName[sizeof(pData->szCurUnexploredName)/sizeof(pData->szCurUnexploredName[0]) - 1] = '\0';
}
else if(strcmp(name, "szDetailedUnexploredName") == 0 )
{
pData->curElement = ELEMENT;
MultiByteToWideChar( CP_UTF8, 0, pData->szCharData, -1, pData->szCurDetailedUnexploredName, sizeof(pData->szCurDetailedUnexploredName)/sizeof(pData->szCurDetailedUnexploredName[0]) );
pData->szCurDetailedUnexploredName[sizeof(pData->szCurDetailedUnexploredName)/sizeof(pData->szCurDetailedUnexploredName[0]) - 1] = '\0';
}
else if(strcmp(name, "szExploredName") == 0 )
{
pData->curElement = ELEMENT;
MultiByteToWideChar( CP_UTF8, 0, pData->szCharData, -1, pData->szCurExploredName, sizeof(pData->szCurExploredName)/sizeof(pData->szCurExploredName[0]) );
pData->szCurExploredName[sizeof(pData->szCurExploredName)/sizeof(pData->szCurExploredName[0]) - 1] = '\0';
}
else if(strcmp(name, "szDetailedExploredName") == 0 )
{
pData->curElement = ELEMENT;
MultiByteToWideChar( CP_UTF8, 0, pData->szCharData, -1, pData->szCurDetailedExploredName, sizeof(pData->szCurDetailedExploredName)/sizeof(pData->szCurDetailedExploredName[0]) );
pData->szCurDetailedExploredName[sizeof(pData->szCurDetailedExploredName)/sizeof(pData->szCurDetailedExploredName[0]) - 1] = '\0';
}
else if(strcmp(name, "sWaterType") == 0)
{
pData->curElement = ELEMENT;
pData->sectordata.usWaterType = (UINT8)atol( pData->szCharData );
}
else if(strcmp(name, "usNaturalDirt") == 0)
{
pData->curElement = ELEMENT;
pData->sectordata.usNaturalDirt = (UINT16)atoi( pData->szCharData );
}
else if(strcmp(name, "usCurfewValue") == 0)
{
pData->curElement = ELEMENT;
pData->sectordata.usCurfewValue = (UINT8)atoi( pData->szCharData );
}
else if(strcmp(name, "sRadioScanModifier") == 0)
{
pData->curElement = ELEMENT;
pData->sectordata.sRadioScanModifier = (INT8)atoi( pData->szCharData );
}
else if ( strcmp( name, "usPrisonRoomNumber" ) == 0 )
{
pData->curElement = ELEMENT;
UINT16 room = (UINT16)atoi( pData->szCharData );
if ( room )
prisonroomvector.push_back( room );
}
else if(strcmp(name, "usCivilianPopulation") == 0)
{
pData->curElement = ELEMENT;
pData->sectordata.usCivilianPopulation = (UINT16)atoi( pData->szCharData );
}
else if ( strcmp( name, "rainchance" ) == 0 )
{
pData->curElement = ELEMENT;
pData->sectordata.rainchance = min( 100, (UINT8)atoi( pData->szCharData ) );
}
else if ( strcmp( name, "sandstormchance" ) == 0 )
{
pData->curElement = ELEMENT;
pData->sectordata.sandstormchance = min( 100, (UINT8)atoi( pData->szCharData ) );
}
else if ( strcmp( name, "snowchance" ) == 0 )
{
pData->curElement = ELEMENT;
pData->sectordata.snowchance = min( 100, (UINT8)atoi( pData->szCharData ) );
}
else if ( strcmp( name, "snakechance" ) == 0 )
{
pData->curElement = ELEMENT;
pData->sectordata.snakechance = min( 100, (UINT8)atoi( pData->szCharData ) );
}
else if ( strcmp( name, "numsnakes" ) == 0 )
{
pData->curElement = ELEMENT;
pData->sectordata.numsnakes = min( 20, (UINT8)atoi( pData->szCharData ) );
}
else if ( strcmp( name, "maxworkers" ) == 0 )
{
pData->curElement = ELEMENT;
pData->sectordata.maxworkers = (UINT8)atoi( pData->szCharData );
}
else if ( strcmp( name, "wealth" ) == 0 )
{
pData->curElement = ELEMENT;
pData->sectordata.wealth = (UINT16)atoi( pData->szCharData );
}
else if ( strcmp( name, "bloodcatraidpossible" ) == 0 )
{
pData->curElement = ELEMENT;
if ( (UINT8)atoi( pData->szCharData ) )
pData->sectordata.usSectorFlagMask |= SECTORFLAG_RAIDPOSSIBLE_BLOODCAT;
}
else if ( strcmp( name, "zombieraidpossible" ) == 0 )
{
pData->curElement = ELEMENT;
if ( (UINT8)atoi( pData->szCharData ) )
pData->sectordata.usSectorFlagMask |= SECTORFLAG_RAIDPOSSIBLE_ZOMBIE;
}
else if ( strcmp( name, "banditraidpossible" ) == 0 )
{
pData->curElement = ELEMENT;
if ( (UINT8)atoi( pData->szCharData ) )
pData->sectordata.usSectorFlagMask |= SECTORFLAG_RAIDPOSSIBLE_BANDIT;
}
pData->maxReadDepth--;
}
pData->currentDepth--;
}
BOOLEAN ReadInSectorNames(STR fileName, BOOLEAN localizedVersion, INT8 Level )
{
HWFILE hFile;
UINT32 uiBytesRead;
UINT32 uiFSize;
CHAR8 * lpcBuffer;
XML_Parser parser = XML_ParserCreate(NULL);
SectorNameParseData pData;
Sector_Level = Level;
SectorName_TextOnly = localizedVersion;
hFile = FileOpen( fileName, FILE_ACCESS_READ, FALSE );
if ( !hFile )
return( localizedVersion );
uiFSize = FileGetSize(hFile);
lpcBuffer = (CHAR8 *) MemAlloc(uiFSize+1);
//Read in block
if ( !FileRead( hFile, lpcBuffer, uiFSize, &uiBytesRead ) )
{
MemFree(lpcBuffer);
return( FALSE );
}
lpcBuffer[uiFSize] = 0; //add a null terminator
FileClose( hFile );
XML_SetElementHandler(parser, SectorNameStartElementHandle, SectorNameEndElementHandle);
XML_SetCharacterDataHandler(parser, SectorNameCharacterDataHandle);
memset(&pData,0,sizeof(pData));
XML_SetUserData(parser, &pData);
if(!XML_Parse(parser, lpcBuffer, uiFSize, TRUE))
{
CHAR8 errorBuf[511];
sprintf(errorBuf, "XML Parser Error in SectorNames.xml: %s at line %d", XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser));
LiveMessage(errorBuf);
MemFree(lpcBuffer);
return FALSE;
}
MemFree(lpcBuffer);
XML_ParserFree(parser);
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink