feat: TU19 (Dec 2014) Features & Content (#155)

* try to resolve merge conflict

* feat: TU19 (Dec 2014) Features & Content (#32)

* December 2014 files

* Working release build

* Fix compilation issues

* Add sound to Windows64Media

* Add DLC content and force Tutorial DLC

* Revert "Add DLC content and force Tutorial DLC"

This reverts commit 97a43994725008e35fceb984d5549df9c8cea470.

* Disable broken light packing

* Disable breakpoint during DLC texture map load

Allows DLC loading but the DLC textures are still broken

* Fix post build not working

* ...

* fix vs2022 build

* fix cmake build

---------

Co-authored-by: Loki <lokirautio@gmail.com>

1 files changed, 291 insertions, 175 deletions

diff --git a/Minecraft.World/NetherBridgePieces.h b/Minecraft.World/NetherBridgePieces.h
index 47d2ca67..81cb1560 100644
--- a/Minecraft.World/NetherBridgePieces.h
+++ b/Minecraft.World/NetherBridgePieces.h
@@ -5,8 +5,8 @@ class NetherBridgePieces
 {
 private:
 	static const int MAX_DEPTH = 30;
-    // the dungeon starts at 64 and traverses downwards to this point
-    static const int LOWEST_Y_POSITION = 10;
+	// the dungeon starts at 64 and traverses downwards to this point
+	static const int LOWEST_Y_POSITION = 10;
 
 	// 4J - added to replace use of Class<? extends NetherBridgePiece> within this class
 	enum EPieceClass
@@ -27,317 +27,433 @@ private:
 		EPieceClass_CastleCorridorTBalconyPiece
 	};
 
-    class PieceWeight
+public:
+	static void loadStatic();
+
+private:
+	class PieceWeight
 	{
 	public:
-        EPieceClass pieceClass;
-        const int weight;
-        int placeCount;
-        int maxPlaceCount;
-        bool allowInRow;
-
-        PieceWeight(EPieceClass pieceClass, int weight, int maxPlaceCount, bool allowInRow);
-        PieceWeight(EPieceClass pieceClass, int weight, int maxPlaceCount);
-        bool doPlace(int depth);
-        bool isValid();
-    };
+		EPieceClass pieceClass;
+		const int weight;
+		int placeCount;
+		int maxPlaceCount;
+		bool allowInRow;
+
+		PieceWeight(EPieceClass pieceClass, int weight, int maxPlaceCount, bool allowInRow);
+		PieceWeight(EPieceClass pieceClass, int weight, int maxPlaceCount);
+		bool doPlace(int depth);
+		bool isValid();
+	};
 
 	static const int BRIDGE_PIECEWEIGHTS_COUNT = 6;
 	static const int CASTLE_PIECEWEIGHTS_COUNT = 7;
-    static NetherBridgePieces::PieceWeight *bridgePieceWeights[BRIDGE_PIECEWEIGHTS_COUNT];
+	static NetherBridgePieces::PieceWeight *bridgePieceWeights[BRIDGE_PIECEWEIGHTS_COUNT];
 	static NetherBridgePieces::PieceWeight *castlePieceWeights[CASTLE_PIECEWEIGHTS_COUNT];
 
 private:
 	class NetherBridgePiece;
 	static NetherBridgePiece *findAndCreateBridgePieceFactory(NetherBridgePieces::PieceWeight *piece, list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int depth);
 
-    /**
-     * 
-     *
-     */
+	/**
+	* 
+	*
+	*/
 public:
 	class StartPiece;
 private:
 
-    class NetherBridgePiece : public StructurePiece
+	class NetherBridgePiece : public StructurePiece
 	{
-		protected:
-				  NetherBridgePiece(int genDepth);
+	protected:
+		static const int FORTRESS_TREASURE_ITEMS_COUNT = 11;
+		static WeighedTreasure *fortressTreasureItems[FORTRESS_TREASURE_ITEMS_COUNT];
+
+	public:
+		NetherBridgePiece();
+
+	protected:
+		NetherBridgePiece(int genDepth);
+
+		virtual void readAdditonalSaveData(CompoundTag *tag);
+		virtual void addAdditonalSaveData(CompoundTag *tag);
+
 	private:
 		int updatePieceWeight(list<PieceWeight *> *currentPieces);
 
-        NetherBridgePiece *generatePiece(StartPiece *startPiece, list<NetherBridgePieces::PieceWeight *> *currentPieces, list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int depth);
-        StructurePiece *generateAndAddPiece(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int depth, bool isCastle);
+		NetherBridgePiece *generatePiece(StartPiece *startPiece, list<NetherBridgePieces::PieceWeight *> *currentPieces, list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int depth);
+		StructurePiece *generateAndAddPiece(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int depth, bool isCastle);
 	protected:
 		StructurePiece *generateChildForward(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int xOff, int yOff, bool isCastle);
 		StructurePiece *generateChildLeft(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int yOff, int zOff, bool isCastle);
 		StructurePiece *generateChildRight(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int yOff, int zOff, bool isCastle);
-		
+
 		static bool isOkBox(BoundingBox *box, StartPiece *startRoom); // 4J added startRoom param
 		void generateLightPost(Level *level, Random *random, BoundingBox *chunkBB, int x, int y, int z, int xOff, int zOff);
-		
+
 		void generateLightPostFacingRight(Level *level, Random *random, BoundingBox *chunkBB, int x, int y, int z);
 		void generateLightPostFacingLeft(Level *level, Random *random, BoundingBox *chunkBB, int x, int y, int z);
 		void generateLightPostFacingUp(Level *level, Random *random, BoundingBox *chunkBB, int x, int y, int z);
 		void generateLightPostFacingDown(Level *level, Random *random, BoundingBox *chunkBB, int x, int y, int z);
-    };
+	};
 
