restructure codebase according to vcproj filters

Minecraft.Client/Common/Source Files/GameRules/LevelGeneration/StructureActions/XboxStructureActionGenerateBox.cpp

@@ -0,0 +1,97 @@
+#include "../../../../../../Minecraft.World/Header Files/stdafx.h"
+#include "XboxStructureActionGenerateBox.h"
+#include "../../../../../../Minecraft.World/ConsoleHelpers/StringHelpers.h"
+#include "../../../../../../Minecraft.World/net/minecraft/world/level/levelgen/structure/net.minecraft.world.level.levelgen.structure.h"
+
+XboxStructureActionGenerateBox::XboxStructureActionGenerateBox() {
+    m_x0 = m_y0 = m_z0 = m_x1 = m_y1 = m_z1 = m_edgeTile = m_fillTile = 0;
+    m_skipAir = false;
+}
+
+void XboxStructureActionGenerateBox::writeAttributes(DataOutputStream* dos,
+                                                     unsigned int numAttrs) {
+    ConsoleGenerateStructureAction::writeAttributes(dos, numAttrs + 9);
+
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_x0);
+    dos->writeUTF(_toString(m_x0));
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_y0);
+    dos->writeUTF(_toString(m_y0));
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_z0);
+    dos->writeUTF(_toString(m_z0));
+
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_x1);
+    dos->writeUTF(_toString(m_x1));
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_y1);
+    dos->writeUTF(_toString(m_y1));
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_z1);
+    dos->writeUTF(_toString(m_z1));
+
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_edgeTile);
+    dos->writeUTF(_toString(m_edgeTile));
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_fillTile);
+    dos->writeUTF(_toString(m_fillTile));
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_skipAir);
+    dos->writeUTF(_toString(m_skipAir));
+}
+
+void XboxStructureActionGenerateBox::addAttribute(
+    const std::wstring& attributeName, const std::wstring& attributeValue) {
+    if (attributeName.compare(L"x0") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_x0 = value;
+        app.DebugPrintf(
+            "XboxStructureActionGenerateBox: Adding parameter x0=%d\n", m_x0);
+    } else if (attributeName.compare(L"y0") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_y0 = value;
+        app.DebugPrintf(
+            "XboxStructureActionGenerateBox: Adding parameter y0=%d\n", m_y0);
+    } else if (attributeName.compare(L"z0") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_z0 = value;
+        app.DebugPrintf(
+            "XboxStructureActionGenerateBox: Adding parameter z0=%d\n", m_z0);
+    } else if (attributeName.compare(L"x1") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_x1 = value;
+        app.DebugPrintf(
+            "XboxStructureActionGenerateBox: Adding parameter x1=%d\n", m_x1);
+    } else if (attributeName.compare(L"y1") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_y1 = value;
+        app.DebugPrintf(
+            "XboxStructureActionGenerateBox: Adding parameter y1=%d\n", m_y1);
+    } else if (attributeName.compare(L"z1") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_z1 = value;
+        app.DebugPrintf(
+            "XboxStructureActionGenerateBox: Adding parameter z1=%d\n", m_z1);
+    } else if (attributeName.compare(L"edgeTile") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_edgeTile = value;
+        app.DebugPrintf(
+            "XboxStructureActionGenerateBox: Adding parameter edgeTile=%d\n",
+            m_edgeTile);
+    } else if (attributeName.compare(L"fillTile") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_fillTile = value;
+        app.DebugPrintf(
+            "XboxStructureActionGenerateBox: Adding parameter fillTile=%d\n",
+            m_fillTile);
+    } else if (attributeName.compare(L"skipAir") == 0) {
+        if (attributeValue.compare(L"true") == 0) m_skipAir = true;
+        app.DebugPrintf(
+            "XboxStructureActionGenerateBox: Adding parameter skipAir=%s\n",
+            m_skipAir ? "true" : "false");
+    } else {
+        GameRuleDefinition::addAttribute(attributeName, attributeValue);
+    }
+}
+
+bool XboxStructureActionGenerateBox::generateBoxInLevel(
+    StructurePiece* structure, Level* level, BoundingBox* chunkBB) {
+    app.DebugPrintf("XboxStructureActionGenerateBox - generating a box\n");
+    structure->generateBox(level, chunkBB, m_x0, m_y0, m_z0, m_x1, m_y1, m_z1,
+                           m_edgeTile, m_fillTile, m_skipAir);
+    return true;
+}

