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

@@ -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 );

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

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);
+					}
 				}
 
 			}

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 ) ),

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;

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 );

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 );

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 );

Tactical/Tactical_VS2005.vcproj

@@ -1116,6 +1116,10 @@
 				RelativePath=".\XML_ItemAdjustments.cpp"
 				>
 			</File>
+			<File
+				RelativePath=".\XML_Keys.cpp"
+				>
+			</File>
 			<File
 				RelativePath=".\XML_Launchable.cpp"
 				>
@@ -1136,6 +1140,10 @@
 				RelativePath=".\XML_LoadScreenHints.cpp"
 				>
 			</File>
+			<File
+				RelativePath=".\XML_Locks.cpp"
+				>
+			</File>
 			<File
 				RelativePath=".\XML_Magazine.cpp"
 				>

Tactical/Tactical_VS2008.vcproj

@@ -1118,6 +1118,10 @@
 				RelativePath=".\XML_ItemAdjustments.cpp"
 				>
 			</File>
+			<File
+				RelativePath=".\XML_Keys.cpp"
+				>
+			</File>
 			<File
 				RelativePath="XML_Launchable.cpp"
 				>
@@ -1138,6 +1142,10 @@
 				RelativePath=".\XML_LoadScreenHints.cpp"
 				>
 			</File>
+			<File
+				RelativePath=".\XML_Locks.cpp"
+				>
+			</File>
 			<File
 				RelativePath="XML_Magazine.cpp"
 				>

Tactical/Tactical_VS2010.vcxproj

@@ -217,11 +217,13 @@
     <ClCompile Include="XML_IMPItemChoices.cpp" />
     <ClCompile Include="XML_IncompatibleAttachments.cpp" />
     <ClCompile Include="XML_ItemAdjustments.cpp" />
+    <ClCompile Include="XML_Keys.cpp" />
     <ClCompile Include="XML_Launchable.cpp" />
     <ClCompile Include="XML_LBEPocket.cpp" />
     <ClCompile Include="XML_LBEPocketPopup.cpp" />
     <ClCompile Include="XML_LoadBearingEquipment.cpp" />
     <ClCompile Include="XML_LoadScreenHints.cpp" />
+    <ClCompile Include="XML_Locks.cpp" />
     <ClCompile Include="XML_Magazine.cpp" />
     <ClCompile Include="XML_Merchants.cpp" />
     <ClCompile Include="XML_MercStartingGear.cpp" />

Tactical/Tactical_VS2010.vcxproj.filters

@@ -662,5 +662,11 @@
     <ClCompile Include="XML_AdditionalTileProperties.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="XML_Locks.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="XML_Keys.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

Tactical/Tactical_VS2013.vcxproj

@@ -217,11 +217,13 @@
     <ClCompile Include="XML_IMPItemChoices.cpp" />
     <ClCompile Include="XML_IncompatibleAttachments.cpp" />
     <ClCompile Include="XML_ItemAdjustments.cpp" />
+	<ClCompile Include="XML_Keys.cpp" />
     <ClCompile Include="XML_Launchable.cpp" />
     <ClCompile Include="XML_LBEPocket.cpp" />
     <ClCompile Include="XML_LBEPocketPopup.cpp" />
     <ClCompile Include="XML_LoadBearingEquipment.cpp" />
     <ClCompile Include="XML_LoadScreenHints.cpp" />
+	<ClCompile Include="XML_Locks.cpp" />
     <ClCompile Include="XML_Magazine.cpp" />
     <ClCompile Include="XML_Merchants.cpp" />
     <ClCompile Include="XML_MercStartingGear.cpp" />

Tactical/Tactical_VS2013.vcxproj.filters

@@ -661,6 +661,12 @@
     </ClCompile>
 	<ClCompile Include="XML_AdditionalTileProperties.cpp">
       <Filter>Source Files</Filter>
+    </ClCompile>
+	<ClCompile Include="XML_Locks.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="XML_Keys.cpp">
+      <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>
 </Project>

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 );

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,"<KEYS>\r\n");
+		for(cnt = 0; cnt < NUM_KEYS; ++cnt)
+		{
+			FilePrintf(hFile,"\t<KEY>\r\n");
+
+			FilePrintf(hFile,"\t\t<ubIndex>%d</ubIndex>\r\n",	cnt);
+			FilePrintf(hFile,"\t\t<usItem>%s</usItem>\r\n",	KeyTable[cnt].usItem);
+
+			FilePrintf(hFile,"\t</KEY>\r\n");
+		}
+		FilePrintf(hFile,"</KEYS>\r\n");
+	}
+	FileClose( hFile );
+
+	return( TRUE );
+}

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,"<LOCKS>\r\n");
+		for(cnt = 0; cnt < NUM_LOCKS; ++cnt)
+		{
+			FilePrintf(hFile,"\t<LOCK>\r\n");
+
+			FilePrintf(hFile,"\t\t<ubLockID>%d</ubLockID>\r\n",	cnt);
+			FilePrintf(hFile,"\t\t<ubEditorName>%s</ubEditorName>\r\n",	LockTable[cnt].ubEditorName);
+			FilePrintf(hFile,"\t\t<usKeyItem>%d</usKeyItem>\r\n",	LockTable[cnt].usKeyItem);
+			FilePrintf(hFile,"\t\t<ubLockType>%d</ubLockType>\r\n",	LockTable[cnt].ubLockType);
+			FilePrintf(hFile,"\t\t<ubPickDifficulty>%d</ubPickDifficulty>\r\n",	LockTable[cnt].ubPickDifficulty);
+			FilePrintf(hFile,"\t\t<ubSmashDifficulty>%d</ubSmashDifficulty>\r\n",	LockTable[cnt].ubSmashDifficulty);
+
+			FilePrintf(hFile,"\t</LOCK>\r\n");
+		}
+		FilePrintf(hFile,"</LOCKS>\r\n");
+	}
+	FileClose( hFile );
+
+	return( TRUE );
+}