-    /**
-     * 
-     *
-     */
+	/**
+	* 
+	*
+	*/
 	class BridgeStraight : public NetherBridgePiece
 	{
+	public:
+		static StructurePiece *Create() { return new BridgeStraight(); }
+		virtual EStructurePiece GetType() { return eStructurePiece_BridgeStraight; }
+
 	private:
 		static const int width = 5;
-        static const int height = 10;
-        static const int depth = 19;
+		static const int height = 10;
+		static const int depth = 19;
 
 	public:
+		BridgeStraight();
 		BridgeStraight(int genDepth, Random *random, BoundingBox *stairsBox, int direction);
-        virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
-        static BridgeStraight *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
-        virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
-    };
+		virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
+		static BridgeStraight *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
+		virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
+	};
 
-    class BridgeEndFiller : public NetherBridgePiece
+	class BridgeEndFiller : public NetherBridgePiece
 	{
+	public:
+		static StructurePiece *Create() { return new BridgeEndFiller(); }
+		virtual EStructurePiece GetType() { return eStructurePiece_BridgeEndFiller; }
+
 	private:
 		static const int width = 5;
-        static const int height = 10;
-        static const int depth = 8;
+		static const int height = 10;
+		static const int depth = 8;
 
-        int selfSeed;
+		int selfSeed;
 
 	public:
+		BridgeEndFiller();
 		BridgeEndFiller(int genDepth, Random *random, BoundingBox *stairsBox, int direction);
-        static BridgeEndFiller *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
-        virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
-    };
 
-    class BridgeCrossing : public NetherBridgePiece
+		static BridgeEndFiller *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
+		virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
+
+	protected:
+		void readAdditonalSaveData(CompoundTag *tag);
+		void addAdditonalSaveData(CompoundTag *tag);
+	};
+
+	class BridgeCrossing : public NetherBridgePiece
 	{
+	public:
+		static StructurePiece *Create() { return new BridgeCrossing(); }
+		virtual EStructurePiece GetType() { return eStructurePiece_BridgeCrossing; }
+
 	private:
 		static const int width = 19;
-        static const int height = 10;
-        static const int depth = 19;
+		static const int height = 10;
+		static const int depth = 19;
 
 	public:
+		BridgeCrossing();
 		BridgeCrossing(int genDepth, Random *random, BoundingBox *stairsBox, int direction);
 	protected:
 		BridgeCrossing(Random *random, int west, int north);
 	public:
-        virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
-        static BridgeCrossing *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
-        virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
-    };
+		virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
+		static BridgeCrossing *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
+		virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
+	};
 
 public:
