From c9a9acec5cf8b077228ee45f5362454eb08cb114 Mon Sep 17 00:00:00 2001 From: Wanne Date: Thu, 24 Apr 2014 18:35:30 +0000 Subject: [PATCH] Merged from revision: 7163 Externalized keys and locks to xml (by anv) - Locks (TableData/Items/Locks.xml): Originally 64 locks were kept in BinaryData/LOCKS.BIN. Now up to 255 locks can be specified in TableData/Locks.xml. If it isn't found, LOCKS.BIN will be loaded normally. - Keys (TableData/Items/Keys.xml): Originally 10 keys were hardcoded in KeyTable[]. Now up to 255 keys can be specified in TableData/Keys.xml. If it isn't found, hardcoded array will be used normally. see: http://www.bears-pit.com/board/ubbthreads.php/topics/331900.html git-svn-id: https://ja2svn.mooo.com/source/ja2/trunk/GameSource/ja2_v1.13/Build@7164 3b4a5df2-a311-0410-b5c6-a8a6f20db521 --- Editor/EditorItems.cpp | 6 +- GameVersion.h | 1 + SaveLoadGame.cpp | 19 +- Tactical/Interface Items.cpp | 3 +- Tactical/Items.cpp | 3 +- Tactical/Keys.cpp | 26 ++- Tactical/Keys.h | 9 +- Tactical/Overhead.cpp | 46 +++- Tactical/Tactical_VS2005.vcproj | 8 + Tactical/Tactical_VS2008.vcproj | 8 + Tactical/Tactical_VS2010.vcxproj | 2 + Tactical/Tactical_VS2010.vcxproj.filters | 6 + Tactical/Tactical_VS2013.vcxproj | 2 + Tactical/Tactical_VS2013.vcxproj.filters | 6 + Tactical/XML.h | 10 + Tactical/XML_Keys.cpp | 208 ++++++++++++++++++ Tactical/XML_Locks.cpp | 256 +++++++++++++++++++++++ 17 files changed, 599 insertions(+), 20 deletions(-) create mode 100644 Tactical/XML_Keys.cpp create mode 100644 Tactical/XML_Locks.cpp diff --git a/Editor/EditorItems.cpp b/Editor/EditorItems.cpp index ab696a77..77797705 100644 --- a/Editor/EditorItems.cpp +++ b/Editor/EditorItems.cpp @@ -376,12 +376,14 @@ void InitEditorItemsInfo(UINT32 uiItemType) { //Keys use a totally different method for determining for( i = 0; i < eInfo.sNumItems; i++ ) { - item = &Item[ KeyTable[ 0 ].usItem + LockTable[ i ].usKeyItem ]; + //item = &Item[ KeyTable[ 0 ].usItem + LockTable[ i ].usKeyItem ]; + item = &Item[ KeyTable[ LockTable[ i ].usKeyItem ].usItem ]; uiVideoObjectIndex = GetInterfaceGraphicForItem( item ); GetVideoObject( &hVObject, uiVideoObjectIndex ); //Store these item pointers for later when rendering selected items. - eInfo.pusItemIndex[i] = KeyTable[ 0 ].usItem + LockTable[ i ].usKeyItem; + //eInfo.pusItemIndex[i] = KeyTable[ 0 ].usItem + LockTable[ i ].usKeyItem; + eInfo.pusItemIndex[i] = KeyTable[ LockTable[ i ].usKeyItem ].usItem; SetFont(SMALLCOMPFONT); SetFontForeground( FONT_MCOLOR_WHITE ); diff --git a/GameVersion.h b/GameVersion.h index ba5302a4..d05a5b84 100644 --- a/GameVersion.h +++ b/GameVersion.h @@ -21,6 +21,7 @@ extern CHAR16 zTrackingNumber[16]; // Keeps track of the saved game version. Increment the saved game version whenever // you will invalidate the saved game file +#define MORE_LOCKS_AND_KEYS 153 // anv: externalized locks and keys to xml #define MILITIA_MOVEMENT 152 // Flugente: allow control of strategic militia movement #define SNITCH_TRAIT_EXTENDED 151 // anv: more soldier flags, remembering exposition of snitch #define CAMPAIGNSTATS 150 // Flugente: store campaign statistics diff --git a/SaveLoadGame.cpp b/SaveLoadGame.cpp index 279d58cb..2af82b8d 100644 --- a/SaveLoadGame.cpp +++ b/SaveLoadGame.cpp @@ -5006,7 +5006,7 @@ BOOLEAN LoadSavedGame( int ubSavedGameID ) - if( !LoadKeyTableFromSaveedGameFile( hFile ) ) + if( !LoadKeyTableFromSaveedGameFile( hFile, guiCurrentSaveGameVersion ) ) { DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String("LoadKeyTableFromSaveedGameFile failed" ) ); FileClose( hFile ); @@ -6541,10 +6541,21 @@ BOOLEAN LoadSoldierStructure( HWFILE hFile ) { // WANNE - BMP: Check -> We get an assert here! // Now Load the .... - FileRead( hFile, Menptr[ cnt ].pKeyRing, NUM_KEYS * sizeof( KEY_ON_RING ), &uiNumBytesRead ); - if( uiNumBytesRead != NUM_KEYS * sizeof( KEY_ON_RING ) ) + if( guiCurrentSaveGameVersion < MORE_LOCKS_AND_KEYS ) { - return(FALSE); + FileRead( hFile, Menptr[ cnt ].pKeyRing, NUM_KEYS_OLD * sizeof( KEY_ON_RING ), &uiNumBytesRead ); + if( uiNumBytesRead != NUM_KEYS_OLD * sizeof( KEY_ON_RING ) ) + { + return(FALSE); + } + } + else + { + FileRead( hFile, Menptr[ cnt ].pKeyRing, NUM_KEYS * sizeof( KEY_ON_RING ), &uiNumBytesRead ); + if( uiNumBytesRead != NUM_KEYS * sizeof( KEY_ON_RING ) ) + { + return(FALSE); + } } } diff --git a/Tactical/Interface Items.cpp b/Tactical/Interface Items.cpp index d90767e4..d55352fd 100644 --- a/Tactical/Interface Items.cpp +++ b/Tactical/Interface Items.cpp @@ -10045,7 +10045,8 @@ void RenderKeyRingPopup( BOOLEAN fFullRender ) , ITEM_BAR_WIDTH, ITEM_BAR_HEIGHT, Get16BPPColor( STATUS_BAR ), Get16BPPColor( STATUS_BAR_SHADOW ), TRUE , FRAME_BUFFER ); // set item type - gTempObject.usItem = FIRST_KEY + LockTable[ gpItemPopupSoldier->pKeyRing[ cnt].ubKeyID ].usKeyItem; + //gTempObject.usItem = FIRST_KEY + LockTable[ gpItemPopupSoldier->pKeyRing[ cnt].ubKeyID ].usKeyItem; + gTempObject.usItem = KeyTable[ LockTable[gpItemPopupSoldier->pKeyRing[cnt].ubKeyID].usKeyItem ].usItem; // render the item INVRenderItem( FRAME_BUFFER, NULL, &gTempObject, (INT16)(gsKeyRingPopupInvX + sOffSetX +( cnt % sKeyRingItemWidth * usWidth ) + 8), ( INT16 )( gsKeyRingPopupInvY + sOffSetY + ( cnt / sKeyRingItemWidth * usHeight ) ), diff --git a/Tactical/Items.cpp b/Tactical/Items.cpp index 23c27fdf..0941e270 100644 --- a/Tactical/Items.cpp +++ b/Tactical/Items.cpp @@ -7270,7 +7270,8 @@ BOOLEAN CreateKeyObject( OBJECTTYPE * pObj , UINT8 ubNumberOfKeys, UINT8 ubKeyID BOOLEAN fRet; pObj->initialize(); - fRet = CreateItems( (UINT16) (FIRST_KEY + LockTable[ ubKeyID ].usKeyItem), 100, ubNumberOfKeys, pObj ); + //fRet = CreateItems( (UINT16) (FIRST_KEY + LockTable[ ubKeyID ].usKeyItem), 100, ubNumberOfKeys, pObj ); + fRet = CreateItems( (UINT16) (KeyTable[LockTable[ ubKeyID ].usKeyItem].usItem), 100, ubNumberOfKeys, pObj ); if (fRet) { (*pObj)[0]->data.key.ubKeyID = ubKeyID; diff --git a/Tactical/Keys.cpp b/Tactical/Keys.cpp index 384d043c..a41b24dc 100644 --- a/Tactical/Keys.cpp +++ b/Tactical/Keys.cpp @@ -41,6 +41,7 @@ #include "GameSettings.h" // added by SANDRO #endif +#include "GameVersion.h" DOOR_STATUS *gpDoorStatus = NULL; UINT8 gubNumDoorStatus=0; @@ -137,7 +138,7 @@ BOOLEAN LoadLockTable( void ) return(FALSE); } - uiBytesToRead = sizeof( LOCK ) * NUM_LOCKS; + uiBytesToRead = sizeof( LOCK ) * NUM_LOCKS_OLD; FileRead( hFile, LockTable, uiBytesToRead, &uiNumBytesRead ); FileClose( hFile ); @@ -2040,16 +2041,27 @@ BOOLEAN SaveKeyTableToSaveGameFile( HWFILE hFile ) return( TRUE ); } -BOOLEAN LoadKeyTableFromSaveedGameFile( HWFILE hFile ) +BOOLEAN LoadKeyTableFromSaveedGameFile( HWFILE hFile, UINT32 uiSaveGameVersion ) { UINT32 uiNumBytesRead=0; - - // Load the KeyTable - FileRead( hFile, KeyTable, sizeof( KEY ) * NUM_KEYS, &uiNumBytesRead ); - if( uiNumBytesRead != sizeof( KEY ) * NUM_KEYS ) + if( uiSaveGameVersion < MORE_LOCKS_AND_KEYS ) { - return( FALSE ); + // Load the KeyTable + FileRead( hFile, KeyTable, sizeof( KEY ) * NUM_KEYS_OLD, &uiNumBytesRead ); + if( uiNumBytesRead != sizeof( KEY ) * NUM_KEYS_OLD ) + { + return( FALSE ); + } + } + else + { + // Load the KeyTable + FileRead( hFile, KeyTable, sizeof( KEY ) * NUM_KEYS, &uiNumBytesRead ); + if( uiNumBytesRead != sizeof( KEY ) * NUM_KEYS ) + { + return( FALSE ); + } } return( TRUE ); diff --git a/Tactical/Keys.h b/Tactical/Keys.h index 26328e0d..8937d292 100644 --- a/Tactical/Keys.h +++ b/Tactical/Keys.h @@ -145,8 +145,11 @@ typedef struct // This is the number of different types of doors we can have // in one map at a time... -#define NUM_KEYS 64 -#define NUM_LOCKS 64 +#define NUM_KEYS 255 +#define NUM_KEYS_OLD 64 // anv: increased max number, kept old so correct number can be read from save files + +#define NUM_LOCKS 255 +#define NUM_LOCKS_OLD 64 // anv: increased max number, kept old so correct number can be read from LOCKS.BIN #define INVALID_KEY_NUMBER 255 #define ANYKEY 252 @@ -253,7 +256,7 @@ BOOLEAN SetDoorPerceivedOpenStatus( INT32 sGridNo, BOOLEAN fPerceivedOpen ); BOOLEAN SaveKeyTableToSaveGameFile( HWFILE hFile ); //Load the key table from the saved game file -BOOLEAN LoadKeyTableFromSaveedGameFile( HWFILE hFile ); +BOOLEAN LoadKeyTableFromSaveedGameFile( HWFILE hFile, UINT32 uiSaveGameVersion ); // Returns a doors status value, NULL if not found DOOR_STATUS *GetDoorStatus( INT32 sGridNo ); diff --git a/Tactical/Overhead.cpp b/Tactical/Overhead.cpp index 1e3daae0..a3200ce0 100644 --- a/Tactical/Overhead.cpp +++ b/Tactical/Overhead.cpp @@ -132,6 +132,8 @@ #include "mercs.h" #endif +#include "XML.h" + // OJW - 20090419 UINT8 giMAXIMUM_NUMBER_OF_PLAYER_MERCS = CODE_MAXIMUM_NUMBER_OF_PLAYER_MERCS; UINT8 giMAXIMUM_NUMBER_OF_PLAYER_VEHICLES = CODE_MAXIMUM_NUMBER_OF_PLAYER_VEHICLES; @@ -571,8 +573,48 @@ BOOLEAN InitTacticalEngine( ) InitializeTacticalInterface( ); // Init Interface stuff InitializeGameVideoObjects( ); // Init system objects LoadPaletteData( ); // Init palette system - if( !LoadLockTable() ) - return(FALSE); + //if( !LoadLockTable() ) + // return(FALSE); + + // anv: externalised locks and keys + //WriteLocks("WriteLocks.xml"); + char fileName[MAX_PATH]; + strcpy(fileName, TABLEDATA_DIRECTORY); + strcat(fileName, LOCKSFILENAME); + if ( FileExists(fileName) ) + { + DebugMsg (TOPIC_JA2,DBG_LEVEL_3,String("LoadExternalGameplayData, fileName = %s", fileName)); + SGP_THROW_IFFALSE(ReadInLocks(fileName,FALSE), LOCKSFILENAME); + } + else + { + DebugMsg (TOPIC_JA2,DBG_LEVEL_3,String("FileName = %s not found, trying to load LOCKS.BIN instead", fileName)); + if( !LoadLockTable() ) + return(FALSE); + } +#ifndef ENGLISH + AddLanguagePrefix(fileName); + if ( FileExists(fileName) ) + { + DebugMsg (TOPIC_JA2,DBG_LEVEL_3,String("LoadExternalGameplayData, fileName = %s", fileName)); + SGP_THROW_IFFALSE(ReadInLocks(fileName,TRUE), LOCKSFILENAME); + } +#endif + + strcpy(fileName, TABLEDATA_DIRECTORY); + strcat(fileName, KEYSFILENAME); + if ( FileExists(fileName) ) + { + DebugMsg (TOPIC_JA2,DBG_LEVEL_3,String("LoadExternalGameplayData, fileName = %s", fileName)); + SGP_THROW_IFFALSE(ReadInKeys(fileName), KEYSFILENAME); + } + else + { + DebugMsg (TOPIC_JA2,DBG_LEVEL_3,String("FileName = %s not found, hardcoded values will be used", fileName)); + } + + + InitInteractiveTileManagement( ); if (!InitPathAI()) // init path code return( FALSE ); diff --git a/Tactical/Tactical_VS2005.vcproj b/Tactical/Tactical_VS2005.vcproj index 2f6b710a..f3f745e3 100644 --- a/Tactical/Tactical_VS2005.vcproj +++ b/Tactical/Tactical_VS2005.vcproj @@ -1116,6 +1116,10 @@ RelativePath=".\XML_ItemAdjustments.cpp" > + + @@ -1136,6 +1140,10 @@ RelativePath=".\XML_LoadScreenHints.cpp" > + + diff --git a/Tactical/Tactical_VS2008.vcproj b/Tactical/Tactical_VS2008.vcproj index ee73d0c7..e8869040 100644 --- a/Tactical/Tactical_VS2008.vcproj +++ b/Tactical/Tactical_VS2008.vcproj @@ -1118,6 +1118,10 @@ RelativePath=".\XML_ItemAdjustments.cpp" > + + @@ -1138,6 +1142,10 @@ RelativePath=".\XML_LoadScreenHints.cpp" > + + diff --git a/Tactical/Tactical_VS2010.vcxproj b/Tactical/Tactical_VS2010.vcxproj index 75a38467..10fc0d52 100644 --- a/Tactical/Tactical_VS2010.vcxproj +++ b/Tactical/Tactical_VS2010.vcxproj @@ -217,11 +217,13 @@ + + diff --git a/Tactical/Tactical_VS2010.vcxproj.filters b/Tactical/Tactical_VS2010.vcxproj.filters index b0b79ddd..b92577d8 100644 --- a/Tactical/Tactical_VS2010.vcxproj.filters +++ b/Tactical/Tactical_VS2010.vcxproj.filters @@ -662,5 +662,11 @@ Source Files + + Source Files + + + Source Files + \ No newline at end of file diff --git a/Tactical/Tactical_VS2013.vcxproj b/Tactical/Tactical_VS2013.vcxproj index f6c92dc5..ecbfab1f 100644 --- a/Tactical/Tactical_VS2013.vcxproj +++ b/Tactical/Tactical_VS2013.vcxproj @@ -217,11 +217,13 @@ + + diff --git a/Tactical/Tactical_VS2013.vcxproj.filters b/Tactical/Tactical_VS2013.vcxproj.filters index cce9e9ae..cea304fe 100644 --- a/Tactical/Tactical_VS2013.vcxproj.filters +++ b/Tactical/Tactical_VS2013.vcxproj.filters @@ -661,6 +661,12 @@ Source Files + + + Source Files + + + Source Files \ No newline at end of file diff --git a/Tactical/XML.h b/Tactical/XML.h index 9ebae47b..f5df6e28 100644 --- a/Tactical/XML.h +++ b/Tactical/XML.h @@ -245,6 +245,9 @@ typedef PARSE_STAGE; #define TAUNTSFILENAMEBEGINNING "EnemyTaunts" // You can add additional taunt files next to the "EnemyTaunts.xml" file. They have to start with "EnemyTaunts*.xml" (e.g: EnemyTauntsKill.xml) #define TAUNTSFILENAMEENDING ".xml" +#define LOCKSFILENAME "Items\\Locks.xml" +#define KEYSFILENAME "Items\\Keys.xml" + #define ENEMY_ADMIN_PROFILE_FILENAME "Profiles\\SoldierProfileEnemyAdmin.xml" #define ENEMY_REGULAR_PROFILE_FILENAME "Profiles\\SoldierProfileEnemyRegular.xml" #define ENEMY_ELITE_PROFILE_FILENAME "Profiles\\SoldierProfileEnemyElite.xml" @@ -495,6 +498,13 @@ extern BOOLEAN WriteTaunts( STR fileName ); extern BOOLEAN ReadInAdditionalTileProperties(STR fileName ); extern BOOLEAN WriteAdditionalTileProperties( STR fileName ); +// anv: externalised locks and keys +extern BOOLEAN ReadInLocks(STR fileName, BOOLEAN localizedVersion ); +extern BOOLEAN WriteLocks( STR fileName ); + +extern BOOLEAN ReadInKeys( STR fileName ); +extern BOOLEAN WriteKeys( STR fileName ); + //Enabled\Disabled profile sound by Jazz extern BOOLEAN ReadInSoundProfile( STR fileName ); extern BOOLEAN WriteSoundProfile( STR fileName ); diff --git a/Tactical/XML_Keys.cpp b/Tactical/XML_Keys.cpp new file mode 100644 index 00000000..281dade4 --- /dev/null +++ b/Tactical/XML_Keys.cpp @@ -0,0 +1,208 @@ +#ifdef PRECOMPILEDHEADERS + #include "Tactical All.h" +#else + #include "sgp.h" + #include "Debug Control.h" + #include "expat.h" + #include "XML.h" + #include "Interface.h" + #include "Keys.h" +#endif + + +struct +{ + PARSE_STAGE curElement; + + CHAR8 szCharData[MAX_CHAR_DATA_LENGTH+1]; + KEY curKey; + KEY * curArray; + + UINT32 maxArraySize; + UINT32 curIndex; + UINT32 currentDepth; + UINT32 maxReadDepth; +} +typedef keyParseData; + +UINT16 num_found_key = 0; // the correct number is set on reading the xml + +static void XMLCALL +keyStartElementHandle(void *userData, const XML_Char *name, const XML_Char **atts) +{ + keyParseData * pData = (keyParseData *)userData; + + if(pData->currentDepth <= pData->maxReadDepth) //are we reading this element? + { + if(strcmp(name, "KEYS") == 0 && pData->curElement == ELEMENT_NONE) + { + pData->curElement = ELEMENT_LIST; + + pData->maxReadDepth++; //we are not skipping this element + } + else if(strcmp(name, "KEY") == 0 && pData->curElement == ELEMENT_LIST) + { + pData->curElement = ELEMENT; + + pData->maxReadDepth++; //we are not skipping this element + } + else if(pData->curElement == ELEMENT && + (strcmp(name, "ubIndex") == 0 || + strcmp(name, "usItem") == 0 ) ) + { + pData->curElement = ELEMENT_PROPERTY; + + pData->maxReadDepth++; //we are not skipping this element + } + + pData->szCharData[0] = '\0'; + } + + pData->currentDepth++; +} + +static void XMLCALL +keyCharacterDataHandle(void *userData, const XML_Char *str, int len) +{ + keyParseData * pData = (keyParseData *)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 +keyEndElementHandle(void *userData, const XML_Char *name) +{ + keyParseData * pData = (keyParseData *)userData; + + if(pData->currentDepth <= pData->maxReadDepth) + { + if(strcmp(name, "KEYS") == 0) + { + pData->curElement = ELEMENT_NONE; + } + else if(strcmp(name, "KEY") == 0) + { + pData->curElement = ELEMENT_LIST; + + if(num_found_key < pData->maxArraySize) + { + + pData->curArray[pData->curIndex] = pData->curKey; + + num_found_key++; + } + } + else if(strcmp(name, "ubIndex") == 0) + { + pData->curElement = ELEMENT; + pData->curIndex = (UINT32) atol(pData->szCharData); + + memset(&pData->curKey, 0, sizeof(KEY)); + + } + else if(strcmp(name, "usItem") == 0) + { + pData->curElement = ELEMENT; + pData->curKey.usItem = (UINT16) atol(pData->szCharData); + } + + pData->maxReadDepth--; + } + pData->currentDepth--; +} + +BOOLEAN ReadInKeys(STR fileName) +{ + HWFILE hFile; + UINT32 uiBytesRead; + UINT32 uiFSize; + CHAR8 * lpcBuffer; + XML_Parser parser = XML_ParserCreate(NULL); + + keyParseData pData; + + DebugMsg(TOPIC_JA2, DBG_LEVEL_3, "Loading Keys.xml" ); + + // Open file + hFile = FileOpen( fileName, FILE_ACCESS_READ, FALSE ); + if ( !hFile ) + return( FALSE ); + + 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, keyStartElementHandle, keyEndElementHandle); + XML_SetCharacterDataHandler(parser, keyCharacterDataHandle); + + + memset(&pData,0,sizeof(pData)); + pData.curArray = KeyTable; + pData.maxArraySize = NUM_KEYS; + + XML_SetUserData(parser, &pData); + if(!XML_Parse(parser, lpcBuffer, uiFSize, TRUE)) + { + CHAR8 errorBuf[511]; + + sprintf(errorBuf, "XML Parser Error in Keys.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 ); +} + + +BOOLEAN WriteKeys( STR fileName ) +{ + HWFILE hFile; + + //Debug code; make sure that what we got from the file is the same as what's there + // Open a new file + hFile = FileOpen( fileName, FILE_ACCESS_WRITE | FILE_CREATE_ALWAYS, FALSE ); + if ( !hFile ) + return( FALSE ); + + { + UINT32 cnt; + + FilePrintf(hFile,"\r\n"); + for(cnt = 0; cnt < NUM_KEYS; ++cnt) + { + FilePrintf(hFile,"\t\r\n"); + + FilePrintf(hFile,"\t\t%d\r\n", cnt); + FilePrintf(hFile,"\t\t%s\r\n", KeyTable[cnt].usItem); + + FilePrintf(hFile,"\t\r\n"); + } + FilePrintf(hFile,"\r\n"); + } + FileClose( hFile ); + + return( TRUE ); +} diff --git a/Tactical/XML_Locks.cpp b/Tactical/XML_Locks.cpp new file mode 100644 index 00000000..74056a60 --- /dev/null +++ b/Tactical/XML_Locks.cpp @@ -0,0 +1,256 @@ +#ifdef PRECOMPILEDHEADERS + #include "Tactical All.h" +#else + #include "sgp.h" + #include "Debug Control.h" + #include "expat.h" + #include "XML.h" + #include "Interface.h" + #include "Keys.h" +#endif + + +struct +{ + PARSE_STAGE curElement; + + CHAR8 szCharData[MAX_CHAR_DATA_LENGTH+1]; + LOCK curLock; + LOCK * curArray; + + UINT32 maxArraySize; + UINT32 curIndex; + UINT32 currentDepth; + UINT32 maxReadDepth; +} +typedef lockParseData; + +BOOLEAN localizedTextOnly_Locks; + +UINT16 num_found_lock = 0; // the correct number is set on reading the xml + +static void XMLCALL +lockStartElementHandle(void *userData, const XML_Char *name, const XML_Char **atts) +{ + lockParseData * pData = (lockParseData *)userData; + + if(pData->currentDepth <= pData->maxReadDepth) //are we reading this element? + { + if(strcmp(name, "LOCKS") == 0 && pData->curElement == ELEMENT_NONE) + { + pData->curElement = ELEMENT_LIST; + + pData->maxReadDepth++; //we are not skipping this element + } + else if(strcmp(name, "LOCK") == 0 && pData->curElement == ELEMENT_LIST) + { + pData->curElement = ELEMENT; + + if ( !localizedTextOnly_Locks ) + memset(&pData->curLock,0,sizeof(LOCK)); + + pData->maxReadDepth++; //we are not skipping this element + } + else if(pData->curElement == ELEMENT && + (strcmp(name, "ubLockID") == 0 || + strcmp(name, "ubEditorName") == 0 || + strcmp(name, "usKeyItem") == 0 || + strcmp(name, "ubLockType") == 0 || + strcmp(name, "ubPickDifficulty") == 0 || + strcmp(name, "ubSmashDifficulty") == 0 ) ) + { + pData->curElement = ELEMENT_PROPERTY; + + pData->maxReadDepth++; //we are not skipping this element + } + + pData->szCharData[0] = '\0'; + } + + pData->currentDepth++; +} + +static void XMLCALL +lockCharacterDataHandle(void *userData, const XML_Char *str, int len) +{ + lockParseData * pData = (lockParseData *)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 +lockEndElementHandle(void *userData, const XML_Char *name) +{ + lockParseData * pData = (lockParseData *)userData; + + if(pData->currentDepth <= pData->maxReadDepth) + { + if(strcmp(name, "LOCKS") == 0) + { + pData->curElement = ELEMENT_NONE; + } + else if(strcmp(name, "LOCK") == 0) + { + pData->curElement = ELEMENT_LIST; + + //if(pData->curLock.uiIndex < pData->maxArraySize) + if(num_found_lock < pData->maxArraySize) + { + if ( localizedTextOnly_Locks ) + { + //wcscpy(zTaunt[offset_index + pData->curLock.ubLockID].szText,pData->curLock.szText); + //wcscpy(zTaunt[offset_index + pData->curLock.ubLockID].szCensoredText,pData->curLock.szCensoredText); + } + else + { + pData->curArray[pData->curIndex] = pData->curLock; + //pData->curArray[num_found_lock-1] = pData->curLock; + + num_found_lock++; + } + } + //num_found_lock++; + //num_found_lock = pData->curLock.uiIndex; + } + else if(strcmp(name, "ubLockID") == 0) + { + pData->curElement = ELEMENT; + pData->curIndex = (UINT32) atol(pData->szCharData); + + memset(&pData->curLock, 0, sizeof(LOCK)); + + } + else if(strcmp(name, "ubEditorName") == 0 ) + { + pData->curElement = ELEMENT; + + strcpy( (CHAR8*)pData->curLock.ubEditorName, pData->szCharData ); + //pData->curLock.ubEditorName[sizeof(pData->curLock.ubEditorName)/sizeof(pData->curLock.ubEditorName[0]) - 1] = '\0'; + } + else if(strcmp(name, "usKeyItem") == 0) + { + pData->curElement = ELEMENT; + pData->curLock.usKeyItem = (UINT16) atol(pData->szCharData); + } + else if(strcmp(name, "ubLockType") == 0) + { + pData->curElement = ELEMENT; + pData->curLock.ubLockType = (UINT8) atol(pData->szCharData); + } + else if(strcmp(name, "ubPickDifficulty") == 0) + { + pData->curElement = ELEMENT; + pData->curLock.ubPickDifficulty = (UINT8) atol(pData->szCharData); + } + else if(strcmp(name, "ubSmashDifficulty") == 0) + { + pData->curElement = ELEMENT; + pData->curLock.ubSmashDifficulty = (UINT8) atol(pData->szCharData); + } + + pData->maxReadDepth--; + } + pData->currentDepth--; +} + +BOOLEAN ReadInLocks(STR fileName, BOOLEAN localizedVersion) +{ + HWFILE hFile; + UINT32 uiBytesRead; + UINT32 uiFSize; + CHAR8 * lpcBuffer; + XML_Parser parser = XML_ParserCreate(NULL); + + lockParseData pData; + + DebugMsg(TOPIC_JA2, DBG_LEVEL_3, "Loading Locks.xml" ); + + localizedTextOnly_Locks = localizedVersion; + + // Open file + hFile = FileOpen( fileName, FILE_ACCESS_READ, FALSE ); + if ( !hFile ) + return( FALSE ); + + 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, lockStartElementHandle, lockEndElementHandle); + XML_SetCharacterDataHandler(parser, lockCharacterDataHandle); + + + memset(&pData,0,sizeof(pData)); + pData.curArray = LockTable; + pData.maxArraySize = NUM_LOCKS; + + XML_SetUserData(parser, &pData); + if(!XML_Parse(parser, lpcBuffer, uiFSize, TRUE)) + { + CHAR8 errorBuf[511]; + + sprintf(errorBuf, "XML Parser Error in Locks.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 ); +} + + +BOOLEAN WriteLocks( STR fileName ) +{ + HWFILE hFile; + + //Debug code; make sure that what we got from the file is the same as what's there + // Open a new file + hFile = FileOpen( fileName, FILE_ACCESS_WRITE | FILE_CREATE_ALWAYS, FALSE ); + if ( !hFile ) + return( FALSE ); + + { + UINT32 cnt; + + FilePrintf(hFile,"\r\n"); + for(cnt = 0; cnt < NUM_LOCKS; ++cnt) + { + FilePrintf(hFile,"\t\r\n"); + + FilePrintf(hFile,"\t\t%d\r\n", cnt); + FilePrintf(hFile,"\t\t%s\r\n", LockTable[cnt].ubEditorName); + FilePrintf(hFile,"\t\t%d\r\n", LockTable[cnt].usKeyItem); + FilePrintf(hFile,"\t\t%d\r\n", LockTable[cnt].ubLockType); + FilePrintf(hFile,"\t\t%d\r\n", LockTable[cnt].ubPickDifficulty); + FilePrintf(hFile,"\t\t%d\r\n", LockTable[cnt].ubSmashDifficulty); + + FilePrintf(hFile,"\t\r\n"); + } + FilePrintf(hFile,"\r\n"); + } + FileClose( hFile ); + + return( TRUE ); +}