Initial commit

1 files changed, 767 insertions, 0 deletions

diff --git a/Minecraft.Client/Common/GameRules/GameRuleManager.cpp b/Minecraft.Client/Common/GameRules/GameRuleManager.cpp
new file mode 100644
index 00000000..0c6a7804
--- /dev/null
+++ b/Minecraft.Client/Common/GameRules/GameRuleManager.cpp
@@ -0,0 +1,767 @@
+#include "stdafx.h"
+#include "..\..\..\Minecraft.World\compression.h"
+#include "..\..\..\Minecraft.World\StringHelpers.h"
+#include "..\..\..\Minecraft.World\File.h"
+#include "..\..\..\Minecraft.World\compression.h"
+#include "..\DLC\DLCPack.h"
+#include "..\DLC\DLCLocalisationFile.h"
+#include "..\DLC\DLCGameRulesFile.h"
+#include "..\DLC\DLCGameRules.h"
+#include "..\DLC\DLCGameRulesHeader.h"
+#include "..\..\StringTable.h"
+#include "ConsoleGameRules.h"
+#include "GameRuleManager.h"
+
+WCHAR *GameRuleManager::wchTagNameA[] =
+{
+	L"", // eGameRuleType_Root
+	L"MapOptions", // eGameRuleType_LevelGenerationOptions
+	L"ApplySchematic", // eGameRuleType_ApplySchematic
+	L"GenerateStructure", // eGameRuleType_GenerateStructure
+	L"GenerateBox", // eGameRuleType_GenerateBox
+	L"PlaceBlock", // eGameRuleType_PlaceBlock
+	L"PlaceContainer", // eGameRuleType_PlaceContainer
+	L"PlaceSpawner", // eGameRuleType_PlaceSpawner
+	L"BiomeOverride", // eGameRuleType_BiomeOverride
+	L"StartFeature", // eGameRuleType_StartFeature
+	L"AddItem", // eGameRuleType_AddItem
+	L"AddEnchantment", // eGameRuleType_AddEnchantment
+	L"LevelRules", // eGameRuleType_LevelRules
+	L"NamedArea", // eGameRuleType_NamedArea
+	L"UseTile", // eGameRuleType_UseTileRule
+	L"CollectItem", // eGameRuleType_CollectItemRule
+	L"CompleteAll", // eGameRuleType_CompleteAllRule
+	L"UpdatePlayer", // eGameRuleType_UpdatePlayerRule
+};
+
+WCHAR *GameRuleManager::wchAttrNameA[] =
+{
+	L"descriptionName", // eGameRuleAttr_descriptionName
+	L"promptName", // eGameRuleAttr_promptName
+	L"dataTag", // eGameRuleAttr_dataTag
+	L"enchantmentId", // eGameRuleAttr_enchantmentId
+	L"enchantmentLevel", // eGameRuleAttr_enchantmentLevel
+	L"itemId", // eGameRuleAttr_itemId
+	L"quantity", // eGameRuleAttr_quantity
+	L"auxValue", // eGameRuleAttr_auxValue
+	L"slot", // eGameRuleAttr_slot
+	L"name", // eGameRuleAttr_name
+	L"food", // eGameRuleAttr_food
+	L"health", // eGameRuleAttr_health
+	L"tileId", // eGameRuleAttr_tileId
+	L"useCoords", // eGameRuleAttr_useCoords
+	L"seed", // eGameRuleAttr_seed
+	L"flatworld", // eGameRuleAttr_flatworld
+	L"filename", // eGameRuleAttr_filename
+	L"rot", // eGameRuleAttr_rot
+	L"data", // eGameRuleAttr_data
+	L"block", // eGameRuleAttr_block
+	L"entity", // eGameRuleAttr_entity
+	L"facing", // eGameRuleAttr_facing
+	L"edgeTile", // eGameRuleAttr_edgeTile
+	L"fillTile", // eGameRuleAttr_fillTile
+	L"skipAir", // eGameRuleAttr_skipAir
+	L"x", // eGameRuleAttr_x
+	L"x0", // eGameRuleAttr_x0
+	L"x1", // eGameRuleAttr_x1
+	L"y", // eGameRuleAttr_y
+	L"y0", // eGameRuleAttr_y0
+	L"y1", // eGameRuleAttr_y1
+	L"z", // eGameRuleAttr_z
+	L"z0", // eGameRuleAttr_z0
+	L"z1", // eGameRuleAttr_z1
+	L"chunkX", // eGameRuleAttr_chunkX
+	L"chunkZ", // eGameRuleAttr_chunkZ
+	L"yRot", // eGameRuleAttr_yRot
+	L"spawnX", // eGameRuleAttr_spawnX
+	L"spawnY", // eGameRuleAttr_spawnY
+	L"spawnZ", // eGameRuleAttr_spawnZ
+	L"orientation",
+	L"dimension",	
+	L"topTileId", // eGameRuleAttr_topTileId
+	L"biomeId", // eGameRuleAttr_biomeId
+	L"feature", // eGameRuleAttr_feature
+};
+
+GameRuleManager::GameRuleManager()
+{
+	m_currentGameRuleDefinitions = NULL;
+	m_currentLevelGenerationOptions = NULL;
+}
+
+void GameRuleManager::loadGameRules(DLCPack *pack)
+{
+	StringTable *strings = NULL;
+
+	if(pack->doesPackContainFile(DLCManager::e_DLCType_LocalisationData,L"languages.loc"))
+	{
+		DLCLocalisationFile *localisationFile = (DLCLocalisationFile *)pack->getFile(DLCManager::e_DLCType_LocalisationData, L"languages.loc");
+		strings = localisationFile->getStringTable();
+	}
+
+	int gameRulesCount = pack->getDLCItemsCount(DLCManager::e_DLCType_GameRulesHeader);
+	for(int i = 0; i < gameRulesCount; ++i)
+	{
+		DLCGameRulesHeader *dlcHeader = (DLCGameRulesHeader *)pack->getFile(DLCManager::e_DLCType_GameRulesHeader, i);
+		DWORD dSize;
+		byte *dData = dlcHeader->getData(dSize);
+
+		LevelGenerationOptions *createdLevelGenerationOptions = new LevelGenerationOptions();
+		//	= loadGameRules(dData, dSize); //, strings);
+
+		createdLevelGenerationOptions->setGrSource( dlcHeader );
+
+		readRuleFile(createdLevelGenerationOptions, dData, dSize, strings);
+
+		createdLevelGenerationOptions->setSrc( LevelGenerationOptions::eSrc_fromDLC );
+		
+
+		//createdLevelGenerationOptions->setSrc( LevelGenerationOptions::eSrc_fromDLC );
+		dlcHeader->lgo = createdLevelGenerationOptions;
+	}
+
+	gameRulesCount = pack->getDLCItemsCount(DLCManager::e_DLCType_GameRules);
+	for (int i = 0; i < gameRulesCount; ++i)
+	{
+		DLCGameRulesFile *dlcFile = (DLCGameRulesFile *)pack->getFile(DLCManager::e_DLCType_GameRules, i);
+
+		DWORD dSize;
+		byte *dData = dlcFile->getData(dSize);
+
+		LevelGenerationOptions *createdLevelGenerationOptions = new LevelGenerationOptions();
+		//	= loadGameRules(dData, dSize); //, strings);
+		
+		createdLevelGenerationOptions->setGrSource( new JustGrSource() );
+		readRuleFile(createdLevelGenerationOptions, dData, dSize, strings);
+
+		createdLevelGenerationOptions->setSrc( LevelGenerationOptions::eSrc_tutorial );
+		
+		//createdLevelGenerationOptions->set_DLCGameRulesFile( dlcFile );
+
+		createdLevelGenerationOptions->setLoadedData();
+	}
+}
+
+LevelGenerationOptions *GameRuleManager::loadGameRules(byte *dIn, UINT dSize)
+{
+	LevelGenerationOptions *lgo = new LevelGenerationOptions();
+	lgo->setGrSource( new JustGrSource() );
+	lgo->setSrc( LevelGenerationOptions::eSrc_fromSave );
+	loadGameRules(lgo, dIn, dSize);
+	lgo->setLoadedData();
+	return lgo;
+}
+
+// 4J-JEV: Reverse of saveGameRules.
+void GameRuleManager::loadGameRules(LevelGenerationOptions *lgo, byte *dIn, UINT dSize)
+{
+	app.DebugPrintf("GameRuleManager::LoadingGameRules:\n");
+
+	ByteArrayInputStream bais( byteArray(dIn,dSize) );
+	DataInputStream dis(&bais);
+
+	// Read file header.
+
+	//dis.readInt(); // File Size
+
+	short version = dis.readShort();
+	assert( 0x1 == version  );
+	app.DebugPrintf("\tversion=%d.\n", version);
+
+	for (int i = 0; i < 8; i++) dis.readByte();
+	
+	BYTE compression_type = dis.readByte();
+
+	app.DebugPrintf("\tcompressionType=%d.\n", compression_type);
+
+	UINT compr_len, decomp_len;
+	compr_len = dis.readInt();
+	decomp_len = dis.readInt();
+
+	app.DebugPrintf("\tcompr_len=%d.\n\tdecomp_len=%d.\n", compr_len, decomp_len);
+	
+
+	// Decompress File Body
+
+	byteArray content(new BYTE[decomp_len], decomp_len), 
+				compr_content(new BYTE[compr_len], compr_len);
+	dis.read(compr_content);
+
+	Compression::getCompression()->SetDecompressionType( (Compression::ECompressionTypes)compression_type );
+	Compression::getCompression()->DecompressLZXRLE(	content.data, &content.length,
+													compr_content.data, compr_content.length);
+	Compression::getCompression()->SetDecompressionType( SAVE_FILE_PLATFORM_LOCAL );
+
+	dis.close();
+	bais.close();
+
+	delete [] compr_content.data;
+
+	ByteArrayInputStream bais2( content );
+	DataInputStream dis2( &bais2 );
+
+	// Read StringTable.
+	byteArray bStringTable;
+	bStringTable.length = dis2.readInt();
+	bStringTable.data = new BYTE[ bStringTable.length ];
+	dis2.read(bStringTable);
+	StringTable *strings = new StringTable(bStringTable.data, bStringTable.length);
+
+	// Read RuleFile.
+	byteArray bRuleFile;
+	bRuleFile.length = content.length - bStringTable.length;
+	bRuleFile.data = new BYTE[ bRuleFile.length ];
+	dis2.read(bRuleFile);
+
+	// 4J-JEV: I don't believe that the path-name is ever used.
+	//DLCGameRulesFile *dlcgr = new DLCGameRulesFile(L"__PLACEHOLDER__");
+	//dlcgr->addData(bRuleFile.data,bRuleFile.length);
+
+	if (readRuleFile(lgo, bRuleFile.data, bRuleFile.length, strings))
+	{
+		// Set current gen options and ruleset.
+		//createdLevelGenerationOptions->setFromSaveGame(true);
+		lgo->setSrc(LevelGenerationOptions::eSrc_fromSave);
+		setLevelGenerationOptions( lgo );
+		//m_currentGameRuleDefinitions = lgo->getRequiredGameRules();
+	}
+	else
+	{
+		delete lgo;
+	}
+
+	//delete [] content.data;
+
+	// Close and return.
+	dis2.close();
+	bais2.close();
+
+	return ;
+}
+
+// 4J-JEV: Reverse of loadGameRules.
+void GameRuleManager::saveGameRules(byte **dOut, UINT *dSize)
+{
+	if (m_currentGameRuleDefinitions == NULL &&
+		m_currentLevelGenerationOptions == NULL)
+	{
+		app.DebugPrintf("GameRuleManager:: Nothing here to save.");
+		*dOut = NULL;
+		*dSize = 0;
+		return;
+	}
+
+	app.DebugPrintf("GameRuleManager::saveGameRules:\n");
+
+	// Initialise output stream.
+	ByteArrayOutputStream baos;
+	DataOutputStream dos(&baos);
+	
+	// Write header.
+
+	// VERSION NUMBER
+	dos.writeShort( 0x1 ); // version_number
+
+	// Write 8 bytes of empty space in case we need them later.
+	// Mainly useful for the ones we save embedded in game saves.
+	for (UINT i = 0; i < 8; i++)
+		dos.writeByte(0x0);
+
+	dos.writeByte(APPROPRIATE_COMPRESSION_TYPE); // m_compressionType
+
+	// -- START COMPRESSED -- //
+	ByteArrayOutputStream compr_baos;
+	DataOutputStream compr_dos(&compr_baos);
+
+	if (m_currentGameRuleDefinitions == NULL)
+	{
+		compr_dos.writeInt( 0 ); // numStrings for StringTable
+		compr_dos.writeInt( version_number );
+		compr_dos.writeByte(Compression::eCompressionType_None); // compression type
+		for (int i=0; i<2; i++) compr_dos.writeByte(0x0); // Padding.
+		compr_dos.writeInt( 0 ); // StringLookup.length
+		compr_dos.writeInt( 0 ); // SchematicFiles.length
+		compr_dos.writeInt( 0 ); // XmlObjects.length
+	}
+	else
+	{	
+		StringTable *st = m_currentGameRuleDefinitions->getStringTable();
+
+		if (st == NULL)
+		{
+			app.DebugPrintf("GameRuleManager::saveGameRules: StringTable == NULL!");
+		}
+		else
+		{
+			// Write string table.
+			byteArray stba;
+			m_currentGameRuleDefinitions->getStringTable()->getData(&stba.data, &stba.length);
+			compr_dos.writeInt( stba.length );
+			compr_dos.write( stba );
+
+			// Write game rule file to second
+			// buffer and generate string lookup.
+			writeRuleFile(&compr_dos);
+		}
+	}
+
+	// Compress compr_dos and write to dos.
+	byteArray compr_ba(new BYTE[ compr_baos.buf.length ], compr_baos.buf.length);
+	Compression::getCompression()->CompressLZXRLE(	compr_ba.data, &compr_ba.length,
+												compr_baos.buf.data, compr_baos.buf.length );
+
+	app.DebugPrintf("\tcompr_ba.length=%d.\n\tcompr_baos.buf.length=%d.\n",
+		compr_ba.length, compr_baos.buf.length );
+
+	dos.writeInt( compr_ba.length ); // Write length
+	dos.writeInt( compr_baos.buf.length );
+	dos.write(compr_ba);
+	
+	delete [] compr_ba.data;
+	
+	compr_dos.close();
+	compr_baos.close();
+	// -- END COMPRESSED -- //
+
+	// return
+	*dSize = baos.buf.length;
+	*dOut = baos.buf.data;
+
+	baos.buf.data = NULL;
+	
+	dos.close(); baos.close();
+}
+
+// 4J-JEV: Reverse of readRuleFile.
+void GameRuleManager::writeRuleFile(DataOutputStream *dos)
+{
+	// Write Header
+	dos->writeShort(version_number); // Version number.
+	dos->writeByte(Compression::eCompressionType_None); // compression type
+	for (int i=0; i<8; i++) dos->writeBoolean(false); // Padding.
+
+	// Write string lookup.
+	int numStrings = ConsoleGameRules::eGameRuleType_Count + ConsoleGameRules::eGameRuleAttr_Count;
+	dos->writeInt(numStrings);
+	for (int i = 0; i < ConsoleGameRules::eGameRuleType_Count; i++)	dos->writeUTF( wchTagNameA[i] );
+	for (int i = 0; i < ConsoleGameRules::eGameRuleAttr_Count; i++)	dos->writeUTF( wchAttrNameA[i] );
+
+	// Write schematic files.
+	unordered_map<wstring, ConsoleSchematicFile *> *files;
+	files = getLevelGenerationOptions()->getUnfinishedSchematicFiles();
+	dos->writeInt( files->size() );
+	for (AUTO_VAR(it, files->begin()); it != files->end(); it++)
+	{
+		wstring filename = it->first;
+		ConsoleSchematicFile *file = it->second;
+
+		ByteArrayOutputStream fileBaos;
+		DataOutputStream fileDos(&fileBaos);
+		file->save(&fileDos);
+
+		dos->writeUTF(filename);
+		//dos->writeInt(file->m_data.length);
+		dos->writeInt(fileBaos.buf.length);
+		dos->write((byteArray)fileBaos.buf);
+
+		fileDos.close(); fileBaos.close();
+	}
+
+	// Write xml objects.
+	dos->writeInt( 2 ); // numChildren
+	m_currentLevelGenerationOptions->write(dos);
+	m_currentGameRuleDefinitions->write(dos);
+}
+
+bool GameRuleManager::readRuleFile(LevelGenerationOptions *lgo, byte *dIn, UINT dSize, StringTable *strings) //(DLCGameRulesFile *dlcFile, StringTable *strings)
+{
+	bool levelGenAdded = false;
+	bool gameRulesAdded = false;
+	LevelGenerationOptions *levelGenerator = lgo;//new LevelGenerationOptions();
+	LevelRuleset *gameRules = new LevelRuleset();
+
+	//DWORD dwLen = 0;
+	//PBYTE pbData = dlcFile->getData(dwLen);
+	//byteArray data(pbData,dwLen);
+	
+	byteArray data(dIn, dSize);
+	ByteArrayInputStream bais(data);
+	DataInputStream dis(&bais);
+
+	// Read File.
+
+	// version_number
+	__int64 version = dis.readShort();
+	unsigned char compressionType = 0;
+	if(version == 0)
+	{
+		for (int i = 0; i < 14; i++) dis.readByte(); // Read padding.
+	}
+	else
+	{
+		compressionType = dis.readByte();
+
+		// Read the spare bytes we inserted for future use
+		for(int i = 0; i < 8; ++i) dis.readBoolean();
+	}
+
+	ByteArrayInputStream *contentBais = NULL;
+	DataInputStream *contentDis = NULL;
+
+	if(compressionType == Compression::eCompressionType_None)
+	{
+		// No compression
+		// No need to read buffer size, as we can read the stream as it is;
+		app.DebugPrintf("De-compressing game rules with: None\n");
+		contentDis = &dis;
+	}
+	else
+	{
+		unsigned int uncompressedSize = dis.readInt();
+		unsigned int compressedSize = dis.readInt();
+		byteArray compressedBuffer(compressedSize);
+		dis.read(compressedBuffer);
+
+		byteArray decompressedBuffer = byteArray(uncompressedSize);
+
+		switch(compressionType)
+		{
+		case Compression::eCompressionType_None:
+			memcpy(decompressedBuffer.data, compressedBuffer.data, uncompressedSize);
+			break;
+
+		case Compression::eCompressionType_RLE:
+			app.DebugPrintf("De-compressing game rules with: RLE\n");
+			Compression::getCompression()->Decompress( decompressedBuffer.data, &decompressedBuffer.length, compressedBuffer.data, compressedSize);
+			break;
+
+		default:
+			app.DebugPrintf("De-compressing game rules.");
+#ifndef _CONTENT_PACKAGE
+			assert( compressionType == APPROPRIATE_COMPRESSION_TYPE );
+#endif
+			// 4J-JEV: DecompressLZXRLE uses the correct platform specific compression type. (need to assert that the data is compressed with it though).
+			Compression::getCompression()->DecompressLZXRLE(decompressedBuffer.data, &decompressedBuffer.length, compressedBuffer.data, compressedSize);
+			break;
+/* 4J-JEV:
+	Each platform has only 1 method of compression, 'compression.h' file deals with it.
+
+		case Compression::eCompressionType_LZXRLE:
+			app.DebugPrintf("De-compressing game rules with: LZX+RLE\n");
+			Compression::getCompression()->DecompressLZXRLE( decompressedBuffer.data, &uncompressedSize, compressedBuffer.data, compressedSize);
+			break;
+		default:
+			app.DebugPrintf("Invalid compression type %d found\n", compressionType);
+			__debugbreak();
+
+			delete [] compressedBuffer.data; delete [] decompressedBuffer.data;
+			dis.close(); bais.reset();
+
+			if(!gameRulesAdded) delete gameRules;
+			return false;
+			*/
+		};
+
+		delete [] compressedBuffer.data;
+
+		contentBais = new ByteArrayInputStream(decompressedBuffer);
+		contentDis = new DataInputStream(contentBais);
+	}
+
+	// string lookup.
+	UINT numStrings = contentDis->readInt();
+	vector<wstring> tagsAndAtts;
+	for (UINT i = 0; i < numStrings; i++)
+		tagsAndAtts.push_back( contentDis->readUTF() );
+
+	unordered_map<int, ConsoleGameRules::EGameRuleType> tagIdMap;
+	for(int type = (int)ConsoleGameRules::eGameRuleType_Root; type < (int)ConsoleGameRules::eGameRuleType_Count; ++type)
+	{
+		for(UINT i = 0; i < numStrings; ++i)
+		{
+			if(tagsAndAtts[i].compare(wchTagNameA[type]) == 0)
+			{
+				tagIdMap.insert( unordered_map<int, ConsoleGameRules::EGameRuleType>::value_type(i, (ConsoleGameRules::EGameRuleType)type) );
+				break;
+			}
+		}
+	}
+
+	// 4J-JEV: TODO: As yet unused.
+	/*
+	unordered_map<int, ConsoleGameRules::EGameRuleAttr> attrIdMap;
+	for(int attr = (int)ConsoleGameRules::eGameRuleAttr_descriptionName; attr < (int)ConsoleGameRules::eGameRuleAttr_Count; ++attr)
+	{
+		for (UINT i = 0; i < numStrings; i++)
+		{
+			if (tagsAndAtts[i].compare(wchAttrNameA[attr]) == 0)
+			{
+				tagIdMap.insert( unordered_map<int, ConsoleGameRules::EGameRuleAttr>::value_type(i , (ConsoleGameRules::EGameRuleAttr)attr) );
+				break;
+			}
+		}
+	}*/
+
+	// subfile 
+	UINT numFiles = contentDis->readInt();
+	for (UINT i = 0; i < numFiles; i++)
+	{
+		wstring sFilename = contentDis->readUTF();
+		int length = contentDis->readInt();
+		byteArray ba( length );
+
+		contentDis->read(ba);
+
+		levelGenerator->loadSchematicFile(sFilename, ba.data, ba.length);
+
+	}
+
+	LEVEL_GEN_ID lgoID = LEVEL_GEN_ID_NULL;
+
+	// xml objects
+	UINT numObjects = contentDis->readInt();
+	for(UINT i = 0; i < numObjects; ++i)
+	{
+		int tagId = contentDis->readInt();
+		ConsoleGameRules::EGameRuleType tagVal = ConsoleGameRules::eGameRuleType_Invalid;
+		AUTO_VAR(it,tagIdMap.find(tagId));
+		if(it != tagIdMap.end()) tagVal = it->second;
+
+		GameRuleDefinition *rule = NULL;
+
+		if(tagVal == ConsoleGameRules::eGameRuleType_LevelGenerationOptions)
+		{
+			rule = levelGenerator;
+			levelGenAdded = true;
+			//m_levelGenerators.addLevelGenerator(L"",levelGenerator);
+			lgoID = addLevelGenerationOptions(levelGenerator);
+			levelGenerator->loadStringTable(strings);
+		}
+		else if(tagVal == ConsoleGameRules::eGameRuleType_LevelRules)
+		{
+			rule = gameRules;
+			gameRulesAdded = true;
+			m_levelRules.addLevelRule(L"",gameRules);
+			levelGenerator->setRequiredGameRules(gameRules);
+			gameRules->loadStringTable(strings);
+		}
+
+		readAttributes(contentDis, &tagsAndAtts, rule);
+		readChildren(contentDis, &tagsAndAtts, &tagIdMap, rule);
+	}
+
+	if(compressionType != 0)
+	{
+		// Not default
+		contentDis->close();
+		if(contentBais != NULL) delete contentBais;
+		delete contentDis;
+	}
+
+	dis.close();
+	bais.reset();
+
+	//if(!levelGenAdded) { delete levelGenerator; levelGenerator = NULL; }
+	if(!gameRulesAdded) delete gameRules;
+
+	return true;
+	//return levelGenerator;
+}
+
+LevelGenerationOptions *GameRuleManager::readHeader(DLCGameRulesHeader *grh)
+{
+	LevelGenerationOptions *out = 
+		new LevelGenerationOptions();
+
+	
+	out->setSrc(LevelGenerationOptions::eSrc_fromDLC);
+	out->setGrSource(grh);
+	addLevelGenerationOptions(out);
+
+	return out;
+}
+
+void GameRuleManager::readAttributes(DataInputStream *dis, vector<wstring> *tagsAndAtts, GameRuleDefinition *rule)
+{
+	int numAttrs = dis->readInt();
+	for (UINT att = 0; att < numAttrs; ++att)
+	{
+		int attID = dis->readInt();
+		wstring value = dis->readUTF();
+
+		if(rule != NULL) rule->addAttribute(tagsAndAtts->at(attID),value);
+	}
+}
+
+void GameRuleManager::readChildren(DataInputStream *dis, vector<wstring> *tagsAndAtts, unordered_map<int, ConsoleGameRules::EGameRuleType> *tagIdMap, GameRuleDefinition *rule)
+{
+	int numChildren = dis->readInt();
+	for(UINT child = 0; child < numChildren; ++child)
+	{
+		int tagId = dis->readInt();
+		ConsoleGameRules::EGameRuleType tagVal = ConsoleGameRules::eGameRuleType_Invalid;
+		AUTO_VAR(it,tagIdMap->find(tagId));
+		if(it != tagIdMap->end()) tagVal = it->second;
+
+		GameRuleDefinition *childRule = NULL;
+		if(rule != NULL) childRule = rule->addChild(tagVal);
+
+		readAttributes(dis,tagsAndAtts,childRule);
+		readChildren(dis,tagsAndAtts,tagIdMap,childRule);
+	}
+}
+
+void GameRuleManager::processSchematics(LevelChunk *levelChunk)
+{
+	if(getLevelGenerationOptions() != NULL)
+	{
+		LevelGenerationOptions *levelGenOptions = getLevelGenerationOptions();
+		levelGenOptions->processSchematics(levelChunk);
+	}
+}
+
+void GameRuleManager::processSchematicsLighting(LevelChunk *levelChunk)
+{
+	if(getLevelGenerationOptions() != NULL)
+	{
+		LevelGenerationOptions *levelGenOptions = getLevelGenerationOptions();
+		levelGenOptions->processSchematicsLighting(levelChunk);
+	}
+}
+
+void GameRuleManager::loadDefaultGameRules()
+{
+#ifdef _XBOX
+#ifdef _TU_BUILD
+	wstring fileRoot = L"UPDATE:\\res\\GameRules\\Tutorial.pck";
+#else
+	wstring fileRoot = L"GAME:\\res\\TitleUpdate\\GameRules\\Tutorial.pck";
+#endif
+	File packedTutorialFile(fileRoot);
+	if(loadGameRulesPack(&packedTutorialFile))
+	{
+		m_levelGenerators.getLevelGenerators()->at(0)->setWorldName(app.GetString(IDS_PLAY_TUTORIAL));
+		//m_levelGenerators.getLevelGenerators()->at(0)->setDefaultSaveName(L"Tutorial");
+		m_levelGenerators.getLevelGenerators()->at(0)->setDefaultSaveName(app.GetString(IDS_TUTORIALSAVENAME));
+	}
+
+#ifndef _CONTENT_PACKAGE
+	// 4J Stu - Remove these just now
+	//File testRulesPath(L"GAME:\\GameRules");
+	//vector<File *> *packFiles = testRulesPath.listFiles();
+
+	//for(AUTO_VAR(it,packFiles->begin()); it != packFiles->end(); ++it)
+	//{
+	//	loadGameRulesPack(*it);
+	//}
+	//delete packFiles;
+#endif
+
+#else // _XBOX
+
+	wstring fpTutorial = L"Tutorial.pck";
+	if(app.getArchiveFileSize(fpTutorial) >= 0)
+	{
+		DLCPack *pack = new DLCPack(L"",0xffffffff);
+		DWORD dwFilesProcessed = 0;
+		if ( app.m_dlcManager.readDLCDataFile(dwFilesProcessed,fpTutorial,pack,true) )
+		{
+			app.m_dlcManager.addPack(pack);
+			m_levelGenerators.getLevelGenerators()->at(0)->setWorldName(app.GetString(IDS_PLAY_TUTORIAL));
+			m_levelGenerators.getLevelGenerators()->at(0)->setDefaultSaveName(app.GetString(IDS_TUTORIALSAVENAME));
+		}
+		else delete pack;
+	}
+	/*StringTable *strings = new StringTable(baStrings.data, baStrings.length);
+	LevelGenerationOptions *lgo = new LevelGenerationOptions();
+	lgo->setGrSource( new JustGrSource() );
+	lgo->setSrc( LevelGenerationOptions::eSrc_tutorial );
+	readRuleFile(lgo, tutorial.data, tutorial.length, strings);
+	lgo->setLoadedData();*/
+
+#endif
+}
+
+bool GameRuleManager::loadGameRulesPack(File *path)
+{
+	bool success = false;
+#ifdef _XBOX
+	if(path->exists())
+	{
+		DLCPack *pack = new DLCPack(L"",0xffffffff);
+		DWORD dwFilesProcessed = 0;
+		if( app.m_dlcManager.readDLCDataFile(dwFilesProcessed, path->getPath(),pack))
+		{
+			app.m_dlcManager.addPack(pack);
+			success = true;
+		}
+		else
+		{
+			delete pack;
+		}
+	}
+#endif
+	return success;
+}
+
+void GameRuleManager::setLevelGenerationOptions(LevelGenerationOptions *levelGen)
+{
+	m_currentGameRuleDefinitions = NULL;
+	m_currentLevelGenerationOptions = levelGen;
+
+	if(m_currentLevelGenerationOptions != NULL && m_currentLevelGenerationOptions->requiresGameRules() )
+	{
+		m_currentGameRuleDefinitions = m_currentLevelGenerationOptions->getRequiredGameRules();
+	}
+
+	if(m_currentLevelGenerationOptions != NULL)
+		m_currentLevelGenerationOptions->reset_start();
+}
+
+LPCWSTR	GameRuleManager::GetGameRulesString(const wstring &key)
+{
+	if(m_currentGameRuleDefinitions != NULL && !key.empty() )
+	{
+		return m_currentGameRuleDefinitions->getString(key);
+	}
+	else
+	{
+		return L"";
+	}
+}
+
+LEVEL_GEN_ID GameRuleManager::addLevelGenerationOptions(LevelGenerationOptions *lgo)
+{
+	vector<LevelGenerationOptions *> *lgs = m_levelGenerators.getLevelGenerators();
+	
+	for (int i = 0; i<lgs->size(); i++)
+		if (lgs->at(i) == lgo)
+			return i;
+
+	lgs->push_back(lgo);
+	return lgs->size() - 1;
+}
+
+void GameRuleManager::unloadCurrentGameRules()
+{
+	if (m_currentLevelGenerationOptions != NULL)
+	{
+		if (m_currentGameRuleDefinitions != NULL
+			&& m_currentLevelGenerationOptions->isFromSave())
+				m_levelRules.removeLevelRule( m_currentGameRuleDefinitions );
+
+		if (m_currentLevelGenerationOptions->isFromSave())
+		{
+			m_levelGenerators.removeLevelGenerator( m_currentLevelGenerationOptions );
+			
+			delete m_currentLevelGenerationOptions;
+		}
+		else if (m_currentLevelGenerationOptions->isFromDLC())
+		{
+			m_currentLevelGenerationOptions->reset_finish();
+		}
+	}
+
+	m_currentGameRuleDefinitions = NULL;
+	m_currentLevelGenerationOptions = NULL;
+}