Something went wrong. Try again.
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
Something went wrong. Try again.
69 kB · 1657 lines
C++
at main
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658#include "stdafx.h"#include "net.minecraft.world.item.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.levelgen.h"#include "net.minecraft.world.level.storage.h"#include "net.minecraft.world.level.levelgen.structure.h"#include "WeighedTreasure.h"#include "NetherBridgePieces.h"#include "Direction.h"
void NetherBridgePieces::loadStatic(){ StructureFeatureIO::setPieceId( eStructurePiece_BridgeCrossing, BridgeCrossing::Create, L"NeBCr"); StructureFeatureIO::setPieceId( eStructurePiece_BridgeEndFiller, BridgeEndFiller::Create, L"NeBEF"); StructureFeatureIO::setPieceId( eStructurePiece_BridgeStraight, BridgeStraight::Create, L"NeBS"); StructureFeatureIO::setPieceId( eStructurePiece_CastleCorridorStairsPiece, CastleCorridorStairsPiece::Create, L"NeCCS"); StructureFeatureIO::setPieceId( eStructurePiece_CastleCorridorTBalconyPiece, CastleCorridorTBalconyPiece::Create, L"NeCTB"); StructureFeatureIO::setPieceId( eStructurePiece_CastleEntrance, CastleEntrance::Create, L"NeCE"); StructureFeatureIO::setPieceId( eStructurePiece_CastleSmallCorridorCrossingPiece, CastleSmallCorridorCrossingPiece::Create, L"NeSCSC"); StructureFeatureIO::setPieceId( eStructurePiece_CastleSmallCorridorLeftTurnPiece, CastleSmallCorridorLeftTurnPiece::Create, L"NeSCLT"); StructureFeatureIO::setPieceId( eStructurePiece_CastleSmallCorridorPiece, CastleSmallCorridorPiece::Create, L"NeSC"); StructureFeatureIO::setPieceId( eStructurePiece_CastleSmallCorridorRightTurnPiece, CastleSmallCorridorRightTurnPiece::Create, L"NeSCRT"); StructureFeatureIO::setPieceId( eStructurePiece_CastleStalkRoom, CastleStalkRoom::Create, L"NeCSR"); StructureFeatureIO::setPieceId( eStructurePiece_MonsterThrone, MonsterThrone::Create, L"NeMT"); StructureFeatureIO::setPieceId( eStructurePiece_RoomCrossing, RoomCrossing::Create, L"NeRC"); StructureFeatureIO::setPieceId( eStructurePiece_StairsRoom, StairsRoom::Create, L"NeSR"); StructureFeatureIO::setPieceId( eStructurePiece_NetherBridgeStartPiece, StartPiece::Create, L"NeStart");}
NetherBridgePieces::PieceWeight::PieceWeight(EPieceClass pieceClass, int weight, int maxPlaceCount, bool allowInRow) : weight(weight){ this->placeCount = 0; this->pieceClass = pieceClass; this->maxPlaceCount = maxPlaceCount; this->allowInRow = allowInRow;}
NetherBridgePieces::PieceWeight::PieceWeight(EPieceClass pieceClass, int weight, int maxPlaceCount) : weight(weight){ this->placeCount = 0; this->pieceClass = pieceClass; this->maxPlaceCount = maxPlaceCount; this->allowInRow = false;}
bool NetherBridgePieces::PieceWeight::doPlace(int depth){ return maxPlaceCount == 0 || placeCount < maxPlaceCount;}
bool NetherBridgePieces::PieceWeight::isValid(){ return maxPlaceCount == 0 || placeCount < maxPlaceCount;}
NetherBridgePieces::PieceWeight *NetherBridgePieces::bridgePieceWeights[NetherBridgePieces::BRIDGE_PIECEWEIGHTS_COUNT] ={ new PieceWeight(EPieceClass_BridgeStraight, 30, 0, true), new PieceWeight(EPieceClass_BridgeCrossing, 10, 4), 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 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 new PieceWeight(EPieceClass_RoomCrossing, 10, 4), new PieceWeight(EPieceClass_StairsRoom, 10, 3),};
NetherBridgePieces::PieceWeight *NetherBridgePieces::castlePieceWeights[NetherBridgePieces::CASTLE_PIECEWEIGHTS_COUNT] = { 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 new PieceWeight(EPieceClass_CastleSmallCorridorPiece, 25, 0, true), new PieceWeight(EPieceClass_CastleSmallCorridorCrossingPiece, 15, 5), new PieceWeight(EPieceClass_CastleSmallCorridorRightTurnPiece, 5, 10), new PieceWeight(EPieceClass_CastleSmallCorridorLeftTurnPiece, 5, 10), new PieceWeight(EPieceClass_CastleCorridorStairsPiece, 10, 3, true), new PieceWeight(EPieceClass_CastleCorridorTBalconyPiece, 7, 2),};
NetherBridgePieces::NetherBridgePiece *NetherBridgePieces::findAndCreateBridgePieceFactory(NetherBridgePieces::PieceWeight *piece, list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int depth){ EPieceClass pieceClass = piece->pieceClass; NetherBridgePiece *structurePiece = NULL;
if (pieceClass == EPieceClass_BridgeStraight) { structurePiece = BridgeStraight::createPiece(pieces, random, footX, footY, footZ, direction, depth); } else if (pieceClass == EPieceClass_BridgeCrossing) { structurePiece = BridgeCrossing::createPiece(pieces, random, footX, footY, footZ, direction, depth); } else if (pieceClass == EPieceClass_RoomCrossing) { structurePiece = RoomCrossing::createPiece(pieces, random, footX, footY, footZ, direction, depth); } else if (pieceClass == EPieceClass_StairsRoom) { structurePiece = StairsRoom::createPiece(pieces, random, footX, footY, footZ, direction, depth); } else if (pieceClass == EPieceClass_MonsterThrone) { structurePiece = MonsterThrone::createPiece(pieces, random, footX, footY, footZ, direction, depth); } else if (pieceClass == EPieceClass_CastleEntrance) { structurePiece = CastleEntrance::createPiece(pieces, random, footX, footY, footZ, direction, depth); } else if (pieceClass == EPieceClass_CastleSmallCorridorPiece) { structurePiece = CastleSmallCorridorPiece::createPiece(pieces, random, footX, footY, footZ, direction, depth); } else if (pieceClass == EPieceClass_CastleSmallCorridorRightTurnPiece) { structurePiece = CastleSmallCorridorRightTurnPiece::createPiece(pieces, random, footX, footY, footZ, direction, depth); } else if (pieceClass == EPieceClass_CastleSmallCorridorLeftTurnPiece) { structurePiece = CastleSmallCorridorLeftTurnPiece::createPiece(pieces, random, footX, footY, footZ, direction, depth); } else if (pieceClass == EPieceClass_CastleCorridorStairsPiece) { structurePiece = CastleCorridorStairsPiece::createPiece(pieces, random, footX, footY, footZ, direction, depth); } else if (pieceClass == EPieceClass_CastleCorridorTBalconyPiece) { structurePiece = CastleCorridorTBalconyPiece::createPiece(pieces, random, footX, footY, footZ, direction, depth); } else if (pieceClass == EPieceClass_CastleSmallCorridorCrossingPiece) { structurePiece = CastleSmallCorridorCrossingPiece::createPiece(pieces, random, footX, footY, footZ, direction, depth); } else if (pieceClass == EPieceClass_CastleStalkRoom) { structurePiece = CastleStalkRoom::createPiece(pieces, random, footX, footY, footZ, direction, depth); } return structurePiece;}
WeighedTreasure *NetherBridgePieces::NetherBridgePiece::fortressTreasureItems[FORTRESS_TREASURE_ITEMS_COUNT] = { new WeighedTreasure(Item::diamond_Id, 0, 1, 3, 5), new WeighedTreasure(Item::ironIngot_Id, 0, 1, 5, 5), new WeighedTreasure(Item::goldIngot_Id, 0, 1, 3, 15), new WeighedTreasure(Item::sword_gold_Id, 0, 1, 1, 5), new WeighedTreasure(Item::chestplate_gold_Id, 0, 1, 1, 5), new WeighedTreasure(Item::flintAndSteel_Id, 0, 1, 1, 5), new WeighedTreasure(Item::netherwart_seeds_Id, 0, 3, 7, 5), new WeighedTreasure(Item::saddle_Id, 0, 1, 1, 10), new WeighedTreasure(Item::horseArmorGold_Id, 0, 1, 1, 8), new WeighedTreasure(Item::horseArmorMetal_Id, 0, 1, 1, 5), new WeighedTreasure(Item::horseArmorDiamond_Id, 0, 1, 1, 3),};
NetherBridgePieces::NetherBridgePiece::NetherBridgePiece(){ // for reflection}
NetherBridgePieces::NetherBridgePiece::NetherBridgePiece(int genDepth) : StructurePiece(genDepth){}
void NetherBridgePieces::NetherBridgePiece::readAdditonalSaveData(CompoundTag *tag){}
void NetherBridgePieces::NetherBridgePiece::addAdditonalSaveData(CompoundTag *tag){}
int NetherBridgePieces::NetherBridgePiece::updatePieceWeight(list<PieceWeight *> *currentPieces){ bool hasAnyPieces = false; int 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 ? totalWeight : -1);}
NetherBridgePieces::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){ int totalWeight = updatePieceWeight(currentPieces); boolean doStuff = totalWeight > 0 && depth <= MAX_DEPTH;
int numAttempts = 0; while (numAttempts < 5 && doStuff) { 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 && !piece->allowInRow)) { break; }
NetherBridgePiece *structurePiece = findAndCreateBridgePieceFactory(piece, pieces, random, footX, footY, footZ, direction, depth); if (structurePiece != NULL) { piece->placeCount++; startPiece->previousPiece = piece;
if (!piece->isValid()) { currentPieces->remove(piece); } return structurePiece; } } } } { return BridgeEndFiller::createPiece(pieces, random, footX, footY, footZ, direction, depth); }
}
StructurePiece *NetherBridgePieces::NetherBridgePiece::generateAndAddPiece(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int depth, bool isCastle){ if (abs(footX - startPiece->getBoundingBox()->x0) > 7 * 16 || abs(footZ - startPiece->getBoundingBox()->z0) > 7 * 16) { return BridgeEndFiller::createPiece(pieces, random, footX, footY, footZ, direction, depth); } list<PieceWeight *> *availablePieces = &startPiece->availableBridgePieces; if (isCastle) { availablePieces = &startPiece->availableCastlePieces; } StructurePiece *newPiece = generatePiece(startPiece, availablePieces, pieces, random, footX, footY, footZ, direction, depth + 1); if (newPiece != NULL) { pieces->push_back(newPiece); startPiece->pendingChildren.push_back(newPiece); } return newPiece;}
StructurePiece *NetherBridgePieces::NetherBridgePiece::generateChildForward(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int xOff, int yOff, bool isCastle){ switch (orientation) { case Direction::NORTH: return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + xOff, boundingBox->y0 + yOff, boundingBox->z0 - 1, orientation, getGenDepth(), isCastle); case Direction::SOUTH: return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + xOff, boundingBox->y0 + yOff, boundingBox->z1 + 1, orientation, getGenDepth(), isCastle); case Direction::WEST: return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 - 1, boundingBox->y0 + yOff, boundingBox->z0 + xOff, orientation, getGenDepth(), isCastle); case Direction::EAST: return generateAndAddPiece(startPiece, pieces, random, boundingBox->x1 + 1, boundingBox->y0 + yOff, boundingBox->z0 + xOff, orientation, getGenDepth(), isCastle); } return NULL;}
StructurePiece *NetherBridgePieces::NetherBridgePiece::generateChildLeft(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int yOff, int zOff, bool isCastle){ switch (orientation) { case Direction::NORTH: return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 - 1, boundingBox->y0 + yOff, boundingBox->z0 + zOff, Direction::WEST, getGenDepth(), isCastle); case Direction::SOUTH: return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 - 1, boundingBox->y0 + yOff, boundingBox->z0 + zOff, Direction::WEST, getGenDepth(), isCastle); case Direction::WEST: return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + zOff, boundingBox->y0 + yOff, boundingBox->z0 - 1, Direction::NORTH, getGenDepth(), isCastle); case Direction::EAST: return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + zOff, boundingBox->y0 + yOff, boundingBox->z0 - 1, Direction::NORTH, getGenDepth(), isCastle); } return NULL;}
StructurePiece *NetherBridgePieces::NetherBridgePiece::generateChildRight(StartPiece *startPiece, list<StructurePiece *> *pieces, Random *random, int yOff, int zOff, bool isCastle){ switch (orientation) { case Direction::NORTH: return generateAndAddPiece(startPiece, pieces, random, boundingBox->x1 + 1, boundingBox->y0 + yOff, boundingBox->z0 + zOff, Direction::EAST, getGenDepth(), isCastle); case Direction::SOUTH: return generateAndAddPiece(startPiece, pieces, random, boundingBox->x1 + 1, boundingBox->y0 + yOff, boundingBox->z0 + zOff, Direction::EAST, getGenDepth(), isCastle); case Direction::WEST: return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + zOff, boundingBox->y0 + yOff, boundingBox->z1 + 1, Direction::SOUTH, getGenDepth(), isCastle); case Direction::EAST: return generateAndAddPiece(startPiece, pieces, random, boundingBox->x0 + zOff, boundingBox->y0 + yOff, boundingBox->z1 + 1, Direction::SOUTH, getGenDepth(), isCastle); } return NULL;}
bool NetherBridgePieces::NetherBridgePiece::isOkBox(BoundingBox *box, StartPiece *startPiece){ bool bIsOk = false;
if(box != NULL) { if( box->y0 > LOWEST_Y_POSITION ) bIsOk = true; int xzSize = (startPiece->m_level->getLevelData()->getXZSize() / startPiece->m_level->getLevelData()->getHellScale()); //HellRandomLevelSource::XZSIZE; 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;}
void NetherBridgePieces::NetherBridgePiece::generateLightPost(Level *level, Random *random, BoundingBox *chunkBB, int x, int y, int z, int xOff, int zOff){ int worldX = getWorldX(x, z); int worldY = getWorldY(y); int worldZ = getWorldZ(x, z);
if (!chunkBB->isInside(worldX, worldY, worldZ)) { return; }
if (level->isEmptyTile(worldX, worldY, worldZ) && level->isEmptyTile(worldX, worldY + 1, worldZ) && level->isEmptyTile(worldX, worldY + 2, worldZ) && level->isEmptyTile(worldX, worldY + 3, worldZ)) { level->setTileAndData(worldX, worldY, worldZ, Tile::netherFence_Id, 0, Tile::UPDATE_CLIENTS); level->setTileAndData(worldX, worldY + 1, worldZ, Tile::netherFence_Id, 0, Tile::UPDATE_CLIENTS); level->setTileAndData(worldX, worldY + 2, worldZ, Tile::netherFence_Id, 0, Tile::UPDATE_CLIENTS); level->setTileAndData(worldX, worldY + 3, worldZ, Tile::netherFence_Id, 0, Tile::UPDATE_CLIENTS); placeBlock(level, Tile::netherFence_Id, 0, x + xOff, y + 3, z + zOff, chunkBB); placeBlock(level, Tile::glowstone_Id, 0, x + xOff, y + 2, z + zOff, chunkBB); }}
void NetherBridgePieces::NetherBridgePiece::generateLightPostFacingRight(Level *level, Random *random, BoundingBox *chunkBB, int x, int y, int z){ generateLightPost(level, random, chunkBB, x, y, z, 1, 0);}
void NetherBridgePieces::NetherBridgePiece::generateLightPostFacingLeft(Level *level, Random *random, BoundingBox *chunkBB, int x, int y, int z){ generateLightPost(level, random, chunkBB, x, y, z, -1, 0);}
void NetherBridgePieces::NetherBridgePiece::generateLightPostFacingUp(Level *level, Random *random, BoundingBox *chunkBB, int x, int y, int z){ generateLightPost(level, random, chunkBB, x, y, z, 0, 1);}
void NetherBridgePieces::NetherBridgePiece::generateLightPostFacingDown(Level *level, Random *random, BoundingBox *chunkBB, int x, int y, int z){ generateLightPost(level, random, chunkBB, x, y, z, 0, -1);}
NetherBridgePieces::BridgeStraight::BridgeStraight(){ // for reflection}
NetherBridgePieces::BridgeStraight::BridgeStraight(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth){ orientation = direction; boundingBox = stairsBox;}
void NetherBridgePieces::BridgeStraight::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random){ generateChildForward((StartPiece *) startPiece, pieces, random, 1, 3, false);}
NetherBridgePieces::BridgeStraight *NetherBridgePieces::BridgeStraight::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth){ BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, -3, 0, width, height, depth, direction);
StartPiece *startPiece = NULL; if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) { delete box; return NULL; }
return new BridgeStraight(genDepth, random, box, direction);}
bool NetherBridgePieces::BridgeStraight::postProcess(Level *level, Random *random, BoundingBox *chunkBB){ // floor generateBox(level, chunkBB, 0, 3, 0, width - 1, 4, depth - 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false); // room air generateBox(level, chunkBB, 1, 5, 0, 3, 7, depth - 1, 0, 0, false);
// hand rails generateBox(level, chunkBB, 0, 5, 0, 0, 5, depth - 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 4, 5, 0, 4, 5, depth - 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// supports generateBox(level, chunkBB, 0, 2, 0, 4, 2, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 2, 13, 4, 2, 18, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 0, 0, 4, 1, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 0, 15, 4, 1, 18, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
for (int x = 0; x <= 4; x++) { for (int z = 0; z <= 2; z++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, 18 - z, chunkBB); } }
generateBox(level, chunkBB, 0, 1, 1, 0, 4, 1, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 0, 3, 4, 0, 4, 4, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 0, 3, 14, 0, 4, 14, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 0, 1, 17, 0, 4, 17, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 4, 1, 1, 4, 4, 1, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 4, 3, 4, 4, 4, 4, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 4, 3, 14, 4, 4, 14, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 4, 1, 17, 4, 4, 17, Tile::netherFence_Id, Tile::netherFence_Id, false);
return true;}
NetherBridgePieces::BridgeEndFiller::BridgeEndFiller(){ // for reflection}
NetherBridgePieces::BridgeEndFiller::BridgeEndFiller(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth){ orientation = direction; boundingBox = stairsBox; selfSeed = random->nextInt();}
NetherBridgePieces::BridgeEndFiller *NetherBridgePieces::BridgeEndFiller::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth){ BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, -3, 0, width, height, depth, direction);
StartPiece *startPiece = NULL; if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) { delete box; return NULL; }
return new BridgeEndFiller(genDepth, random, box, direction);}
bool NetherBridgePieces::BridgeEndFiller::postProcess(Level *level, Random *random, BoundingBox *chunkBB){ Random *selfRandom = new Random(selfSeed);
// floor for (int x = 0; x <= 4; x++) { for (int y = 3; y <= 4; y++) { int z = selfRandom->nextInt(8); generateBox(level, chunkBB, x, y, 0, x, y, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false); } }
// hand rails { int z = selfRandom->nextInt(8); generateBox(level, chunkBB, 0, 5, 0, 0, 5, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false); } { int z = selfRandom->nextInt(8); generateBox(level, chunkBB, 4, 5, 0, 4, 5, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false); }
// supports for (int x = 0; x <= 4; x++) { int z = selfRandom->nextInt(5); generateBox(level, chunkBB, x, 2, 0, x, 2, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false); } for (int x = 0; x <= 4; x++) { for (int y = 0; y <= 1; y++) { int z = selfRandom->nextInt(3); generateBox(level, chunkBB, x, y, 0, x, y, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false); } }
delete selfRandom;
return true;}
void NetherBridgePieces::BridgeEndFiller::readAdditonalSaveData(CompoundTag *tag){ NetherBridgePiece::readAdditonalSaveData(tag);
selfSeed = tag->getInt(L"Seed");}
void NetherBridgePieces::BridgeEndFiller::addAdditonalSaveData(CompoundTag *tag){ NetherBridgePiece::addAdditonalSaveData(tag);
tag->putInt(L"Seed", selfSeed);}
NetherBridgePieces::BridgeCrossing::BridgeCrossing(){ // for reflection}
NetherBridgePieces::BridgeCrossing::BridgeCrossing(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth){ orientation = direction; boundingBox = stairsBox;}
NetherBridgePieces::BridgeCrossing::BridgeCrossing(Random *random, int west, int north) : NetherBridgePiece(0){ 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; }}
void NetherBridgePieces::BridgeCrossing::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random){ generateChildForward((StartPiece *) startPiece, pieces, random, 8, 3, false); generateChildLeft((StartPiece *) startPiece, pieces, random, 3, 8, false); generateChildRight((StartPiece *) startPiece, pieces, random, 3, 8, false);}
NetherBridgePieces::BridgeCrossing *NetherBridgePieces::BridgeCrossing::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth){ BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -8, -3, 0, width, height, depth, direction);
StartPiece *startPiece = NULL; if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) { delete box; return NULL; }
return new BridgeCrossing(genDepth, random, box, direction);}
bool NetherBridgePieces::BridgeCrossing::postProcess(Level *level, Random *random, BoundingBox *chunkBB){ // floor generateBox(level, chunkBB, 7, 3, 0, 11, 4, 18, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 3, 7, 18, 4, 11, Tile::netherBrick_Id, Tile::netherBrick_Id, false); // room air generateBox(level, chunkBB, 8, 5, 0, 10, 7, 18, 0, 0, false); generateBox(level, chunkBB, 0, 5, 8, 18, 7, 10, 0, 0, false); // hand rails generateBox(level, chunkBB, 7, 5, 0, 7, 5, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 7, 5, 11, 7, 5, 18, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 11, 5, 0, 11, 5, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 11, 5, 11, 11, 5, 18, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 5, 7, 7, 5, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 11, 5, 7, 18, 5, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 5, 11, 7, 5, 11, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 11, 5, 11, 18, 5, 11, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// supports generateBox(level, chunkBB, 7, 2, 0, 11, 2, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 7, 2, 13, 11, 2, 18, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 7, 0, 0, 11, 1, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 7, 0, 15, 11, 1, 18, Tile::netherBrick_Id, Tile::netherBrick_Id, false); for (int x = 7; x <= 11; x++) { for (int z = 0; z <= 2; z++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, 18 - z, chunkBB); } }
generateBox(level, chunkBB, 0, 2, 7, 5, 2, 11, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 13, 2, 7, 18, 2, 11, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 0, 7, 3, 1, 11, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 15, 0, 7, 18, 1, 11, Tile::netherBrick_Id, Tile::netherBrick_Id, false); for (int x = 0; x <= 2; x++) { for (int z = 7; z <= 11; z++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); fillColumnDown(level, Tile::netherBrick_Id, 0, 18 - x, -1, z, chunkBB); } }
return true;}
NetherBridgePieces::StartPiece::StartPiece(){ // for reflection previousPiece = NULL;}
NetherBridgePieces::StartPiece::StartPiece(Random *random, int west, int north, Level *level) : BridgeCrossing(random, west, north){ previousPiece = NULL; m_level = level;
for( int i = 0; i < BRIDGE_PIECEWEIGHTS_COUNT; i++ ) { PieceWeight *piece = bridgePieceWeights[i]; piece->placeCount = 0; availableBridgePieces.push_back(piece); }
for( int i = 0; i < CASTLE_PIECEWEIGHTS_COUNT; i++ ) { PieceWeight *piece = castlePieceWeights[i];
piece->placeCount = 0; availableCastlePieces.push_back(piece); }}
void NetherBridgePieces::StartPiece::readAdditonalSaveData(CompoundTag *tag){ BridgeCrossing::readAdditonalSaveData(tag);}
void NetherBridgePieces::StartPiece::addAdditonalSaveData(CompoundTag *tag){ BridgeCrossing::addAdditonalSaveData(tag);}
NetherBridgePieces::RoomCrossing::RoomCrossing(){ // for reflection}
NetherBridgePieces::RoomCrossing::RoomCrossing(int genDepth, Random *random, BoundingBox *box, int direction) : NetherBridgePiece(genDepth){ orientation = direction; boundingBox = box;}
void NetherBridgePieces::RoomCrossing::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random){ generateChildForward((StartPiece *) startPiece, pieces, random, 2, 0, false); generateChildLeft((StartPiece *) startPiece, pieces, random, 0, 2, false); generateChildRight((StartPiece *) startPiece, pieces, random, 0, 2, false);}
NetherBridgePieces::RoomCrossing *NetherBridgePieces::RoomCrossing::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth){ BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -2, 0, 0, width, height, depth, direction);
StartPiece *startPiece = NULL; if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) { delete box; return NULL; }
return new RoomCrossing(genDepth, random, box, direction);}
bool NetherBridgePieces::RoomCrossing::postProcess(Level *level, Random *random, BoundingBox *chunkBB){ // floor generateBox(level, chunkBB, 0, 0, 0, width - 1, 1, depth - 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false); // room air generateBox(level, chunkBB, 0, 2, 0, 6, 7, 6, 0, 0, false);
// walls generateBox(level, chunkBB, 0, 2, 0, 1, 6, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 2, 6, 1, 6, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 5, 2, 0, 6, 6, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 5, 2, 6, 6, 6, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 2, 0, 0, 6, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 2, 5, 0, 6, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 6, 2, 0, 6, 6, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 6, 2, 5, 6, 6, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// entries generateBox(level, chunkBB, 2, 6, 0, 4, 6, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 2, 5, 0, 4, 5, 0, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 2, 6, 6, 4, 6, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 2, 5, 6, 4, 5, 6, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 0, 6, 2, 0, 6, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 5, 2, 0, 5, 4, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 6, 6, 2, 6, 6, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 6, 5, 2, 6, 5, 4, Tile::netherFence_Id, Tile::netherFence_Id, false);
for (int x = 0; x <= 6; x++) { for (int z = 0; z <= 6; z++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); } }
return true;}
NetherBridgePieces::StairsRoom::StairsRoom(){ // for reflection}
NetherBridgePieces::StairsRoom::StairsRoom(int genDepth, Random *random, BoundingBox *box, int direction) : NetherBridgePiece(genDepth){ orientation = direction; boundingBox = box;}
void NetherBridgePieces::StairsRoom::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random){ generateChildRight((StartPiece *) startPiece, pieces, random, 6, 2, false);}
NetherBridgePieces::StairsRoom *NetherBridgePieces::StairsRoom::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth){ BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -2, 0, 0, width, height, depth, direction);
StartPiece *startPiece = NULL; if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) { delete box; return NULL; }
return new StairsRoom(genDepth, random, box, direction);}
bool NetherBridgePieces::StairsRoom::postProcess(Level *level, Random *random, BoundingBox *chunkBB){ // floor generateBox(level, chunkBB, 0, 0, 0, width - 1, 1, depth - 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false); // room air generateBox(level, chunkBB, 0, 2, 0, 6, 10, 6, 0, 0, false);
// walls generateBox(level, chunkBB, 0, 2, 0, 1, 8, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 5, 2, 0, 6, 8, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 2, 1, 0, 8, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 6, 2, 1, 6, 8, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 1, 2, 6, 5, 8, 6, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// wall decorations generateBox(level, chunkBB, 0, 3, 2, 0, 5, 4, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 6, 3, 2, 6, 5, 2, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 6, 3, 4, 6, 5, 4, Tile::netherFence_Id, Tile::netherFence_Id, false);
// stair placeBlock(level, Tile::netherBrick_Id, 0, 5, 2, 5, chunkBB); generateBox(level, chunkBB, 4, 2, 5, 4, 3, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 3, 2, 5, 3, 4, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 2, 2, 5, 2, 5, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 1, 2, 5, 1, 6, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// top floor generateBox(level, chunkBB, 1, 7, 1, 5, 7, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 6, 8, 2, 6, 8, 4, 0, 0, false);
// entries generateBox(level, chunkBB, 2, 6, 0, 4, 8, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 2, 5, 0, 4, 5, 0, Tile::netherFence_Id, Tile::netherFence_Id, false);
for (int x = 0; x <= 6; x++) { for (int z = 0; z <= 6; z++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); } }
return true;
}
NetherBridgePieces::MonsterThrone::MonsterThrone(){ // for reflection}
NetherBridgePieces::MonsterThrone::MonsterThrone(int genDepth, Random *random, BoundingBox *box, int direction) : NetherBridgePiece(genDepth){ orientation = direction; boundingBox = box; hasPlacedMobSpawner = false;}
NetherBridgePieces::MonsterThrone *NetherBridgePieces::MonsterThrone::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth){ BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -2, 0, 0, width, height, depth, direction);
StartPiece *startPiece = NULL; if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) { delete box; return NULL; }
return new MonsterThrone(genDepth, random, box, direction);}
void NetherBridgePieces::MonsterThrone::readAdditonalSaveData(CompoundTag *tag){ NetherBridgePiece::readAdditonalSaveData(tag);
hasPlacedMobSpawner = tag->getBoolean(L"Mob");}
void NetherBridgePieces::MonsterThrone::addAdditonalSaveData(CompoundTag *tag){ NetherBridgePiece::addAdditonalSaveData(tag);
tag->putBoolean(L"Mob", hasPlacedMobSpawner);}
bool NetherBridgePieces::MonsterThrone::postProcess(Level *level, Random *random, BoundingBox *chunkBB){ generateBox(level, chunkBB, 0, 2, 0, 6, 7, 7, 0, 0, false);
// floors generateBox(level, chunkBB, 1, 0, 0, 5, 1, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 1, 2, 1, 5, 2, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 1, 3, 2, 5, 3, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 1, 4, 3, 5, 4, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// rails generateBox(level, chunkBB, 1, 2, 0, 1, 4, 2, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 5, 2, 0, 5, 4, 2, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 1, 5, 2, 1, 5, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 5, 5, 2, 5, 5, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 5, 3, 0, 5, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 6, 5, 3, 6, 5, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 1, 5, 8, 5, 5, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
placeBlock(level, Tile::netherFence_Id, 0, 1, 6, 3, chunkBB); placeBlock(level, Tile::netherFence_Id, 0, 5, 6, 3, chunkBB); generateBox(level, chunkBB, 0, 6, 3, 0, 6, 8, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 6, 6, 3, 6, 6, 8, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 1, 6, 8, 5, 7, 8, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 2, 8, 8, 4, 8, 8, Tile::netherFence_Id, Tile::netherFence_Id, false);
if (!hasPlacedMobSpawner) { int y = getWorldY(5), x = getWorldX(3, 5), z = getWorldZ(3, 5); if (chunkBB->isInside(x, y, z)) { hasPlacedMobSpawner = true; level->setTileAndData(x, y, z, Tile::mobSpawner_Id, 0, Tile::UPDATE_CLIENTS); shared_ptr<MobSpawnerTileEntity> entity = dynamic_pointer_cast<MobSpawnerTileEntity>( level->getTileEntity(x, y, z) ); if (entity != NULL) entity->getSpawner()->setEntityId(L"Blaze"); } }
for (int x = 0; x <= 6; x++) { for (int z = 0; z <= 6; z++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); } }
return true;}
NetherBridgePieces::CastleEntrance::CastleEntrance(){ // for reflection}
NetherBridgePieces::CastleEntrance::CastleEntrance(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth){ orientation = direction; boundingBox = stairsBox;}
void NetherBridgePieces::CastleEntrance::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random){ generateChildForward((StartPiece *) startPiece, pieces, random, 5, 3, true);}
NetherBridgePieces::CastleEntrance *NetherBridgePieces::CastleEntrance::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth){ BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -5, -3, 0, width, height, depth, direction);
StartPiece *startPiece = NULL; if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) { delete box; return NULL; }
return new CastleEntrance(genDepth, random, box, direction);}
bool NetherBridgePieces::CastleEntrance::postProcess(Level *level, Random *random, BoundingBox *chunkBB){ // floor generateBox(level, chunkBB, 0, 3, 0, 12, 4, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); // room air generateBox(level, chunkBB, 0, 5, 0, 12, 13, 12, 0, 0, false);
// walls generateBox(level, chunkBB, 0, 5, 0, 1, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 11, 5, 0, 12, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 2, 5, 11, 4, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 8, 5, 11, 10, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 5, 9, 11, 7, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 2, 5, 0, 4, 12, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 8, 5, 0, 10, 12, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 5, 9, 0, 7, 12, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// roof generateBox(level, chunkBB, 2, 11, 2, 10, 12, 10, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// entrance decoration generateBox(level, chunkBB, 5, 8, 0, 7, 8, 0, Tile::netherFence_Id, Tile::netherFence_Id, false);
// wall decorations for (int i = 1; i <= 11; i += 2) { generateBox(level, chunkBB, i, 10, 0, i, 11, 0, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, i, 10, 12, i, 11, 12, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 0, 10, i, 0, 11, i, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 12, 10, i, 12, 11, i, Tile::netherFence_Id, Tile::netherFence_Id, false); placeBlock(level, Tile::netherBrick_Id, 0, i, 13, 0, chunkBB); placeBlock(level, Tile::netherBrick_Id, 0, i, 13, 12, chunkBB); placeBlock(level, Tile::netherBrick_Id, 0, 0, 13, i, chunkBB); placeBlock(level, Tile::netherBrick_Id, 0, 12, 13, i, chunkBB); placeBlock(level, Tile::netherFence_Id, 0, i + 1, 13, 0, chunkBB); placeBlock(level, Tile::netherFence_Id, 0, i + 1, 13, 12, chunkBB); placeBlock(level, Tile::netherFence_Id, 0, 0, 13, i + 1, chunkBB); placeBlock(level, Tile::netherFence_Id, 0, 12, 13, i + 1, chunkBB); } placeBlock(level, Tile::netherFence_Id, 0, 0, 13, 0, chunkBB); placeBlock(level, Tile::netherFence_Id, 0, 0, 13, 12, chunkBB); placeBlock(level, Tile::netherFence_Id, 0, 0, 13, 0, chunkBB); placeBlock(level, Tile::netherFence_Id, 0, 12, 13, 0, chunkBB);
// inside decorations for (int z = 3; z <= 9; z += 2) { generateBox(level, chunkBB, 1, 7, z, 1, 8, z, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 11, 7, z, 11, 8, z, Tile::netherFence_Id, Tile::netherFence_Id, false); }
// supports generateBox(level, chunkBB, 4, 2, 0, 8, 2, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 2, 4, 12, 2, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
generateBox(level, chunkBB, 4, 0, 0, 8, 1, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 4, 0, 9, 8, 1, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 0, 4, 3, 1, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 9, 0, 4, 12, 1, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
for (int x = 4; x <= 8; x++) { for (int z = 0; z <= 2; z++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, 12 - z, chunkBB); } } for (int x = 0; x <= 2; x++) { for (int z = 4; z <= 8; z++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); fillColumnDown(level, Tile::netherBrick_Id, 0, 12 - x, -1, z, chunkBB); } }
// lava well generateBox(level, chunkBB, 5, 5, 5, 7, 5, 7, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 6, 1, 6, 6, 4, 6, 0, 0, false); placeBlock(level, Tile::netherBrick_Id, 0, 6, 0, 6, chunkBB); placeBlock(level, Tile::lava_Id, 0, 6, 5, 6, chunkBB); // tick lava well int x = getWorldX(6, 6); int y = getWorldY(5); int z = getWorldZ(6, 6); if (chunkBB->isInside(x, y, z)) { level->setInstaTick(true); Tile::tiles[Tile::lava_Id]->tick(level, x, y, z, random); level->setInstaTick(false); }
return true;}
NetherBridgePieces::CastleStalkRoom::CastleStalkRoom(){ // for reflection}
NetherBridgePieces::CastleStalkRoom::CastleStalkRoom(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth){ orientation = direction; boundingBox = stairsBox;}
void NetherBridgePieces::CastleStalkRoom::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random){ generateChildForward((StartPiece *) startPiece, pieces, random, 5, 3, true); generateChildForward((StartPiece *) startPiece, pieces, random, 5, 11, true);}
NetherBridgePieces::CastleStalkRoom *NetherBridgePieces::CastleStalkRoom::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth){ BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -5, -3, 0, width, height, depth, direction);
StartPiece *startPiece = NULL; if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) { delete box; return NULL; }
return new CastleStalkRoom(genDepth, random, box, direction);}
bool NetherBridgePieces::CastleStalkRoom::postProcess(Level *level, Random *random, BoundingBox *chunkBB){ // floor generateBox(level, chunkBB, 0, 3, 0, 12, 4, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); // room air generateBox(level, chunkBB, 0, 5, 0, 12, 13, 12, 0, 0, false);
// walls generateBox(level, chunkBB, 0, 5, 0, 1, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 11, 5, 0, 12, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 2, 5, 11, 4, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 8, 5, 11, 10, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 5, 9, 11, 7, 12, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 2, 5, 0, 4, 12, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 8, 5, 0, 10, 12, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 5, 9, 0, 7, 12, 1, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// roof generateBox(level, chunkBB, 2, 11, 2, 10, 12, 10, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// wall decorations for (int i = 1; i <= 11; i += 2) { generateBox(level, chunkBB, i, 10, 0, i, 11, 0, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, i, 10, 12, i, 11, 12, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 0, 10, i, 0, 11, i, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 12, 10, i, 12, 11, i, Tile::netherFence_Id, Tile::netherFence_Id, false); placeBlock(level, Tile::netherBrick_Id, 0, i, 13, 0, chunkBB); placeBlock(level, Tile::netherBrick_Id, 0, i, 13, 12, chunkBB); placeBlock(level, Tile::netherBrick_Id, 0, 0, 13, i, chunkBB); placeBlock(level, Tile::netherBrick_Id, 0, 12, 13, i, chunkBB); placeBlock(level, Tile::netherFence_Id, 0, i + 1, 13, 0, chunkBB); placeBlock(level, Tile::netherFence_Id, 0, i + 1, 13, 12, chunkBB); placeBlock(level, Tile::netherFence_Id, 0, 0, 13, i + 1, chunkBB); placeBlock(level, Tile::netherFence_Id, 0, 12, 13, i + 1, chunkBB); } placeBlock(level, Tile::netherFence_Id, 0, 0, 13, 0, chunkBB); placeBlock(level, Tile::netherFence_Id, 0, 0, 13, 12, chunkBB); placeBlock(level, Tile::netherFence_Id, 0, 0, 13, 0, chunkBB); placeBlock(level, Tile::netherFence_Id, 0, 12, 13, 0, chunkBB);
// inside decorations for (int z = 3; z <= 9; z += 2) { generateBox(level, chunkBB, 1, 7, z, 1, 8, z, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 11, 7, z, 11, 8, z, Tile::netherFence_Id, Tile::netherFence_Id, false); }
// inside stair int stairOrientation = getOrientationData(Tile::stairs_netherBricks_Id, 3); for (int i = 0; i <= 6; i++) { int z = i + 4; for (int x = 5; x <= 7; x++) { placeBlock(level, Tile::stairs_netherBricks_Id, stairOrientation, x, 5 + i, z, chunkBB); } if (z >= 5 && z <= 8) { generateBox(level, chunkBB, 5, 5, z, 7, i + 4, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false); } else if (z >= 9 && z <= 10) { generateBox(level, chunkBB, 5, 8, z, 7, i + 4, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false); } if (i >= 1) { generateBox(level, chunkBB, 5, 6 + i, z, 7, 9 + i, z, 0, 0, false); } } for (int x = 5; x <= 7; x++) { placeBlock(level, Tile::stairs_netherBricks_Id, stairOrientation, x, 12, 11, chunkBB); } generateBox(level, chunkBB, 5, 6, 7, 5, 7, 7, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 7, 6, 7, 7, 7, 7, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 5, 13, 12, 7, 13, 12, 0, 0, false);
// farmland catwalks generateBox(level, chunkBB, 2, 5, 2, 3, 5, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 2, 5, 9, 3, 5, 10, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 2, 5, 4, 2, 5, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 9, 5, 2, 10, 5, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 9, 5, 9, 10, 5, 10, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 10, 5, 4, 10, 5, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false); int eastOrientation = getOrientationData(Tile::stairs_netherBricks_Id, 0); int westOrientation = getOrientationData(Tile::stairs_netherBricks_Id, 1); placeBlock(level, Tile::stairs_netherBricks_Id, westOrientation, 4, 5, 2, chunkBB); placeBlock(level, Tile::stairs_netherBricks_Id, westOrientation, 4, 5, 3, chunkBB); placeBlock(level, Tile::stairs_netherBricks_Id, westOrientation, 4, 5, 9, chunkBB); placeBlock(level, Tile::stairs_netherBricks_Id, westOrientation, 4, 5, 10, chunkBB); placeBlock(level, Tile::stairs_netherBricks_Id, eastOrientation, 8, 5, 2, chunkBB); placeBlock(level, Tile::stairs_netherBricks_Id, eastOrientation, 8, 5, 3, chunkBB); placeBlock(level, Tile::stairs_netherBricks_Id, eastOrientation, 8, 5, 9, chunkBB); placeBlock(level, Tile::stairs_netherBricks_Id, eastOrientation, 8, 5, 10, chunkBB);
// farmlands generateBox(level, chunkBB, 3, 4, 4, 4, 4, 8, Tile::soulsand_Id, Tile::soulsand_Id, false); generateBox(level, chunkBB, 8, 4, 4, 9, 4, 8, Tile::soulsand_Id, Tile::soulsand_Id, false); generateBox(level, chunkBB, 3, 5, 4, 4, 5, 8, Tile::netherStalk_Id, Tile::netherStalk_Id, false); generateBox(level, chunkBB, 8, 5, 4, 9, 5, 8, Tile::netherStalk_Id, Tile::netherStalk_Id, false);
// supports generateBox(level, chunkBB, 4, 2, 0, 8, 2, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 2, 4, 12, 2, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
generateBox(level, chunkBB, 4, 0, 0, 8, 1, 3, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 4, 0, 9, 8, 1, 12, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 0, 4, 3, 1, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 9, 0, 4, 12, 1, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
for (int x = 4; x <= 8; x++) { for (int z = 0; z <= 2; z++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, 12 - z, chunkBB); } } for (int x = 0; x <= 2; x++) { for (int z = 4; z <= 8; z++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); fillColumnDown(level, Tile::netherBrick_Id, 0, 12 - x, -1, z, chunkBB); } }
return true;
}
NetherBridgePieces::CastleSmallCorridorPiece::CastleSmallCorridorPiece(){ // for reflection}
NetherBridgePieces::CastleSmallCorridorPiece::CastleSmallCorridorPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth){ orientation = direction; boundingBox = stairsBox;}
void NetherBridgePieces::CastleSmallCorridorPiece::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random){ generateChildForward((StartPiece *) startPiece, pieces, random, 1, 0, true);}
NetherBridgePieces::CastleSmallCorridorPiece *NetherBridgePieces::CastleSmallCorridorPiece::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth){
BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, 0, 0, width, height, depth, direction);
StartPiece *startPiece = NULL; if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) { delete box; return NULL; }
return new CastleSmallCorridorPiece(genDepth, random, box, direction);}
bool NetherBridgePieces::CastleSmallCorridorPiece::postProcess(Level *level, Random *random, BoundingBox *chunkBB){ // floor generateBox(level, chunkBB, 0, 0, 0, 4, 1, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false); // room air generateBox(level, chunkBB, 0, 2, 0, 4, 5, 4, 0, 0, false);
// walls generateBox(level, chunkBB, 0, 2, 0, 0, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 4, 2, 0, 4, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 3, 1, 0, 4, 1, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 0, 3, 3, 0, 4, 3, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 4, 3, 1, 4, 4, 1, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 4, 3, 3, 4, 4, 3, Tile::netherFence_Id, Tile::netherFence_Id, false);
// roof generateBox(level, chunkBB, 0, 6, 0, 4, 6, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// supports for (int x = 0; x <= 4; x++) { for (int z = 0; z <= 4; z++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); } }
return true;}
NetherBridgePieces::CastleSmallCorridorCrossingPiece::CastleSmallCorridorCrossingPiece(){ // for reflection}
NetherBridgePieces::CastleSmallCorridorCrossingPiece::CastleSmallCorridorCrossingPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth){ orientation = direction; boundingBox = stairsBox;}
void NetherBridgePieces::CastleSmallCorridorCrossingPiece::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random){ generateChildForward((StartPiece *) startPiece, pieces, random, 1, 0, true); generateChildLeft((StartPiece *) startPiece, pieces, random, 0, 1, true); generateChildRight((StartPiece *) startPiece, pieces, random, 0, 1, true);}
NetherBridgePieces::CastleSmallCorridorCrossingPiece *NetherBridgePieces::CastleSmallCorridorCrossingPiece::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth){ BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, 0, 0, width, height, depth, direction);
StartPiece *startPiece = NULL; if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) { delete box; return NULL; }
return new CastleSmallCorridorCrossingPiece(genDepth, random, box, direction);}
bool NetherBridgePieces::CastleSmallCorridorCrossingPiece::postProcess(Level *level, Random *random, BoundingBox *chunkBB){ // floor generateBox(level, chunkBB, 0, 0, 0, 4, 1, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false); // room air generateBox(level, chunkBB, 0, 2, 0, 4, 5, 4, 0, 0, false);
// walls generateBox(level, chunkBB, 0, 2, 0, 0, 5, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 4, 2, 0, 4, 5, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 2, 4, 0, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 4, 2, 4, 4, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// roof generateBox(level, chunkBB, 0, 6, 0, 4, 6, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// supports for (int x = 0; x <= 4; x++) { for (int z = 0; z <= 4; z++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); } }
return true;}
NetherBridgePieces::CastleSmallCorridorRightTurnPiece::CastleSmallCorridorRightTurnPiece(){ // for reflection isNeedingChest = false;}
NetherBridgePieces::CastleSmallCorridorRightTurnPiece::CastleSmallCorridorRightTurnPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth){ orientation = direction; boundingBox = stairsBox; isNeedingChest = random->nextInt(3) == 0;}
void NetherBridgePieces::CastleSmallCorridorRightTurnPiece::readAdditonalSaveData(CompoundTag *tag){ NetherBridgePiece::readAdditonalSaveData(tag);
isNeedingChest = tag->getBoolean(L"Chest");}
void NetherBridgePieces::CastleSmallCorridorRightTurnPiece::addAdditonalSaveData(CompoundTag *tag){ NetherBridgePiece::addAdditonalSaveData(tag);
tag->putBoolean(L"Chest", isNeedingChest);}
void NetherBridgePieces::CastleSmallCorridorRightTurnPiece::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random){ generateChildRight((StartPiece *) startPiece, pieces, random, 0, 1, true);}
NetherBridgePieces::CastleSmallCorridorRightTurnPiece *NetherBridgePieces::CastleSmallCorridorRightTurnPiece::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth){ BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, 0, 0, width, height, depth, direction);
StartPiece *startPiece = NULL; if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) { delete box; return NULL; }
return new CastleSmallCorridorRightTurnPiece(genDepth, random, box, direction);}
bool NetherBridgePieces::CastleSmallCorridorRightTurnPiece::postProcess(Level *level, Random *random, BoundingBox *chunkBB){ // floor generateBox(level, chunkBB, 0, 0, 0, 4, 1, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false); // room air generateBox(level, chunkBB, 0, 2, 0, 4, 5, 4, 0, 0, false);
// walls generateBox(level, chunkBB, 0, 2, 0, 0, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 0, 3, 1, 0, 4, 1, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 0, 3, 3, 0, 4, 3, Tile::netherFence_Id, Tile::netherFence_Id, false);
generateBox(level, chunkBB, 4, 2, 0, 4, 5, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
generateBox(level, chunkBB, 1, 2, 4, 4, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 1, 3, 4, 1, 4, 4, Tile::netherFence_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 3, 3, 4, 3, 4, 4, Tile::netherFence_Id, Tile::netherBrick_Id, false);
if (isNeedingChest) { int y = getWorldY(2); int x = getWorldX(1, 3), z = getWorldZ(1, 3); if (chunkBB->isInside(x, y, z)) { isNeedingChest = false; createChest(level, chunkBB, random, 1, 2, 3, WeighedTreasureArray(fortressTreasureItems,FORTRESS_TREASURE_ITEMS_COUNT), 2 + random->nextInt(4)); } }
// roof generateBox(level, chunkBB, 0, 6, 0, 4, 6, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// supports for (int x = 0; x <= 4; x++) { for (int z = 0; z <= 4; z++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); } }
return true;}
NetherBridgePieces::CastleSmallCorridorLeftTurnPiece::CastleSmallCorridorLeftTurnPiece(){ isNeedingChest = false; // for reflection}
NetherBridgePieces::CastleSmallCorridorLeftTurnPiece::CastleSmallCorridorLeftTurnPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth){ orientation = direction; boundingBox = stairsBox; isNeedingChest = random->nextInt(3) == 0;}
void NetherBridgePieces::CastleSmallCorridorLeftTurnPiece::readAdditonalSaveData(CompoundTag *tag){ NetherBridgePiece::readAdditonalSaveData(tag);
isNeedingChest = tag->getBoolean(L"Chest");}
void NetherBridgePieces::CastleSmallCorridorLeftTurnPiece::addAdditonalSaveData(CompoundTag *tag){ NetherBridgePiece::addAdditonalSaveData(tag);
tag->putBoolean(L"Chest", isNeedingChest);}
void NetherBridgePieces::CastleSmallCorridorLeftTurnPiece::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random){ generateChildLeft((StartPiece *) startPiece, pieces, random, 0, 1, true);}
NetherBridgePieces::CastleSmallCorridorLeftTurnPiece *NetherBridgePieces::CastleSmallCorridorLeftTurnPiece::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth){ BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, 0, 0, width, height, depth, direction);
StartPiece *startPiece = NULL; if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) { delete box; return NULL; }
return new CastleSmallCorridorLeftTurnPiece(genDepth, random, box, direction);}
bool NetherBridgePieces::CastleSmallCorridorLeftTurnPiece::postProcess(Level *level, Random *random, BoundingBox *chunkBB){ // floor generateBox(level, chunkBB, 0, 0, 0, 4, 1, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false); // room air generateBox(level, chunkBB, 0, 2, 0, 4, 5, 4, 0, 0, false);
// walls generateBox(level, chunkBB, 4, 2, 0, 4, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 4, 3, 1, 4, 4, 1, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 4, 3, 3, 4, 4, 3, Tile::netherFence_Id, Tile::netherFence_Id, false);
generateBox(level, chunkBB, 0, 2, 0, 0, 5, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
generateBox(level, chunkBB, 0, 2, 4, 3, 5, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 1, 3, 4, 1, 4, 4, Tile::netherFence_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 3, 3, 4, 3, 4, 4, Tile::netherFence_Id, Tile::netherBrick_Id, false);
if (isNeedingChest) { int y = getWorldY(2); int x = getWorldX(3, 3), z = getWorldZ(3, 3); if (chunkBB->isInside(x, y, z)) { isNeedingChest = false; createChest(level, chunkBB, random, 3, 2, 3, WeighedTreasureArray(fortressTreasureItems,FORTRESS_TREASURE_ITEMS_COUNT), 2 + random->nextInt(4)); } }
// roof generateBox(level, chunkBB, 0, 6, 0, 4, 6, 4, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// supports for (int x = 0; x <= 4; x++) { for (int z = 0; z <= 4; z++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); } }
return true;}
NetherBridgePieces::CastleCorridorStairsPiece::CastleCorridorStairsPiece(){ // for reflection}
NetherBridgePieces::CastleCorridorStairsPiece::CastleCorridorStairsPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth){ orientation = direction; boundingBox = stairsBox;}
void NetherBridgePieces::CastleCorridorStairsPiece::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random){ generateChildForward((StartPiece *) startPiece, pieces, random, 1, 0, true);}
NetherBridgePieces::CastleCorridorStairsPiece *NetherBridgePieces::CastleCorridorStairsPiece::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth){ BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -1, -7, 0, width, height, depth, direction);
StartPiece *startPiece = NULL; if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) { delete box; return NULL; }
return new CastleCorridorStairsPiece(genDepth, random, box, direction);}
bool NetherBridgePieces::CastleCorridorStairsPiece::postProcess(Level *level, Random *random, BoundingBox *chunkBB){ // generate stairs int stairsData = getOrientationData(Tile::stairs_netherBricks_Id, 2); for (int step = 0; step <= 9; step++) { int floor = max(1, 7 - step); int roof = min(max(floor + 5, 14 - step), 13); int z = step;
// floor generateBox(level, chunkBB, 0, 0, z, 4, floor, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false); // room air generateBox(level, chunkBB, 1, floor + 1, z, 3, roof - 1, z, 0, 0, false); if (step <= 6) { placeBlock(level, Tile::stairs_netherBricks_Id, stairsData, 1, floor + 1, z, chunkBB); placeBlock(level, Tile::stairs_netherBricks_Id, stairsData, 2, floor + 1, z, chunkBB); placeBlock(level, Tile::stairs_netherBricks_Id, stairsData, 3, floor + 1, z, chunkBB); } // roof generateBox(level, chunkBB, 0, roof, z, 4, roof, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false); // walls generateBox(level, chunkBB, 0, floor + 1, z, 0, roof - 1, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 4, floor + 1, z, 4, roof - 1, z, Tile::netherBrick_Id, Tile::netherBrick_Id, false); if ((step & 1) == 0) { generateBox(level, chunkBB, 0, floor + 2, z, 0, floor + 3, z, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 4, floor + 2, z, 4, floor + 3, z, Tile::netherFence_Id, Tile::netherFence_Id, false); }
// supports for (int x = 0; x <= 4; x++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); } }
return true;}
NetherBridgePieces::CastleCorridorTBalconyPiece::CastleCorridorTBalconyPiece(){ // for reflection}
NetherBridgePieces::CastleCorridorTBalconyPiece::CastleCorridorTBalconyPiece(int genDepth, Random *random, BoundingBox *stairsBox, int direction) : NetherBridgePiece(genDepth){ orientation = direction; boundingBox = stairsBox;}
void NetherBridgePieces::CastleCorridorTBalconyPiece::addChildren(StructurePiece *startPiece, list<StructurePiece *> *pieces, Random *random){ int zOff = 1; // compensate for weird negative-facing behaviour if (orientation == Direction::WEST || orientation == Direction::NORTH) { zOff = 5; }
generateChildLeft((StartPiece *) startPiece, pieces, random, 0, zOff, random->nextInt(8) > 0); generateChildRight((StartPiece *) startPiece, pieces, random, 0, zOff, random->nextInt(8) > 0);}
NetherBridgePieces::CastleCorridorTBalconyPiece *NetherBridgePieces::CastleCorridorTBalconyPiece::createPiece(list<StructurePiece *> *pieces, Random *random, int footX, int footY, int footZ, int direction, int genDepth){ BoundingBox *box = BoundingBox::orientBox(footX, footY, footZ, -3, 0, 0, width, height, depth, direction);
StartPiece *startPiece = NULL; if(pieces != NULL) startPiece = ((NetherBridgePieces::StartPiece *) pieces->front());
if (!isOkBox(box, startPiece) || StructurePiece::findCollisionPiece(pieces, box) != NULL) { delete box; return NULL; }
return new CastleCorridorTBalconyPiece(genDepth, random, box, direction);}
bool NetherBridgePieces::CastleCorridorTBalconyPiece::postProcess(Level *level, Random *random, BoundingBox *chunkBB){ // floor generateBox(level, chunkBB, 0, 0, 0, 8, 1, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false); // room air generateBox(level, chunkBB, 0, 2, 0, 8, 5, 8, 0, 0, false); // corridor roof generateBox(level, chunkBB, 0, 6, 0, 8, 6, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false);
// inside walls generateBox(level, chunkBB, 0, 2, 0, 2, 5, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 6, 2, 0, 8, 5, 0, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 1, 3, 0, 1, 4, 0, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 7, 3, 0, 7, 4, 0, Tile::netherFence_Id, Tile::netherFence_Id, false);
// balcony floor generateBox(level, chunkBB, 0, 2, 4, 8, 2, 8, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 1, 1, 4, 2, 2, 4, 0, 0, false); generateBox(level, chunkBB, 6, 1, 4, 7, 2, 4, 0, 0, false);
// hand rails generateBox(level, chunkBB, 0, 3, 8, 8, 3, 8, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 0, 3, 6, 0, 3, 7, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 8, 3, 6, 8, 3, 7, Tile::netherFence_Id, Tile::netherFence_Id, false);
// balcony walls generateBox(level, chunkBB, 0, 3, 4, 0, 5, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 8, 3, 4, 8, 5, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 1, 3, 5, 2, 5, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 6, 3, 5, 7, 5, 5, Tile::netherBrick_Id, Tile::netherBrick_Id, false); generateBox(level, chunkBB, 1, 4, 5, 1, 5, 5, Tile::netherFence_Id, Tile::netherFence_Id, false); generateBox(level, chunkBB, 7, 4, 5, 7, 5, 5, Tile::netherFence_Id, Tile::netherFence_Id, false);
// supports for (int z = 0; z <= 5; z++) { for (int x = 0; x <= 8; x++) { fillColumnDown(level, Tile::netherBrick_Id, 0, x, -1, z, chunkBB); } }
return true;}