ocrm.bsky.social
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
1#include "stdafx.h"
2#include "net.minecraft.world.item.h"
3#include "net.minecraft.world.level.h"
4#include "net.minecraft.world.level.tile.h"
5#include "net.minecraft.world.level.tile.entity.h"
6#include "net.minecraft.world.level.levelgen.h"
7#include "net.minecraft.world.level.storage.h"
8#include "net.minecraft.world.level.levelgen.structure.h"
9#include "WeighedTreasure.h"
10#include "NetherBridgePieces.h"
11#include "Direction.h"
12
13void NetherBridgePieces::loadStatic()
14{
15 StructureFeatureIO::setPieceId( eStructurePiece_BridgeCrossing, BridgeCrossing::Create, L"NeBCr");
16 StructureFeatureIO::setPieceId( eStructurePiece_BridgeEndFiller, BridgeEndFiller::Create, L"NeBEF");
17 StructureFeatureIO::setPieceId( eStructurePiece_BridgeStraight, BridgeStraight::Create, L"NeBS");
18 StructureFeatureIO::setPieceId( eStructurePiece_CastleCorridorStairsPiece, CastleCorridorStairsPiece::Create, L"NeCCS");
19 StructureFeatureIO::setPieceId( eStructurePiece_CastleCorridorTBalconyPiece, CastleCorridorTBalconyPiece::Create, L"NeCTB");
20 StructureFeatureIO::setPieceId( eStructurePiece_CastleEntrance, CastleEntrance::Create, L"NeCE");
21 StructureFeatureIO::setPieceId( eStructurePiece_CastleSmallCorridorCrossingPiece, CastleSmallCorridorCrossingPiece::Create, L"NeSCSC");
22 StructureFeatureIO::setPieceId( eStructurePiece_CastleSmallCorridorLeftTurnPiece, CastleSmallCorridorLeftTurnPiece::Create, L"NeSCLT");
23 StructureFeatureIO::setPieceId( eStructurePiece_CastleSmallCorridorPiece, CastleSmallCorridorPiece::Create, L"NeSC");
24 StructureFeatureIO::setPieceId( eStructurePiece_CastleSmallCorridorRightTurnPiece, CastleSmallCorridorRightTurnPiece::Create, L"NeSCRT");
25 StructureFeatureIO::setPieceId( eStructurePiece_CastleStalkRoom, CastleStalkRoom::Create, L"NeCSR");
26 StructureFeatureIO::setPieceId( eStructurePiece_MonsterThrone, MonsterThrone::Create, L"NeMT");
27 StructureFeatureIO::setPieceId( eStructurePiece_RoomCrossing, RoomCrossing::Create, L"NeRC");
28 StructureFeatureIO::setPieceId( eStructurePiece_StairsRoom, StairsRoom::Create, L"NeSR");
29 StructureFeatureIO::setPieceId( eStructurePiece_NetherBridgeStartPiece, StartPiece::Create, L"NeStart");
30}
31
32NetherBridgePieces::PieceWeight::PieceWeight(EPieceClass pieceClass, int weight, int maxPlaceCount, bool allowInRow) : weight(weight)
33{
34 this->placeCount = 0;
35 this->pieceClass = pieceClass;
36 this->maxPlaceCount = maxPlaceCount;
37 this->allowInRow = allowInRow;
38}
39
40NetherBridgePieces::PieceWeight::PieceWeight(EPieceClass pieceClass, int weight, int maxPlaceCount) : weight(weight)
41{
42 this->placeCount = 0;
43 this->pieceClass = pieceClass;
44 this->maxPlaceCount = maxPlaceCount;
45 this->allowInRow = false;
46}
47
48bool NetherBridgePieces::PieceWeight::doPlace(int depth)
49{
50 return maxPlaceCount == 0 || placeCount < maxPlaceCount;
51}
52
53bool NetherBridgePieces::PieceWeight::isValid()
54{
55 return maxPlaceCount == 0 || placeCount < maxPlaceCount;
56}
57
58NetherBridgePieces::PieceWeight *NetherBridgePieces::bridgePieceWeights[NetherBridgePieces::BRIDGE_PIECEWEIGHTS_COUNT] =
59{
60 new PieceWeight(EPieceClass_BridgeStraight, 30, 0, true),
61 new PieceWeight(EPieceClass_BridgeCrossing, 10, 4),
62 new PieceWeight(EPieceClass_MonsterThrone, 15, 2), // 4J Stu - Increased weight to ensure that we have these (was 5), required for Blazes and therefore required for brewing
63 new PieceWeight(EPieceClass_CastleEntrance, 15, 1), // 4J Stu - Increased weight to ensure that we have these (was 5), required for CastleStalkRoom, and therefore required for brewing
64 new PieceWeight(EPieceClass_RoomCrossing, 10, 4),
65 new PieceWeight(EPieceClass_StairsRoom, 10, 3),
66};
67
68NetherBridgePieces::PieceWeight *NetherBridgePieces::castlePieceWeights[NetherBridgePieces::CASTLE_PIECEWEIGHTS_COUNT] =
69{
70 new PieceWeight(EPieceClass_CastleStalkRoom, 30, 2), // 4J Stu - Increased weight to ensure that we have these (was 5), required for Nether Wart, and therefore required for brewing
71 new PieceWeight(EPieceClass_CastleSmallCorridorPiece, 25, 0, true),
72 new PieceWeight(EPieceClass_CastleSmallCorridorCrossingPiece, 15, 5),
73 new PieceWeight(EPieceClass_CastleSmallCorridorRightTurnPiece, 5, 10),
74 new PieceWeight(EPieceClass_CastleSmallCorridorLeftTurnPiece, 5, 10),
75 new PieceWeight(EPieceClass_CastleCorridorStairsPiece, 10, 3, true),
76 new PieceWeight(EPieceClass_CastleCorridorTBalconyPiece, 7, 2),
77};
78
79NetherBridgePieces::NetherBridgePiece *NetherBridgePieces::findAndCreateBridgePieceFactory(NetherBridgePieces::PieceWeight *piece, list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int depth)
80{
81 EPieceClass pieceClass = piece->pieceClass;
82 NetherBridgePiece *structurePiece = NULL;
83
84 if (pieceClass == EPieceClass_BridgeStraight)
85 {
86 structurePiece = BridgeStraight::createPiece(pieces, random, footX, footY, footZ, direction, depth);
87 }
88 else if (pieceClass == EPieceClass_BridgeCrossing)
89 {
90 structurePiece = BridgeCrossing::createPiece(pieces, random, footX, footY, footZ, direction, depth);
91 }
92 else if (pieceClass == EPieceClass_RoomCrossing)
93 {
94 structurePiece = RoomCrossing::createPiece(pieces, random, footX, footY, footZ, direction, depth);
95 }
96 else if (pieceClass == EPieceClass_StairsRoom)
97 {
98 structurePiece = StairsRoom::createPiece(pieces, random, footX, footY, footZ, direction, depth);
99 }
100 else if (pieceClass == EPieceClass_MonsterThrone)
101 {
102 structurePiece = MonsterThrone::createPiece(pieces, random, footX, footY, footZ, direction, depth);
103 }
104 else if (pieceClass == EPieceClass_CastleEntrance)
105 {
106 structurePiece = CastleEntrance::createPiece(pieces, random, footX, footY, footZ, direction, depth);
107 }
108 else if (pieceClass == EPieceClass_CastleSmallCorridorPiece)
109 {
110 structurePiece = CastleSmallCorridorPiece::createPiece(pieces, random, footX, footY, footZ, direction, depth);
111 }
112 else if (pieceClass == EPieceClass_CastleSmallCorridorRightTurnPiece)
113 {
114 structurePiece = CastleSmallCorridorRightTurnPiece::createPiece(pieces, random, footX, footY, footZ, direction, depth);
115 }
116 else if (pieceClass == EPieceClass_CastleSmallCorridorLeftTurnPiece)
117 {
118 structurePiece = CastleSmallCorridorLeftTurnPiece::createPiece(pieces, random, footX, footY, footZ, direction, depth);
119 }
120 else if (pieceClass == EPieceClass_CastleCorridorStairsPiece)
121 {
122 structurePiece = CastleCorridorStairsPiece::createPiece(pieces, random, footX, footY, footZ, direction, depth);
123 }
124 else if (pieceClass == EPieceClass_CastleCorridorTBalconyPiece)
125 {
126 structurePiece = CastleCorridorTBalconyPiece::createPiece(pieces, random, footX, footY, footZ, direction, depth);
127 }
128 else if (pieceClass == EPieceClass_CastleSmallCorridorCrossingPiece)
129 {
130 structurePiece = CastleSmallCorridorCrossingPiece::createPiece(pieces, random, footX, footY, footZ, direction, depth);
131 }
132 else if (pieceClass == EPieceClass_CastleStalkRoom)
133 {
134 structurePiece = CastleStalkRoom::createPiece(pieces, random, footX, footY, footZ, direction, depth);
135 }
136 return structurePiece;
137}
138
139WeighedTreasure *NetherBridgePieces::NetherBridgePiece::fortressTreasureItems[FORTRESS_TREASURE_ITEMS_COUNT] = {
140 new WeighedTreasure(Item::diamond_Id, 0, 1, 3, 5),
141 new WeighedTreasure(Item::ironIngot_Id, 0, 1, 5, 5),
142 new WeighedTreasure(Item::goldIngot_Id, 0, 1, 3, 15),
143 new WeighedTreasure(Item::sword_gold_Id, 0, 1, 1, 5),
144 new WeighedTreasure(Item::chestplate_gold_Id, 0, 1, 1, 5),
145 new WeighedTreasure(Item::flintAndSteel_Id, 0, 1, 1, 5),
146 new WeighedTreasure(Item::netherwart_seeds_Id, 0, 3, 7, 5),
147 new WeighedTreasure(Item::saddle_Id, 0, 1, 1, 10),
148 new WeighedTreasure(Item::horseArmorGold_Id, 0, 1, 1, 8),
149 new WeighedTreasure(Item::horseArmorMetal_Id, 0, 1, 1, 5),
150 new WeighedTreasure(Item::horseArmorDiamond_Id, 0, 1, 1, 3),
151};
152
153NetherBridgePieces::NetherBridgePiece::NetherBridgePiece()
154{
155 // for reflection
156}
157
158NetherBridgePieces::NetherBridgePiece::NetherBridgePiece(int genDepth) : StructurePiece(genDepth)
159{
160}
161
162void NetherBridgePieces::NetherBridgePiece::readAdditonalSaveData(CompoundTag *tag)
163{
164}
165
166void NetherBridgePieces::NetherBridgePiece::addAdditonalSaveData(CompoundTag *tag)
167{
168}
169
170int NetherBridgePieces::NetherBridgePiece::updatePieceWeight(list<PieceWeight *> *currentPieces)
171{
172 bool hasAnyPieces = false;
173 int totalWeight = 0;
174 for( AUTO_VAR(it, currentPieces->begin()); it != currentPieces->end(); it++ )
175 {
176 PieceWeight *piece = *it;
177
178 if (piece->maxPlaceCount > 0 && piece->placeCount < piece->maxPlaceCount)
179 {
180 hasAnyPieces = true;
181 }
182 totalWeight += piece->weight;
183 }
184 return (hasAnyPieces ? totalWeight : -1);
185}
186
187NetherBridgePieces::NetherBridgePiece *NetherBridgePieces::NetherBridgePiece::generatePiece(StartPiece *startPiece, list<NetherBridgePieces::PieceWeight *> *currentPieces, list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int depth)
188{
189 int totalWeight = updatePieceWeight(currentPieces);
190 boolean doStuff = totalWeight > 0 && depth <= MAX_DEPTH;
191
192 int numAttempts = 0;
193 while (numAttempts < 5 && doStuff)
194 {
195 numAttempts++;
196
197 int weightSelection = random->nextInt(totalWeight);
198 for( AUTO_VAR(it, currentPieces->begin()); it != currentPieces->end(); it++ )
199 {
200 PieceWeight *piece = *it;
201 weightSelection -= piece->weight;
202 if (weightSelection < 0)
203 {
204 if (!piece->doPlace(depth) || (piece == startPiece->previousPiece && !piece->allowInRow))
205 {
206 break;
207 }
208
209 NetherBridgePiece *structurePiece = findAndCreateBridgePieceFactory(piece, pieces, random, footX, footY, footZ, direction, depth);
210 if (structurePiece != NULL)
211 {
212 piece->placeCount++;
213 startPiece->previousPiece = piece;
214
215 if (!piece->isValid())
216 {
217 currentPieces->remove(piece);
218 }
219 return structurePiece;
220 }
221 }
222 }
223 }
224 {
225 return BridgeEndFiller::createPiece(pieces, random, footX, footY, footZ, direction, depth);
226 }
227
228}
229
230StructurePiece *NetherBridgePieces::NetherBridgePiece::generateAndAddPiece(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int depth, bool isCastle)
231{
232 if (abs(footX - startPiece->getBoundingBox()->x0) > 7 * 16 || abs(footZ - startPiece->getBoundingBox()->z0) > 7 * 16)
233 {
234 return BridgeEndFiller::createPiece(pieces, random, footX, footY, footZ, direction, depth);
235 }
236 list<PieceWeight *> *availablePieces = &startPiece->availableBridgePieces;
237 if (isCastle)
238 {
239 availablePieces = &startPiece->availableCastlePieces;
240 }
241 StructurePiece *newPiece = generatePiece(startPiece, availablePieces, pieces, random, footX, footY, footZ, direction, depth + 1);
242 if (newPiece != NULL)
243 {
244 pieces->push_back(newPiece);
245 startPiece->pendingChildren.push_back(newPiece);
246 }
247 return newPiece;
248}
249
250StructurePiece *NetherBridgePieces::NetherBridgePiece::generateChildForward(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int xOff, int yOff, bool isCastle)
251{
252 switch (orientation)
253 {
254 case Direction::NORTH:
255 return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + xOff, boundingBox->y0 + yOff, boundingBox->z0 - 1, orientation, getGenDepth(), isCastle);
256 case Direction::SOUTH:
257 return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + xOff, boundingBox->y0 + yOff, boundingBox->z1 + 1, orientation, getGenDepth(), isCastle);
258 case Direction::WEST:
259 return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 - 1, boundingBox->y0 + yOff, boundingBox->z0 + xOff, orientation, getGenDepth(), isCastle);
260 case Direction::EAST:
261 return generateAndAddPiece(startPiece, pieces, random, boundingBox->x1 + 1, boundingBox->y0 + yOff, boundingBox->z0 + xOff, orientation, getGenDepth(), isCastle);
262 }
263 return NULL;
264}
265
266StructurePiece *NetherBridgePieces::NetherBridgePiece::generateChildLeft(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int yOff, int zOff, bool isCastle)
267{
268 switch (orientation)
269 {
270 case Direction::NORTH:
271 return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 - 1, boundingBox->y0 + yOff, boundingBox->z0 + zOff, Direction::WEST, getGenDepth(), isCastle);
272 case Direction::SOUTH:
273 return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 - 1, boundingBox->y0 + yOff, boundingBox->z0 + zOff, Direction::WEST, getGenDepth(), isCastle);
274 case Direction::WEST:
275 return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + zOff, boundingBox->y0 + yOff, boundingBox->z0 - 1, Direction::NORTH, getGenDepth(), isCastle);
276 case Direction::EAST:
277 return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + zOff, boundingBox->y0 + yOff, boundingBox->z0 - 1, Direction::NORTH, getGenDepth(), isCastle);
278 }
279 return NULL;
280}
281
282StructurePiece *NetherBridgePieces::NetherBridgePiece::generateChildRight(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int yOff, int zOff, bool isCastle)
283{
284 switch (orientation)
285 {
286 case Direction::NORTH:
287 return generateAndAddPiece(startPiece, pieces, random, boundingBox->x1 + 1, boundingBox->y0 + yOff, boundingBox->z0 + zOff, Direction::EAST, getGenDepth(), isCastle);
288 case Direction::SOUTH:
289 return generateAndAddPiece(startPiece, pieces, random, boundingBox->x1 + 1, boundingBox->y0 + yOff, boundingBox->z0 + zOff, Direction::EAST, getGenDepth(), isCastle);
290 case Direction::WEST:
291 return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + zOff, boundingBox->y0 + yOff, boundingBox->z1 + 1, Direction::SOUTH, getGenDepth(), isCastle);
292 case Direction::EAST:
293 return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + zOff, boundingBox->y0 + yOff, boundingBox->z1 + 1, Direction::SOUTH, getGenDepth(), isCastle);
294 }
295 return NULL;
296}
297
298bool NetherBridgePieces::NetherBridgePiece::isOkBox(BoundingBox *box, StartPiece *startPiece)
299{
300 bool bIsOk = false;
301
302 if(box != NULL)
303 {
304 if( box->y0 > LOWEST_Y_POSITION ) bIsOk = true;
305 int xzSize = (startPiece->m_level->getLevelData()->getXZSize() / startPiece->m_level->getLevelData()->getHellScale()); //HellRandomLevelSource::XZSIZE;
306 int blockMin = -( (xzSize << 4) / 2) + 1;
307 int blockMax = ( (xzSize << 4) / 2 ) - 1;
308
309 if(box->x0 <= blockMin) bIsOk = false;
310 if(box->z0 <= blockMin) bIsOk = false;
311 if(box->x1 >= blockMax) bIsOk = false;
312 if(box->z1 >= blockMax) bIsOk = false;
313 }
314
315 return bIsOk;
316}
317
318void NetherBridgePieces::NetherBridgePiece::generateLightPost(Level *level, Random *random, BoundingBox *chunkBB, int x, int y, int z, int xOff, int zOff)
319{
320 int worldX = getWorldX(x, z);
321 int worldY = getWorldY(y);
322 int worldZ = getWorldZ(x, z);
323
324 if (!chunkBB->isInside(worldX, worldY, worldZ))
325 {
326 return;
327 }
328
329 if (level->isEmptyTile(worldX, worldY, worldZ) && level->isEmptyTile(worldX, worldY + 1, worldZ) && level->isEmptyTile(worldX, worldY + 2, worldZ)
330 && level->isEmptyTile(worldX, worldY + 3, worldZ))
331 {
332 level->setTileAndData(worldX, worldY, worldZ, Tile::netherFence_Id, 0, Tile::UPDATE_CLIENTS);
333 level->setTileAndData(worldX, worldY + 1, worldZ, Tile::netherFence_Id, 0, Tile::UPDATE_CLIENTS);
334 level->setTileAndData(worldX, worldY + 2, worldZ, Tile::netherFence_Id, 0, Tile::UPDATE_CLIENTS);
335 level->setTileAndData(worldX, worldY + 3, worldZ, Tile::netherFence_Id, 0, Tile::UPDATE_CLIENTS);
336 placeBlock(level, Tile::netherFence_Id, 0, x + xOff, y + 3, z + zOff, chunkBB);
337 placeBlock(level, Tile::glowstone_Id, 0, x + xOff, y + 2, z + zOff, chunkBB);
338 }
339}
340
341void NetherBridgePieces::NetherBridgePiece::generateLightPostFacingRight(Level *level, Random *random, BoundingBox *chunkBB, int x, int y, int z)
342{
343 generateLightPost(level, random, chunkBB, x, y, z, 1, 0);
344}
345
346void NetherBridgePieces::NetherBridgePiece::generateLightPostFacingLeft(Level *level, Random *random, BoundingBox *chunkBB, int x, int y, int z)
347{
348 generateLightPost(level, random, chunkBB, x, y, z, -1, 0);
349}
350
351void NetherBridgePieces::NetherBridgePiece::generateLightPostFacingUp(Level *level, Random *random, BoundingBox *chunkBB, int x, int y, int z)
352{
353 generateLightPost(level, random, chunkBB, x, y, z, 0, 1);
354}
355
356void NetherBridgePieces::NetherBridgePiece::generateLightPostFacingDown(Level *level, Random *random, BoundingBox *chunkBB, int x, int y, int z)
357{
358 generateLightPost(level, random, chunkBB, x, y, z, 0, -1);
359}
360
361NetherBridgePieces::BridgeStraight::BridgeStraight()
362{
363 // for reflection
364}
365
366NetherBridgePieces::BridgeStraight::BridgeStraight(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth)
367{
368 orientation = direction;
369 boundingBox = stairsBox;
370}
371
372void NetherBridgePieces::BridgeStraight::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random)
373{
374 generateChildForward((StartPiece *) startPiece, pieces, random, 1, 3, false);
375}
376
377NetherBridgePieces::BridgeStraight *NetherBridgePieces::BridgeStraight::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth)
378{
379 BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, -3, 0, width, height, depth, direction);
380
381 StartPiece *startPiece = NULL;
382 if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
383
384 if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL)
385 {
386 delete box;
387 return NULL;
388 }
389
390 return new BridgeStraight(genDepth, random, box, direction);
391}
392
393bool NetherBridgePieces::BridgeStraight::postProcess(Level *level, Random *random, BoundingBox *chunkBB)
394{
395 // floor
396 generateBox(level, chunkBB, 0, 3, 0, width - 1, 4, depth - 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
397 // room air
398 generateBox(level, chunkBB, 1, 5, 0, 3, 7, depth - 1, 0, 0, false);
399
400 // hand rails
401 generateBox(level, chunkBB, 0, 5, 0, 0, 5, depth - 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
402 generateBox(level, chunkBB, 4, 5, 0, 4, 5, depth - 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
403
404 // supports
405 generateBox(level, chunkBB, 0, 2, 0, 4, 2, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
406 generateBox(level, chunkBB, 0, 2, 13, 4, 2, 18, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
407 generateBox(level, chunkBB, 0, 0, 0, 4, 1, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
408 generateBox(level, chunkBB, 0, 0, 15, 4, 1, 18, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
409
410 for (int x = 0; x <= 4; x++)
411 {
412 for (int z = 0; z <= 2; z++)
413 {
414 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
415 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, 18 - z, chunkBB);
416 }
417 }
418
419 generateBox(level, chunkBB, 0, 1, 1, 0, 4, 1, Tile::netherFence_Id, Tile::netherFence_Id, false);
420 generateBox(level, chunkBB, 0, 3, 4, 0, 4, 4, Tile::netherFence_Id, Tile::netherFence_Id, false);
421 generateBox(level, chunkBB, 0, 3, 14, 0, 4, 14, Tile::netherFence_Id, Tile::netherFence_Id, false);
422 generateBox(level, chunkBB, 0, 1, 17, 0, 4, 17, Tile::netherFence_Id, Tile::netherFence_Id, false);
423 generateBox(level, chunkBB, 4, 1, 1, 4, 4, 1, Tile::netherFence_Id, Tile::netherFence_Id, false);
424 generateBox(level, chunkBB, 4, 3, 4, 4, 4, 4, Tile::netherFence_Id, Tile::netherFence_Id, false);
425 generateBox(level, chunkBB, 4, 3, 14, 4, 4, 14, Tile::netherFence_Id, Tile::netherFence_Id, false);
426 generateBox(level, chunkBB, 4, 1, 17, 4, 4, 17, Tile::netherFence_Id, Tile::netherFence_Id, false);
427
428 return true;
429}
430
431NetherBridgePieces::BridgeEndFiller::BridgeEndFiller()
432{
433 // for reflection
434}
435
436NetherBridgePieces::BridgeEndFiller::BridgeEndFiller(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth)
437{
438 orientation = direction;
439 boundingBox = stairsBox;
440 selfSeed = random->nextInt();
441}
442
443NetherBridgePieces::BridgeEndFiller *NetherBridgePieces::BridgeEndFiller::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth)
444{
445 BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, -3, 0, width, height, depth, direction);
446
447 StartPiece *startPiece = NULL;
448 if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
449
450 if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL)
451 {
452 delete box;
453 return NULL;
454 }
455
456 return new BridgeEndFiller(genDepth, random, box, direction);
457}
458
459bool NetherBridgePieces::BridgeEndFiller::postProcess(Level *level, Random *random, BoundingBox *chunkBB)
460{
461 Random *selfRandom = new Random(selfSeed);
462
463 // floor
464 for (int x = 0; x <= 4; x++)
465 {
466 for (int y = 3; y <= 4; y++)
467 {
468 int z = selfRandom->nextInt(8);
469 generateBox(level, chunkBB, x, y, 0, x, y, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
470 }
471 }
472
473 // hand rails
474 {
475 int z = selfRandom->nextInt(8);
476 generateBox(level, chunkBB, 0, 5, 0, 0, 5, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
477 }
478 {
479 int z = selfRandom->nextInt(8);
480 generateBox(level, chunkBB, 4, 5, 0, 4, 5, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
481 }
482
483 // supports
484 for (int x = 0; x <= 4; x++)
485 {
486 int z = selfRandom->nextInt(5);
487 generateBox(level, chunkBB, x, 2, 0, x, 2, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
488 }
489 for (int x = 0; x <= 4; x++)
490 {
491 for (int y = 0; y <= 1; y++)
492 {
493 int z = selfRandom->nextInt(3);
494 generateBox(level, chunkBB, x, y, 0, x, y, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
495 }
496 }
497
498 delete selfRandom;
499
500 return true;
501}
502
503void NetherBridgePieces::BridgeEndFiller::readAdditonalSaveData(CompoundTag *tag)
504{
505 NetherBridgePiece::readAdditonalSaveData(tag);
506
507 selfSeed = tag->getInt(L"Seed");
508}
509
510void NetherBridgePieces::BridgeEndFiller::addAdditonalSaveData(CompoundTag *tag)
511{
512 NetherBridgePiece::addAdditonalSaveData(tag);
513
514 tag->putInt(L"Seed", selfSeed);
515}
516
517NetherBridgePieces::BridgeCrossing::BridgeCrossing()
518{
519 // for reflection
520}
521
522NetherBridgePieces::BridgeCrossing::BridgeCrossing(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth)
523{
524 orientation = direction;
525 boundingBox = stairsBox;
526}
527
528NetherBridgePieces::BridgeCrossing::BridgeCrossing(Random *random, int west, int north) : NetherBridgePiece(0)
529{
530 orientation = random->nextInt(4);
531
532 switch (orientation)
533 {
534 case Direction::NORTH:
535 case Direction::SOUTH:
536 boundingBox = new BoundingBox(west, 64, north, west + width - 1, 64 + height - 1, north + depth - 1);
537 break;
538 default:
539 boundingBox = new BoundingBox(west, 64, north, west + depth - 1, 64 + height - 1, north + width - 1);
540 break;
541 }
542}
543
544void NetherBridgePieces::BridgeCrossing::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random)
545{
546 generateChildForward((StartPiece *) startPiece, pieces, random, 8, 3, false);
547 generateChildLeft((StartPiece *) startPiece, pieces, random, 3, 8, false);
548 generateChildRight((StartPiece *) startPiece, pieces, random, 3, 8, false);
549}
550
551NetherBridgePieces::BridgeCrossing *NetherBridgePieces::BridgeCrossing::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth)
552{
553 BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -8, -3, 0, width, height, depth, direction);
554
555 StartPiece *startPiece = NULL;
556 if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
557
558 if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL)
559 {
560 delete box;
561 return NULL;
562 }
563
564 return new BridgeCrossing(genDepth, random, box, direction);
565}
566
567bool NetherBridgePieces::BridgeCrossing::postProcess(Level *level, Random *random, BoundingBox *chunkBB)
568{
569 // floor
570 generateBox(level, chunkBB, 7, 3, 0, 11, 4, 18, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
571 generateBox(level, chunkBB, 0, 3, 7, 18, 4, 11, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
572 // room air
573 generateBox(level, chunkBB, 8, 5, 0, 10, 7, 18, 0, 0, false);
574 generateBox(level, chunkBB, 0, 5, 8, 18, 7, 10, 0, 0, false);
575 // hand rails
576 generateBox(level, chunkBB, 7, 5, 0, 7, 5, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
577 generateBox(level, chunkBB, 7, 5, 11, 7, 5, 18, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
578 generateBox(level, chunkBB, 11, 5, 0, 11, 5, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
579 generateBox(level, chunkBB, 11, 5, 11, 11, 5, 18, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
580 generateBox(level, chunkBB, 0, 5, 7, 7, 5, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
581 generateBox(level, chunkBB, 11, 5, 7, 18, 5, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
582 generateBox(level, chunkBB, 0, 5, 11, 7, 5, 11, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
583 generateBox(level, chunkBB, 11, 5, 11, 18, 5, 11, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
584
585 // supports
586 generateBox(level, chunkBB, 7, 2, 0, 11, 2, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
587 generateBox(level, chunkBB, 7, 2, 13, 11, 2, 18, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
588 generateBox(level, chunkBB, 7, 0, 0, 11, 1, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
589 generateBox(level, chunkBB, 7, 0, 15, 11, 1, 18, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
590 for (int x = 7; x <= 11; x++)
591 {
592 for (int z = 0; z <= 2; z++)
593 {
594 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
595 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, 18 - z, chunkBB);
596 }
597 }
598
599 generateBox(level, chunkBB, 0, 2, 7, 5, 2, 11, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
600 generateBox(level, chunkBB, 13, 2, 7, 18, 2, 11, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
601 generateBox(level, chunkBB, 0, 0, 7, 3, 1, 11, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
602 generateBox(level, chunkBB, 15, 0, 7, 18, 1, 11, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
603 for (int x = 0; x <= 2; x++)
604 {
605 for (int z = 7; z <= 11; z++)
606 {
607 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
608 fillColumnDown(level, Tile::netherBrick_Id, 0, 18 - x, -1, z, chunkBB);
609 }
610 }
611
612 return true;
613}
614
615NetherBridgePieces::StartPiece::StartPiece()
616{
617 // for reflection
618 previousPiece = NULL;
619}
620
621NetherBridgePieces::StartPiece::StartPiece(Random *random, int west, int north, Level *level) : BridgeCrossing(random, west, north)
622{
623 previousPiece = NULL;
624 m_level = level;
625
626 for( int i = 0; i < BRIDGE_PIECEWEIGHTS_COUNT; i++ )
627 {
628 PieceWeight *piece = bridgePieceWeights[i];
629 piece->placeCount = 0;
630 availableBridgePieces.push_back(piece);
631 }
632
633 for( int i = 0; i < CASTLE_PIECEWEIGHTS_COUNT; i++ )
634 {
635 PieceWeight *piece = castlePieceWeights[i];
636
637 piece->placeCount = 0;
638 availableCastlePieces.push_back(piece);
639 }
640}
641
642void NetherBridgePieces::StartPiece::readAdditonalSaveData(CompoundTag *tag)
643{
644 BridgeCrossing::readAdditonalSaveData(tag);
645}
646
647void NetherBridgePieces::StartPiece::addAdditonalSaveData(CompoundTag *tag)
648{
649 BridgeCrossing::addAdditonalSaveData(tag);
650}
651
652NetherBridgePieces::RoomCrossing::RoomCrossing()
653{
654 // for reflection
655}
656
657NetherBridgePieces::RoomCrossing::RoomCrossing(int genDepth, Random *random, BoundingBox *box, int direction) : NetherBridgePiece(genDepth)
658{
659 orientation = direction;
660 boundingBox = box;
661}
662
663void NetherBridgePieces::RoomCrossing::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random)
664{
665 generateChildForward((StartPiece *) startPiece, pieces, random, 2, 0, false);
666 generateChildLeft((StartPiece *) startPiece, pieces, random, 0, 2, false);
667 generateChildRight((StartPiece *) startPiece, pieces, random, 0, 2, false);
668}
669
670NetherBridgePieces::RoomCrossing *NetherBridgePieces::RoomCrossing::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth)
671{
672 BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -2, 0, 0, width, height, depth, direction);
673
674 StartPiece *startPiece = NULL;
675 if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
676
677 if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL)
678 {
679 delete box;
680 return NULL;
681 }
682
683 return new RoomCrossing(genDepth, random, box, direction);
684}
685
686bool NetherBridgePieces::RoomCrossing::postProcess(Level *level, Random *random, BoundingBox *chunkBB)
687{
688 // floor
689 generateBox(level, chunkBB, 0, 0, 0, width - 1, 1, depth - 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
690 // room air
691 generateBox(level, chunkBB, 0, 2, 0, 6, 7, 6, 0, 0, false);
692
693 // walls
694 generateBox(level, chunkBB, 0, 2, 0, 1, 6, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
695 generateBox(level, chunkBB, 0, 2, 6, 1, 6, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
696 generateBox(level, chunkBB, 5, 2, 0, 6, 6, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
697 generateBox(level, chunkBB, 5, 2, 6, 6, 6, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
698 generateBox(level, chunkBB, 0, 2, 0, 0, 6, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
699 generateBox(level, chunkBB, 0, 2, 5, 0, 6, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
700 generateBox(level, chunkBB, 6, 2, 0, 6, 6, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
701 generateBox(level, chunkBB, 6, 2, 5, 6, 6, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
702
703 // entries
704 generateBox(level, chunkBB, 2, 6, 0, 4, 6, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
705 generateBox(level, chunkBB, 2, 5, 0, 4, 5, 0, Tile::netherFence_Id, Tile::netherFence_Id, false);
706 generateBox(level, chunkBB, 2, 6, 6, 4, 6, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
707 generateBox(level, chunkBB, 2, 5, 6, 4, 5, 6, Tile::netherFence_Id, Tile::netherFence_Id, false);
708 generateBox(level, chunkBB, 0, 6, 2, 0, 6, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
709 generateBox(level, chunkBB, 0, 5, 2, 0, 5, 4, Tile::netherFence_Id, Tile::netherFence_Id, false);
710 generateBox(level, chunkBB, 6, 6, 2, 6, 6, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
711 generateBox(level, chunkBB, 6, 5, 2, 6, 5, 4, Tile::netherFence_Id, Tile::netherFence_Id, false);
712
713 for (int x = 0; x <= 6; x++)
714 {
715 for (int z = 0; z <= 6; z++)
716 {
717 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
718 }
719 }
720
721 return true;
722}
723
724NetherBridgePieces::StairsRoom::StairsRoom()
725{
726 // for reflection
727}
728
729NetherBridgePieces::StairsRoom::StairsRoom(int genDepth, Random *random, BoundingBox *box, int direction) : NetherBridgePiece(genDepth)
730{
731 orientation = direction;
732 boundingBox = box;
733}
734
735void NetherBridgePieces::StairsRoom::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random)
736{
737 generateChildRight((StartPiece *) startPiece, pieces, random, 6, 2, false);
738}
739
740NetherBridgePieces::StairsRoom *NetherBridgePieces::StairsRoom::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth)
741{
742 BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -2, 0, 0, width, height, depth, direction);
743
744 StartPiece *startPiece = NULL;
745 if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
746
747 if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL)
748 {
749 delete box;
750 return NULL;
751 }
752
753 return new StairsRoom(genDepth, random, box, direction);
754}
755
756bool NetherBridgePieces::StairsRoom::postProcess(Level *level, Random *random, BoundingBox *chunkBB)
757{
758 // floor
759 generateBox(level, chunkBB, 0, 0, 0, width - 1, 1, depth - 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
760 // room air
761 generateBox(level, chunkBB, 0, 2, 0, 6, 10, 6, 0, 0, false);
762
763 // walls
764 generateBox(level, chunkBB, 0, 2, 0, 1, 8, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
765 generateBox(level, chunkBB, 5, 2, 0, 6, 8, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
766 generateBox(level, chunkBB, 0, 2, 1, 0, 8, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
767 generateBox(level, chunkBB, 6, 2, 1, 6, 8, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
768 generateBox(level, chunkBB, 1, 2, 6, 5, 8, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
769
770 // wall decorations
771 generateBox(level, chunkBB, 0, 3, 2, 0, 5, 4, Tile::netherFence_Id, Tile::netherFence_Id, false);
772 generateBox(level, chunkBB, 6, 3, 2, 6, 5, 2, Tile::netherFence_Id, Tile::netherFence_Id, false);
773 generateBox(level, chunkBB, 6, 3, 4, 6, 5, 4, Tile::netherFence_Id, Tile::netherFence_Id, false);
774
775 // stair
776 placeBlock(level, Tile::netherBrick_Id, 0, 5, 2, 5, chunkBB);
777 generateBox(level, chunkBB, 4, 2, 5, 4, 3, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
778 generateBox(level, chunkBB, 3, 2, 5, 3, 4, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
779 generateBox(level, chunkBB, 2, 2, 5, 2, 5, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
780 generateBox(level, chunkBB, 1, 2, 5, 1, 6, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
781
782 // top floor
783 generateBox(level, chunkBB, 1, 7, 1, 5, 7, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
784 generateBox(level, chunkBB, 6, 8, 2, 6, 8, 4, 0, 0, false);
785
786 // entries
787 generateBox(level, chunkBB, 2, 6, 0, 4, 8, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
788 generateBox(level, chunkBB, 2, 5, 0, 4, 5, 0, Tile::netherFence_Id, Tile::netherFence_Id, false);
789
790 for (int x = 0; x <= 6; x++)
791 {
792 for (int z = 0; z <= 6; z++)
793 {
794 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
795 }
796 }
797
798 return true;
799
800}
801
802NetherBridgePieces::MonsterThrone::MonsterThrone()
803{
804 // for reflection
805}
806
807NetherBridgePieces::MonsterThrone::MonsterThrone(int genDepth, Random *random, BoundingBox *box, int direction) : NetherBridgePiece(genDepth)
808{
809 orientation = direction;
810 boundingBox = box;
811 hasPlacedMobSpawner = false;
812}
813
814NetherBridgePieces::MonsterThrone *NetherBridgePieces::MonsterThrone::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth)
815{
816 BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -2, 0, 0, width, height, depth, direction);
817
818 StartPiece *startPiece = NULL;
819 if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
820
821 if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL)
822 {
823 delete box;
824 return NULL;
825 }
826
827 return new MonsterThrone(genDepth, random, box, direction);
828}
829
830void NetherBridgePieces::MonsterThrone::readAdditonalSaveData(CompoundTag *tag)
831{
832 NetherBridgePiece::readAdditonalSaveData(tag);
833
834 hasPlacedMobSpawner = tag->getBoolean(L"Mob");
835}
836
837void NetherBridgePieces::MonsterThrone::addAdditonalSaveData(CompoundTag *tag)
838{
839 NetherBridgePiece::addAdditonalSaveData(tag);
840
841 tag->putBoolean(L"Mob", hasPlacedMobSpawner);
842}
843
844bool NetherBridgePieces::MonsterThrone::postProcess(Level *level, Random *random, BoundingBox *chunkBB)
845{
846 generateBox(level, chunkBB, 0, 2, 0, 6, 7, 7, 0, 0, false);
847
848 // floors
849 generateBox(level, chunkBB, 1, 0, 0, 5, 1, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
850 generateBox(level, chunkBB, 1, 2, 1, 5, 2, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
851 generateBox(level, chunkBB, 1, 3, 2, 5, 3, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
852 generateBox(level, chunkBB, 1, 4, 3, 5, 4, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
853
854 // rails
855 generateBox(level, chunkBB, 1, 2, 0, 1, 4, 2, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
856 generateBox(level, chunkBB, 5, 2, 0, 5, 4, 2, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
857 generateBox(level, chunkBB, 1, 5, 2, 1, 5, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
858 generateBox(level, chunkBB, 5, 5, 2, 5, 5, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
859 generateBox(level, chunkBB, 0, 5, 3, 0, 5, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
860 generateBox(level, chunkBB, 6, 5, 3, 6, 5, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
861 generateBox(level, chunkBB, 1, 5, 8, 5, 5, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
862
863 placeBlock(level, Tile::netherFence_Id, 0, 1, 6, 3, chunkBB);
864 placeBlock(level, Tile::netherFence_Id, 0, 5, 6, 3, chunkBB);
865 generateBox(level, chunkBB, 0, 6, 3, 0, 6, 8, Tile::netherFence_Id, Tile::netherFence_Id, false);
866 generateBox(level, chunkBB, 6, 6, 3, 6, 6, 8, Tile::netherFence_Id, Tile::netherFence_Id, false);
867 generateBox(level, chunkBB, 1, 6, 8, 5, 7, 8, Tile::netherFence_Id, Tile::netherFence_Id, false);
868 generateBox(level, chunkBB, 2, 8, 8, 4, 8, 8, Tile::netherFence_Id, Tile::netherFence_Id, false);
869
870
871 if (!hasPlacedMobSpawner)
872 {
873 int y = getWorldY(5), x = getWorldX(3, 5), z = getWorldZ(3, 5);
874 if (chunkBB->isInside(x, y, z))
875 {
876 hasPlacedMobSpawner = true;
877 level->setTileAndData(x, y, z, Tile::mobSpawner_Id, 0, Tile::UPDATE_CLIENTS);
878 shared_ptr<MobSpawnerTileEntity> entity = dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x, y, z) );
879 if (entity != NULL) entity->getSpawner()->setEntityId(L"Blaze");
880 }
881 }
882
883 for (int x = 0; x <= 6; x++)
884 {
885 for (int z = 0; z <= 6; z++)
886 {
887 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
888 }
889 }
890
891 return true;
892}
893
894NetherBridgePieces::CastleEntrance::CastleEntrance()
895{
896 // for reflection
897}
898
899NetherBridgePieces::CastleEntrance::CastleEntrance(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth)
900{
901 orientation = direction;
902 boundingBox = stairsBox;
903}
904
905void NetherBridgePieces::CastleEntrance::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random)
906{
907 generateChildForward((StartPiece *) startPiece, pieces, random, 5, 3, true);
908}
909
910NetherBridgePieces::CastleEntrance *NetherBridgePieces::CastleEntrance::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth)
911{
912 BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -5, -3, 0, width, height, depth, direction);
913
914 StartPiece *startPiece = NULL;
915 if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
916
917 if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL)
918 {
919 delete box;
920 return NULL;
921 }
922
923 return new CastleEntrance(genDepth, random, box, direction);
924}
925
926bool NetherBridgePieces::CastleEntrance::postProcess(Level *level, Random *random, BoundingBox *chunkBB)
927{
928 // floor
929 generateBox(level, chunkBB, 0, 3, 0, 12, 4, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
930 // room air
931 generateBox(level, chunkBB, 0, 5, 0, 12, 13, 12, 0, 0, false);
932
933 // walls
934 generateBox(level, chunkBB, 0, 5, 0, 1, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
935 generateBox(level, chunkBB, 11, 5, 0, 12, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
936 generateBox(level, chunkBB, 2, 5, 11, 4, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
937 generateBox(level, chunkBB, 8, 5, 11, 10, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
938 generateBox(level, chunkBB, 5, 9, 11, 7, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
939 generateBox(level, chunkBB, 2, 5, 0, 4, 12, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
940 generateBox(level, chunkBB, 8, 5, 0, 10, 12, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
941 generateBox(level, chunkBB, 5, 9, 0, 7, 12, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
942
943 // roof
944 generateBox(level, chunkBB, 2, 11, 2, 10, 12, 10, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
945
946 // entrance decoration
947 generateBox(level, chunkBB, 5, 8, 0, 7, 8, 0, Tile::netherFence_Id, Tile::netherFence_Id, false);
948
949 // wall decorations
950 for (int i = 1; i <= 11; i += 2)
951 {
952 generateBox(level, chunkBB, i, 10, 0, i, 11, 0, Tile::netherFence_Id, Tile::netherFence_Id, false);
953 generateBox(level, chunkBB, i, 10, 12, i, 11, 12, Tile::netherFence_Id, Tile::netherFence_Id, false);
954 generateBox(level, chunkBB, 0, 10, i, 0, 11, i, Tile::netherFence_Id, Tile::netherFence_Id, false);
955 generateBox(level, chunkBB, 12, 10, i, 12, 11, i, Tile::netherFence_Id, Tile::netherFence_Id, false);
956 placeBlock(level, Tile::netherBrick_Id, 0, i, 13, 0, chunkBB);
957 placeBlock(level, Tile::netherBrick_Id, 0, i, 13, 12, chunkBB);
958 placeBlock(level, Tile::netherBrick_Id, 0, 0, 13, i, chunkBB);
959 placeBlock(level, Tile::netherBrick_Id, 0, 12, 13, i, chunkBB);
960 placeBlock(level, Tile::netherFence_Id, 0, i + 1, 13, 0, chunkBB);
961 placeBlock(level, Tile::netherFence_Id, 0, i + 1, 13, 12, chunkBB);
962 placeBlock(level, Tile::netherFence_Id, 0, 0, 13, i + 1, chunkBB);
963 placeBlock(level, Tile::netherFence_Id, 0, 12, 13, i + 1, chunkBB);
964 }
965 placeBlock(level, Tile::netherFence_Id, 0, 0, 13, 0, chunkBB);
966 placeBlock(level, Tile::netherFence_Id, 0, 0, 13, 12, chunkBB);
967 placeBlock(level, Tile::netherFence_Id, 0, 0, 13, 0, chunkBB);
968 placeBlock(level, Tile::netherFence_Id, 0, 12, 13, 0, chunkBB);
969
970 // inside decorations
971 for (int z = 3; z <= 9; z += 2)
972 {
973 generateBox(level, chunkBB, 1, 7, z, 1, 8, z, Tile::netherFence_Id, Tile::netherFence_Id, false);
974 generateBox(level, chunkBB, 11, 7, z, 11, 8, z, Tile::netherFence_Id, Tile::netherFence_Id, false);
975 }
976
977 // supports
978 generateBox(level, chunkBB, 4, 2, 0, 8, 2, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
979 generateBox(level, chunkBB, 0, 2, 4, 12, 2, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
980
981 generateBox(level, chunkBB, 4, 0, 0, 8, 1, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
982 generateBox(level, chunkBB, 4, 0, 9, 8, 1, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
983 generateBox(level, chunkBB, 0, 0, 4, 3, 1, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
984 generateBox(level, chunkBB, 9, 0, 4, 12, 1, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
985
986 for (int x = 4; x <= 8; x++)
987 {
988 for (int z = 0; z <= 2; z++)
989 {
990 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
991 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, 12 - z, chunkBB);
992 }
993 }
994 for (int x = 0; x <= 2; x++)
995 {
996 for (int z = 4; z <= 8; z++)
997 {
998 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
999 fillColumnDown(level, Tile::netherBrick_Id, 0, 12 - x, -1, z, chunkBB);
1000 }
1001 }
1002
1003 // lava well
1004 generateBox(level, chunkBB, 5, 5, 5, 7, 5, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1005 generateBox(level, chunkBB, 6, 1, 6, 6, 4, 6, 0, 0, false);
1006 placeBlock(level, Tile::netherBrick_Id, 0, 6, 0, 6, chunkBB);
1007 placeBlock(level, Tile::lava_Id, 0, 6, 5, 6, chunkBB);
1008 // tick lava well
1009 int x = getWorldX(6, 6);
1010 int y = getWorldY(5);
1011 int z = getWorldZ(6, 6);
1012 if (chunkBB->isInside(x, y, z))
1013 {
1014 level->setInstaTick(true);
1015 Tile::tiles[Tile::lava_Id]->tick(level, x, y, z, random);
1016 level->setInstaTick(false);
1017 }
1018
1019
1020 return true;
1021}
1022
1023NetherBridgePieces::CastleStalkRoom::CastleStalkRoom()
1024{
1025 // for reflection
1026}
1027
1028NetherBridgePieces::CastleStalkRoom::CastleStalkRoom(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth)
1029{
1030 orientation = direction;
1031 boundingBox = stairsBox;
1032}
1033
1034void NetherBridgePieces::CastleStalkRoom::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random)
1035{
1036 generateChildForward((StartPiece *) startPiece, pieces, random, 5, 3, true);
1037 generateChildForward((StartPiece *) startPiece, pieces, random, 5, 11, true);
1038}
1039
1040NetherBridgePieces::CastleStalkRoom *NetherBridgePieces::CastleStalkRoom::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth)
1041{
1042 BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -5, -3, 0, width, height, depth, direction);
1043
1044 StartPiece *startPiece = NULL;
1045 if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
1046
1047 if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL)
1048 {
1049 delete box;
1050 return NULL;
1051 }
1052
1053 return new CastleStalkRoom(genDepth, random, box, direction);
1054}
1055
1056bool NetherBridgePieces::CastleStalkRoom::postProcess(Level *level, Random *random, BoundingBox *chunkBB)
1057{
1058 // floor
1059 generateBox(level, chunkBB, 0, 3, 0, 12, 4, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1060 // room air
1061 generateBox(level, chunkBB, 0, 5, 0, 12, 13, 12, 0, 0, false);
1062
1063 // walls
1064 generateBox(level, chunkBB, 0, 5, 0, 1, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1065 generateBox(level, chunkBB, 11, 5, 0, 12, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1066 generateBox(level, chunkBB, 2, 5, 11, 4, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1067 generateBox(level, chunkBB, 8, 5, 11, 10, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1068 generateBox(level, chunkBB, 5, 9, 11, 7, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1069 generateBox(level, chunkBB, 2, 5, 0, 4, 12, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1070 generateBox(level, chunkBB, 8, 5, 0, 10, 12, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1071 generateBox(level, chunkBB, 5, 9, 0, 7, 12, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1072
1073 // roof
1074 generateBox(level, chunkBB, 2, 11, 2, 10, 12, 10, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1075
1076 // wall decorations
1077 for (int i = 1; i <= 11; i += 2)
1078 {
1079 generateBox(level, chunkBB, i, 10, 0, i, 11, 0, Tile::netherFence_Id, Tile::netherFence_Id, false);
1080 generateBox(level, chunkBB, i, 10, 12, i, 11, 12, Tile::netherFence_Id, Tile::netherFence_Id, false);
1081 generateBox(level, chunkBB, 0, 10, i, 0, 11, i, Tile::netherFence_Id, Tile::netherFence_Id, false);
1082 generateBox(level, chunkBB, 12, 10, i, 12, 11, i, Tile::netherFence_Id, Tile::netherFence_Id, false);
1083 placeBlock(level, Tile::netherBrick_Id, 0, i, 13, 0, chunkBB);
1084 placeBlock(level, Tile::netherBrick_Id, 0, i, 13, 12, chunkBB);
1085 placeBlock(level, Tile::netherBrick_Id, 0, 0, 13, i, chunkBB);
1086 placeBlock(level, Tile::netherBrick_Id, 0, 12, 13, i, chunkBB);
1087 placeBlock(level, Tile::netherFence_Id, 0, i + 1, 13, 0, chunkBB);
1088 placeBlock(level, Tile::netherFence_Id, 0, i + 1, 13, 12, chunkBB);
1089 placeBlock(level, Tile::netherFence_Id, 0, 0, 13, i + 1, chunkBB);
1090 placeBlock(level, Tile::netherFence_Id, 0, 12, 13, i + 1, chunkBB);
1091 }
1092 placeBlock(level, Tile::netherFence_Id, 0, 0, 13, 0, chunkBB);
1093 placeBlock(level, Tile::netherFence_Id, 0, 0, 13, 12, chunkBB);
1094 placeBlock(level, Tile::netherFence_Id, 0, 0, 13, 0, chunkBB);
1095 placeBlock(level, Tile::netherFence_Id, 0, 12, 13, 0, chunkBB);
1096
1097 // inside decorations
1098 for (int z = 3; z <= 9; z += 2)
1099 {
1100 generateBox(level, chunkBB, 1, 7, z, 1, 8, z, Tile::netherFence_Id, Tile::netherFence_Id, false);
1101 generateBox(level, chunkBB, 11, 7, z, 11, 8, z, Tile::netherFence_Id, Tile::netherFence_Id, false);
1102 }
1103
1104 // inside stair
1105 int stairOrientation = getOrientationData(Tile::stairs_netherBricks_Id, 3);
1106 for (int i = 0; i <= 6; i++)
1107 {
1108 int z = i + 4;
1109 for (int x = 5; x <= 7; x++)
1110 {
1111 placeBlock(level, Tile::stairs_netherBricks_Id, stairOrientation, x, 5 + i, z, chunkBB);
1112 }
1113 if (z >= 5 && z <= 8)
1114 {
1115 generateBox(level, chunkBB, 5, 5, z, 7, i + 4, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1116 }
1117 else if (z >= 9 && z <= 10)
1118 {
1119 generateBox(level, chunkBB, 5, 8, z, 7, i + 4, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1120 }
1121 if (i >= 1)
1122 {
1123 generateBox(level, chunkBB, 5, 6 + i, z, 7, 9 + i, z, 0, 0, false);
1124 }
1125 }
1126 for (int x = 5; x <= 7; x++)
1127 {
1128 placeBlock(level, Tile::stairs_netherBricks_Id, stairOrientation, x, 12, 11, chunkBB);
1129 }
1130 generateBox(level, chunkBB, 5, 6, 7, 5, 7, 7, Tile::netherFence_Id, Tile::netherFence_Id, false);
1131 generateBox(level, chunkBB, 7, 6, 7, 7, 7, 7, Tile::netherFence_Id, Tile::netherFence_Id, false);
1132 generateBox(level, chunkBB, 5, 13, 12, 7, 13, 12, 0, 0, false);
1133
1134 // farmland catwalks
1135 generateBox(level, chunkBB, 2, 5, 2, 3, 5, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1136 generateBox(level, chunkBB, 2, 5, 9, 3, 5, 10, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1137 generateBox(level, chunkBB, 2, 5, 4, 2, 5, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1138 generateBox(level, chunkBB, 9, 5, 2, 10, 5, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1139 generateBox(level, chunkBB, 9, 5, 9, 10, 5, 10, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1140 generateBox(level, chunkBB, 10, 5, 4, 10, 5, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1141 int eastOrientation = getOrientationData(Tile::stairs_netherBricks_Id, 0);
1142 int westOrientation = getOrientationData(Tile::stairs_netherBricks_Id, 1);
1143 placeBlock(level, Tile::stairs_netherBricks_Id, westOrientation, 4, 5, 2, chunkBB);
1144 placeBlock(level, Tile::stairs_netherBricks_Id, westOrientation, 4, 5, 3, chunkBB);
1145 placeBlock(level, Tile::stairs_netherBricks_Id, westOrientation, 4, 5, 9, chunkBB);
1146 placeBlock(level, Tile::stairs_netherBricks_Id, westOrientation, 4, 5, 10, chunkBB);
1147 placeBlock(level, Tile::stairs_netherBricks_Id, eastOrientation, 8, 5, 2, chunkBB);
1148 placeBlock(level, Tile::stairs_netherBricks_Id, eastOrientation, 8, 5, 3, chunkBB);
1149 placeBlock(level, Tile::stairs_netherBricks_Id, eastOrientation, 8, 5, 9, chunkBB);
1150 placeBlock(level, Tile::stairs_netherBricks_Id, eastOrientation, 8, 5, 10, chunkBB);
1151
1152 // farmlands
1153 generateBox(level, chunkBB, 3, 4, 4, 4, 4, 8, Tile::soulsand_Id, Tile::soulsand_Id, false);
1154 generateBox(level, chunkBB, 8, 4, 4, 9, 4, 8, Tile::soulsand_Id, Tile::soulsand_Id, false);
1155 generateBox(level, chunkBB, 3, 5, 4, 4, 5, 8, Tile::netherStalk_Id, Tile::netherStalk_Id, false);
1156 generateBox(level, chunkBB, 8, 5, 4, 9, 5, 8, Tile::netherStalk_Id, Tile::netherStalk_Id, false);
1157
1158 // supports
1159 generateBox(level, chunkBB, 4, 2, 0, 8, 2, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1160 generateBox(level, chunkBB, 0, 2, 4, 12, 2, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1161
1162 generateBox(level, chunkBB, 4, 0, 0, 8, 1, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1163 generateBox(level, chunkBB, 4, 0, 9, 8, 1, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1164 generateBox(level, chunkBB, 0, 0, 4, 3, 1, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1165 generateBox(level, chunkBB, 9, 0, 4, 12, 1, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1166
1167 for (int x = 4; x <= 8; x++)
1168 {
1169 for (int z = 0; z <= 2; z++)
1170 {
1171 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
1172 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, 12 - z, chunkBB);
1173 }
1174 }
1175 for (int x = 0; x <= 2; x++)
1176 {
1177 for (int z = 4; z <= 8; z++)
1178 {
1179 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
1180 fillColumnDown(level, Tile::netherBrick_Id, 0, 12 - x, -1, z, chunkBB);
1181 }
1182 }
1183
1184 return true;
1185
1186}
1187
1188NetherBridgePieces::CastleSmallCorridorPiece::CastleSmallCorridorPiece()
1189{
1190 // for reflection
1191}
1192
1193NetherBridgePieces::CastleSmallCorridorPiece::CastleSmallCorridorPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth)
1194{
1195 orientation = direction;
1196 boundingBox = stairsBox;
1197}
1198
1199
1200void NetherBridgePieces::CastleSmallCorridorPiece::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random)
1201{
1202 generateChildForward((StartPiece *) startPiece, pieces, random, 1, 0, true);
1203}
1204
1205NetherBridgePieces::CastleSmallCorridorPiece *NetherBridgePieces::CastleSmallCorridorPiece::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth)
1206{
1207
1208 BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, 0, 0, width, height, depth, direction);
1209
1210 StartPiece *startPiece = NULL;
1211 if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
1212
1213 if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL)
1214 {
1215 delete box;
1216 return NULL;
1217 }
1218
1219 return new CastleSmallCorridorPiece(genDepth, random, box, direction);
1220}
1221
1222bool NetherBridgePieces::CastleSmallCorridorPiece::postProcess(Level *level, Random *random, BoundingBox *chunkBB)
1223{
1224 // floor
1225 generateBox(level, chunkBB, 0, 0, 0, 4, 1, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1226 // room air
1227 generateBox(level, chunkBB, 0, 2, 0, 4, 5, 4, 0, 0, false);
1228
1229 // walls
1230 generateBox(level, chunkBB, 0, 2, 0, 0, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1231 generateBox(level, chunkBB, 4, 2, 0, 4, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1232 generateBox(level, chunkBB, 0, 3, 1, 0, 4, 1, Tile::netherFence_Id, Tile::netherFence_Id, false);
1233 generateBox(level, chunkBB, 0, 3, 3, 0, 4, 3, Tile::netherFence_Id, Tile::netherFence_Id, false);
1234 generateBox(level, chunkBB, 4, 3, 1, 4, 4, 1, Tile::netherFence_Id, Tile::netherFence_Id, false);
1235 generateBox(level, chunkBB, 4, 3, 3, 4, 4, 3, Tile::netherFence_Id, Tile::netherFence_Id, false);
1236
1237 // roof
1238 generateBox(level, chunkBB, 0, 6, 0, 4, 6, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1239
1240 // supports
1241 for (int x = 0; x <= 4; x++)
1242 {
1243 for (int z = 0; z <= 4; z++)
1244 {
1245 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
1246 }
1247 }
1248
1249 return true;
1250}
1251
1252NetherBridgePieces::CastleSmallCorridorCrossingPiece::CastleSmallCorridorCrossingPiece()
1253{
1254 // for reflection
1255}
1256
1257NetherBridgePieces::CastleSmallCorridorCrossingPiece::CastleSmallCorridorCrossingPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth)
1258{
1259 orientation = direction;
1260 boundingBox = stairsBox;
1261}
1262
1263void NetherBridgePieces::CastleSmallCorridorCrossingPiece::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random)
1264{
1265 generateChildForward((StartPiece *) startPiece, pieces, random, 1, 0, true);
1266 generateChildLeft((StartPiece *) startPiece, pieces, random, 0, 1, true);
1267 generateChildRight((StartPiece *) startPiece, pieces, random, 0, 1, true);
1268}
1269
1270NetherBridgePieces::CastleSmallCorridorCrossingPiece *NetherBridgePieces::CastleSmallCorridorCrossingPiece::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth)
1271{
1272 BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, 0, 0, width, height, depth, direction);
1273
1274 StartPiece *startPiece = NULL;
1275 if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
1276
1277 if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL)
1278 {
1279 delete box;
1280 return NULL;
1281 }
1282
1283 return new CastleSmallCorridorCrossingPiece(genDepth, random, box, direction);
1284}
1285
1286bool NetherBridgePieces::CastleSmallCorridorCrossingPiece::postProcess(Level *level, Random *random, BoundingBox *chunkBB)
1287{
1288 // floor
1289 generateBox(level, chunkBB, 0, 0, 0, 4, 1, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1290 // room air
1291 generateBox(level, chunkBB, 0, 2, 0, 4, 5, 4, 0, 0, false);
1292
1293 // walls
1294 generateBox(level, chunkBB, 0, 2, 0, 0, 5, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1295 generateBox(level, chunkBB, 4, 2, 0, 4, 5, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1296 generateBox(level, chunkBB, 0, 2, 4, 0, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1297 generateBox(level, chunkBB, 4, 2, 4, 4, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1298
1299 // roof
1300 generateBox(level, chunkBB, 0, 6, 0, 4, 6, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1301
1302 // supports
1303 for (int x = 0; x <= 4; x++)
1304 {
1305 for (int z = 0; z <= 4; z++)
1306 {
1307 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
1308 }
1309 }
1310
1311 return true;
1312}
1313
1314NetherBridgePieces::CastleSmallCorridorRightTurnPiece::CastleSmallCorridorRightTurnPiece()
1315{
1316 // for reflection
1317 isNeedingChest = false;
1318}
1319
1320NetherBridgePieces::CastleSmallCorridorRightTurnPiece::CastleSmallCorridorRightTurnPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth)
1321{
1322 orientation = direction;
1323 boundingBox = stairsBox;
1324 isNeedingChest = random->nextInt(3) == 0;
1325}
1326
1327void NetherBridgePieces::CastleSmallCorridorRightTurnPiece::readAdditonalSaveData(CompoundTag *tag)
1328{
1329 NetherBridgePiece::readAdditonalSaveData(tag);
1330
1331 isNeedingChest = tag->getBoolean(L"Chest");
1332}
1333
1334void NetherBridgePieces::CastleSmallCorridorRightTurnPiece::addAdditonalSaveData(CompoundTag *tag)
1335{
1336 NetherBridgePiece::addAdditonalSaveData(tag);
1337
1338 tag->putBoolean(L"Chest", isNeedingChest);
1339}
1340
1341void NetherBridgePieces::CastleSmallCorridorRightTurnPiece::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random)
1342{
1343 generateChildRight((StartPiece *) startPiece, pieces, random, 0, 1, true);
1344}
1345
1346NetherBridgePieces::CastleSmallCorridorRightTurnPiece *NetherBridgePieces::CastleSmallCorridorRightTurnPiece::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth)
1347{
1348 BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, 0, 0, width, height, depth, direction);
1349
1350 StartPiece *startPiece = NULL;
1351 if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
1352
1353 if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL)
1354 {
1355 delete box;
1356 return NULL;
1357 }
1358
1359 return new CastleSmallCorridorRightTurnPiece(genDepth, random, box, direction);
1360}
1361
1362bool NetherBridgePieces::CastleSmallCorridorRightTurnPiece::postProcess(Level *level, Random *random, BoundingBox *chunkBB)
1363{
1364 // floor
1365 generateBox(level, chunkBB, 0, 0, 0, 4, 1, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1366 // room air
1367 generateBox(level, chunkBB, 0, 2, 0, 4, 5, 4, 0, 0, false);
1368
1369 // walls
1370 generateBox(level, chunkBB, 0, 2, 0, 0, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1371 generateBox(level, chunkBB, 0, 3, 1, 0, 4, 1, Tile::netherFence_Id, Tile::netherFence_Id, false);
1372 generateBox(level, chunkBB, 0, 3, 3, 0, 4, 3, Tile::netherFence_Id, Tile::netherFence_Id, false);
1373
1374 generateBox(level, chunkBB, 4, 2, 0, 4, 5, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1375
1376 generateBox(level, chunkBB, 1, 2, 4, 4, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1377 generateBox(level, chunkBB, 1, 3, 4, 1, 4, 4, Tile::netherFence_Id, Tile::netherBrick_Id, false);
1378 generateBox(level, chunkBB, 3, 3, 4, 3, 4, 4, Tile::netherFence_Id, Tile::netherBrick_Id, false);
1379
1380 if (isNeedingChest)
1381 {
1382 int y = getWorldY(2);
1383 int x = getWorldX(1, 3), z = getWorldZ(1, 3);
1384 if (chunkBB->isInside(x, y, z))
1385 {
1386 isNeedingChest = false;
1387 createChest(level, chunkBB, random, 1, 2, 3, WeighedTreasureArray(fortressTreasureItems,FORTRESS_TREASURE_ITEMS_COUNT), 2 + random->nextInt(4));
1388 }
1389 }
1390
1391 // roof
1392 generateBox(level, chunkBB, 0, 6, 0, 4, 6, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1393
1394 // supports
1395 for (int x = 0; x <= 4; x++)
1396 {
1397 for (int z = 0; z <= 4; z++)
1398 {
1399 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
1400 }
1401 }
1402
1403 return true;
1404}
1405
1406NetherBridgePieces::CastleSmallCorridorLeftTurnPiece::CastleSmallCorridorLeftTurnPiece()
1407{
1408 isNeedingChest = false;
1409 // for reflection
1410}
1411
1412NetherBridgePieces::CastleSmallCorridorLeftTurnPiece::CastleSmallCorridorLeftTurnPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth)
1413{
1414 orientation = direction;
1415 boundingBox = stairsBox;
1416 isNeedingChest = random->nextInt(3) == 0;
1417}
1418
1419void NetherBridgePieces::CastleSmallCorridorLeftTurnPiece::readAdditonalSaveData(CompoundTag *tag)
1420{
1421 NetherBridgePiece::readAdditonalSaveData(tag);
1422
1423 isNeedingChest = tag->getBoolean(L"Chest");
1424}
1425
1426void NetherBridgePieces::CastleSmallCorridorLeftTurnPiece::addAdditonalSaveData(CompoundTag *tag)
1427{
1428 NetherBridgePiece::addAdditonalSaveData(tag);
1429
1430 tag->putBoolean(L"Chest", isNeedingChest);
1431}
1432
1433void NetherBridgePieces::CastleSmallCorridorLeftTurnPiece::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random)
1434{
1435 generateChildLeft((StartPiece *) startPiece, pieces, random, 0, 1, true);
1436}
1437
1438NetherBridgePieces::CastleSmallCorridorLeftTurnPiece *NetherBridgePieces::CastleSmallCorridorLeftTurnPiece::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth)
1439{
1440 BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, 0, 0, width, height, depth, direction);
1441
1442 StartPiece *startPiece = NULL;
1443 if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
1444
1445 if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL)
1446 {
1447 delete box;
1448 return NULL;
1449 }
1450
1451 return new CastleSmallCorridorLeftTurnPiece(genDepth, random, box, direction);
1452}
1453
1454bool NetherBridgePieces::CastleSmallCorridorLeftTurnPiece::postProcess(Level *level, Random *random, BoundingBox *chunkBB)
1455{
1456 // floor
1457 generateBox(level, chunkBB, 0, 0, 0, 4, 1, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1458 // room air
1459 generateBox(level, chunkBB, 0, 2, 0, 4, 5, 4, 0, 0, false);
1460
1461 // walls
1462 generateBox(level, chunkBB, 4, 2, 0, 4, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1463 generateBox(level, chunkBB, 4, 3, 1, 4, 4, 1, Tile::netherFence_Id, Tile::netherFence_Id, false);
1464 generateBox(level, chunkBB, 4, 3, 3, 4, 4, 3, Tile::netherFence_Id, Tile::netherFence_Id, false);
1465
1466 generateBox(level, chunkBB, 0, 2, 0, 0, 5, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1467
1468 generateBox(level, chunkBB, 0, 2, 4, 3, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1469 generateBox(level, chunkBB, 1, 3, 4, 1, 4, 4, Tile::netherFence_Id, Tile::netherBrick_Id, false);
1470 generateBox(level, chunkBB, 3, 3, 4, 3, 4, 4, Tile::netherFence_Id, Tile::netherBrick_Id, false);
1471
1472 if (isNeedingChest)
1473 {
1474 int y = getWorldY(2);
1475 int x = getWorldX(3, 3), z = getWorldZ(3, 3);
1476 if (chunkBB->isInside(x, y, z))
1477 {
1478 isNeedingChest = false;
1479 createChest(level, chunkBB, random, 3, 2, 3, WeighedTreasureArray(fortressTreasureItems,FORTRESS_TREASURE_ITEMS_COUNT), 2 + random->nextInt(4));
1480 }
1481 }
1482
1483 // roof
1484 generateBox(level, chunkBB, 0, 6, 0, 4, 6, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1485
1486 // supports
1487 for (int x = 0; x <= 4; x++)
1488 {
1489 for (int z = 0; z <= 4; z++)
1490 {
1491 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
1492 }
1493 }
1494
1495 return true;
1496}
1497
1498NetherBridgePieces::CastleCorridorStairsPiece::CastleCorridorStairsPiece()
1499{
1500 // for reflection
1501}
1502
1503NetherBridgePieces::CastleCorridorStairsPiece::CastleCorridorStairsPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth)
1504{
1505 orientation = direction;
1506 boundingBox = stairsBox;
1507}
1508
1509void NetherBridgePieces::CastleCorridorStairsPiece::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random)
1510{
1511 generateChildForward((StartPiece *) startPiece, pieces, random, 1, 0, true);
1512}
1513
1514NetherBridgePieces::CastleCorridorStairsPiece *NetherBridgePieces::CastleCorridorStairsPiece::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth)
1515{
1516 BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, -7, 0, width, height, depth, direction);
1517
1518 StartPiece *startPiece = NULL;
1519 if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
1520
1521 if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL)
1522 {
1523 delete box;
1524 return NULL;
1525 }
1526
1527 return new CastleCorridorStairsPiece(genDepth, random, box, direction);
1528}
1529
1530bool NetherBridgePieces::CastleCorridorStairsPiece::postProcess(Level *level, Random *random, BoundingBox *chunkBB)
1531{
1532 // generate stairs
1533 int stairsData = getOrientationData(Tile::stairs_netherBricks_Id, 2);
1534 for (int step = 0; step <= 9; step++)
1535 {
1536 int floor = max(1, 7 - step);
1537 int roof = min(max(floor + 5, 14 - step), 13);
1538 int z = step;
1539
1540 // floor
1541 generateBox(level, chunkBB, 0, 0, z, 4, floor, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1542 // room air
1543 generateBox(level, chunkBB, 1, floor + 1, z, 3, roof - 1, z, 0, 0, false);
1544 if (step <= 6)
1545 {
1546 placeBlock(level, Tile::stairs_netherBricks_Id, stairsData, 1, floor + 1, z, chunkBB);
1547 placeBlock(level, Tile::stairs_netherBricks_Id, stairsData, 2, floor + 1, z, chunkBB);
1548 placeBlock(level, Tile::stairs_netherBricks_Id, stairsData, 3, floor + 1, z, chunkBB);
1549 }
1550 // roof
1551 generateBox(level, chunkBB, 0, roof, z, 4, roof, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1552 // walls
1553 generateBox(level, chunkBB, 0, floor + 1, z, 0, roof - 1, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1554 generateBox(level, chunkBB, 4, floor + 1, z, 4, roof - 1, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1555 if ((step & 1) == 0)
1556 {
1557 generateBox(level, chunkBB, 0, floor + 2, z, 0, floor + 3, z, Tile::netherFence_Id, Tile::netherFence_Id, false);
1558 generateBox(level, chunkBB, 4, floor + 2, z, 4, floor + 3, z, Tile::netherFence_Id, Tile::netherFence_Id, false);
1559 }
1560
1561 // supports
1562 for (int x = 0; x <= 4; x++)
1563 {
1564 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
1565 }
1566 }
1567
1568
1569 return true;
1570}
1571
1572NetherBridgePieces::CastleCorridorTBalconyPiece::CastleCorridorTBalconyPiece()
1573{
1574 // for reflection
1575}
1576
1577NetherBridgePieces::CastleCorridorTBalconyPiece::CastleCorridorTBalconyPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth)
1578{
1579 orientation = direction;
1580 boundingBox = stairsBox;
1581}
1582
1583void NetherBridgePieces::CastleCorridorTBalconyPiece::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random)
1584{
1585 int zOff = 1;
1586 // compensate for weird negative-facing behaviour
1587 if (orientation == Direction::WEST || orientation == Direction::NORTH)
1588 {
1589 zOff = 5;
1590 }
1591
1592 generateChildLeft((StartPiece *) startPiece, pieces, random, 0, zOff, random->nextInt(8) > 0);
1593 generateChildRight((StartPiece *) startPiece, pieces, random, 0, zOff, random->nextInt(8) > 0);
1594}
1595
1596NetherBridgePieces::CastleCorridorTBalconyPiece *NetherBridgePieces::CastleCorridorTBalconyPiece::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth)
1597{
1598 BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -3, 0, 0, width, height, depth, direction);
1599
1600 StartPiece *startPiece = NULL;
1601 if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
1602
1603 if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL)
1604 {
1605 delete box;
1606 return NULL;
1607 }
1608
1609 return new CastleCorridorTBalconyPiece(genDepth, random, box, direction);
1610}
1611
1612bool NetherBridgePieces::CastleCorridorTBalconyPiece::postProcess(Level *level, Random *random, BoundingBox *chunkBB)
1613{
1614 // floor
1615 generateBox(level, chunkBB, 0, 0, 0, 8, 1, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1616 // room air
1617 generateBox(level, chunkBB, 0, 2, 0, 8, 5, 8, 0, 0, false);
1618 // corridor roof
1619 generateBox(level, chunkBB, 0, 6, 0, 8, 6, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1620
1621 // inside walls
1622 generateBox(level, chunkBB, 0, 2, 0, 2, 5, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1623 generateBox(level, chunkBB, 6, 2, 0, 8, 5, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1624 generateBox(level, chunkBB, 1, 3, 0, 1, 4, 0, Tile::netherFence_Id, Tile::netherFence_Id, false);
1625 generateBox(level, chunkBB, 7, 3, 0, 7, 4, 0, Tile::netherFence_Id, Tile::netherFence_Id, false);
1626
1627 // balcony floor
1628 generateBox(level, chunkBB, 0, 2, 4, 8, 2, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1629 generateBox(level, chunkBB, 1, 1, 4, 2, 2, 4, 0, 0, false);
1630 generateBox(level, chunkBB, 6, 1, 4, 7, 2, 4, 0, 0, false);
1631
1632 // hand rails
1633 generateBox(level, chunkBB, 0, 3, 8, 8, 3, 8, Tile::netherFence_Id, Tile::netherFence_Id, false);
1634 generateBox(level, chunkBB, 0, 3, 6, 0, 3, 7, Tile::netherFence_Id, Tile::netherFence_Id, false);
1635 generateBox(level, chunkBB, 8, 3, 6, 8, 3, 7, Tile::netherFence_Id, Tile::netherFence_Id, false);
1636
1637 // balcony walls
1638 generateBox(level, chunkBB, 0, 3, 4, 0, 5, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1639 generateBox(level, chunkBB, 8, 3, 4, 8, 5, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1640 generateBox(level, chunkBB, 1, 3, 5, 2, 5, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1641 generateBox(level, chunkBB, 6, 3, 5, 7, 5, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
1642 generateBox(level, chunkBB, 1, 4, 5, 1, 5, 5, Tile::netherFence_Id, Tile::netherFence_Id, false);
1643 generateBox(level, chunkBB, 7, 4, 5, 7, 5, 5, Tile::netherFence_Id, Tile::netherFence_Id, false);
1644
1645 // supports
1646 for (int z = 0; z <= 5; z++)
1647 {
1648 for (int x = 0; x <= 8; x++)
1649 {
1650 fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB);
1651 }
1652 }
1653
1654 return true;
1655}
1656
1657