Minecraft.Client/Common/Source Files/GameRules/LevelGeneration/StructureActions/XboxStructureActionGenerateBox.h

@@ -0,0 +1,30 @@
+#pragma once
+#include "../ConsoleGenerateStructureAction.h"
+
+class StructurePiece;
+class Level;
+class BoundingBox;
+
+class XboxStructureActionGenerateBox : public ConsoleGenerateStructureAction {
+private:
+    int m_x0, m_y0, m_z0, m_x1, m_y1, m_z1, m_edgeTile, m_fillTile;
+    bool m_skipAir;
+
+public:
+    XboxStructureActionGenerateBox();
+
+    virtual ConsoleGameRules::EGameRuleType getActionType() {
+        return ConsoleGameRules::eGameRuleType_GenerateBox;
+    }
+
+    virtual int getEndX() { return m_x1; }
+    virtual int getEndY() { return m_y1; }
+    virtual int getEndZ() { return m_z1; }
+
+    virtual void writeAttributes(DataOutputStream* dos, unsigned int numAttrs);
+    virtual void addAttribute(const std::wstring& attributeName,
+                              const std::wstring& attributeValue);
+
+    bool generateBoxInLevel(StructurePiece* structure, Level* level,
+                            BoundingBox* chunkBB);
+};

Minecraft.Client/Common/Source Files/GameRules/LevelGeneration/StructureActions/XboxStructureActionPlaceBlock.cpp

@@ -0,0 +1,67 @@
+#include "../../../../../../Minecraft.World/Header Files/stdafx.h"
+#include "XboxStructureActionPlaceBlock.h"
+#include "../../../../../../Minecraft.World/ConsoleHelpers/StringHelpers.h"
+#include "../../../../../../Minecraft.World/net/minecraft/world/level/levelgen/structure/net.minecraft.world.level.levelgen.structure.h"
+
+XboxStructureActionPlaceBlock::XboxStructureActionPlaceBlock() {
+    m_x = m_y = m_z = m_tile = m_data = 0;
+}
+
+void XboxStructureActionPlaceBlock::writeAttributes(DataOutputStream* dos,
+                                                    unsigned int numAttrs) {
+    ConsoleGenerateStructureAction::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_data);
+    dos->writeUTF(_toString(m_data));
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_block);
+    dos->writeUTF(_toString(m_tile));
+}
+
+void XboxStructureActionPlaceBlock::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(
+            "XboxStructureActionPlaceBlock: Adding parameter x=%d\n", m_x);
+    } else if (attributeName.compare(L"y") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_y = value;
+        app.DebugPrintf(
+            "XboxStructureActionPlaceBlock: Adding parameter y=%d\n", m_y);
+    } else if (attributeName.compare(L"z") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_z = value;
+        app.DebugPrintf(
+            "XboxStructureActionPlaceBlock: Adding parameter z=%d\n", m_z);
+    } else if (attributeName.compare(L"block") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_tile = value;
+        app.DebugPrintf(
+            "XboxStructureActionPlaceBlock: Adding parameter block=%d\n",
+            m_tile);
+    } else if (attributeName.compare(L"data") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_data = value;
+        app.DebugPrintf(
+            "XboxStructureActionPlaceBlock: Adding parameter data=%d\n",
+            m_data);
+    } else {
+        GameRuleDefinition::addAttribute(attributeName, attributeValue);
+    }
+}
+
+bool XboxStructureActionPlaceBlock::placeBlockInLevel(StructurePiece* structure,
+                                                      Level* level,
+                                                      BoundingBox* chunkBB) {
+    app.DebugPrintf("XboxStructureActionPlaceBlock - placing a block\n");
+    structure->placeBlock(level, m_tile, m_data, m_x, m_y, m_z, chunkBB);
+    return true;
+}

