1dot13/source
1
0
Fork 0
mirror of https://github.com/1dot13/source.git synced 2026-07-22 13:40:22 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
80b1af930a33c48c77582ce325552312dae32fc0
source/Strategic/XML_SectorNames.cpp
T
majcostaandGitHub 24425a82b1 More unused stuff removal (#49) 
* More unused stuff removal

delete:
- giant 'metaheaders' (JA2 All.h, Laptop All.h, etc), preferring to add #includes directly where needed
- unused ExceptionHandling and DbMan translation units
- unused WizShare.h, Bitmap.h, trle.h, video_private.h headers

* remove mentions from vc proj files too

* remove preprocessor conditionals for unused definitions

find . -iname '*.h' -o -iname '*.cpp' -exec unifdef.exe -m -UPRECOMPILED_HEADERS -UJA2_PRECOMPILED_HEADERS -UWIZ8_PRECOMPILED_HEADERS -UPRECOMPILEDHEADERS {} ';'

then manually fixed a couple files the tool errored out on

* yes, the comments too

as title
2023-01-03 15:51:48 +02:00

478 lines
17 KiB
C++
Raw Blame History

#include "builddefines.h"
#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