restructure codebase according to vcproj filters

2026-06-22 15:45:34 +00:00 · 2026-03-30 09:50:58 -05:00
parent d5cf90c713
commit 451682693e
3015 changed files with 46858 additions and 54635 deletions
--- a/Files/GameRules/LevelGeneration/ConsoleGenerateStructure.cpp
+++ b/Files/GameRules/LevelGeneration/ConsoleGenerateStructure.cpp
@@ -0,0 +1,161 @@
+#include "../../../../../Minecraft.World/Header Files/stdafx.h"
+#include "ConsoleGenerateStructure.h"
+#include "../ConsoleGameRules.h"
+#include "../../../../../Minecraft.World/net/minecraft/world/level/net.minecraft.world.level.h"
+#include "../../../../../Minecraft.World/net/minecraft/world/level/dimension/net.minecraft.world.level.dimension.h"
+#include "../../../../../Minecraft.World/net/minecraft/world/level/levelgen/structure/net.minecraft.world.level.levelgen.structure.h"
+#include "../../../../../Minecraft.World/ConsoleHelpers/StringHelpers.h"
+#include "../../../../../Minecraft.World/net/minecraft/net.minecraft.h"
+
+ConsoleGenerateStructure::ConsoleGenerateStructure() : StructurePiece(0) {
+    m_x = m_y = m_z = 0;
+    boundingBox = nullptr;
+    orientation = Direction::NORTH;
+    m_dimension = 0;
+}
+
+void ConsoleGenerateStructure::getChildren(
+    std::vector<GameRuleDefinition*>* children) {
+    GameRuleDefinition::getChildren(children);
+
+    for (auto it = m_actions.begin(); it != m_actions.end(); it++)
+        children->push_back(*it);
+}
+
+GameRuleDefinition* ConsoleGenerateStructure::addChild(
+    ConsoleGameRules::EGameRuleType ruleType) {
+    GameRuleDefinition* rule = nullptr;
+    if (ruleType == ConsoleGameRules::eGameRuleType_GenerateBox) {
+        rule = new XboxStructureActionGenerateBox();
+        m_actions.push_back((XboxStructureActionGenerateBox*)rule);
+    } else if (ruleType == ConsoleGameRules::eGameRuleType_PlaceBlock) {
+        rule = new XboxStructureActionPlaceBlock();
+        m_actions.push_back((XboxStructureActionPlaceBlock*)rule);
+    } else if (ruleType == ConsoleGameRules::eGameRuleType_PlaceContainer) {
+        rule = new XboxStructureActionPlaceContainer();
+        m_actions.push_back((XboxStructureActionPlaceContainer*)rule);
+    } else if (ruleType == ConsoleGameRules::eGameRuleType_PlaceSpawner) {
+        rule = new XboxStructureActionPlaceSpawner();
+        m_actions.push_back((XboxStructureActionPlaceSpawner*)rule);
+    } else {
+#ifndef _CONTENT_PACKAGE
+        wprintf(
+            L"ConsoleGenerateStructure: Attempted to add invalid child rule - "
+            L"%d\n",
+            ruleType);
+#endif
+    }
+    return rule;
+}
+
+void ConsoleGenerateStructure::writeAttributes(DataOutputStream* dos,
+                                               unsigned int numAttrs) {
+    GameRuleDefinition::writeAttributes(dos, numAttrs + 5);
+
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_x);
+    dos->writeUTF(_toString(m_x));
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_y);
+    dos->writeUTF(_toString(m_y));
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_z);
+    dos->writeUTF(_toString(m_z));
+
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_orientation);
+    dos->writeUTF(_toString(orientation));
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_dimension);
+    dos->writeUTF(_toString(m_dimension));
+}
+
+void ConsoleGenerateStructure::addAttribute(
+    const std::wstring& attributeName, const std::wstring& attributeValue) {
+    if (attributeName.compare(L"x") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_x = value;
+        app.DebugPrintf("ConsoleGenerateStructure: Adding parameter x=%d\n",
+                        m_x);
+    } else if (attributeName.compare(L"y") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_y = value;
+        app.DebugPrintf("ConsoleGenerateStructure: Adding parameter y=%d\n",
+                        m_y);
+    } else if (attributeName.compare(L"z") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_z = value;
+        app.DebugPrintf("ConsoleGenerateStructure: Adding parameter z=%d\n",
+                        m_z);
+    } else if (attributeName.compare(L"orientation") == 0) {
+        int value = _fromString<int>(attributeValue);
+        orientation = value;
+        app.DebugPrintf(
+            "ConsoleGenerateStructure: Adding parameter orientation=%d\n",
+            orientation);
+    } else if (attributeName.compare(L"dim") == 0) {
+        m_dimension = _fromString<int>(attributeValue);
+        if (m_dimension > 1 || m_dimension < -1) m_dimension = 0;
+        app.DebugPrintf(
+            "ApplySchematicRuleDefinition: Adding parameter dimension=%d\n",
+            m_dimension);
+    } else {
+        GameRuleDefinition::addAttribute(attributeName, attributeValue);
+    }
+}
+
+BoundingBox* ConsoleGenerateStructure::getBoundingBox() {
+    if (boundingBox == nullptr) {
+        // Find the max bounds
+        int maxX, maxY, maxZ;
+        maxX = maxY = maxZ = 1;
+        for (auto it = m_actions.begin(); it != m_actions.end(); ++it) {
+            ConsoleGenerateStructureAction* action = *it;
+            maxX = std::max(maxX, action->getEndX());
+            maxY = std::max(maxY, action->getEndY());
+            maxZ = std::max(maxZ, action->getEndZ());
+        }
+
+        boundingBox =
+            new BoundingBox(m_x, m_y, m_z, m_x + maxX, m_y + maxY, m_z + maxZ);
+    }
+    return boundingBox;
+}
+
+bool ConsoleGenerateStructure::postProcess(Level* level, Random* random,
+                                           BoundingBox* chunkBB) {
+    if (level->dimension->id != m_dimension) return false;
+
+    for (auto it = m_actions.begin(); it != m_actions.end(); ++it) {
+        ConsoleGenerateStructureAction* action = *it;
+
+        switch (action->getActionType()) {
+            case ConsoleGameRules::eGameRuleType_GenerateBox: {
+                XboxStructureActionGenerateBox* genBox =
+                    (XboxStructureActionGenerateBox*)action;
+                genBox->generateBoxInLevel(this, level, chunkBB);
+            } break;
+            case ConsoleGameRules::eGameRuleType_PlaceBlock: {
+                XboxStructureActionPlaceBlock* pPlaceBlock =
+                    (XboxStructureActionPlaceBlock*)action;
+                pPlaceBlock->placeBlockInLevel(this, level, chunkBB);
+            } break;
+            case ConsoleGameRules::eGameRuleType_PlaceContainer: {
+                XboxStructureActionPlaceContainer* pPlaceContainer =
+                    (XboxStructureActionPlaceContainer*)action;
+                pPlaceContainer->placeContainerInLevel(this, level, chunkBB);
+            } break;
+            case ConsoleGameRules::eGameRuleType_PlaceSpawner: {
+                XboxStructureActionPlaceSpawner* pPlaceSpawner =
+                    (XboxStructureActionPlaceSpawner*)action;
+                pPlaceSpawner->placeSpawnerInLevel(this, level, chunkBB);
+            } break;
+            default:
+                break;
+        };
+    }
+
+    return false;
+}
+
+bool ConsoleGenerateStructure::checkIntersects(int x0, int y0, int z0, int x1,
+                                               int y1, int z1) {
+    return getBoundingBox()->intersects(x0, y0, z0, x1, y1, z1);
+}
+
+int ConsoleGenerateStructure::getMinY() { return getBoundingBox()->y0; }