From b691c43c44ff180d10e7d4a9afc83b98551ff586 Mon Sep 17 00:00:00 2001 From: daoge_cmd <3523206925@qq.com> Date: Sun, 1 Mar 2026 12:16:08 +0800 Subject: Initial commit --- Minecraft.World/LevelData.cpp | 589 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 589 insertions(+) create mode 100644 Minecraft.World/LevelData.cpp (limited to 'Minecraft.World/LevelData.cpp') 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 > *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; +} -- cgit v1.2.3