Minecraft.Client/Common/Source Files/GameRules/LevelGeneration/StructureActions/XboxStructureActionPlaceBlock.h

@@ -0,0 +1,29 @@
+#pragma once
+#include "../ConsoleGenerateStructureAction.h"
+
+class StructurePiece;
+class Level;
+class BoundingBox;
+
+class XboxStructureActionPlaceBlock : public ConsoleGenerateStructureAction {
+protected:
+    int m_x, m_y, m_z, m_tile, m_data;
+
+public:
+    XboxStructureActionPlaceBlock();
+
+    virtual ConsoleGameRules::EGameRuleType getActionType() {
+        return ConsoleGameRules::eGameRuleType_PlaceBlock;
+    }
+
+    virtual int getEndX() { return m_x; }
+    virtual int getEndY() { return m_y; }
+    virtual int getEndZ() { return m_z; }
+
+    virtual void writeAttributes(DataOutputStream* dos, unsigned int numAttrs);
+    virtual void addAttribute(const std::wstring& attributeName,
+                              const std::wstring& attributeValue);
+
+    bool placeBlockInLevel(StructurePiece* structure, Level* level,
+                           BoundingBox* chunkBB);
+};

Minecraft.Client/Common/Source Files/GameRules/LevelGeneration/StructureActions/XboxStructureActionPlaceContainer.cpp

@@ -0,0 +1,103 @@
+#include "../../../../../../Minecraft.World/Header Files/stdafx.h"
+#include "../../../../../../Minecraft.World/ConsoleHelpers/StringHelpers.h"
+#include "XboxStructureActionPlaceContainer.h"
+#include "../../LevelRules/RuleDefinitions/AddItemRuleDefinition.h"
+#include "../../../../../../Minecraft.World/net/minecraft/world/level/levelgen/structure/net.minecraft.world.level.levelgen.structure.h"
+#include "../../../../../../Minecraft.World/net/minecraft/world/level/net.minecraft.world.level.h"
+#include "../../../../../../Minecraft.World/net/minecraft/world/level/tile/net.minecraft.world.level.tile.h"
+#include "../../../../../../Minecraft.World/net/minecraft/world/inventory/net.minecraft.world.inventory.h"
+
+XboxStructureActionPlaceContainer::XboxStructureActionPlaceContainer() {
+    m_tile = Tile::chest_Id;
+}
+
+XboxStructureActionPlaceContainer::~XboxStructureActionPlaceContainer() {
+    for (auto it = m_items.begin(); it != m_items.end(); ++it) {
+        delete *it;
+    }
+}
+
+// 4J-JEV: Super class handles attr-facing fine.
+// void XboxStructureActionPlaceContainer::writeAttributes(DataOutputStream
+// *dos, uint32_t numAttrs)
+
+void XboxStructureActionPlaceContainer::getChildren(
+    std::vector<GameRuleDefinition*>* children) {
+    XboxStructureActionPlaceBlock::getChildren(children);
+    for (auto it = m_items.begin(); it != m_items.end(); it++)
+        children->push_back(*it);
+}
+
+GameRuleDefinition* XboxStructureActionPlaceContainer::addChild(
+    ConsoleGameRules::EGameRuleType ruleType) {
+    GameRuleDefinition* rule = nullptr;
+    if (ruleType == ConsoleGameRules::eGameRuleType_AddItem) {
+        rule = new AddItemRuleDefinition();
+        m_items.push_back((AddItemRuleDefinition*)rule);
+    } else {
+#ifndef _CONTENT_PACKAGE
+        wprintf(
+            L"XboxStructureActionPlaceContainer: Attempted to add invalid "
+            L"child rule - %d\n",
+            ruleType);
+#endif
+    }
+    return rule;
+}
+
+void XboxStructureActionPlaceContainer::addAttribute(
+    const std::wstring& attributeName, const std::wstring& attributeValue) {
+    if (attributeName.compare(L"facing") == 0) {
+        int value = _fromString<int>(attributeValue);
+        m_data = value;
+        app.DebugPrintf(
+            "XboxStructureActionPlaceContainer: Adding parameter facing=%d\n",
+            m_data);
+    } else {
+        XboxStructureActionPlaceBlock::addAttribute(attributeName,
+                                                    attributeValue);
+    }
+}
+
+bool XboxStructureActionPlaceContainer::placeContainerInLevel(
+    StructurePiece* structure, Level* level, BoundingBox* chunkBB) {
+    int worldX = structure->getWorldX(m_x, m_z);
+    int worldY = structure->getWorldY(m_y);
+    int worldZ = structure->getWorldZ(m_x, m_z);
+
+    if (chunkBB->isInside(worldX, worldY, worldZ)) {
+        if (level->getTileEntity(worldX, worldY, worldZ) != nullptr) {
+            // Remove the current tile entity
+            level->removeTileEntity(worldX, worldY, worldZ);
+            level->setTileAndData(worldX, worldY, worldZ, 0, 0,
+                                  Tile::UPDATE_ALL);
+        }
+
+        level->setTileAndData(worldX, worldY, worldZ, m_tile, 0,
+                              Tile::UPDATE_ALL);
+        std::shared_ptr<Container> container =
+            std::dynamic_pointer_cast<Container>(
+                level->getTileEntity(worldX, worldY, worldZ));
+
+        app.DebugPrintf(
+            "XboxStructureActionPlaceContainer - placing a container at "
+            "(%d,%d,%d)\n",
+            worldX, worldY, worldZ);
+        if (container != nullptr) {
+            level->setData(worldX, worldY, worldZ, m_data,
+                           Tile::UPDATE_CLIENTS);
+            // Add items
+            int slotId = 0;
+            for (auto it = m_items.begin();
+                 it != m_items.end() &&
+                 (slotId < container->getContainerSize());
+                 ++it, ++slotId) {
+                AddItemRuleDefinition* addItem = *it;
+
+                addItem->addItemToContainer(container, slotId);
+            }
+        }
+        return true;
+    }
+    return false;
+}