-    class StartPiece : public BridgeCrossing
+	class StartPiece : public BridgeCrossing
 	{
+	public:
+		virtual EStructurePiece GetType() { return eStructurePiece_NetherBridgeStartPiece; }
 
 	public:
-		bool isLibraryAdded;
-        PieceWeight *previousPiece;
+		PieceWeight *previousPiece;
 		Level *m_level;
 
-        list<PieceWeight *> availableBridgePieces;
-        list<PieceWeight *> availableCastlePieces;
+		list<PieceWeight *> availableBridgePieces;
+		list<PieceWeight *> availableCastlePieces;
 
-        // this queue is used so that the addChildren calls are
-        // called in a random order
-        vector<StructurePiece *> pendingChildren;
+		// this queue is used so that the addChildren calls are
+		// called in a random order
+		vector<StructurePiece *> pendingChildren;
 
-        StartPiece(Random *random, int west, int north, Level *level); // 4J Added level param
+		StartPiece();
+		StartPiece(Random *random, int west, int north, Level *level); // 4J Added level param
 
-    };
+	protected:
+		virtual void readAdditonalSaveData(CompoundTag *tag);
+		virtual void addAdditonalSaveData(CompoundTag *tag);
+	};
 
 private:
-    class RoomCrossing : public NetherBridgePiece
+	class RoomCrossing : public NetherBridgePiece
 	{
+	public:
+		static StructurePiece *Create() { return new RoomCrossing(); }
+		virtual EStructurePiece GetType() { return eStructurePiece_RoomCrossing; }
+
 	private:
 		static const int width = 7;
-        static const int height = 9;
-        static const int depth = 7;
+		static const int height = 9;
+		static const int depth = 7;
 
 	public:
+		RoomCrossing();
 		RoomCrossing(int genDepth, Random *random, BoundingBox *box, int direction);
-        virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
-        static RoomCrossing *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
-        virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
-    };
+		virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
+		static RoomCrossing *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
+		virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
+	};
 
-    class StairsRoom : public NetherBridgePiece
+	class StairsRoom : public NetherBridgePiece
 	{
+	public:
+		static StructurePiece *Create() { return new StairsRoom(); }
+		virtual EStructurePiece GetType() { return eStructurePiece_StairsRoom; }
+
 	private:
 		static const int width = 7;
-        static const int height = 11;
-        static const int depth = 7;
+		static const int height = 11;
+		static const int depth = 7;
 
 	public:
+		StairsRoom();
 		StairsRoom(int genDepth, Random *random, BoundingBox *box, int direction);
 		virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
-        static StairsRoom *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
-        virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
-    };
+		static StairsRoom *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
+		virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
+	};
 
