Initial commit

1 files changed, 589 insertions, 0 deletions

diff --git a/Minecraft.World/LevelData.cpp b/Minecraft.World/LevelData.cpp
new file mode 100644
index 00000000..026dca70
--- /dev/null
+++ b/Minecraft.World/LevelData.cpp
@@ -0,0 +1,589 @@
+#include "stdafx.h"
+#include "System.h"
+#include "net.minecraft.world.entity.player.h"
+#include "com.mojang.nbt.h"
+#include "LevelData.h"
+#include "LevelType.h"
+#include "LevelSettings.h"
+
+LevelData::LevelData()
+{
+}
+
+LevelData::LevelData(CompoundTag *tag)
+{
+    seed = tag->getLong(L"RandomSeed");
+	m_pGenerator = LevelType::lvl_normal;
+	if (tag->contains(L"generatorName")) 
+	{
+		wstring generatorName = tag->getString(L"generatorName");
+		m_pGenerator = LevelType::getLevelType(generatorName);
+		if (m_pGenerator == NULL) 
+		{
+			m_pGenerator = LevelType::lvl_normal;
+		} 
+		else if (m_pGenerator->hasReplacement()) 
+		{
+			int generatorVersion = 0;
+			if (tag->contains(L"generatorVersion")) 
+			{
+				generatorVersion = tag->getInt(L"generatorVersion");
+			}
+			m_pGenerator = m_pGenerator->getReplacementForVersion(generatorVersion);
+		}
+	}
+
+	gameType = GameType::byId(tag->getInt(L"GameType"));
+    if (tag->contains(L"MapFeatures"))
+	{
+         generateMapFeatures = tag->getBoolean(L"MapFeatures");
+    }
+	else
+	{
+		generateMapFeatures = true;
+    }
+	spawnBonusChest = tag->getBoolean(L"spawnBonusChest");
+
+    xSpawn = tag->getInt(L"SpawnX");
+    ySpawn = tag->getInt(L"SpawnY");
+    zSpawn = tag->getInt(L"SpawnZ");
+    time = tag->getLong(L"Time");
+    lastPlayed = tag->getLong(L"LastPlayed");
+    sizeOnDisk = tag->getLong(L"SizeOnDisk");
+    levelName = tag->getString(L"LevelName");
+    version = tag->getInt(L"version");
+    rainTime = tag->getInt(L"rainTime");
+    raining = tag->getBoolean(L"raining");
+    thunderTime = tag->getInt(L"thunderTime");
+    thundering = tag->getBoolean(L"thundering");
+	hardcore = tag->getBoolean(L"hardcore");
+
+	if (tag->contains(L"initialized"))
+	{
+		initialized = tag->getBoolean(L"initialized");
+	}
+	else
+	{
+		initialized = true;
+	}
+
+	if (tag->contains(L"allowCommands"))
+	{
+		allowCommands = tag->getBoolean(L"allowCommands");
+	}
+	else
+	{
+		allowCommands = gameType == GameType::CREATIVE;
+	}
+
+	newSeaLevel = tag->getBoolean(L"newSeaLevel"); // 4J added - only use new sea level for newly created maps. This read defaults to false. (sea level changes in 1.8.2)
+	hasBeenInCreative = tag->getBoolean(L"hasBeenInCreative"); // 4J added so we can not award achievements to levels modified in creative
+
+	// 4J added - for stronghold position
+	bStronghold = tag->getBoolean(L"hasStronghold"); 
+
+	if(bStronghold==false)
+	{
+		// we need to generate the position
+		xStronghold=yStronghold=zStronghold=0;
+	}
+	else
+	{
+		xStronghold = tag->getInt(L"StrongholdX");
+		yStronghold = tag->getInt(L"StrongholdY");
+		zStronghold = tag->getInt(L"StrongholdZ");
+	}
+
+	// 4J added - for stronghold end portal position
+	bStrongholdEndPortal = tag->getBoolean(L"hasStrongholdEndPortal"); 
+
+	if(bStrongholdEndPortal==false)
+	{
+		// we need to generate the position
+		xStrongholdEndPortal=zStrongholdEndPortal=0;
+	}
+	else
+	{
+		xStrongholdEndPortal = tag->getInt(L"StrongholdEndPortalX");
+		zStrongholdEndPortal = tag->getInt(L"StrongholdEndPortalZ");
+	}
+
+	// 4J Added
+	m_xzSize = tag->getInt(L"XZSize");
+	m_hellScale = tag->getInt(L"HellScale");
+	
+	m_xzSize = min(m_xzSize,LEVEL_MAX_WIDTH);
+	m_xzSize = max(m_xzSize,LEVEL_MIN_WIDTH);
+
+	m_hellScale = min(m_hellScale,HELL_LEVEL_MAX_SCALE);
+	m_hellScale = max(m_hellScale,HELL_LEVEL_MIN_SCALE);
+
+	int hellXZSize = m_xzSize / m_hellScale;
+	while(hellXZSize > HELL_LEVEL_MAX_WIDTH && m_hellScale < HELL_LEVEL_MAX_SCALE)
+	{
+		++m_hellScale;
+		hellXZSize = m_xzSize / m_hellScale;
+	}
+
+	/* 4J - we don't store this anymore
+    if (tag->contains(L"Player")) 
+	{
+        loadedPlayerTag = tag->getCompound(L"Player");
+        dimension = loadedPlayerTag->getInt(L"Dimension");
+    }
+	else
+	{		
+		this->loadedPlayerTag = NULL;
+	}
+	*/
+	dimension = 0;
+}
+
+LevelData::LevelData(LevelSettings *levelSettings, const wstring& levelName) 
+{
+    this->seed = levelSettings->getSeed();
+    this->gameType = levelSettings->getGameType();
+    this->generateMapFeatures = levelSettings->isGenerateMapFeatures();
+	this->spawnBonusChest = levelSettings->hasStartingBonusItems();
+    this->levelName = levelName;
+	this->m_pGenerator = levelSettings->getLevelType();
+	this->hardcore = levelSettings->isHardcore();
+
+	// 4J Stu - Default initers	
+    this->xSpawn = 0;
+    this->ySpawn = 0;
+    this->zSpawn = 0;
+    this->time = -1;		// 4J-JEV: Edited: To know when this is uninitialized.
+    this->lastPlayed = 0;
+    this->sizeOnDisk = 0;
+//    this->loadedPlayerTag = NULL;	// 4J - we don't store this anymore
+    this->dimension = 0;
+    this->version = 0;
+    this->rainTime = 0;
+    this->raining = false;
+    this->thunderTime = 0;
+    this->thundering = false;
+	this->allowCommands = levelSettings->getAllowCommands();
+	this->initialized = false;
+	this->newSeaLevel = levelSettings->useNewSeaLevel();	// 4J added - only use new sea level for newly created maps (sea level changes in 1.8.2)
+	this->hasBeenInCreative = levelSettings->getGameType() == GameType::CREATIVE; // 4J added
+
+	// 4J-PB for the stronghold position
+	this->bStronghold=false;
+	this->xStronghold = 0;
+	this->yStronghold = 0;
+	this->zStronghold = 0;
+
+	this->xStrongholdEndPortal = 0;
+	this->zStrongholdEndPortal = 0;
+	this->bStrongholdEndPortal = false;
+	m_xzSize = levelSettings->getXZSize();
+	m_hellScale = levelSettings->getHellScale();
+	
+	m_xzSize = min(m_xzSize,LEVEL_MAX_WIDTH);
+	m_xzSize = max(m_xzSize,LEVEL_MIN_WIDTH);
+
+	m_hellScale = min(m_hellScale,HELL_LEVEL_MAX_SCALE);
+	m_hellScale = max(m_hellScale,HELL_LEVEL_MIN_SCALE);
+
+	int hellXZSize = m_xzSize / m_hellScale;
+	while(hellXZSize > HELL_LEVEL_MAX_WIDTH && m_hellScale < HELL_LEVEL_MAX_SCALE)
+	{
+		++m_hellScale;
+		hellXZSize = m_xzSize / m_hellScale;
+}
+}
+
+LevelData::LevelData(LevelData *copy)
+{
+    this->seed = copy->seed;
+	this->m_pGenerator = copy->m_pGenerator;
+    this->gameType = copy->gameType;
+    this->generateMapFeatures = copy->generateMapFeatures;
+	this->spawnBonusChest = copy->spawnBonusChest;
+    this->xSpawn = copy->xSpawn;
+    this->ySpawn = copy->ySpawn;
+    this->zSpawn = copy->zSpawn;
+    this->time = copy->time;
+    this->lastPlayed = copy->lastPlayed;
+    this->sizeOnDisk = copy->sizeOnDisk;
+//    this->loadedPlayerTag = copy->loadedPlayerTag;		// 4J - we don't store this anymore
+    this->dimension = copy->dimension;
+    this->levelName = copy->levelName;
+    this->version = copy->version;
+    this->rainTime = copy->rainTime;
+    this->raining = copy->raining;
+    this->thunderTime = copy->thunderTime;
+    this->thundering = copy->thundering;
+	this->hardcore = copy->hardcore;
+	this->allowCommands = copy->allowCommands;
+	this->initialized = copy->initialized;
+	this->newSeaLevel = copy->newSeaLevel;
+	this->hasBeenInCreative = copy->hasBeenInCreative;
+
+	// 4J-PB for the stronghold position
+	this->bStronghold=copy->bStronghold;
+	this->xStronghold = copy->xStronghold;
+	this->yStronghold = copy->yStronghold;
+	this->zStronghold = copy->zStronghold;
+
+	this->xStrongholdEndPortal = copy->xStrongholdEndPortal;
+	this->zStrongholdEndPortal = copy->zStrongholdEndPortal;
+	this->bStrongholdEndPortal = copy->bStrongholdEndPortal;
+	m_xzSize = copy->m_xzSize;
+	m_hellScale = copy->m_hellScale;
+}
+
+CompoundTag *LevelData::createTag()
+{
+    CompoundTag *tag = new CompoundTag();
+
+    setTagData(tag);
+
+    return tag;
+}
+
+CompoundTag *LevelData::createTag(vector<shared_ptr<Player> > *players) 
+{
+	// 4J - removed all code for storing tags for players
+	return createTag();
+}
+
+void LevelData::setTagData(CompoundTag *tag) 
+{
+    tag->putLong(L"RandomSeed", seed);
+	tag->putString(L"generatorName", m_pGenerator->getGeneratorName());
+	tag->putInt(L"generatorVersion", m_pGenerator->getVersion());
+    tag->putInt(L"GameType", gameType->getId());
+    tag->putBoolean(L"MapFeatures", generateMapFeatures);
+	tag->putBoolean(L"spawnBonusChest",spawnBonusChest);
+    tag->putInt(L"SpawnX", xSpawn);
+    tag->putInt(L"SpawnY", ySpawn);
+    tag->putInt(L"SpawnZ", zSpawn);
+    tag->putLong(L"Time", time);
+    tag->putLong(L"SizeOnDisk", sizeOnDisk);
+    tag->putLong(L"LastPlayed", System::currentTimeMillis());
+    tag->putString(L"LevelName", levelName);
+    tag->putInt(L"version", version);
+    tag->putInt(L"rainTime", rainTime);
+    tag->putBoolean(L"raining", raining);
+    tag->putInt(L"thunderTime", thunderTime);
+    tag->putBoolean(L"thundering", thundering);
+	tag->putBoolean(L"hardcore", hardcore);
+	tag->putBoolean(L"allowCommands", allowCommands);
+	tag->putBoolean(L"initialized", initialized);
+	tag->putBoolean(L"newSeaLevel", newSeaLevel);
+	tag->putBoolean(L"hasBeenInCreative", hasBeenInCreative);
+	// store the stronghold position
+	tag->putBoolean(L"hasStronghold", bStronghold);
+	tag->putInt(L"StrongholdX", xStronghold);
+	tag->putInt(L"StrongholdY", yStronghold);
+	tag->putInt(L"StrongholdZ", zStronghold);
+	// store the stronghold end portal position
+	tag->putBoolean(L"hasStrongholdEndPortal", bStrongholdEndPortal);
+	tag->putInt(L"StrongholdEndPortalX", xStrongholdEndPortal);
+	tag->putInt(L"StrongholdEndPortalZ", zStrongholdEndPortal);
+	tag->putInt(L"XZSize", m_xzSize);
+	tag->putInt(L"HellScale", m_hellScale);
+}
+
+__int64 LevelData::getSeed() 
+{
+    return seed;
+}
+
+int LevelData::getXSpawn() 
+{
+    return xSpawn;
+}
+
+int LevelData::getYSpawn() 
+{
+    return ySpawn;
+}
+
+int LevelData::getZSpawn()
+{
+    return zSpawn;
+}
+
+int LevelData::getXStronghold() 
+{
+	return xStronghold;
+}
+
+
+int LevelData::getZStronghold()
+{
+	return zStronghold;
+}
+
+int LevelData::getXStrongholdEndPortal() 
+{
+	return xStrongholdEndPortal;
+}
+
+
+int LevelData::getZStrongholdEndPortal()
+{
+	return zStrongholdEndPortal;
+}
+
+__int64 LevelData::getTime()
+{
+    return time;
+}
+
+__int64 LevelData::getSizeOnDisk()
+{
+    return sizeOnDisk;
+}
+
+CompoundTag *LevelData::getLoadedPlayerTag()
+{
+    return NULL;	// 4J - we don't store this anymore
+}
+
+// 4J Removed TU9 as it's never accurate due to the dimension never being set
+//int LevelData::getDimension()
+//{
+//    return dimension;
+//}
+
+void LevelData::setSeed(__int64 seed)
+{
+    this->seed = seed;
+}
+
+void LevelData::setXSpawn(int xSpawn)
+{
+    this->xSpawn = xSpawn;
+}
+
+void LevelData::setYSpawn(int ySpawn) 
+{
+    this->ySpawn = ySpawn;
+}
+
+void LevelData::setZSpawn(int zSpawn)
+{
+    this->zSpawn = zSpawn;
+}
+
+void LevelData::setHasStronghold()
+{
+	this->bStronghold = true;
+}
+
+bool LevelData::getHasStronghold()
+{
+	return this->bStronghold;
+}
+
+
+void LevelData::setXStronghold(int xStronghold)
+{
+	this->xStronghold = xStronghold;
+}
+
+void LevelData::setZStronghold(int zStronghold)
+{
+	this->zStronghold = zStronghold;
+}
+
+void LevelData::setHasStrongholdEndPortal()
+{
+	this->bStrongholdEndPortal = true;
+}
+
+bool LevelData::getHasStrongholdEndPortal()
+{
+	return this->bStrongholdEndPortal;
+}
+
+void LevelData::setXStrongholdEndPortal(int xStrongholdEndPortal)
+{
+	this->xStrongholdEndPortal = xStrongholdEndPortal;
+}
+
+void LevelData::setZStrongholdEndPortal(int zStrongholdEndPortal)
+{
+	this->zStrongholdEndPortal = zStrongholdEndPortal;
+}
+
+void LevelData::setTime(__int64 time)
+{
+    this->time = time;
+}
+
+void LevelData::setSizeOnDisk(__int64 sizeOnDisk)
+{
+    this->sizeOnDisk = sizeOnDisk;
+}
+
+void LevelData::setLoadedPlayerTag(CompoundTag *loadedPlayerTag)
+{
+	// 4J - we don't store this anymore
+//    this->loadedPlayerTag = loadedPlayerTag;
+}
+
+// 4J Remove TU9 as it's never used
+//void LevelData::setDimension(int dimension) 
+//{
+//    this->dimension = dimension;
+//}
+
+void LevelData::setSpawn(int xSpawn, int ySpawn, int zSpawn)
+{
+    this->xSpawn = xSpawn;
+    this->ySpawn = ySpawn;
+    this->zSpawn = zSpawn;
+}
+
+wstring LevelData::getLevelName() 
+{
+    return levelName;
+}
+
+void LevelData::setLevelName(const wstring& levelName)
+{
+    this->levelName = levelName;
+}
+
+int LevelData::getVersion() 
+{
+    return version;
+}
+
+void LevelData::setVersion(int version)
+{
+    this->version = version;
+}
+
+__int64 LevelData::getLastPlayed()
+{
+    return lastPlayed;
+}
+
+bool LevelData::isThundering()
+{
+    return thundering;
+}
+
+void LevelData::setThundering(bool thundering)
+{
+    this->thundering = thundering;
+}
+
+int LevelData::getThunderTime()
+{
+    return thunderTime;
+}
+
+void LevelData::setThunderTime(int thunderTime)
+{
+    this->thunderTime = thunderTime;
+}
+
+bool LevelData::isRaining() 
+{
+    return raining;
+}
+
+void LevelData::setRaining(bool raining)
+{
+    this->raining = raining;
+}
+
+int LevelData::getRainTime()
+{
+    return rainTime;
+}
+
+void LevelData::setRainTime(int rainTime)
+{
+    this->rainTime = rainTime;
+}
+
+GameType *LevelData::getGameType()
+{
+	return gameType;
+}
+
+bool LevelData::isGenerateMapFeatures()
+{
+	return generateMapFeatures;
+}
+
+bool LevelData::getSpawnBonusChest()
+{
+	return spawnBonusChest;
+}
+
+void LevelData::setGameType(GameType *gameType)
+{
+	this->gameType = gameType;
+
+	// 4J Added
+	hasBeenInCreative = hasBeenInCreative || (gameType == GameType::CREATIVE) || app.GetGameHostOption(eGameHostOption_CheatsEnabled) > 0;
+}
+
+bool LevelData::useNewSeaLevel()
+{
+	return newSeaLevel;
+}
+
+bool LevelData::getHasBeenInCreative()
+{
+	return hasBeenInCreative;
+}
+
+void LevelData::setHasBeenInCreative(bool value)
+{
+	hasBeenInCreative = value;
+}
+
+LevelType *LevelData::getGenerator() 
+{
+	return m_pGenerator;
+}
+
+void LevelData::setGenerator(LevelType *generator) 
+{
+	m_pGenerator = generator;
+}
+
+bool LevelData::isHardcore()
+{
+	return hardcore;
+}
+
+bool LevelData::getAllowCommands()
+{
+	return allowCommands;
+}
+
+void LevelData::setAllowCommands(bool allowCommands)
+{
+	this->allowCommands = allowCommands;
+}
+
+bool LevelData::isInitialized()
+{
+	return initialized;
+}
+
+void LevelData::setInitialized(bool initialized)
+{
+	this->initialized = initialized;
+}
+
+int LevelData::getXZSize()
+{
+	return m_xzSize;
+}
+
+int LevelData::getHellScale()
+{
+	return m_hellScale;
+}