Minecraft.Client/Common/Source Files/GameRules/LevelGeneration/StructureActions/XboxStructureActionPlaceContainer.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "XboxStructureActionPlaceBlock.h"
+
+class AddItemRuleDefinition;
+class StructurePiece;
+class Level;
+class BoundingBox;
+
+class XboxStructureActionPlaceContainer : public XboxStructureActionPlaceBlock {
+private:
+    std::vector<AddItemRuleDefinition*> m_items;
+
+public:
+    XboxStructureActionPlaceContainer();
+    ~XboxStructureActionPlaceContainer();
+
+    virtual ConsoleGameRules::EGameRuleType getActionType() {
+        return ConsoleGameRules::eGameRuleType_PlaceContainer;
+    }
+
+    virtual void getChildren(std::vector<GameRuleDefinition*>* children);
+    virtual GameRuleDefinition* addChild(
+        ConsoleGameRules::EGameRuleType ruleType);
+
+    // 4J-JEV: Super class handles attr-facing fine.
+    // virtual void writeAttributes(DataOutputStream *dos, uint32_t
+    // numAttributes);
+
+    virtual void addAttribute(const std::wstring& attributeName,
+                              const std::wstring& attributeValue);
+
+    bool placeContainerInLevel(StructurePiece* structure, Level* level,
+                               BoundingBox* chunkBB);
+};

Minecraft.Client/Common/Source Files/GameRules/LevelGeneration/StructureActions/XboxStructureActionPlaceSpawner.cpp