-    class MonsterThrone : public NetherBridgePiece
+	class MonsterThrone : public NetherBridgePiece
 	{
+	public:
+		static StructurePiece *Create() { return new MonsterThrone(); }
+		virtual EStructurePiece GetType() { return eStructurePiece_MonsterThrone; }
+
 	private:
 		static const int width = 7;
-        static const int height = 8;
-        static const int depth = 9;
+		static const int height = 8;
+		static const int depth = 9;
 
-        bool hasPlacedMobSpawner;
+		bool hasPlacedMobSpawner;
 
 	public:
+		MonsterThrone();
 		MonsterThrone(int genDepth, Random *random, BoundingBox *box, int direction);
-        static MonsterThrone *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
-        virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
-    };
-
-    /**
-     * 
-     *
-     */
-    class CastleEntrance : public NetherBridgePiece
+
+	protected:
+		virtual void readAdditonalSaveData(CompoundTag *tag);
+		virtual void addAdditonalSaveData(CompoundTag *tag);
+
+	public:
+		static MonsterThrone *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
+		virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
+	};
+
+	/**
+	* 
+	*
+	*/
+	class CastleEntrance : public NetherBridgePiece
 	{
+	public:
+		static StructurePiece *Create() { return new CastleEntrance(); }
+		virtual EStructurePiece GetType() { return eStructurePiece_CastleEntrance; }
+
 	private:
-        static const int width = 13;
-        static const int height = 14;
-        static const int depth = 13;
-	public:
-        CastleEntrance(int genDepth, Random *random, BoundingBox *stairsBox, int direction);
-        virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
-        static CastleEntrance *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
-        virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
-    };
-
-    /**
-     * 
-     *
-     */
-    class CastleStalkRoom : public NetherBridgePiece
+		static const int width = 13;
+		static const int height = 14;
+		static const int depth = 13;
+	public:
+		CastleEntrance();
+		CastleEntrance(int genDepth, Random *random, BoundingBox *stairsBox, int direction);
+		virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
+		static CastleEntrance *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
+		virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
+	};
+
+	/**
+	* 
+	*
+	*/
+	class CastleStalkRoom : public NetherBridgePiece
 	{
+	public:
+		static StructurePiece *Create() { return new CastleStalkRoom(); }
+		virtual EStructurePiece GetType() { return eStructurePiece_CastleStalkRoom; }
+
 	private:
-        static const int width = 13;
-        static const int height = 14;
-        static const int depth = 13;
+		static const int width = 13;
+		static const int height = 14;
+		static const int depth = 13;
 
 	public:
+		CastleStalkRoom();
 		CastleStalkRoom(int genDepth, Random *random, BoundingBox *stairsBox, int direction);
-        virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
-        static CastleStalkRoom *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
-        virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
-    };
-
-    /**
-     * 
-     *
-     */
+		virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
+		static CastleStalkRoom *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
+		virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
+	};
+
+	/**
+	* 
+	*
+	*/
 	class CastleSmallCorridorPiece : public NetherBridgePiece
 	{
+	public:
+		static StructurePiece *Create() { return new CastleSmallCorridorPiece(); }
+		virtual EStructurePiece GetType() { return eStructurePiece_CastleSmallCorridorPiece; }
+
 	private:
-        static const int width = 5;
-        static const int height = 7;
-        static const int depth = 5;
+		static const int width = 5;
+		static const int height = 7;
+		static const int depth = 5;
 
 	public:
+		CastleSmallCorridorPiece();
 		CastleSmallCorridorPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction);
-        virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
-        static CastleSmallCorridorPiece *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
-        virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
-    };
-
-    /**
-     * 
-     *
-     */
-    class CastleSmallCorridorCrossingPiece : public NetherBridgePiece
+		virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
+		static CastleSmallCorridorPiece *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
+		virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
+	};
+
+	/**
+	* 
+	*
+	*/
+	class CastleSmallCorridorCrossingPiece : public NetherBridgePiece
 	{
+	public:
+		static StructurePiece *Create() { return new CastleSmallCorridorCrossingPiece(); }
+		virtual EStructurePiece GetType() { return eStructurePiece_CastleSmallCorridorCrossingPiece; }
+
 	private:
-        static const int width = 5;
-        static const int height = 7;
-        static const int depth = 5;
+		static const int width = 5;
+		static const int height = 7;
+		static const int depth = 5;
 
 	public:
+		CastleSmallCorridorCrossingPiece();
 		CastleSmallCorridorCrossingPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction);
