diff options
Diffstat (limited to 'Minecraft.World/StrongholdPieces.cpp')
| -rw-r--r-- | Minecraft.World/StrongholdPieces.cpp | 1517 |
1 files changed, 1517 insertions, 0 deletions
diff --git a/Minecraft.World/StrongholdPieces.cpp b/Minecraft.World/StrongholdPieces.cpp new file mode 100644 index 00000000..0168b2ba --- /dev/null +++ b/Minecraft.World/StrongholdPieces.cpp @@ -0,0 +1,1517 @@ +#include "stdafx.h" +#include "StrongholdPieces.h" +#include "net.minecraft.world.level.h" +#include "net.minecraft.world.level.tile.h" +#include "net.minecraft.world.level.tile.entity.h" +#include "net.minecraft.world.level.storage.h" +#include "net.minecraft.world.level.levelgen.h" +#include "net.minecraft.world.item.h" +#include "WeighedTreasure.h" +#include "FileHeader.h" +#include "Facing.h" + +int StrongholdPieces::totalWeight = 0; +list<StrongholdPieces::PieceWeight *> StrongholdPieces::currentPieces; +StrongholdPieces::EPieceClass StrongholdPieces::imposedPiece; +const bool StrongholdPieces::CHECK_AIR = true; + +StrongholdPieces::PieceWeight::PieceWeight(EPieceClass pieceClass, int weight, int maxPlaceCount) : weight(weight) +{ + this->placeCount = 0; // 4J added initialiser + this->pieceClass = pieceClass; + this->maxPlaceCount = maxPlaceCount; +} + +bool StrongholdPieces::PieceWeight::doPlace(int depth) +{ + return maxPlaceCount == 0 || placeCount < maxPlaceCount; +} + +bool StrongholdPieces::PieceWeight::isValid() +{ + return maxPlaceCount == 0 || placeCount < maxPlaceCount; +} + +void StrongholdPieces::resetPieces() +{ + for( AUTO_VAR(it, currentPieces.begin()); it != currentPieces.end(); it++ ) + { + delete (*it); + } + currentPieces.clear(); + + currentPieces.push_back( new PieceWeight(EPieceClass_Straight, 40, 0) ); + currentPieces.push_back( new PieceWeight(EPieceClass_PrisonHall, 5, 5) ); + currentPieces.push_back( new PieceWeight(EPieceClass_LeftTurn, 20, 0) ); + currentPieces.push_back( new PieceWeight(EPieceClass_RightTurn, 20, 0) ); + currentPieces.push_back( new PieceWeight(EPieceClass_RoomCrossing, 10, 6) ); + currentPieces.push_back( new PieceWeight(EPieceClass_StraightStairsDown, 5, 5) ); + currentPieces.push_back( new PieceWeight(EPieceClass_StairsDown, 5, 5) ); + currentPieces.push_back( new PieceWeight(EPieceClass_FiveCrossing, 5, 4) ); + currentPieces.push_back( new PieceWeight(EPieceClass_ChestCorridor, 5, 4) ); + currentPieces.push_back( new PieceWeight_Library(EPieceClass_Library, 10, 2) ); + currentPieces.push_back( new PieceWeight_PortalRoom(EPieceClass_PortalRoom, 20, 1) ); + + imposedPiece = EPieceClass_NULL; +} + +bool StrongholdPieces::updatePieceWeight() +{ + bool hasAnyPieces = false; + totalWeight = 0; + for( AUTO_VAR(it, currentPieces.begin()); it != currentPieces.end(); it++ ) + { + PieceWeight *piece = *it; + if (piece->maxPlaceCount > 0 && piece->placeCount < piece->maxPlaceCount) + { + hasAnyPieces = true; + } + totalWeight += piece->weight; + } + return hasAnyPieces; +} + +StrongholdPieces::StrongholdPiece *StrongholdPieces::findAndCreatePieceFactory(EPieceClass pieceClass, list<StructurePiece*> *pieces, Random *random, int footX, int footY, int footZ, int direction, int depth) +{ + StrongholdPiece *strongholdPiece = NULL; + + if (pieceClass == EPieceClass_Straight) + { + strongholdPiece = Straight::createPiece(pieces, random, footX, footY, footZ, direction, depth); + } + else if (pieceClass == EPieceClass_PrisonHall) + { + strongholdPiece = PrisonHall::createPiece(pieces, random, footX, footY, footZ, direction, depth); + } + else if (pieceClass == EPieceClass_LeftTurn) + { + strongholdPiece = LeftTurn::createPiece(pieces, random, footX, footY, footZ, direction, depth); + } + else if (pieceClass == EPieceClass_RightTurn) + { + strongholdPiece = RightTurn::createPiece(pieces, random, footX, footY, footZ, direction, depth); + } + else if (pieceClass == EPieceClass_RoomCrossing) + { + strongholdPiece = RoomCrossing::createPiece(pieces, random, footX, footY, footZ, direction, depth); + } + else if (pieceClass == EPieceClass_StraightStairsDown) + { + strongholdPiece = StraightStairsDown::createPiece(pieces, random, footX, footY, footZ, direction, depth); + } + else if (pieceClass == EPieceClass_StairsDown) + { + strongholdPiece = StairsDown::createPiece(pieces, random, footX, footY, footZ, direction, depth); + } + else if (pieceClass == EPieceClass_FiveCrossing) + { + strongholdPiece = FiveCrossing::createPiece(pieces, random, footX, footY, footZ, direction, depth); + } + else if (pieceClass == EPieceClass_ChestCorridor) + { + strongholdPiece = ChestCorridor::createPiece(pieces, random, footX, footY, footZ, direction, depth); + } + else if (pieceClass == EPieceClass_Library) + { + strongholdPiece = Library::createPiece(pieces, random, footX, footY, footZ, direction, depth); + } + else if (pieceClass == EPieceClass_PortalRoom) + { + strongholdPiece = PortalRoom::createPiece(pieces, random, footX, footY, footZ, direction, depth); + } + + + return strongholdPiece; +} + +StrongholdPieces::StrongholdPiece *StrongholdPieces::generatePieceFromSmallDoor(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int depth) +{ + if (!updatePieceWeight()) + { + return NULL; + } + + if (imposedPiece != EPieceClass_NULL) + { + StrongholdPiece *strongholdPiece = findAndCreatePieceFactory(imposedPiece, pieces, random, footX, footY, footZ, direction, depth); + imposedPiece = EPieceClass_NULL; + + if (strongholdPiece != NULL) + { + return strongholdPiece; + } + } + + int numAttempts = 0; + while (numAttempts < 5) + { + numAttempts++; + + int weightSelection = random->nextInt(totalWeight); + for( AUTO_VAR(it, currentPieces.begin()); it != currentPieces.end(); it++ ) + { + PieceWeight *piece = *it; + weightSelection -= piece->weight; + if (weightSelection < 0) + { + if (!piece->doPlace(depth) || piece == startPiece->previousPiece) + { + break; + } + + StrongholdPiece *strongholdPiece = findAndCreatePieceFactory(piece->pieceClass, pieces, random, footX, footY, footZ, direction, depth); + if (strongholdPiece != NULL) + { + piece->placeCount++; + startPiece->previousPiece = piece; + + if (!piece->isValid()) + { + currentPieces.remove(piece); + } + return strongholdPiece; + } + } + } + } + { + BoundingBox *box = FillerCorridor::findPieceBox(pieces, random, footX, footY, footZ, direction); + if (box != NULL && box->y0 > 1) + { + return new FillerCorridor(depth, random, box, direction); + } + if(box != NULL) delete box; + } + + return NULL; +} + +StructurePiece *StrongholdPieces::generateAndAddPiece(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int depth) +{ + if (depth > MAX_DEPTH) + { + return NULL; + } + if (abs(footX - startPiece->getBoundingBox()->x0) > 3 * 16 || abs(footZ - startPiece->getBoundingBox()->z0) > 3 * 16) + { + // Force attempt at spawning a portal room + if(startPiece->m_level->getOriginalSaveVersion() >= SAVE_FILE_VERSION_MOVED_STRONGHOLD && !startPiece->m_level->getLevelData()->getHasStrongholdEndPortal()) + { + for( AUTO_VAR(it, currentPieces.begin()); it != currentPieces.end(); it++ ) + { + PieceWeight *piece = *it; + + if(piece->pieceClass != EPieceClass_PortalRoom) continue; + +#ifndef _CONTENT_PACKAGE + printf("Portal room forcing attempt\n"); +#endif + StrongholdPiece *strongholdPiece = PortalRoom::createPiece(pieces, random, footX, footY, footZ, direction, depth); + if (strongholdPiece != NULL) + { + piece->placeCount++; + startPiece->previousPiece = piece; + + if (!piece->isValid()) + { + currentPieces.remove(piece); + } +#ifndef _CONTENT_PACKAGE + printf("Success\n"); +#endif + return strongholdPiece; + } + } + } + return NULL; + } + + StructurePiece *newPiece = generatePieceFromSmallDoor(startPiece, pieces, random, footX, footY, footZ, direction, depth + 1); + if (newPiece != NULL) + { + pieces->push_back(newPiece); + startPiece->pendingChildren.push_back(newPiece); +// newPiece.addChildren(startPiece, pieces, random, depth + 1); + } + return newPiece; +} + +StrongholdPieces::StrongholdPiece::StrongholdPiece(int genDepth) : StructurePiece(genDepth) +{ +} + +void StrongholdPieces::StrongholdPiece::generateSmallDoor(Level *level, Random *random, BoundingBox *chunkBB, StrongholdPieces::StrongholdPiece::SmallDoorType doorType, int footX, int footY, int footZ) +{ + switch (doorType) + { + default: + case OPENING: + generateBox(level, chunkBB, footX, footY, footZ, footX + SMALL_DOOR_WIDTH - 1, footY + SMALL_DOOR_HEIGHT - 1, footZ, 0, 0, false); + break; + case WOOD_DOOR: + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, footX, footY, footZ, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, footX, footY + 1, footZ, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, footX, footY + 2, footZ, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, footX + 1, footY + 2, footZ, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, footX + 2, footY + 2, footZ, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, footX + 2, footY + 1, footZ, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, footX + 2, footY, footZ, chunkBB); + placeBlock(level, Tile::door_wood_Id, 0, footX + 1, footY, footZ, chunkBB); + placeBlock(level, Tile::door_wood_Id, DoorTile::UPPER_BIT, footX + 1, footY + 1, footZ, chunkBB); + break; + case GRATES: + placeBlock(level, 0, 0, footX + 1, footY, footZ, chunkBB); + placeBlock(level, 0, 0, footX + 1, footY + 1, footZ, chunkBB); + placeBlock(level, Tile::ironFence_Id, 0, footX, footY, footZ, chunkBB); + placeBlock(level, Tile::ironFence_Id, 0, footX, footY + 1, footZ, chunkBB); + placeBlock(level, Tile::ironFence_Id, 0, footX, footY + 2, footZ, chunkBB); + placeBlock(level, Tile::ironFence_Id, 0, footX + 1, footY + 2, footZ, chunkBB); + placeBlock(level, Tile::ironFence_Id, 0, footX + 2, footY + 2, footZ, chunkBB); + placeBlock(level, Tile::ironFence_Id, 0, footX + 2, footY + 1, footZ, chunkBB); + placeBlock(level, Tile::ironFence_Id, 0, footX + 2, footY, footZ, chunkBB); + break; + case IRON_DOOR: + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, footX, footY, footZ, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, footX, footY + 1, footZ, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, footX, footY + 2, footZ, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, footX + 1, footY + 2, footZ, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, footX + 2, footY + 2, footZ, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, footX + 2, footY + 1, footZ, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, footX + 2, footY, footZ, chunkBB); + placeBlock(level, Tile::door_iron_Id, 0, footX + 1, footY, footZ, chunkBB); + placeBlock(level, Tile::door_iron_Id, DoorTile::UPPER_BIT, footX + 1, footY + 1, footZ, chunkBB); + placeBlock(level, Tile::button_stone_Id, getOrientationData(Tile::button_stone_Id, 4), footX + 2, footY + 1, footZ + 1, chunkBB); + placeBlock(level, Tile::button_stone_Id, getOrientationData(Tile::button_stone_Id, 3), footX + 2, footY + 1, footZ - 1, chunkBB); + break; + } + +} + +StrongholdPieces::StrongholdPiece::SmallDoorType StrongholdPieces::StrongholdPiece::randomSmallDoor(Random *random) +{ + int selection = random->nextInt(5); + switch (selection) + { + default: + case 0: + case 1: + return OPENING; + case 2: + return WOOD_DOOR; + case 3: + return GRATES; + case 4: + return IRON_DOOR; + } +} + +StructurePiece *StrongholdPieces::StrongholdPiece::generateSmallDoorChildForward(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int xOff, int yOff) +{ + switch (orientation) + { + case Direction::NORTH: + return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + xOff, boundingBox->y0 + yOff, boundingBox->z0 - 1, orientation, getGenDepth()); + case Direction::SOUTH: + return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + xOff, boundingBox->y0 + yOff, boundingBox->z1 + 1, orientation, getGenDepth()); + case Direction::WEST: + return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 - 1, boundingBox->y0 + yOff, boundingBox->z0 + xOff, orientation, getGenDepth()); + case Direction::EAST: + return generateAndAddPiece(startPiece, pieces, random, boundingBox->x1 + 1, boundingBox->y0 + yOff, boundingBox->z0 + xOff, orientation, getGenDepth()); + } + return NULL; +} + +StructurePiece *StrongholdPieces::StrongholdPiece::generateSmallDoorChildLeft(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int yOff, int zOff) +{ + switch (orientation) + { + case Direction::NORTH: + return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 - 1, boundingBox->y0 + yOff, boundingBox->z0 + zOff, Direction::WEST, getGenDepth()); + case Direction::SOUTH: + return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 - 1, boundingBox->y0 + yOff, boundingBox->z0 + zOff, Direction::WEST, getGenDepth()); + case Direction::WEST: + return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + zOff, boundingBox->y0 + yOff, boundingBox->z0 - 1, Direction::NORTH, getGenDepth()); + case Direction::EAST: + return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + zOff, boundingBox->y0 + yOff, boundingBox->z0 - 1, Direction::NORTH, getGenDepth()); + } + return NULL; +} + +StructurePiece *StrongholdPieces::StrongholdPiece::generateSmallDoorChildRight(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int yOff, int zOff) +{ + switch (orientation) + { + case Direction::NORTH: + return generateAndAddPiece(startPiece, pieces, random, boundingBox->x1 + 1, boundingBox->y0 + yOff, boundingBox->z0 + zOff, Direction::EAST, getGenDepth()); + case Direction::SOUTH: + return generateAndAddPiece(startPiece, pieces, random, boundingBox->x1 + 1, boundingBox->y0 + yOff, boundingBox->z0 + zOff, Direction::EAST, getGenDepth()); + case Direction::WEST: + return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + zOff, boundingBox->y0 + yOff, boundingBox->z1 + 1, Direction::SOUTH, getGenDepth()); + case Direction::EAST: + return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + zOff, boundingBox->y0 + yOff, boundingBox->z1 + 1, Direction::SOUTH, getGenDepth()); + } + return NULL; +} + +bool StrongholdPieces::StrongholdPiece::isOkBox(BoundingBox *box, StartPiece *startRoom) +{ + //return box != NULL && box->y0 > LOWEST_Y_POSITION; + + bool bIsOk = false; + + if(box != NULL) + { + if( box->y0 > LOWEST_Y_POSITION ) bIsOk = true; + + if( startRoom != NULL && startRoom->m_level->getOriginalSaveVersion() >= SAVE_FILE_VERSION_MOVED_STRONGHOLD ) + { + int xzSize = startRoom->m_level->getLevelData()->getXZSize(); + int blockMin = -( (xzSize << 4) / 2) + 1; + int blockMax = ( (xzSize << 4) / 2 ) - 1; + + if(box->x0 <= blockMin) bIsOk = false; + if(box->z0 <= blockMin) bIsOk = false; + if(box->x1 >= blockMax) bIsOk = false; + if(box->z1 >= blockMax) bIsOk = false; + } + } + + return bIsOk; +} + +StrongholdPieces::FillerCorridor::FillerCorridor(int genDepth, Random *random, BoundingBox *corridorBox, int direction) : StrongholdPiece(genDepth), + steps((direction == Direction::NORTH || direction == Direction::SOUTH) ? corridorBox->getZSpan() : corridorBox->getXSpan()) +{ + orientation = direction; + boundingBox = corridorBox; +} + +BoundingBox *StrongholdPieces::FillerCorridor::findPieceBox(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction) +{ + const int maxLength = 3; + + BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, -1, 0, 5, 5, maxLength + 1, direction); + + StructurePiece *collisionPiece = StructurePiece::findCollisionPiece(pieces, box); + + if (collisionPiece == NULL) + { + delete box; + // the filler must collide with something in order to be + // generated + return NULL; + } + + if (collisionPiece->getBoundingBox()->y0 == box->y0) + { + delete box; + // attempt to make a smaller piece until it fits + for (int depth = maxLength; depth >= 1; depth--) + { + box = BoundingBox::orientBox(footX, footY, footZ, -1, -1, 0, 5, 5, depth - 1, direction); + if (!collisionPiece->getBoundingBox()->intersects(box)) + { + delete box; + // the corridor has shrunk enough to fit, but make it + // one step too big to build an entrance into the other + // block + return BoundingBox::orientBox(footX, footY, footZ, -1, -1, 0, 5, 5, depth, direction); + } + delete box; + } + } + + return NULL; +} + +bool StrongholdPieces::FillerCorridor::postProcess(Level *level, Random *random, BoundingBox *chunkBB) +{ + if (edgesLiquid(level, chunkBB)) + { + return false; + } + + // filler corridor + for (int i = 0; i < steps; i++) + { + // row 0 + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 0, 0, i, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 1, 0, i, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 2, 0, i, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 3, 0, i, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 4, 0, i, chunkBB); + // row 1-3 + for (int y = 1; y <= 3; y++) + { + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 0, y, i, chunkBB); + placeBlock(level, 0, 0, 1, y, i, chunkBB); + placeBlock(level, 0, 0, 2, y, i, chunkBB); + placeBlock(level, 0, 0, 3, y, i, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 4, y, i, chunkBB); + } + // row 4 + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 0, 4, i, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 1, 4, i, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 2, 4, i, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 3, 4, i, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 4, 4, i, chunkBB); + } + + return true; +} + +StrongholdPieces::StairsDown::StairsDown(int genDepth, Random *random, int west, int north) : StrongholdPiece(genDepth), isSource(true), entryDoor(OPENING) +{ + orientation = random->nextInt(4); + + switch (orientation) + { + case Direction::NORTH: + case Direction::SOUTH: + boundingBox = new BoundingBox(west, 64, north, west + width - 1, 64 + height - 1, north + depth - 1); + break; + default: + boundingBox = new BoundingBox(west, 64, north, west + depth - 1, 64 + height - 1, north + width - 1); + break; + } +} + +StrongholdPieces::StairsDown::StairsDown(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : StrongholdPiece(genDepth), isSource(false), entryDoor(randomSmallDoor(random)) +{ + orientation = direction; + boundingBox = stairsBox; +} + +void StrongholdPieces::StairsDown::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random) +{ + if( isSource ) + { + imposedPiece = EPieceClass_FiveCrossing; + } + generateSmallDoorChildForward((StartPiece *) startPiece, pieces, random, 1, 1); +} + +StrongholdPieces::StairsDown *StrongholdPieces::StairsDown::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth) +{ + BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, 4 - height, 0, width, height, depth, direction); + + StartPiece *startPiece = NULL; + if(pieces != NULL) startPiece = ((StrongholdPieces::StartPiece *) pieces->front()); + + if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) + { + delete box; + return NULL; + } + + return new StairsDown(genDepth, random, box, direction); +} + +bool StrongholdPieces::StairsDown::postProcess(Level *level, Random *random, BoundingBox *chunkBB) +{ + if (edgesLiquid(level, chunkBB)) + { + return false; + } + + // bounding walls + generateBox(level, chunkBB, 0, 0, 0, width - 1, height - 1, depth - 1, CHECK_AIR, random, (BlockSelector *)smoothStoneSelector); + // entry door + generateSmallDoor(level, random, chunkBB, entryDoor, 1, height - SMALL_DOOR_HEIGHT - 1, 0); + // exit door + generateSmallDoor(level, random, chunkBB, OPENING, 1, 1, depth - 1); + + // stair steps + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 2, 6, 1, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 1, 5, 1, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, StoneSlabTile::STONE_SLAB, 1, 6, 1, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 1, 5, 2, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 1, 4, 3, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, StoneSlabTile::STONE_SLAB, 1, 5, 3, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 2, 4, 3, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 3, 3, 3, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, StoneSlabTile::STONE_SLAB, 3, 4, 3, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 3, 3, 2, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 3, 2, 1, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, StoneSlabTile::STONE_SLAB, 3, 3, 1, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 2, 2, 1, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 1, 1, 1, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, StoneSlabTile::STONE_SLAB, 1, 2, 1, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 1, 1, 2, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, StoneSlabTile::STONE_SLAB, 1, 1, 3, chunkBB); + + return true; +} + +StrongholdPieces::StartPiece::StartPiece(int genDepth, Random *random, int west, int north, Level *level) : StairsDown(0, random, west, north) +{ + // 4J added initialisers + isLibraryAdded = false; + previousPiece = NULL; + portalRoomPiece = NULL; + + m_level = level; +} + +TilePos *StrongholdPieces::StartPiece::getLocatorPosition() +{ + if( portalRoomPiece != NULL ) + { + return portalRoomPiece->getLocatorPosition(); + } + return StairsDown::getLocatorPosition(); +} + +StrongholdPieces::Straight::Straight(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : StrongholdPiece(genDepth), + entryDoor(randomSmallDoor(random)), + leftChild(random->nextInt(2) == 0), + rightChild(random->nextInt(2) == 0) +{ + orientation = direction; + boundingBox = stairsBox; +} + +void StrongholdPieces::Straight::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random) +{ + generateSmallDoorChildForward((StartPiece *) startPiece, pieces, random, 1, 1); + if (leftChild) generateSmallDoorChildLeft((StartPiece *) startPiece, pieces, random, 1, 2); + if (rightChild) generateSmallDoorChildRight((StartPiece *) startPiece, pieces, random, 1, 2); +} + +StrongholdPieces::Straight *StrongholdPieces::Straight::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth) +{ + BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, -1, 0, width, height, depth, direction); + + StartPiece *startPiece = NULL; + if(pieces != NULL) startPiece = ((StrongholdPieces::StartPiece *) pieces->front()); + + if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) + { + delete box; + return NULL; + } + + return new Straight(genDepth, random, box, direction); +} + +bool StrongholdPieces::Straight::postProcess(Level *level, Random *random, BoundingBox *chunkBB) +{ + if (edgesLiquid(level, chunkBB)) + { + return false; + } + + // bounding walls + generateBox(level, chunkBB, 0, 0, 0, width - 1, height - 1, depth - 1, CHECK_AIR, random, (BlockSelector *)smoothStoneSelector); + // entry door + generateSmallDoor(level, random, chunkBB, entryDoor, 1, height - SMALL_DOOR_HEIGHT - 1, 0); + // exit door + generateSmallDoor(level, random, chunkBB, OPENING, 1, 1, depth - 1); + + maybeGenerateBlock(level, chunkBB, random, .1f, 1, 2, 1, Tile::torch_Id, 0); + maybeGenerateBlock(level, chunkBB, random, .1f, 3, 2, 1, Tile::torch_Id, 0); + maybeGenerateBlock(level, chunkBB, random, .1f, 1, 2, 5, Tile::torch_Id, 0); + maybeGenerateBlock(level, chunkBB, random, .1f, 3, 2, 5, Tile::torch_Id, 0); + + if (leftChild) + { + generateBox(level, chunkBB, 0, 1, 2, 0, 3, 4, 0, 0, false); + } + if (rightChild) + { + generateBox(level, chunkBB, 4, 1, 2, 4, 3, 4, 0, 0, false); + } + + return true; +} + +WeighedTreasure *StrongholdPieces::ChestCorridor::treasureItems[TREASURE_ITEMS_COUNT] = +{ + new WeighedTreasure(Item::enderPearl_Id, 0, 1, 1, 10), + new WeighedTreasure(Item::diamond_Id, 0, 1, 3, 3), + new WeighedTreasure(Item::ironIngot_Id, 0, 1, 5, 10), + new WeighedTreasure(Item::goldIngot_Id, 0, 1, 3, 5), + new WeighedTreasure(Item::redStone_Id, 0, 4, 9, 5), + new WeighedTreasure(Item::bread_Id, 0, 1, 3, 15), + new WeighedTreasure(Item::apple_Id, 0, 1, 3, 15), + new WeighedTreasure(Item::pickAxe_iron_Id, 0, 1, 1, 5), + new WeighedTreasure(Item::sword_iron_Id, 0, 1, 1, 5), + new WeighedTreasure(Item::chestplate_iron_Id, 0, 1, 1, 5), + new WeighedTreasure(Item::helmet_iron_Id, 0, 1, 1, 5), + new WeighedTreasure(Item::leggings_iron_Id, 0, 1, 1, 5), + new WeighedTreasure(Item::boots_iron_Id, 0, 1, 1, 5), + new WeighedTreasure(Item::apple_gold_Id, 0, 1, 1, 1) +}; + +StrongholdPieces::ChestCorridor::ChestCorridor(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : StrongholdPiece(genDepth), entryDoor(randomSmallDoor(random)) +{ + orientation = direction; + boundingBox = stairsBox; +} + +void StrongholdPieces::ChestCorridor::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random) +{ + generateSmallDoorChildForward((StartPiece *) startPiece, pieces, random, 1, 1); +} + +StrongholdPieces::ChestCorridor *StrongholdPieces::ChestCorridor::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth) +{ + BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, -1, 0, width, height, depth, direction); + + StartPiece *startPiece = NULL; + if(pieces != NULL) startPiece = ((StrongholdPieces::StartPiece *) pieces->front()); + + if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) + { + delete box; + return NULL; + } + + return new ChestCorridor(genDepth, random, box, direction); +} + +bool StrongholdPieces::ChestCorridor::postProcess(Level *level, Random *random, BoundingBox *chunkBB) +{ + if (edgesLiquid(level, chunkBB)) + { + return false; + } + + // bounding walls + generateBox(level, chunkBB, 0, 0, 0, width - 1, height - 1, depth - 1, CHECK_AIR, random, (BlockSelector *)smoothStoneSelector); + // entry door + generateSmallDoor(level, random, chunkBB, entryDoor, 1, height - SMALL_DOOR_HEIGHT - 1, 0); + // exit door + generateSmallDoor(level, random, chunkBB, OPENING, 1, 1, depth - 1); + + // chest placement + generateBox(level, chunkBB, 3, 1, 2, 3, 1, 4, Tile::stoneBrickSmooth_Id, Tile::stoneBrickSmooth_Id, false); + placeBlock(level, Tile::stoneSlabHalf_Id, StoneSlabTile::SMOOTHBRICK_SLAB, 3, 1, 1, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, StoneSlabTile::SMOOTHBRICK_SLAB, 3, 1, 5, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, StoneSlabTile::SMOOTHBRICK_SLAB, 3, 2, 2, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, StoneSlabTile::SMOOTHBRICK_SLAB, 3, 2, 4, chunkBB); + for (int z = 2; z <= 4; z++) + { + placeBlock(level, Tile::stoneSlabHalf_Id, StoneSlabTile::SMOOTHBRICK_SLAB, 2, 1, z, chunkBB); + } + + if (!hasPlacedChest) + { + int y = getWorldY(2); + int x = getWorldX(3, 3), z = getWorldZ(3, 3); + if (chunkBB->isInside(x, y, z)) + { + hasPlacedChest = true; + createChest(level, chunkBB, random, 3, 2, 3, WeighedTreasure::addToTreasure(WeighedTreasureArray(treasureItems,TREASURE_ITEMS_COUNT), Item::enchantedBook->createForRandomTreasure(random)), 2 + random->nextInt(2)); + } + } + + return true; +} + +StrongholdPieces::StraightStairsDown::StraightStairsDown(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : StrongholdPiece(genDepth), entryDoor(randomSmallDoor(random)) +{ + orientation = direction; + boundingBox = stairsBox; +} + +void StrongholdPieces::StraightStairsDown::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random) +{ + generateSmallDoorChildForward((StartPiece *) startPiece, pieces, random, 1, 1); +} + +StrongholdPieces::StraightStairsDown *StrongholdPieces::StraightStairsDown::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth) +{ + BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, 4 - height, 0, width, height, depth, direction); + + StartPiece *startPiece = NULL; + if(pieces != NULL) startPiece = ((StrongholdPieces::StartPiece *) pieces->front()); + + if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) + { + delete box; + return NULL; + } + + return new StraightStairsDown(genDepth, random, box, direction); +} + +bool StrongholdPieces::StraightStairsDown::postProcess(Level *level, Random *random, BoundingBox *chunkBB) +{ + if (edgesLiquid(level, chunkBB)) + { + return false; + } + + // bounding walls + generateBox(level, chunkBB, 0, 0, 0, width - 1, height - 1, depth - 1, CHECK_AIR, random, (BlockSelector *)smoothStoneSelector); + // entry door + generateSmallDoor(level, random, chunkBB, entryDoor, 1, height - SMALL_DOOR_HEIGHT - 1, 0); + // exit door + generateSmallDoor(level, random, chunkBB, OPENING, 1, 1, depth - 1); + + // stairs + int orientationData = getOrientationData(Tile::stairs_stone_Id, 2); + for (int i = 0; i < 6; i++) + { + placeBlock(level, Tile::stairs_stone_Id, orientationData, 1, height - 5 - i, 1 + i, chunkBB); + placeBlock(level, Tile::stairs_stone_Id, orientationData, 2, height - 5 - i, 1 + i, chunkBB); + placeBlock(level, Tile::stairs_stone_Id, orientationData, 3, height - 5 - i, 1 + i, chunkBB); + if (i < 5) + { + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 1, height - 6 - i, 1 + i, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 2, height - 6 - i, 1 + i, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 3, height - 6 - i, 1 + i, chunkBB); + } + } + + return true; +} + +StrongholdPieces::LeftTurn::LeftTurn(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : StrongholdPiece(genDepth), entryDoor(randomSmallDoor(random)) +{ + orientation = direction; + boundingBox = stairsBox; +} + +void StrongholdPieces::LeftTurn::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random) +{ + if (orientation == Direction::NORTH || orientation == Direction::EAST) + { + generateSmallDoorChildLeft((StartPiece *) startPiece, pieces, random, 1, 1); + } + else + { + generateSmallDoorChildRight((StartPiece *) startPiece, pieces, random, 1, 1); + } +} + +StrongholdPieces::LeftTurn *StrongholdPieces::LeftTurn::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth) +{ + BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, -1, 0, width, height, depth, direction); + + StartPiece *startPiece = NULL; + if(pieces != NULL) startPiece = ((StrongholdPieces::StartPiece *) pieces->front()); + + if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) + { + delete box; + return NULL; + } + + return new LeftTurn(genDepth, random, box, direction); +} + +bool StrongholdPieces::LeftTurn::postProcess(Level *level, Random *random, BoundingBox *chunkBB) +{ + if (edgesLiquid(level, chunkBB)) + { + return false; + } + + // bounding walls + generateBox(level, chunkBB, 0, 0, 0, width - 1, height - 1, depth - 1, CHECK_AIR, random, (BlockSelector *)smoothStoneSelector); + // entry door + generateSmallDoor(level, random, chunkBB, entryDoor, 1, height - SMALL_DOOR_HEIGHT - 1, 0); + // exit opening + if (orientation == Direction::NORTH || orientation == Direction::EAST) + { + generateBox(level, chunkBB, 0, 1, 1, 0, 3, 3, 0, 0, false); + } + else + { + generateBox(level, chunkBB, 4, 1, 1, 4, 3, 3, 0, 0, false); + } + + return true; +} + +StrongholdPieces::RightTurn::RightTurn(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : LeftTurn(genDepth, random, stairsBox, direction) +{ +} + +void StrongholdPieces::RightTurn::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random) +{ + if (orientation == Direction::NORTH || orientation == Direction::EAST) + { + generateSmallDoorChildRight((StartPiece *) startPiece, pieces, random, 1, 1); + } + else + { + generateSmallDoorChildLeft((StartPiece *) startPiece, pieces, random, 1, 1); + } +} + +bool StrongholdPieces::RightTurn::postProcess(Level *level, Random *random, BoundingBox *chunkBB) +{ + if (edgesLiquid(level, chunkBB)) + { + return false; + } + + // bounding walls + generateBox(level, chunkBB, 0, 0, 0, width - 1, height - 1, depth - 1, CHECK_AIR, random, (BlockSelector *)smoothStoneSelector); + // entry door + generateSmallDoor(level, random, chunkBB, entryDoor, 1, height - SMALL_DOOR_HEIGHT - 1, 0); + // exit opening + if (orientation == Direction::NORTH || orientation == Direction::EAST) + { + generateBox(level, chunkBB, 4, 1, 1, 4, 3, 3, 0, 0, false); + } + else + { + generateBox(level, chunkBB, 0, 1, 1, 0, 3, 3, 0, 0, false); + } + + return true; +} + + +StrongholdPieces::RoomCrossing::RoomCrossing(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : StrongholdPiece(genDepth), entryDoor(randomSmallDoor(random)), type(random->nextInt(5)) +{ + orientation = direction; + boundingBox = stairsBox; +} + +void StrongholdPieces::RoomCrossing::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random) +{ + generateSmallDoorChildForward((StartPiece*) startPiece, pieces, random, 4, 1); + generateSmallDoorChildLeft((StartPiece*) startPiece, pieces, random, 1, 4); + generateSmallDoorChildRight((StartPiece*) startPiece, pieces, random, 1, 4); +} + +StrongholdPieces::RoomCrossing *StrongholdPieces::RoomCrossing::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth) +{ + BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -4, -1, 0, width, height, depth, direction); + + StartPiece *startPiece = NULL; + if(pieces != NULL) startPiece = ((StrongholdPieces::StartPiece *) pieces->front()); + + if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) + { + delete box; + return NULL; + } + + return new RoomCrossing(genDepth, random, box, direction); +} + +WeighedTreasure *StrongholdPieces::RoomCrossing::smallTreasureItems[SMALL_TREASURE_ITEMS_COUNT] = +{ + new WeighedTreasure(Item::ironIngot_Id, 0, 1, 5, 10), + new WeighedTreasure(Item::goldIngot_Id, 0, 1, 3, 5), + new WeighedTreasure(Item::redStone_Id, 0, 4, 9, 5), + new WeighedTreasure(Item::coal_Id, CoalItem::STONE_COAL, 3, 8, 10), + new WeighedTreasure(Item::bread_Id, 0, 1, 3, 15), + new WeighedTreasure(Item::apple_Id, 0, 1, 3, 15), + new WeighedTreasure(Item::pickAxe_iron_Id, 0, 1, 1, 1), +}; + +bool StrongholdPieces::RoomCrossing::postProcess(Level *level, Random *random, BoundingBox *chunkBB) +{ + if (edgesLiquid(level, chunkBB)) + { + return false; + } + + // bounding walls + generateBox(level, chunkBB, 0, 0, 0, width - 1, height - 1, depth - 1, CHECK_AIR, random, (BlockSelector *)smoothStoneSelector); + // entry door + generateSmallDoor(level, random, chunkBB, entryDoor, 4, 1, 0); + // exit openings + generateBox(level, chunkBB, 4, 1, depth - 1, 6, 3, depth - 1, 0, 0, false); + generateBox(level, chunkBB, 0, 1, 4, 0, 3, 6, 0, 0, false); + generateBox(level, chunkBB, width - 1, 1, 4, width - 1, 3, 6, 0, 0, false); + + switch (type) + { + default: + break; + case 0: + // middle torch pillar + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 5, 1, 5, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 5, 2, 5, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 5, 3, 5, chunkBB); + placeBlock(level, Tile::torch_Id, 0, 4, 3, 5, chunkBB); + placeBlock(level, Tile::torch_Id, 0, 6, 3, 5, chunkBB); + placeBlock(level, Tile::torch_Id, 0, 5, 3, 4, chunkBB); + placeBlock(level, Tile::torch_Id, 0, 5, 3, 6, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, 0, 4, 1, 4, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, 0, 4, 1, 5, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, 0, 4, 1, 6, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, 0, 6, 1, 4, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, 0, 6, 1, 5, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, 0, 6, 1, 6, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, 0, 5, 1, 4, chunkBB); + placeBlock(level, Tile::stoneSlabHalf_Id, 0, 5, 1, 6, chunkBB); + break; + case 1: + { + for (int i = 0; i < 5; i++) + { + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 3, 1, 3 + i, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 7, 1, 3 + i, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 3 + i, 1, 3, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 3 + i, 1, 7, chunkBB); + } + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 5, 1, 5, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 5, 2, 5, chunkBB); + placeBlock(level, Tile::stoneBrickSmooth_Id, 0, 5, 3, 5, chunkBB); + placeBlock(level, Tile::water_Id, 0, 5, 4, 5, chunkBB); + } + break; + case 2: + { + for (int z = 1; z <= 9; z++) + { + placeBlock(level, Tile::stoneBrick_Id, 0, 1, 3, z, chunkBB); + placeBlock(level, Tile::stoneBrick_Id, 0, 9, 3, z, chunkBB); + } + for (int x = 1; x <= 9; x++) + { + placeBlock(level, Tile::stoneBrick_Id, 0, x, 3, 1, chunkBB); + placeBlock(level, Tile::stoneBrick_Id, 0, x, 3, 9, chunkBB); + } + placeBlock(level, Tile::stoneBrick_Id, 0, 5, 1, 4, chunkBB); + placeBlock(level, Tile::stoneBrick_Id, 0, 5, 1, 6, chunkBB); + placeBlock(level, Tile::stoneBrick_Id, 0, 5, 3, 4, chunkBB); + placeBlock(level, Tile::stoneBrick_Id, 0, 5, 3, 6, chunkBB); + placeBlock(level, Tile::stoneBrick_Id, 0, 4, 1, 5, chunkBB); + placeBlock(level, Tile::stoneBrick_Id, 0, 6, 1, 5, chunkBB); + placeBlock(level, Tile::stoneBrick_Id, 0, 4, 3, 5, chunkBB); + placeBlock(level, Tile::stoneBrick_Id, 0, 6, 3, 5, chunkBB); + for (int y = 1; y <= 3; y++) + { + placeBlock(level, Tile::stoneBrick_Id, 0, 4, y, 4, chunkBB); + placeBlock(level, Tile::stoneBrick_Id, 0, 6, y, 4, chunkBB); + placeBlock(level, Tile::stoneBrick_Id, 0, 4, y, 6, chunkBB); + placeBlock(level, Tile::stoneBrick_Id, 0, 6, y, 6, chunkBB); + } + placeBlock(level, Tile::torch_Id, 0, 5, 3, 5, chunkBB); + for (int z = 2; z <= 8; z++) + { + placeBlock(level, Tile::wood_Id, 0, 2, 3, z, chunkBB); + placeBlock(level, Tile::wood_Id, 0, 3, 3, z, chunkBB); + if (z <= 3 || z >= 7) + { + placeBlock(level, Tile::wood_Id, 0, 4, 3, z, chunkBB); + placeBlock(level, Tile::wood_Id, 0, 5, 3, z, chunkBB); + placeBlock(level, Tile::wood_Id, 0, 6, 3, z, chunkBB); + } + placeBlock(level, Tile::wood_Id, 0, 7, 3, z, chunkBB); + placeBlock(level, Tile::wood_Id, 0, 8, 3, z, chunkBB); + } + placeBlock(level, Tile::ladder_Id, getOrientationData(Tile::ladder_Id, Facing::WEST), 9, 1, 3, chunkBB); + placeBlock(level, Tile::ladder_Id, getOrientationData(Tile::ladder_Id, Facing::WEST), 9, 2, 3, chunkBB); + placeBlock(level, Tile::ladder_Id, getOrientationData(Tile::ladder_Id, Facing::WEST), 9, 3, 3, chunkBB); + + createChest(level, chunkBB, random, 3, 4, 8, WeighedTreasure::addToTreasure(WeighedTreasureArray(smallTreasureItems,SMALL_TREASURE_ITEMS_COUNT), Item::enchantedBook->createForRandomTreasure(random)), 1 + random->nextInt(4)); + // System.out.println("Created chest at " + getWorldX(3, 8) + + // "," + getWorldY(4) + "," + getWorldZ(3, 8)); + + } + break; + } + return true; +} + +StrongholdPieces::PrisonHall::PrisonHall(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : StrongholdPiece(genDepth), entryDoor(randomSmallDoor(random)) +{ + orientation = direction; + boundingBox = stairsBox; +} + +void StrongholdPieces::PrisonHall::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random) +{ + generateSmallDoorChildForward((StartPiece *) startPiece, pieces, random, 1, 1); +} + +StrongholdPieces::PrisonHall *StrongholdPieces::PrisonHall::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth) +{ + BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, -1, 0, width, height, depth, direction); + + StartPiece *startPiece = NULL; + if(pieces != NULL) startPiece = ((StrongholdPieces::StartPiece *) pieces->front()); + + if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) + { + delete box; + return NULL; + } + + return new PrisonHall(genDepth, random, box, direction); +} + +bool StrongholdPieces::PrisonHall::postProcess(Level *level, Random *random, BoundingBox *chunkBB) +{ + if (edgesLiquid(level, chunkBB)) + { + return false; + } + + // bounding walls + generateBox(level, chunkBB, 0, 0, 0, width - 1, height - 1, depth - 1, CHECK_AIR, random, (BlockSelector *)smoothStoneSelector); + // entry door + generateSmallDoor(level, random, chunkBB, entryDoor, 1, 1, 0); + // exit openings + generateBox(level, chunkBB, 1, 1, depth - 1, 3, 3, depth - 1, 0, 0, false); + + // door pillars + generateBox(level, chunkBB, 4, 1, 1, 4, 3, 1, false, random, (BlockSelector *)smoothStoneSelector); + generateBox(level, chunkBB, 4, 1, 3, 4, 3, 3, false, random, (BlockSelector *)smoothStoneSelector); + generateBox(level, chunkBB, 4, 1, 7, 4, 3, 7, false, random, (BlockSelector *)smoothStoneSelector); + generateBox(level, chunkBB, 4, 1, 9, 4, 3, 9, false, random, (BlockSelector *)smoothStoneSelector); + + // grates + generateBox(level, chunkBB, 4, 1, 4, 4, 3, 6, Tile::ironFence_Id, Tile::ironFence_Id, false); + generateBox(level, chunkBB, 5, 1, 5, 7, 3, 5, Tile::ironFence_Id, Tile::ironFence_Id, false); + + // doors + placeBlock(level, Tile::ironFence_Id, 0, 4, 3, 2, chunkBB); + placeBlock(level, Tile::ironFence_Id, 0, 4, 3, 8, chunkBB); + placeBlock(level, Tile::door_iron_Id, getOrientationData(Tile::door_iron_Id, 3), 4, 1, 2, chunkBB); + placeBlock(level, Tile::door_iron_Id, getOrientationData(Tile::door_iron_Id, 3) + DoorTile::UPPER_BIT, 4, 2, 2, chunkBB); + placeBlock(level, Tile::door_iron_Id, getOrientationData(Tile::door_iron_Id, 3), 4, 1, 8, chunkBB); + placeBlock(level, Tile::door_iron_Id, getOrientationData(Tile::door_iron_Id, 3) + DoorTile::UPPER_BIT, 4, 2, 8, chunkBB); + + return true; + +} + +StrongholdPieces::Library::Library(int genDepth, Random *random, BoundingBox *roomBox, int direction) : StrongholdPiece(genDepth), + entryDoor(randomSmallDoor(random)), + isTall(roomBox->getYSpan() > height) +{ + orientation = direction; + boundingBox = roomBox; +} + +StrongholdPieces::Library *StrongholdPieces::Library::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth) +{ + // attempt to make a tall library first + BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -4, -1, 0, width, tallHeight, depth, direction); + + StartPiece *startPiece = NULL; + if(pieces != NULL) startPiece = ((StrongholdPieces::StartPiece *) pieces->front()); + + if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) + { + delete box; + // make a short library + box = BoundingBox::orientBox(footX, footY, footZ, -4, -1, 0, width, height, depth, direction); + + if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) + { + delete box; + return NULL; + } + } + + return new Library(genDepth, random, box, direction); +} + +WeighedTreasure *StrongholdPieces::Library::libraryTreasureItems[LIBRARY_TREASURE_ITEMS_COUNT] = +{ + new WeighedTreasure(Item::book_Id, 0, 1, 3, 20), + new WeighedTreasure(Item::paper_Id, 0, 2, 7, 20), + new WeighedTreasure(Item::map_Id, 0, 1, 1, 1), + new WeighedTreasure(Item::compass_Id, 0, 1, 1, 1), +}; + +bool StrongholdPieces::Library::postProcess(Level *level, Random *random, BoundingBox *chunkBB) +{ + if (edgesLiquid(level, chunkBB)) + { + return false; + } + + int currentHeight = tallHeight; + if (!isTall) + { + currentHeight = height; + } + + // bounding walls + generateBox(level, chunkBB, 0, 0, 0, width - 1, currentHeight - 1, depth - 1, CHECK_AIR, random, (BlockSelector *)smoothStoneSelector); + // entry door + generateSmallDoor(level, random, chunkBB, entryDoor, 4, 1, 0); + + // place sparse cob webs + generateMaybeBox(level, chunkBB, random, .07f, 2, 1, 1, width - 1 - 2, height - 2, depth - 2, Tile::web_Id, Tile::web_Id, false); + + const int bookLeft = 1; + const int bookRight = width - 2; + + // place library walls + for (int d = 1; d <= depth - 2; d++) { + if (((d - 1) % 4) == 0) { + generateBox(level, chunkBB, bookLeft, 1, d, bookLeft, 4, d, Tile::wood_Id, Tile::wood_Id, false); + generateBox(level, chunkBB, bookRight, 1, d, bookRight, 4, d, Tile::wood_Id, Tile::wood_Id, false); + + placeBlock(level, Tile::torch_Id, 0, 2, 3, d, chunkBB); + placeBlock(level, Tile::torch_Id, 0, width - 3, 3, d, chunkBB); + + if (isTall) + { + generateBox(level, chunkBB, bookLeft, 6, d, bookLeft, 9, d, Tile::wood_Id, Tile::wood_Id, false); + generateBox(level, chunkBB, bookRight, 6, d, bookRight, 9, d, Tile::wood_Id, Tile::wood_Id, false); + } + } + else + { + generateBox(level, chunkBB, bookLeft, 1, d, bookLeft, 4, d, Tile::bookshelf_Id, Tile::bookshelf_Id, false); + generateBox(level, chunkBB, bookRight, 1, d, bookRight, 4, d, Tile::bookshelf_Id, Tile::bookshelf_Id, false); + + if (isTall) + { + generateBox(level, chunkBB, bookLeft, 6, d, bookLeft, 9, d, Tile::bookshelf_Id, Tile::bookshelf_Id, false); + generateBox(level, chunkBB, bookRight, 6, d, bookRight, 9, d, Tile::bookshelf_Id, Tile::bookshelf_Id, false); + } + } + } + + // place book shelves + for (int d = 3; d < depth - 3; d += 2) + { + generateBox(level, chunkBB, 3, 1, d, 4, 3, d, Tile::bookshelf_Id, Tile::bookshelf_Id, false); + generateBox(level, chunkBB, 6, 1, d, 7, 3, d, Tile::bookshelf_Id, Tile::bookshelf_Id, false); + generateBox(level, chunkBB, 9, 1, d, 10, 3, d, Tile::bookshelf_Id, Tile::bookshelf_Id, false); + } + + if (isTall) + { + // create balcony + generateBox(level, chunkBB, 1, 5, 1, 3, 5, depth - 2, Tile::wood_Id, Tile::wood_Id, false); + generateBox(level, chunkBB, width - 4, 5, 1, width - 2, 5, depth - 2, Tile::wood_Id, Tile::wood_Id, false); + generateBox(level, chunkBB, 4, 5, 1, width - 5, 5, 2, Tile::wood_Id, Tile::wood_Id, false); + generateBox(level, chunkBB, 4, 5, depth - 3, width - 5, 5, depth - 2, Tile::wood_Id, Tile::wood_Id, false); + + placeBlock(level, Tile::wood_Id, 0, width - 5, 5, depth - 4, chunkBB); + placeBlock(level, Tile::wood_Id, 0, width - 6, 5, depth - 4, chunkBB); + placeBlock(level, Tile::wood_Id, 0, width - 5, 5, depth - 5, chunkBB); + + // balcony fences + generateBox(level, chunkBB, 3, 6, 2, 3, 6, depth - 3, Tile::fence_Id, Tile::fence_Id, false); + generateBox(level, chunkBB, width - 4, 6, 2, width - 4, 6, depth - 5, Tile::fence_Id, Tile::fence_Id, false); + generateBox(level, chunkBB, 4, 6, 2, width - 5, 6, 2, Tile::fence_Id, Tile::fence_Id, false); + generateBox(level, chunkBB, 4, 6, depth - 3, 8, 6, depth - 3, Tile::fence_Id, Tile::fence_Id, false); + placeBlock(level, Tile::fence_Id, 0, width - 5, 6, depth - 4, chunkBB); + placeBlock(level, Tile::fence_Id, 0, width - 6, 6, depth - 4, chunkBB); + placeBlock(level, Tile::fence_Id, 0, width - 5, 6, depth - 5, chunkBB); + + // ladder + int orientationData = getOrientationData(Tile::ladder_Id, 3); + placeBlock(level, Tile::ladder_Id, orientationData, width - 4, 1, depth - 2, chunkBB); + placeBlock(level, Tile::ladder_Id, orientationData, width - 4, 2, depth - 2, chunkBB); + placeBlock(level, Tile::ladder_Id, orientationData, width - 4, 3, depth - 2, chunkBB); + placeBlock(level, Tile::ladder_Id, orientationData, width - 4, 4, depth - 2, chunkBB); + placeBlock(level, Tile::ladder_Id, orientationData, width - 4, 5, depth - 2, chunkBB); + placeBlock(level, Tile::ladder_Id, orientationData, width - 4, 6, depth - 2, chunkBB); + placeBlock(level, Tile::ladder_Id, orientationData, width - 4, 7, depth - 2, chunkBB); + + // chandelier + int x = width / 2; + int z = depth / 2; + placeBlock(level, Tile::fence_Id, 0, x - 1, tallHeight - 2, z, chunkBB); + placeBlock(level, Tile::fence_Id, 0, x, tallHeight - 2, z, chunkBB); + placeBlock(level, Tile::fence_Id, 0, x - 1, tallHeight - 3, z, chunkBB); + placeBlock(level, Tile::fence_Id, 0, x, tallHeight - 3, z, chunkBB); + placeBlock(level, Tile::fence_Id, 0, x - 1, tallHeight - 4, z, chunkBB); + placeBlock(level, Tile::fence_Id, 0, x, tallHeight - 4, z, chunkBB); + + placeBlock(level, Tile::fence_Id, 0, x - 2, tallHeight - 4, z, chunkBB); + placeBlock(level, Tile::fence_Id, 0, x + 1, tallHeight - 4, z, chunkBB); + placeBlock(level, Tile::fence_Id, 0, x - 1, tallHeight - 4, z - 1, chunkBB); + placeBlock(level, Tile::fence_Id, 0, x - 1, tallHeight - 4, z + 1, chunkBB); + placeBlock(level, Tile::fence_Id, 0, x, tallHeight - 4, z - 1, chunkBB); + placeBlock(level, Tile::fence_Id, 0, x, tallHeight - 4, z + 1, chunkBB); + + placeBlock(level, Tile::torch_Id, 0, x - 2, tallHeight - 3, z, chunkBB); + placeBlock(level, Tile::torch_Id, 0, x + 1, tallHeight - 3, z, chunkBB); + placeBlock(level, Tile::torch_Id, 0, x - 1, tallHeight - 3, z - 1, chunkBB); + placeBlock(level, Tile::torch_Id, 0, x - 1, tallHeight - 3, z + 1, chunkBB); + placeBlock(level, Tile::torch_Id, 0, x, tallHeight - 3, z - 1, chunkBB); + placeBlock(level, Tile::torch_Id, 0, x, tallHeight - 3, z + 1, chunkBB); + } + + // place chests + createChest(level, chunkBB, random, 3, 3, 5, WeighedTreasure::addToTreasure(WeighedTreasureArray(libraryTreasureItems,LIBRARY_TREASURE_ITEMS_COUNT), Item::enchantedBook->createForRandomTreasure(random, 1, 5, 2)), 1 + random->nextInt(4)); + if (isTall) + { + placeBlock(level, 0, 0, width - 2, tallHeight - 2, 1, chunkBB); + createChest(level, chunkBB, random, width - 2, tallHeight - 3, 1, WeighedTreasure::addToTreasure(WeighedTreasureArray(libraryTreasureItems,LIBRARY_TREASURE_ITEMS_COUNT), Item::enchantedBook->createForRandomTreasure(random, 1, 5, 2)), 1 + random->nextInt(4)); + } + + return true; + +} + +StrongholdPieces::FiveCrossing::FiveCrossing(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : StrongholdPiece(genDepth), entryDoor(randomSmallDoor(random)) +{ + orientation = direction; + boundingBox = stairsBox; + + leftLow = random->nextBoolean(); + leftHigh = random->nextBoolean(); + rightLow = random->nextBoolean(); + rightHigh = random->nextInt(3) > 0; +} + +void StrongholdPieces::FiveCrossing::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random) +{ + int zOffA = 3; + int zOffB = 5; + // compensate for weird negative-facing behaviour + if (orientation == Direction::WEST || orientation == Direction::NORTH) + { + zOffA = depth - 3 - zOffA; + zOffB = depth - 3 - zOffB; + } + + generateSmallDoorChildForward((StartPiece *) startPiece, pieces, random, 5, 1); + if (leftLow) generateSmallDoorChildLeft((StartPiece *) startPiece, pieces, random, zOffA, 1); + if (leftHigh) generateSmallDoorChildLeft((StartPiece *) startPiece, pieces, random, zOffB, 7); + if (rightLow) generateSmallDoorChildRight((StartPiece *) startPiece, pieces, random, zOffA, 1); + if (rightHigh) generateSmallDoorChildRight((StartPiece *) startPiece, pieces, random, zOffB, 7); +} + +StrongholdPieces::FiveCrossing *StrongholdPieces::FiveCrossing::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth) +{ + BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -4, -3, 0, width, height, depth, direction); + + StartPiece *startPiece = NULL; + if(pieces != NULL) startPiece = ((StrongholdPieces::StartPiece *) pieces->front()); + + if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) + { + delete box; + return NULL; + } + + return new FiveCrossing(genDepth, random, box, direction); +} + +bool StrongholdPieces::FiveCrossing::postProcess(Level *level, Random *random, BoundingBox *chunkBB) +{ + if (edgesLiquid(level, chunkBB)) + { + return false; + } + + // bounding walls + generateBox(level, chunkBB, 0, 0, 0, width - 1, height - 1, depth - 1, CHECK_AIR, random, (BlockSelector *)smoothStoneSelector); + // entry door + generateSmallDoor(level, random, chunkBB, entryDoor, 4, 3, 0); + + // exit openings + if (leftLow) generateBox(level, chunkBB, 0, 3, 1, 0, 5, 3, 0, 0, false); + if (rightLow) generateBox(level, chunkBB, 9, 3, 1, 9, 5, 3, 0, 0, false); + if (leftHigh) generateBox(level, chunkBB, 0, 5, 7, 0, 7, 9, 0, 0, false); + if (rightHigh) generateBox(level, chunkBB, 9, 5, 7, 9, 7, 9, 0, 0, false); + generateBox(level, chunkBB, 5, 1, 10, 7, 3, 10, 0, 0, false); + + // main floor + generateBox(level, chunkBB, 1, 2, 1, 8, 2, 6, false, random, (BlockSelector *)smoothStoneSelector); + // side walls + generateBox(level, chunkBB, 4, 1, 5, 4, 4, 9, false, random, (BlockSelector *)smoothStoneSelector); + generateBox(level, chunkBB, 8, 1, 5, 8, 4, 9, false, random, (BlockSelector *)smoothStoneSelector); + // upper floor + generateBox(level, chunkBB, 1, 4, 7, 3, 4, 9, false, random, (BlockSelector *)smoothStoneSelector); + + // left stairs + generateBox(level, chunkBB, 1, 3, 5, 3, 3, 6, false, random, (BlockSelector *)smoothStoneSelector); + generateBox(level, chunkBB, 1, 3, 4, 3, 3, 4, Tile::stoneSlabHalf_Id, Tile::stoneSlabHalf_Id, false); + generateBox(level, chunkBB, 1, 4, 6, 3, 4, 6, Tile::stoneSlabHalf_Id, Tile::stoneSlabHalf_Id, false); + + // lower stairs + generateBox(level, chunkBB, 5, 1, 7, 7, 1, 8, false, random, (BlockSelector *)smoothStoneSelector); + generateBox(level, chunkBB, 5, 1, 9, 7, 1, 9, Tile::stoneSlabHalf_Id, Tile::stoneSlabHalf_Id, false); + generateBox(level, chunkBB, 5, 2, 7, 7, 2, 7, Tile::stoneSlabHalf_Id, Tile::stoneSlabHalf_Id, false); + + // bridge + generateBox(level, chunkBB, 4, 5, 7, 4, 5, 9, Tile::stoneSlabHalf_Id, Tile::stoneSlabHalf_Id, false); + generateBox(level, chunkBB, 8, 5, 7, 8, 5, 9, Tile::stoneSlabHalf_Id, Tile::stoneSlabHalf_Id, false); + generateBox(level, chunkBB, 5, 5, 7, 7, 5, 9, Tile::stoneSlab_Id, Tile::stoneSlab_Id, false); + placeBlock(level, Tile::torch_Id, 0, 6, 5, 6, chunkBB); + + return true; + +} + +StrongholdPieces::PortalRoom::PortalRoom(int genDepth, Random *random, BoundingBox *box, int direction) : StrongholdPiece(genDepth) +{ + hasPlacedMobSpawner = false; + orientation = direction; + boundingBox = box; +} + +void StrongholdPieces::PortalRoom::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random) +{ + if (startPiece != NULL) + { + ((StartPiece *) startPiece)->portalRoomPiece = this; + } +} + +StrongholdPieces::PortalRoom *StrongholdPieces::PortalRoom::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth) +{ + BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -4, -1, 0, width, height, depth, direction); + + // 4J Added so that we can check that Portals stay within the bounds of the world (which they ALWAYS should anyway) + StartPiece *startPiece = NULL; + if(pieces != NULL) startPiece = ((StrongholdPieces::StartPiece *) pieces->front()); + + if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) + { + delete box; + return NULL; + } + + return new PortalRoom(genDepth, random, box, direction); +} + +bool StrongholdPieces::PortalRoom::postProcess(Level *level, Random *random, BoundingBox *chunkBB) +{ + // bounding walls + generateBox(level, chunkBB, 0, 0, 0, width - 1, height - 1, depth - 1, false, random, (BlockSelector *)smoothStoneSelector); + // entry door + generateSmallDoor(level, random, chunkBB, GRATES, 4, 1, 0); + + // inner roof row + int y = height - 2; + generateBox(level, chunkBB, 1, y, 1, 1, y, depth - 2, false, random, (BlockSelector *)smoothStoneSelector); + generateBox(level, chunkBB, width - 2, y, 1, width - 2, y, depth - 2, false, random, (BlockSelector *)smoothStoneSelector); + generateBox(level, chunkBB, 2, y, 1, width - 3, y, 2, false, random, (BlockSelector *)smoothStoneSelector); + generateBox(level, chunkBB, 2, y, depth - 2, width - 3, y, depth - 2, false, random, (BlockSelector *)smoothStoneSelector); + + // entrance lava pools + generateBox(level, chunkBB, 1, 1, 1, 2, 1, 4, false, random, (BlockSelector *)smoothStoneSelector); + generateBox(level, chunkBB, width - 3, 1, 1, width - 2, 1, 4, false, random, (BlockSelector *)smoothStoneSelector); + generateBox(level, chunkBB, 1, 1, 1, 1, 1, 3, Tile::lava_Id, Tile::lava_Id, false); + generateBox(level, chunkBB, width - 2, 1, 1, width - 2, 1, 3, Tile::lava_Id, Tile::lava_Id, false); + + // portal lava pool + generateBox(level, chunkBB, 3, 1, 8, 7, 1, 12, false, random, (BlockSelector *)smoothStoneSelector); + generateBox(level, chunkBB, 4, 1, 9, 6, 1, 11, Tile::lava_Id, Tile::lava_Id, false); + + // wall decorations + for (int z = 3; z < depth - 2; z += 2) + { + generateBox(level, chunkBB, 0, 3, z, 0, 4, z, Tile::ironFence_Id, Tile::ironFence_Id, false); + generateBox(level, chunkBB, width - 1, 3, z, width - 1, 4, z, Tile::ironFence_Id, Tile::ironFence_Id, false); + } + for (int x = 2; x < width - 2; x += 2) + { + generateBox(level, chunkBB, x, 3, depth - 1, x, 4, depth - 1, Tile::ironFence_Id, Tile::ironFence_Id, false); + } + + // stair + int orientationData = getOrientationData(Tile::stairs_stoneBrickSmooth_Id, 3); + generateBox(level, chunkBB, 4, 1, 5, 6, 1, 7, false, random, (BlockSelector *)smoothStoneSelector); + generateBox(level, chunkBB, 4, 2, 6, 6, 2, 7, false, random, (BlockSelector *)smoothStoneSelector); + generateBox(level, chunkBB, 4, 3, 7, 6, 3, 7, false, random, (BlockSelector *)smoothStoneSelector); + for (int x = 4; x <= 6; x++) + { + placeBlock(level, Tile::stairs_stoneBrickSmooth_Id, orientationData, x, 1, 4, chunkBB); + placeBlock(level, Tile::stairs_stoneBrickSmooth_Id, orientationData, x, 2, 5, chunkBB); + placeBlock(level, Tile::stairs_stoneBrickSmooth_Id, orientationData, x, 3, 6, chunkBB); + } + + int north = Direction::NORTH; + int south = Direction::SOUTH; + int east = Direction::EAST; + int west = Direction::WEST; + + switch (orientation) + { + case Direction::SOUTH: + north = Direction::SOUTH; + south = Direction::NORTH; + break; + case Direction::EAST: + north = Direction::EAST; + south = Direction::WEST; + east = Direction::SOUTH; + west = Direction::NORTH; + break; + case Direction::WEST: + north = Direction::WEST; + south = Direction::EAST; + east = Direction::SOUTH; + west = Direction::NORTH; + break; + } + + // 4J-PB - Removed for Christmas update since we don't have The End + + // 4J-PB - not going to remove it, so that maps generated will have it in, but it can't be activated + placeBlock(level, Tile::endPortalFrameTile_Id, north + ((random->nextFloat() > 0.9f) ? TheEndPortalFrameTile::EYE_BIT : 0), 4, 3, 8, chunkBB); + placeBlock(level, Tile::endPortalFrameTile_Id, north + ((random->nextFloat() > 0.9f) ? TheEndPortalFrameTile::EYE_BIT : 0), 5, 3, 8, chunkBB); + placeBlock(level, Tile::endPortalFrameTile_Id, north + ((random->nextFloat() > 0.9f) ? TheEndPortalFrameTile::EYE_BIT : 0), 6, 3, 8, chunkBB); + placeBlock(level, Tile::endPortalFrameTile_Id, south + ((random->nextFloat() > 0.9f) ? TheEndPortalFrameTile::EYE_BIT : 0), 4, 3, 12, chunkBB); + placeBlock(level, Tile::endPortalFrameTile_Id, south + ((random->nextFloat() > 0.9f) ? TheEndPortalFrameTile::EYE_BIT : 0), 5, 3, 12, chunkBB); + placeBlock(level, Tile::endPortalFrameTile_Id, south + ((random->nextFloat() > 0.9f) ? TheEndPortalFrameTile::EYE_BIT : 0), 6, 3, 12, chunkBB); + placeBlock(level, Tile::endPortalFrameTile_Id, east + ((random->nextFloat() > 0.9f) ? TheEndPortalFrameTile::EYE_BIT : 0), 3, 3, 9, chunkBB); + placeBlock(level, Tile::endPortalFrameTile_Id, east + ((random->nextFloat() > 0.9f) ? TheEndPortalFrameTile::EYE_BIT : 0), 3, 3, 10, chunkBB); + placeBlock(level, Tile::endPortalFrameTile_Id, east + ((random->nextFloat() > 0.9f) ? TheEndPortalFrameTile::EYE_BIT : 0), 3, 3, 11, chunkBB); + placeBlock(level, Tile::endPortalFrameTile_Id, west + ((random->nextFloat() > 0.9f) ? TheEndPortalFrameTile::EYE_BIT : 0), 7, 3, 9, chunkBB); + placeBlock(level, Tile::endPortalFrameTile_Id, west + ((random->nextFloat() > 0.9f) ? TheEndPortalFrameTile::EYE_BIT : 0), 7, 3, 10, chunkBB); + placeBlock(level, Tile::endPortalFrameTile_Id, west + ((random->nextFloat() > 0.9f) ? TheEndPortalFrameTile::EYE_BIT : 0), 7, 3, 11, chunkBB); + + + if (!hasPlacedMobSpawner) + { + y = getWorldY(3); + int x = getWorldX(5, 6), z = getWorldZ(5, 6); + if (chunkBB->isInside(x, y, z)) + { + // 4J Stu - The mob spawner location is close enough for the map icon display, and this ensures that we only need to set the position once + app.AddTerrainFeaturePosition(eTerrainFeature_StrongholdEndPortal,x,z); + level->getLevelData()->setXStrongholdEndPortal(x); + level->getLevelData()->setZStrongholdEndPortal(z); + level->getLevelData()->setHasStrongholdEndPortal(); + + hasPlacedMobSpawner = true; + level->setTile(x, y, z, Tile::mobSpawner_Id); + shared_ptr<MobSpawnerTileEntity> entity = dynamic_pointer_cast<MobSpawnerTileEntity>(level->getTileEntity(x, y, z)); + if (entity != NULL) entity->setEntityId(L"Silverfish"); + } + } + + return true; + +} + +void StrongholdPieces::SmoothStoneSelector::next(Random *random, int worldX, int worldY, int worldZ, bool isEdge) +{ + if (isEdge) + { + nextId = Tile::stoneBrickSmooth_Id; + + float selection = random->nextFloat(); + if (selection < 0.2f) + { + nextData = SmoothStoneBrickTile::TYPE_CRACKED; + } + else if (selection < 0.5f) + { + nextData = SmoothStoneBrickTile::TYPE_MOSSY; + } + else if (selection < 0.55f) + { + nextId = Tile::monsterStoneEgg_Id; + nextData = StoneMonsterTile::HOST_STONEBRICK; + } + else + { + nextData = 0; + } + } + else + { + nextId = 0; + nextData = 0; + } +} + +const StrongholdPieces::SmoothStoneSelector *StrongholdPieces::smoothStoneSelector = new SmoothStoneSelector(); |