@@ -0,0 +1,70 @@
+#include "../../../../../../Minecraft.World/Header Files/stdafx.h"
+#include "../../../../../../Minecraft.World/ConsoleHelpers/StringHelpers.h"
+#include "XboxStructureActionPlaceSpawner.h"
+#include "../../../../../../Minecraft.World/net/minecraft/world/level/levelgen/structure/net.minecraft.world.level.levelgen.structure.h"
+#include "../../../../../../Minecraft.World/net/minecraft/world/level/net.minecraft.world.level.h"
+#include "../../../../../../Minecraft.World/net/minecraft/world/level/tile/entity/net.minecraft.world.level.tile.entity.h"
+
+XboxStructureActionPlaceSpawner::XboxStructureActionPlaceSpawner() {
+    m_tile = Tile::mobSpawner_Id;
+    m_entityId = L"Pig";
+}
+
+XboxStructureActionPlaceSpawner::~XboxStructureActionPlaceSpawner() {}
+
+void XboxStructureActionPlaceSpawner::writeAttributes(DataOutputStream* dos,
+                                                      unsigned int numAttrs) {
+    XboxStructureActionPlaceBlock::writeAttributes(dos, numAttrs + 1);
+
+    ConsoleGameRules::write(dos, ConsoleGameRules::eGameRuleAttr_entity);
+    dos->writeUTF(m_entityId);
+}
+
+void XboxStructureActionPlaceSpawner::addAttribute(
+    const std::wstring& attributeName, const std::wstring& attributeValue) {
+    if (attributeName.compare(L"entity") == 0) {
+        m_entityId = attributeValue;
+#ifndef _CONTENT_PACKAGE
+        wprintf(
+            L"XboxStructureActionPlaceSpawner: Adding parameter entity=%ls\n",
+            m_entityId.c_str());
+#endif
+    } else {
+        XboxStructureActionPlaceBlock::addAttribute(attributeName,
+                                                    attributeValue);
+    }
+}
+
+bool XboxStructureActionPlaceSpawner::placeSpawnerInLevel(
+    StructurePiece* structure, Level* level, BoundingBox* chunkBB) {
+    int worldX = structure->getWorldX(m_x, m_z);
+    int worldY = structure->getWorldY(m_y);
+    int worldZ = structure->getWorldZ(m_x, m_z);
+
+    if (chunkBB->isInside(worldX, worldY, worldZ)) {
+        if (level->getTileEntity(worldX, worldY, worldZ) != nullptr) {
+            // Remove the current tile entity
+            level->removeTileEntity(worldX, worldY, worldZ);
+            level->setTileAndData(worldX, worldY, worldZ, 0, 0,
+                                  Tile::UPDATE_ALL);
+        }
+
+        level->setTileAndData(worldX, worldY, worldZ, m_tile, 0,
+                              Tile::UPDATE_ALL);
+        std::shared_ptr<MobSpawnerTileEntity> entity =
+            std::dynamic_pointer_cast<MobSpawnerTileEntity>(
+                level->getTileEntity(worldX, worldY, worldZ));
+
+#ifndef _CONTENT_PACKAGE
+        wprintf(
+            L"XboxStructureActionPlaceSpawner - placing a %ls spawner at "
+            L"(%d,%d,%d)\n",
+            m_entityId.c_str(), worldX, worldY, worldZ);
+#endif
+        if (entity != nullptr) {
+            entity->setEntityId(m_entityId);
+        }
+        return true;
+    }
+    return false;
+}

Minecraft.Client/Common/Source Files/GameRules/LevelGeneration/StructureActions/XboxStructureActionPlaceSpawner.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "XboxStructureActionPlaceBlock.h"
+
+class StructurePiece;
+class Level;
+class BoundingBox;
+class GRFObject;
+
+class XboxStructureActionPlaceSpawner : public XboxStructureActionPlaceBlock {
+private:
+    std::wstring m_entityId;
+
+public:
+    XboxStructureActionPlaceSpawner();
+    ~XboxStructureActionPlaceSpawner();
+
+    virtual ConsoleGameRules::EGameRuleType getActionType() {
+        return ConsoleGameRules::eGameRuleType_PlaceSpawner;
+    }
+
+    virtual void writeAttributes(DataOutputStream* dos, unsigned int numAttrs);
+    virtual void addAttribute(const std::wstring& attributeName,
+                              const std::wstring& attributeValue);
+
+    bool placeSpawnerInLevel(StructurePiece* structure, Level* level,
+                             BoundingBox* chunkBB);
+};