-        virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
-        static CastleSmallCorridorCrossingPiece *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
-        virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
-    };
-
-    /**
-     * 
-     *
-     */
-    class CastleSmallCorridorRightTurnPiece : public NetherBridgePiece
+		virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
+		static CastleSmallCorridorCrossingPiece *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
+		virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
+	};
+
+	/**
+	* 
+	*
+	*/
+	class CastleSmallCorridorRightTurnPiece : public NetherBridgePiece
 	{
+	public:
+		static StructurePiece *Create() { return new CastleSmallCorridorRightTurnPiece(); }
+		virtual EStructurePiece GetType() { return eStructurePiece_CastleSmallCorridorRightTurnPiece; }
+
 	private:
 		static const int width = 5;
 		static const int height = 7;
 		static const int depth = 5;
 
+		bool isNeedingChest;
+
 	public:
+		CastleSmallCorridorRightTurnPiece();
 		CastleSmallCorridorRightTurnPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction);
-        virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
-        static CastleSmallCorridorRightTurnPiece *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
-        virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
 
-    };
+	protected:
+		virtual void readAdditonalSaveData(CompoundTag *tag);
+		virtual void addAdditonalSaveData(CompoundTag *tag);
+
+	public:
+		virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
+		static CastleSmallCorridorRightTurnPiece *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
+		virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
+
+	};
 
-    /**
-     * 
-     *
-     */
-    class CastleSmallCorridorLeftTurnPiece : public NetherBridgePiece
+	/**
+	* 
+	*
+	*/
+	class CastleSmallCorridorLeftTurnPiece : public NetherBridgePiece
 	{
+	public:
+		static StructurePiece *Create() { return new CastleSmallCorridorLeftTurnPiece(); }
+		virtual EStructurePiece GetType() { return eStructurePiece_CastleSmallCorridorLeftTurnPiece; }
+
 	private:
 		static const int width = 5;
 		static const int height = 7;
 		static const int depth = 5;
+		bool isNeedingChest;
 
 	public:
+		CastleSmallCorridorLeftTurnPiece();
 		CastleSmallCorridorLeftTurnPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction);
-        virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
-        static CastleSmallCorridorLeftTurnPiece *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
-        virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
-    };
-
-    /**
-     * 
-     *
-     */
-    class CastleCorridorStairsPiece : public NetherBridgePiece
+
+	protected:
+		virtual void readAdditonalSaveData(CompoundTag *tag);
+		virtual void addAdditonalSaveData(CompoundTag *tag);
+
+	public:
+		virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
+		static CastleSmallCorridorLeftTurnPiece *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
+		virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
+	};
+
+	/**
+	* 
+	*
+	*/
+	class CastleCorridorStairsPiece : public NetherBridgePiece
 	{
+	public:
+		static StructurePiece *Create() { return new CastleCorridorStairsPiece(); }
+		virtual EStructurePiece GetType() { return eStructurePiece_CastleCorridorStairsPiece; }
+
 	private:
 		static const int width = 5;
 		static const int height = 14;
 		static const int depth = 10;
 
 	public:
+		CastleCorridorStairsPiece();
 		CastleCorridorStairsPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction);
-        virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
-        static CastleCorridorStairsPiece *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
-        virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
+		virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
+		static CastleCorridorStairsPiece *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
+		virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
 
-    };
+	};
 
-    /**
-     * 
-     *
-     */
-    class CastleCorridorTBalconyPiece : public NetherBridgePiece
+	/**
+	* 
+	*
+	*/
+	class CastleCorridorTBalconyPiece : public NetherBridgePiece
 	{
+	public:
+		static StructurePiece *Create() { return new CastleCorridorTBalconyPiece(); }
+		virtual EStructurePiece GetType() { return eStructurePiece_CastleCorridorTBalconyPiece; }
+
 	private:
-        static const int width = 9;
-        static const int height = 7;
-        static const int depth = 9;
+		static const int width = 9;
+		static const int height = 7;
+		static const int depth = 9;
 
 	public:
+		CastleCorridorTBalconyPiece();
 		CastleCorridorTBalconyPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction);
-        virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
-        static CastleCorridorTBalconyPiece *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
-        virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
-    };
+		virtual void addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random);
+		static CastleCorridorTBalconyPiece *createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth);
+		virtual bool postProcess(Level *level, Random *random, BoundingBox *chunkBB);
+	};
 };