TU19: merge Minecraft.World/Level

2026-05-24 04:46:34 +00:00 · 2026-03-21 17:07:51 -05:00
parent 29522d1ac9
commit 86e08af338
73 changed files with 3013 additions and 1259 deletions
--- a/Minecraft.World/Level/LevelData.cpp
+++ b/Minecraft.World/Level/LevelData.cpp
@@ -24,6 +24,9 @@ LevelData::LevelData(CompoundTag* tag) {
            m_pGenerator =
                m_pGenerator->getReplacementForVersion(generatorVersion);
        }
+
+        if (tag->contains(L"generatorOptions"))
+            generatorOptions = tag->getString(L"generatorOptions");
    }

    gameType = GameType::byId(tag->getInt(L"GameType"));
@@ -37,7 +40,12 @@ LevelData::LevelData(CompoundTag* tag) {
    xSpawn = tag->getInt(L"SpawnX");
    ySpawn = tag->getInt(L"SpawnY");
    zSpawn = tag->getInt(L"SpawnZ");
-    time = tag->getLong(L"Time");
+    gameTime = tag->getLong(L"Time");
+    if (tag->contains(L"DayTime")) {
+        dayTime = tag->getLong(L"DayTime");
+    } else {
+        dayTime = gameTime;
+    }
    lastPlayed = tag->getLong(L"LastPlayed");
    sizeOnDisk = tag->getLong(L"SizeOnDisk");
    levelName = tag->getString(L"LevelName");
@@ -60,6 +68,12 @@ LevelData::LevelData(CompoundTag* tag) {
        allowCommands = gameType == GameType::CREATIVE;
    }

+    // 4J: Game rules are now stored with app game host options
+    /*if (tag->contains(L"GameRules"))
+    {
+            gameRules.loadFromTag(tag->getCompound(L"GameRules"));
+    }*/
+
    newSeaLevel = tag->getBoolean(
        L"newSeaLevel");  // 4J added - only use new sea level for newly created
                          // maps. This read defaults to false. (sea level
@@ -95,6 +109,37 @@ LevelData::LevelData(CompoundTag* tag) {
    m_xzSize = tag->getInt(L"XZSize");
    m_hellScale = tag->getInt(L"HellScale");

+#ifdef _LARGE_WORLDS
+    m_classicEdgeMoat = tag->getInt(L"ClassicMoat");
+    m_smallEdgeMoat = tag->getInt(L"SmallMoat");
+    m_mediumEdgeMoat = tag->getInt(L"MediumMoat");
+
+    int newWorldSize = app.GetGameNewWorldSize();
+    int newHellScale = app.GetGameNewHellScale();
+    m_hellScaleOld = m_hellScale;
+    m_xzSizeOld = m_xzSize;
+    if (newWorldSize > m_xzSize) {
+        bool bUseMoat = app.GetGameNewWorldSizeUseMoat();
+        switch (m_xzSize) {
+            case LEVEL_WIDTH_CLASSIC:
+                m_classicEdgeMoat = bUseMoat;
+                break;
+            case LEVEL_WIDTH_SMALL:
+                m_smallEdgeMoat = bUseMoat;
+                break;
+            case LEVEL_WIDTH_MEDIUM:
+                m_mediumEdgeMoat = bUseMoat;
+                break;
+            default:
+                assert(0);
+                break;
+        }
+        assert(newWorldSize > m_xzSize);
+        m_xzSize = newWorldSize;
+        m_hellScale = newHellScale;
+    }
+#endif
+
    m_xzSize = std::min(m_xzSize, LEVEL_MAX_WIDTH);
    m_xzSize = std::max(m_xzSize, LEVEL_MIN_WIDTH);

@@ -108,15 +153,38 @@ LevelData::LevelData(CompoundTag* tag) {
        hellXZSize = m_xzSize / m_hellScale;
    }

+#ifdef _LARGE_WORLDS
+    // set the host option, in case it wasn't setup already
+    EGameHostOptionWorldSize hostOptionworldSize = e_worldSize_Unknown;
+    switch (m_xzSize) {
+        case LEVEL_WIDTH_CLASSIC:
+            hostOptionworldSize = e_worldSize_Classic;
+            break;
+        case LEVEL_WIDTH_SMALL:
+            hostOptionworldSize = e_worldSize_Small;
+            break;
+        case LEVEL_WIDTH_MEDIUM:
+            hostOptionworldSize = e_worldSize_Medium;
+            break;
+        case LEVEL_WIDTH_LARGE:
+            hostOptionworldSize = e_worldSize_Large;
+            break;
+        default:
+            assert(0);
+            break;
+    }
+    app.SetGameHostOption(eGameHostOption_WorldSize, hostOptionworldSize);
+#endif
+
    /* 4J - we don't store this anymore
-if (tag->contains(L"Player"))
+    if (tag->contains(L"Player"))
    {
    loadedPlayerTag = tag->getCompound(L"Player");
    dimension = loadedPlayerTag->getInt(L"Dimension");
-}
+    }
    else
    {
-            this->loadedPlayerTag = NULL;
+    this->loadedPlayerTag = NULL;
    }
    */
    dimension = 0;
@@ -124,46 +192,48 @@ if (tag->contains(L"Player"))

 LevelData::LevelData(LevelSettings* levelSettings,
                     const std::wstring& levelName) {
-    this->seed = levelSettings->getSeed();
-    this->gameType = levelSettings->getGameType();
-    this->generateMapFeatures = levelSettings->isGenerateMapFeatures();
-    this->spawnBonusChest = levelSettings->hasStartingBonusItems();
+    seed = levelSettings->getSeed();
+    gameType = levelSettings->getGameType();
+    generateMapFeatures = levelSettings->isGenerateMapFeatures();
+    spawnBonusChest = levelSettings->hasStartingBonusItems();
    this->levelName = levelName;
-    this->m_pGenerator = levelSettings->getLevelType();
-    this->hardcore = levelSettings->isHardcore();
+    m_pGenerator = levelSettings->getLevelType();
+    hardcore = levelSettings->isHardcore();
+    generatorOptions = levelSettings->getLevelTypeOptions();
+    allowCommands = levelSettings->getAllowCommands();

    // 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;
+    xSpawn = 0;
+    ySpawn = 0;
+    zSpawn = 0;
+    dayTime = -1;  // 4J-JEV: Edited: To know when this is uninitialized.
+    gameTime = -1;
+    lastPlayed = 0;
+    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 =
+    dimension = 0;
+    version = 0;
+    rainTime = 0;
+    raining = false;
+    thunderTime = 0;
+    thundering = false;
+    initialized = false;
+    newSeaLevel =
        levelSettings
            ->useNewSeaLevel();  // 4J added - only use new sea level for newly
                                 // created maps (sea level changes in 1.8.2)
-    this->hasBeenInCreative =
+    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;
+    bStronghold = false;
+    xStronghold = 0;
+    yStronghold = 0;
+    zStronghold = 0;

-    this->xStrongholdEndPortal = 0;
-    this->zStrongholdEndPortal = 0;
-    this->bStrongholdEndPortal = false;
+    xStrongholdEndPortal = 0;
+    zStrongholdEndPortal = 0;
+    bStrongholdEndPortal = false;
    m_xzSize = levelSettings->getXZSize();
    m_hellScale = levelSettings->getHellScale();

@@ -179,46 +249,63 @@ LevelData::LevelData(LevelSettings* levelSettings,
        ++m_hellScale;
        hellXZSize = m_xzSize / m_hellScale;
    }
+#ifdef _LARGE_WORLDS
+    m_hellScaleOld = m_hellScale;
+    m_xzSizeOld = m_xzSize;
+    m_classicEdgeMoat = false;
+    m_smallEdgeMoat = false;
+    m_mediumEdgeMoat = false;
+#endif
 }

 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;
+    seed = copy->seed;
+    m_pGenerator = copy->m_pGenerator;
+    generatorOptions = copy->generatorOptions;
+    gameType = copy->gameType;
+    generateMapFeatures = copy->generateMapFeatures;
+    spawnBonusChest = copy->spawnBonusChest;
+    xSpawn = copy->xSpawn;
+    ySpawn = copy->ySpawn;
+    zSpawn = copy->zSpawn;
+    gameTime = copy->gameTime;
+    dayTime = copy->dayTime;
+    lastPlayed = copy->lastPlayed;
+    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;
+    dimension = copy->dimension;
+    levelName = copy->levelName;
+    version = copy->version;
+    rainTime = copy->rainTime;
+    raining = copy->raining;
+    thunderTime = copy->thunderTime;
+    thundering = copy->thundering;
+    hardcore = copy->hardcore;
+    allowCommands = copy->allowCommands;
+    initialized = copy->initialized;
+    newSeaLevel = copy->newSeaLevel;
+    hasBeenInCreative = copy->hasBeenInCreative;
+    gameRules = copy->gameRules;

    // 4J-PB for the stronghold position
-    this->bStronghold = copy->bStronghold;
-    this->xStronghold = copy->xStronghold;
-    this->yStronghold = copy->yStronghold;
-    this->zStronghold = copy->zStronghold;
+    bStronghold = copy->bStronghold;
+    xStronghold = copy->xStronghold;
+    yStronghold = copy->yStronghold;
+    zStronghold = copy->zStronghold;

-    this->xStrongholdEndPortal = copy->xStrongholdEndPortal;
-    this->zStrongholdEndPortal = copy->zStrongholdEndPortal;
-    this->bStrongholdEndPortal = copy->bStrongholdEndPortal;
+    xStrongholdEndPortal = copy->xStrongholdEndPortal;
+    zStrongholdEndPortal = copy->zStrongholdEndPortal;
+    bStrongholdEndPortal = copy->bStrongholdEndPortal;
    m_xzSize = copy->m_xzSize;
    m_hellScale = copy->m_hellScale;
+#ifdef _LARGE_WORLDS
+    m_classicEdgeMoat = copy->m_classicEdgeMoat;
+    m_smallEdgeMoat = copy->m_smallEdgeMoat;
+    m_mediumEdgeMoat = copy->m_mediumEdgeMoat;
+    m_xzSizeOld = copy->m_xzSizeOld;
+    m_hellScaleOld = copy->m_hellScaleOld;
+#endif
 }

 CompoundTag* LevelData::createTag() {
@@ -239,13 +326,15 @@ 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->putString(L"generatorOptions", generatorOptions);
    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"Time", gameTime);
+    tag->putLong(L"DayTime", dayTime);
    tag->putLong(L"SizeOnDisk", sizeOnDisk);
    tag->putLong(L"LastPlayed", System::currentTimeMillis());
    tag->putString(L"LevelName", levelName);
@@ -257,6 +346,8 @@ void LevelData::setTagData(CompoundTag* tag) {
    tag->putBoolean(L"hardcore", hardcore);
    tag->putBoolean(L"allowCommands", allowCommands);
    tag->putBoolean(L"initialized", initialized);
+    // 4J: Game rules are now stored with app game host options
+    // tag->putCompound(L"GameRules", gameRules.createTag());
    tag->putBoolean(L"newSeaLevel", newSeaLevel);
    tag->putBoolean(L"hasBeenInCreative", hasBeenInCreative);
    // store the stronghold position
@@ -269,10 +360,16 @@ void LevelData::setTagData(CompoundTag* tag) {
    tag->putInt(L"StrongholdEndPortalX", xStrongholdEndPortal);
    tag->putInt(L"StrongholdEndPortalZ", zStrongholdEndPortal);
    tag->putInt(L"XZSize", m_xzSize);
+#ifdef _LARGE_WORLDS
+    tag->putInt(L"ClassicMoat", m_classicEdgeMoat);
+    tag->putInt(L"SmallMoat", m_smallEdgeMoat);
+    tag->putInt(L"MediumMoat", m_mediumEdgeMoat);
+#endif
+
    tag->putInt(L"HellScale", m_hellScale);
 }

-__int64 LevelData::getSeed() { return seed; }
+int64_t LevelData::getSeed() { return seed; }

 int LevelData::getXSpawn() { return xSpawn; }

@@ -288,9 +385,11 @@ int LevelData::getXStrongholdEndPortal() { return xStrongholdEndPortal; }

 int LevelData::getZStrongholdEndPortal() { return zStrongholdEndPortal; }

-__int64 LevelData::getTime() { return time; }
+int64_t LevelData::getGameTime() { return gameTime; }

-__int64 LevelData::getSizeOnDisk() { return sizeOnDisk; }
+int64_t LevelData::getDayTime() { return dayTime; }
+
+int64_t LevelData::getSizeOnDisk() { return sizeOnDisk; }

 CompoundTag* LevelData::getLoadedPlayerTag() {
    return NULL;  // 4J - we don't store this anymore
@@ -302,7 +401,7 @@ CompoundTag* LevelData::getLoadedPlayerTag() {
 //    return dimension;
 //}

-void LevelData::setSeed(__int64 seed) { this->seed = seed; }
+void LevelData::setSeed(int64_t seed) { this->seed = seed; }

 void LevelData::setXSpawn(int xSpawn) { this->xSpawn = xSpawn; }

@@ -338,9 +437,11 @@ void LevelData::setZStrongholdEndPortal(int zStrongholdEndPortal) {
    this->zStrongholdEndPortal = zStrongholdEndPortal;
 }

-void LevelData::setTime(__int64 time) { this->time = time; }
+void LevelData::setGameTime(int64_t time) { gameTime = time; }

-void LevelData::setSizeOnDisk(__int64 sizeOnDisk) {
+void LevelData::setDayTime(int64_t time) { dayTime = time; }
+
+void LevelData::setSizeOnDisk(int64_t sizeOnDisk) {
    this->sizeOnDisk = sizeOnDisk;
 }

@@ -371,7 +472,7 @@ int LevelData::getVersion() { return version; }

 void LevelData::setVersion(int version) { this->version = version; }

-__int64 LevelData::getLastPlayed() { return lastPlayed; }
+int64_t LevelData::getLastPlayed() { return lastPlayed; }

 bool LevelData::isThundering() { return thundering; }

@@ -405,7 +506,7 @@ void LevelData::setGameType(GameType* gameType) {
    // 4J Added
    hasBeenInCreative =
        hasBeenInCreative || (gameType == GameType::CREATIVE) ||
-        app.GetGameHostOption(eGameHostOption_CheatsEnabled) > 0;
+        (app.GetGameHostOption(eGameHostOption_CheatsEnabled) > 0);
 }

 bool LevelData::useNewSeaLevel() { return newSeaLevel; }
@@ -418,6 +519,12 @@ LevelType* LevelData::getGenerator() { return m_pGenerator; }

 void LevelData::setGenerator(LevelType* generator) { m_pGenerator = generator; }

+std::wstring LevelData::getGeneratorOptions() { return generatorOptions; }
+
+void LevelData::setGeneratorOptions(const std::wstring& options) {
+    generatorOptions = options;
+}
+
 bool LevelData::isHardcore() { return hardcore; }

 bool LevelData::getAllowCommands() { return allowCommands; }
@@ -432,6 +539,33 @@ void LevelData::setInitialized(bool initialized) {
    this->initialized = initialized;
 }

+GameRules* LevelData::getGameRules() { return &gameRules; }
+
 int LevelData::getXZSize() { return m_xzSize; }

+#ifdef _LARGE_WORLDS
+int LevelData::getXZSizeOld() { return m_xzSizeOld; }
+
+void LevelData::getMoatFlags(bool* bClassicEdgeMoat, bool* bSmallEdgeMoat,
+                             bool* bMediumEdgeMoat) {
+    *bClassicEdgeMoat = m_classicEdgeMoat;
+    *bSmallEdgeMoat = m_smallEdgeMoat;
+    *bMediumEdgeMoat = m_mediumEdgeMoat;
+}
+
+int LevelData::getXZHellSizeOld() {
+    int hellXZSizeOld = ceil((float)m_xzSizeOld / m_hellScaleOld);
+
+    while (hellXZSizeOld > HELL_LEVEL_MAX_WIDTH &&
+           m_hellScaleOld < HELL_LEVEL_MAX_SCALE) {
+        assert(0);  // should never get in here?
+        ++m_hellScaleOld;
+        hellXZSizeOld = m_xzSize / m_hellScale;
+    }
+
+    return hellXZSizeOld;
+}
+
+#endif
+
 int LevelData::getHellScale() { return m_hellScale; }