package com.medievalknights.world.structure; import com.medievalknights.registry.ModBlocks; import com.medievalknights.registry.ModEntities; import net.minecraft.block.*; import net.minecraft.block.entity.BlockEntity; import net.minecraft.block.entity.ChestBlockEntity; import net.minecraft.block.enums.BlockHalf; import net.minecraft.block.enums.DoubleBlockHalf; import net.minecraft.block.enums.SlabType; import net.minecraft.entity.SpawnReason; import net.minecraft.item.ItemStack; import net.minecraft.item.Items; import net.minecraft.nbt.NbtCompound; import net.minecraft.structure.StructureContext; import net.minecraft.structure.StructurePiece; import net.minecraft.structure.StructurePieceType; import net.minecraft.util.math.BlockBox; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.ChunkPos; import net.minecraft.util.math.Direction; import net.minecraft.util.math.random.Random; import net.minecraft.world.StructureWorldAccess; import net.minecraft.world.gen.StructureAccessor; import net.minecraft.world.gen.chunk.ChunkGenerator; import java.util.ArrayList; import java.util.List; public class CastleStructurePiece extends StructurePiece { private static final int WIDTH = 84; private static final int DEPTH = 84; private static final int WALL_HEIGHT = 12; private static final int WALL_THICKNESS = 3; private static final int TOWER_SIZE = 9; private static final int TOWER_HEIGHT = 20; private static final int KEEP_X = 16; private static final int KEEP_Z = 54; private static final int KEEP_W = 52; private static final int KEEP_D = 26; private static final int KEEP_FLOOR_HEIGHT = 8; private static final int KEEP_FLOORS = 4; private static final int KEEP_HEIGHT = KEEP_FLOORS * KEEP_FLOOR_HEIGHT; public CastleStructurePiece(StructurePieceType type, BlockPos origin, Random random) { super(type, 0, computeBoundingBox(origin)); this.setOrientation(Direction.NORTH); } public CastleStructurePiece(StructurePieceType type, NbtCompound nbt) { super(type, nbt); } private static BlockBox computeBoundingBox(BlockPos origin) { return new BlockBox( origin.getX(), origin.getY() - 1, origin.getZ(), origin.getX() + WIDTH, origin.getY() + KEEP_HEIGHT + 14, origin.getZ() + DEPTH); } @Override protected void writeNbt(StructureContext context, NbtCompound nbt) { } @Override public void generate(StructureWorldAccess world, StructureAccessor structureAccessor, ChunkGenerator chunkGenerator, Random random, BlockBox chunkBox, ChunkPos chunkPos, BlockPos pivot) { BlockPos origin = new BlockPos(this.boundingBox.getMinX(), this.boundingBox.getMinY() + 1, this.boundingBox.getMinZ()); generateCastle(world, origin, random, chunkBox); BlockPos mobAnchor = origin.add(WIDTH / 2, 1, DEPTH / 2); if (chunkBox.contains(mobAnchor)) { spawnMobs(world, origin, random); } } private boolean sectionOverlaps(BlockBox chunkBox, BlockPos origin, int x1, int y1, int z1, int x2, int y2, int z2) { BlockBox section = new BlockBox( origin.getX() + x1, origin.getY() + y1, origin.getZ() + z1, origin.getX() + x2, origin.getY() + y2, origin.getZ() + z2); return chunkBox.intersects(section); } private void generateCastle(StructureWorldAccess world, BlockPos origin, Random random, BlockBox chunkBox) { generateCourtyard(world, origin, chunkBox); generateOuterWalls(world, origin, random, chunkBox); generateCornerTowers(world, origin, random, chunkBox); generateFrontGate(world, origin, random, chunkBox); generateHouses(world, origin, random, chunkBox); generateBarn(world, origin, random, chunkBox); generateMarketplace(world, origin, random, chunkBox); generateKeep(world, origin, random, chunkBox); } private void generateCourtyard(StructureWorldAccess world, BlockPos origin, BlockBox chunkBox) { if (!sectionOverlaps(chunkBox, origin, WALL_THICKNESS, -1, WALL_THICKNESS, WIDTH - WALL_THICKNESS, 0, DEPTH - WALL_THICKNESS)) return; for (int x = WALL_THICKNESS; x < WIDTH - WALL_THICKNESS; x++) { for (int z = WALL_THICKNESS; z < DEPTH - WALL_THICKNESS; z++) { BlockState floor; if ((x + z) % 7 == 0) { floor = Blocks.MOSSY_COBBLESTONE.getDefaultState(); } else if ((x * z) % 11 == 0) { floor = Blocks.COBBLESTONE.getDefaultState(); } else { floor = Blocks.STONE_BRICKS.getDefaultState(); } placeBlock(world, origin.add(x, -1, z), floor, chunkBox); placeBlock(world, origin.add(x, 0, z), Blocks.AIR.getDefaultState(), chunkBox); } } } private void generateOuterWalls(StructureWorldAccess world, BlockPos origin, Random random, BlockBox chunkBox) { if (!sectionOverlaps(chunkBox, origin, 0, 0, 0, WIDTH, WALL_HEIGHT + 1, DEPTH)) return; for (int y = 0; y < WALL_HEIGHT; y++) { for (int t = 0; t < WALL_THICKNESS; t++) { for (int x = 0; x <= WIDTH; x++) { placeRunicBlock(world, origin.add(x, y, t), random, chunkBox); placeRunicBlock(world, origin.add(x, y, DEPTH - t), random, chunkBox); } for (int z = 0; z <= DEPTH; z++) { placeRunicBlock(world, origin.add(t, y, z), random, chunkBox); placeRunicBlock(world, origin.add(WIDTH - t, y, z), random, chunkBox); } } } for (int x = TOWER_SIZE; x <= WIDTH - TOWER_SIZE; x++) { boolean merlon = x % 3 != 1; if (merlon) { placeBlock(world, origin.add(x, WALL_HEIGHT, 0), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); placeBlock(world, origin.add(x, WALL_HEIGHT, DEPTH), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); } } for (int z = TOWER_SIZE; z <= DEPTH - TOWER_SIZE; z++) { boolean merlon = z % 3 != 1; if (merlon) { placeBlock(world, origin.add(0, WALL_HEIGHT, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); placeBlock(world, origin.add(WIDTH, WALL_HEIGHT, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); } } for (int x = TOWER_SIZE + 4; x <= WIDTH - TOWER_SIZE - 4; x += 7) { placeBlock(world, origin.add(x, WALL_HEIGHT - 1, 1), Blocks.LANTERN.getDefaultState(), chunkBox); placeBlock(world, origin.add(x, WALL_HEIGHT - 1, DEPTH - 1), Blocks.LANTERN.getDefaultState(), chunkBox); } for (int z = TOWER_SIZE + 4; z <= DEPTH - TOWER_SIZE - 4; z += 7) { placeBlock(world, origin.add(1, WALL_HEIGHT - 1, z), Blocks.LANTERN.getDefaultState(), chunkBox); placeBlock(world, origin.add(WIDTH - 1, WALL_HEIGHT - 1, z), Blocks.LANTERN.getDefaultState(), chunkBox); } generateWallWalkway(world, origin, chunkBox); } private void generateWallWalkway(StructureWorldAccess world, BlockPos origin, BlockBox chunkBox) { int wy = WALL_HEIGHT - 1; for (int x = WALL_THICKNESS; x < WIDTH - WALL_THICKNESS; x++) { placeBlock(world, origin.add(x, wy, WALL_THICKNESS - 1), ModBlocks.RUNIC_STONE_BRICK_SLAB.getDefaultState() .with(SlabBlock.TYPE, SlabType.TOP), chunkBox); placeBlock(world, origin.add(x, wy, DEPTH - WALL_THICKNESS + 1), ModBlocks.RUNIC_STONE_BRICK_SLAB.getDefaultState() .with(SlabBlock.TYPE, SlabType.TOP), chunkBox); } for (int z = WALL_THICKNESS; z < DEPTH - WALL_THICKNESS; z++) { placeBlock(world, origin.add(WALL_THICKNESS - 1, wy, z), ModBlocks.RUNIC_STONE_BRICK_SLAB.getDefaultState() .with(SlabBlock.TYPE, SlabType.TOP), chunkBox); placeBlock(world, origin.add(WIDTH - WALL_THICKNESS + 1, wy, z), ModBlocks.RUNIC_STONE_BRICK_SLAB.getDefaultState() .with(SlabBlock.TYPE, SlabType.TOP), chunkBox); } } private void generateCornerTowers(StructureWorldAccess world, BlockPos origin, Random random, BlockBox chunkBox) { generateTower(world, origin, 0, 0, random, chunkBox); generateTower(world, origin, WIDTH - TOWER_SIZE + 1, 0, random, chunkBox); generateTower(world, origin, 0, DEPTH - TOWER_SIZE + 1, random, chunkBox); generateTower(world, origin, WIDTH - TOWER_SIZE + 1, DEPTH - TOWER_SIZE + 1, random, chunkBox); } private void generateTower(StructureWorldAccess world, BlockPos origin, int tx, int tz, Random random, BlockBox chunkBox) { if (!sectionOverlaps(chunkBox, origin, tx, 0, tz, tx + TOWER_SIZE, TOWER_HEIGHT + 2, tz + TOWER_SIZE)) return; int ts = TOWER_SIZE; for (int y = 0; y < TOWER_HEIGHT; y++) { for (int x = tx; x < tx + ts; x++) { for (int z = tz; z < tz + ts; z++) { boolean isWall = x == tx || x == tx + ts - 1 || z == tz || z == tz + ts - 1; if (isWall) { placeRunicBlock(world, origin.add(x, y, z), random, chunkBox); } else if (y == 0) { placeBlock(world, origin.add(x, y, z), ModBlocks.RUNIC_STONE_BRICK_SLAB.getDefaultState(), chunkBox); } else { placeBlock(world, origin.add(x, y, z), Blocks.AIR.getDefaultState(), chunkBox); } } } } for (int x = tx; x < tx + ts; x++) { for (int z = tz; z < tz + ts; z++) { boolean isWall = x == tx || x == tx + ts - 1 || z == tz || z == tz + ts - 1; if (isWall) { if ((x + z) % 2 == 0) { placeBlock(world, origin.add(x, TOWER_HEIGHT, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); placeBlock(world, origin.add(x, TOWER_HEIGHT + 1, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); } else { placeBlock(world, origin.add(x, TOWER_HEIGHT, z), ModBlocks.RUNIC_STONE_BRICK_SLAB.getDefaultState() .with(SlabBlock.TYPE, SlabType.TOP), chunkBox); } } } } for (int x = tx + 1; x < tx + ts - 1; x++) { for (int z = tz + 1; z < tz + ts - 1; z++) { placeBlock(world, origin.add(x, TOWER_HEIGHT, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); } } placeBlock(world, origin.add(tx + ts / 2, TOWER_HEIGHT + 1, tz + ts / 2), Blocks.LANTERN.getDefaultState(), chunkBox); for (int y = 4; y < TOWER_HEIGHT; y += 5) { placeBlock(world, origin.add(tx + 1, y, tz + ts / 2), Blocks.LANTERN.getDefaultState(), chunkBox); } generateTowerStairs(world, origin, tx, tz, ts, random, chunkBox); } private void generateTowerStairs(StructureWorldAccess world, BlockPos origin, int tx, int tz, int ts, Random random, BlockBox chunkBox) { int cx = tx + ts / 2; int cz = tz + ts / 2; for (int y = 1; y < TOWER_HEIGHT; y++) { int lx = cx, lz = cz; switch (y % 4) { case 0 -> lx = tx + 1; case 1 -> lz = tz + 1; case 2 -> lx = tx + ts - 2; case 3 -> lz = tz + ts - 2; } placeBlock(world, origin.add(lx, y, lz), Blocks.OAK_FENCE.getDefaultState(), chunkBox); } } private void generateFrontGate(StructureWorldAccess world, BlockPos origin, Random random, BlockBox chunkBox) { int gx = WIDTH / 2; int gateWidth = 5; int gateHeight = 8; if (!sectionOverlaps(chunkBox, origin, gx - 15, 0, 0, gx + 15, gateHeight + 2, WALL_THICKNESS + 1)) return; int leftGateTowerX = gx - gateWidth / 2 - 7; int rightGateTowerX = gx + gateWidth / 2 + 3; generateGateTower(world, origin, leftGateTowerX, 0, random, chunkBox); generateGateTower(world, origin, rightGateTowerX, 0, random, chunkBox); for (int x = gx - gateWidth / 2; x <= gx + gateWidth / 2; x++) { for (int y = 0; y < gateHeight; y++) { for (int t = 0; t < WALL_THICKNESS; t++) { placeBlock(world, origin.add(x, y, t), Blocks.AIR.getDefaultState(), chunkBox); } } } for (int y = 0; y < gateHeight; y++) { for (int t = 0; t < WALL_THICKNESS; t++) { placeRunicBlock(world, origin.add(gx - gateWidth / 2 - 1, y, t), random, chunkBox); placeRunicBlock(world, origin.add(gx + gateWidth / 2 + 1, y, t), random, chunkBox); } } for (int x = gx - gateWidth / 2; x <= gx + gateWidth / 2; x++) { for (int t = 0; t < WALL_THICKNESS; t++) { placeRunicBlock(world, origin.add(x, gateHeight, t), random, chunkBox); } } for (int y = 1; y < gateHeight - 1; y++) { for (int x = gx - gateWidth / 2; x <= gx + gateWidth / 2; x++) { if (x == gx - gateWidth / 2 || x == gx + gateWidth / 2 || y % 3 == 0) { placeBlock(world, origin.add(x, y, 1), Blocks.IRON_BARS.getDefaultState(), chunkBox); } } } placeBlock(world, origin.add(gx - 2, 3, 1), Blocks.CHAIN.getDefaultState() .with(ChainBlock.AXIS, Direction.Axis.Y), chunkBox); placeBlock(world, origin.add(gx + 2, 3, 1), Blocks.CHAIN.getDefaultState() .with(ChainBlock.AXIS, Direction.Axis.Y), chunkBox); placeBlock(world, origin.add(gx - 2, 2, 1), Blocks.LANTERN.getDefaultState(), chunkBox); placeBlock(world, origin.add(gx + 2, 2, 1), Blocks.LANTERN.getDefaultState(), chunkBox); for (int x = gx - gateWidth / 2; x <= gx + gateWidth / 2; x++) { for (int t = 0; t < WALL_THICKNESS; t++) { placeBlock(world, origin.add(x, gateHeight + 1, t), ModBlocks.RUNIC_STONE_BRICK_STAIRS.getDefaultState() .with(StairsBlock.FACING, Direction.SOUTH) .with(StairsBlock.HALF, BlockHalf.TOP), chunkBox); } } } private void generateGateTower(StructureWorldAccess world, BlockPos origin, int tx, int tz, Random random, BlockBox chunkBox) { int ts = 7; int th = WALL_HEIGHT + 4; if (!sectionOverlaps(chunkBox, origin, tx, 0, tz, tx + ts, th + 1, tz + ts)) return; for (int y = 0; y < th; y++) { for (int x = tx; x < tx + ts; x++) { for (int z = tz; z < tz + ts; z++) { boolean isWall = x == tx || x == tx + ts - 1 || z == tz || z == tz + ts - 1; if (isWall) { placeRunicBlock(world, origin.add(x, y, z), random, chunkBox); } else if (y == 0) { placeBlock(world, origin.add(x, y, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); } else { placeBlock(world, origin.add(x, y, z), Blocks.AIR.getDefaultState(), chunkBox); } } } } for (int x = tx; x < tx + ts; x++) { for (int z = tz; z < tz + ts; z++) { boolean isWall = x == tx || x == tx + ts - 1 || z == tz || z == tz + ts - 1; if (isWall && (x + z) % 2 == 0) { placeBlock(world, origin.add(x, th, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); } } } placeBlock(world, origin.add(tx + ts / 2, th - 1, tz + ts / 2), Blocks.LANTERN.getDefaultState(), chunkBox); } private void generateHouses(StructureWorldAccess world, BlockPos origin, Random random, BlockBox chunkBox) { if (!sectionOverlaps(chunkBox, origin, 5, -1, 5, 35, 20, 47)) return; generateHouse(world, origin, 5, 5, 12, 9, 3, random, chunkBox); generateHouse(world, origin, 5, 20, 11, 9, 2, random, chunkBox); generateHouse(world, origin, 5, 35, 12, 9, 3, random, chunkBox); generateHouse(world, origin, 21, 5, 11, 9, 2, random, chunkBox); generateHouse(world, origin, 21, 20, 12, 9, 3, random, chunkBox); } private void generateHouse(StructureWorldAccess world, BlockPos origin, int hx, int hz, int w, int d, int floors, Random random, BlockBox chunkBox) { int floorH = 5; int totalH = floors * floorH + w / 2 + 2; if (!sectionOverlaps(chunkBox, origin, hx - 1, 0, hz - 1, hx + w + 1, totalH, hz + d + 1)) return; for (int floor = 0; floor < floors; floor++) { int baseY = floor * floorH; for (int y = 0; y < floorH; y++) { for (int x = hx; x < hx + w; x++) { for (int z = hz; z < hz + d; z++) { boolean isWall = x == hx || x == hx + w - 1 || z == hz || z == hz + d - 1; if (isWall) { if (y == 0 || y == floorH - 1) { placeBlock(world, origin.add(x, baseY + y, z), Blocks.OAK_LOG.getDefaultState(), chunkBox); } else { placeRunicBlock(world, origin.add(x, baseY + y, z), random, chunkBox); } } else if (y == 0) { if (floor == 0) { placeBlock(world, origin.add(x, baseY + y, z), Blocks.OAK_PLANKS.getDefaultState(), chunkBox); } else { placeBlock(world, origin.add(x, baseY - 1, z), Blocks.OAK_PLANKS.getDefaultState(), chunkBox); placeBlock(world, origin.add(x, baseY + y, z), Blocks.AIR.getDefaultState(), chunkBox); } } else { placeBlock(world, origin.add(x, baseY + y, z), Blocks.AIR.getDefaultState(), chunkBox); } } } } for (int x = hx + 2; x < hx + w - 2; x += 3) { placeBlock(world, origin.add(x, baseY + 2, hz), Blocks.GLASS_PANE.getDefaultState(), chunkBox); placeBlock(world, origin.add(x, baseY + 3, hz), Blocks.GLASS_PANE.getDefaultState(), chunkBox); placeBlock(world, origin.add(x, baseY + 2, hz + d - 1), Blocks.GLASS_PANE.getDefaultState(), chunkBox); placeBlock(world, origin.add(x, baseY + 3, hz + d - 1), Blocks.GLASS_PANE.getDefaultState(), chunkBox); } for (int z = hz + 2; z < hz + d - 2; z += 3) { placeBlock(world, origin.add(hx, baseY + 2, z), Blocks.GLASS_PANE.getDefaultState(), chunkBox); placeBlock(world, origin.add(hx, baseY + 3, z), Blocks.GLASS_PANE.getDefaultState(), chunkBox); } furnishFloor(world, origin, hx, hz, w, d, baseY, floor, random, chunkBox); } placeBlock(world, origin.add(hx + w / 2, 0, hz), Blocks.OAK_DOOR.getDefaultState() .with(DoorBlock.FACING, Direction.NORTH) .with(DoorBlock.HALF, DoubleBlockHalf.LOWER), chunkBox); placeBlock(world, origin.add(hx + w / 2, 1, hz), Blocks.OAK_DOOR.getDefaultState() .with(DoorBlock.FACING, Direction.NORTH) .with(DoorBlock.HALF, DoubleBlockHalf.UPPER), chunkBox); for (int floor = 0; floor < floors - 1; floor++) { int ladderY = floor * floorH; int lx = hx + w - 2; int lz = hz + 1; for (int y = ladderY + 1; y <= ladderY + floorH; y++) { placeBlock(world, origin.add(lx, y, lz), Blocks.LADDER.getDefaultState() .with(LadderBlock.FACING, Direction.SOUTH), chunkBox); } } generateHouseRoof(world, origin, hx, hz, w, d, floors * floorH, chunkBox); placeBlock(world, origin.add(hx + 1, 1, hz + 1), Blocks.LANTERN.getDefaultState(), chunkBox); } private void furnishFloor(StructureWorldAccess world, BlockPos origin, int hx, int hz, int w, int d, int baseY, int floor, Random random, BlockBox chunkBox) { if (floor == 0) { placeBlock(world, origin.add(hx + 1, baseY + 1, hz + 2), Blocks.CRAFTING_TABLE.getDefaultState(), chunkBox); placeBlock(world, origin.add(hx + w - 2, baseY + 1, hz + 2), Blocks.FURNACE.getDefaultState() .with(FurnaceBlock.FACING, Direction.EAST), chunkBox); placeBlock(world, origin.add(hx + 2, baseY + 1, hz + d - 2), Blocks.OAK_FENCE.getDefaultState(), chunkBox); placeBlock(world, origin.add(hx + 3, baseY + 1, hz + d - 2), Blocks.OAK_FENCE.getDefaultState(), chunkBox); placeBlock(world, origin.add(hx + 2, baseY + 2, hz + d - 2), Blocks.OAK_PRESSURE_PLATE.getDefaultState(), chunkBox); placeBlock(world, origin.add(hx + 3, baseY + 2, hz + d - 2), Blocks.OAK_PRESSURE_PLATE.getDefaultState(), chunkBox); BlockPos chestPos = origin.add(hx + w - 2, baseY + 1, hz + d - 2); placeBlock(world, chestPos, Blocks.CHEST.getDefaultState() .with(ChestBlock.FACING, Direction.NORTH), chunkBox); if (chunkBox.contains(chestPos)) { BlockEntity be = world.getBlockEntity(chestPos); if (be instanceof ChestBlockEntity chest) { fillHouseChest(chest, random); } } } else if (floor == 1) { placeBlock(world, origin.add(hx + 1, baseY, hz + 2), Blocks.RED_BED.getDefaultState().with(BedBlock.FACING, Direction.EAST).with(BedBlock.PART, net.minecraft.block.enums.BedPart.FOOT), chunkBox); placeBlock(world, origin.add(hx + 2, baseY, hz + 2), Blocks.RED_BED.getDefaultState().with(BedBlock.FACING, Direction.EAST).with(BedBlock.PART, net.minecraft.block.enums.BedPart.HEAD), chunkBox); placeBlock(world, origin.add(hx + 1, baseY + 1, hz + d - 2), Blocks.BOOKSHELF.getDefaultState(), chunkBox); placeBlock(world, origin.add(hx + 2, baseY + 1, hz + d - 2), Blocks.BOOKSHELF.getDefaultState(), chunkBox); } else { placeBlock(world, origin.add(hx + 1, baseY + 1, hz + 2), Blocks.BARREL.getDefaultState(), chunkBox); placeBlock(world, origin.add(hx + w - 2, baseY + 1, hz + 2), Blocks.BARREL.getDefaultState(), chunkBox); } placeBlock(world, origin.add(hx + w / 2, baseY + 1, hz + d - 2), Blocks.LANTERN.getDefaultState(), chunkBox); } private void generateHouseRoof(StructureWorldAccess world, BlockPos origin, int hx, int hz, int w, int d, int baseY, BlockBox chunkBox) { int roofLayers = (w / 2) + 1; for (int layer = 0; layer < roofLayers; layer++) { for (int z = hz - 1; z <= hz + d; z++) { int x1 = hx - 1 + layer; int x2 = hx + w - layer; placeBlock(world, origin.add(x1, baseY + layer, z), Blocks.SPRUCE_STAIRS.getDefaultState() .with(StairsBlock.FACING, Direction.EAST) .with(StairsBlock.HALF, BlockHalf.BOTTOM), chunkBox); placeBlock(world, origin.add(x2, baseY + layer, z), Blocks.SPRUCE_STAIRS.getDefaultState() .with(StairsBlock.FACING, Direction.WEST) .with(StairsBlock.HALF, BlockHalf.BOTTOM), chunkBox); } } for (int z = hz - 1; z <= hz + d; z++) { placeBlock(world, origin.add(hx + w / 2, baseY + roofLayers - 1, z), Blocks.SPRUCE_PLANKS.getDefaultState(), chunkBox); } } private void fillHouseChest(ChestBlockEntity chest, Random random) { ItemStack[] items = { new ItemStack(Items.BREAD, 2 + random.nextInt(3)), new ItemStack(Items.APPLE, 1 + random.nextInt(3)), new ItemStack(Items.TORCH, 4 + random.nextInt(8)), new ItemStack(Items.ARROW, 4 + random.nextInt(12)), new ItemStack(Items.COOKED_BEEF, 1 + random.nextInt(3)), }; List slots = buildSlotList(27); for (ItemStack it : items) { if (slots.isEmpty()) break; chest.setStack(slots.remove(random.nextInt(slots.size())), it); } } private void generateBarn(StructureWorldAccess world, BlockPos origin, Random random, BlockBox chunkBox) { int bx = 50; int bz = 5; int bw = 20; int bd = 14; int bh = 8; if (!sectionOverlaps(chunkBox, origin, bx - 1, 0, bz - 1, bx + bw + 1, bh + bw / 2 + 2, bz + bd + 1)) return; for (int y = 0; y < bh; y++) { for (int x = bx; x < bx + bw; x++) { for (int z = bz; z < bz + bd; z++) { boolean isWall = x == bx || x == bx + bw - 1 || z == bz || z == bz + bd - 1; boolean isFront = z == bz; if (isWall) { if (isFront && x > bx + 3 && x < bx + bw - 4 && y > 0 && y < bh - 1) { placeBlock(world, origin.add(x, y, z), Blocks.AIR.getDefaultState(), chunkBox); } else { BlockState wall = (y < 2 || y == bh - 1) ? Blocks.OAK_LOG.getDefaultState() : Blocks.OAK_PLANKS.getDefaultState(); placeBlock(world, origin.add(x, y, z), wall, chunkBox); } } else if (y == 0) { placeBlock(world, origin.add(x, y, z), Blocks.DIRT_PATH.getDefaultState(), chunkBox); } else { placeBlock(world, origin.add(x, y, z), Blocks.AIR.getDefaultState(), chunkBox); } } } } for (int x = bx + 1; x < bx + bw - 1; x++) { for (int z = bz + 1; z < bz + bd - 1; z++) { placeBlock(world, origin.add(x, bh, z), Blocks.SPRUCE_PLANKS.getDefaultState(), chunkBox); } } for (int layer = 0; layer <= bw / 2; layer++) { placeBlock(world, origin.add(bx - 1 + layer, bh + layer, bz - 1), Blocks.SPRUCE_STAIRS.getDefaultState() .with(StairsBlock.FACING, Direction.EAST).with(StairsBlock.HALF, BlockHalf.BOTTOM), chunkBox); placeBlock(world, origin.add(bx + bw - layer, bh + layer, bz - 1), Blocks.SPRUCE_STAIRS.getDefaultState() .with(StairsBlock.FACING, Direction.WEST).with(StairsBlock.HALF, BlockHalf.BOTTOM), chunkBox); placeBlock(world, origin.add(bx - 1 + layer, bh + layer, bz + bd), Blocks.SPRUCE_STAIRS.getDefaultState() .with(StairsBlock.FACING, Direction.EAST).with(StairsBlock.HALF, BlockHalf.BOTTOM), chunkBox); placeBlock(world, origin.add(bx + bw - layer, bh + layer, bz + bd), Blocks.SPRUCE_STAIRS.getDefaultState() .with(StairsBlock.FACING, Direction.WEST).with(StairsBlock.HALF, BlockHalf.BOTTOM), chunkBox); } for (int hbx = bx + 2; hbx < bx + bw - 2; hbx += 4) { for (int hbz = bz + 2; hbz < bz + bd - 2; hbz += 4) { for (int stack = 0; stack < 3; stack++) { placeBlock(world, origin.add(hbx, 1 + stack, hbz), Blocks.HAY_BLOCK.getDefaultState(), chunkBox); } } } placeBlock(world, origin.add(bx + 2, 1, bz + 1), Blocks.LANTERN.getDefaultState(), chunkBox); placeBlock(world, origin.add(bx + bw - 3, 1, bz + 1), Blocks.LANTERN.getDefaultState(), chunkBox); placeBlock(world, origin.add(bx + 2, 1, bz + bd - 2), Blocks.LANTERN.getDefaultState(), chunkBox); placeBlock(world, origin.add(bx + bw - 3, 1, bz + bd - 2), Blocks.LANTERN.getDefaultState(), chunkBox); placeBlock(world, origin.add(bx + bw / 2, bh - 1, bz + bd / 2), Blocks.LANTERN.getDefaultState(), chunkBox); } private void generateMarketplace(StructureWorldAccess world, BlockPos origin, Random random, BlockBox chunkBox) { int mx = 30; int mz = 22; int mw = 18; int md = 16; if (!sectionOverlaps(chunkBox, origin, mx, -1, mz, mx + mw, 4, mz + md)) return; for (int x = mx; x < mx + mw; x++) { for (int z = mz; z < mz + md; z++) { boolean isBorder = x == mx || x == mx + mw - 1 || z == mz || z == mz + md - 1; BlockState floor = isBorder ? ModBlocks.RUNIC_STONE_BRICK_SLAB.getDefaultState().with(SlabBlock.TYPE, SlabType.TOP) : Blocks.STONE_BRICKS.getDefaultState(); placeBlock(world, origin.add(x, -1, z), floor, chunkBox); placeBlock(world, origin.add(x, 0, z), Blocks.AIR.getDefaultState(), chunkBox); } } for (int x = mx + 3; x < mx + mw - 3; x += 12) { placeBlock(world, origin.add(x, 0, mz + md / 2), Blocks.LANTERN.getDefaultState(), chunkBox); } placeBlock(world, origin.add(mx + mw / 2, 0, mz + md / 2), Blocks.LANTERN.getDefaultState(), chunkBox); generateMarketStall(world, origin, mx + 1, mz + 1, random, chunkBox); generateMarketStall(world, origin, mx + 11, mz + 1, random, chunkBox); generateMarketStall(world, origin, mx + 1, mz + 9, random, chunkBox); generateMarketStall(world, origin, mx + 11, mz + 9, random, chunkBox); } private void generateMarketStall(StructureWorldAccess world, BlockPos origin, int sx, int sz, Random random, BlockBox chunkBox) { if (!sectionOverlaps(chunkBox, origin, sx, 0, sz, sx + 4, 3, sz + 4)) return; for (int x = sx; x <= sx + 4; x++) { placeBlock(world, origin.add(x, 0, sz), Blocks.OAK_FENCE.getDefaultState(), chunkBox); placeBlock(world, origin.add(x, 0, sz + 4), Blocks.OAK_FENCE.getDefaultState(), chunkBox); } for (int z = sz; z <= sz + 4; z++) { placeBlock(world, origin.add(sx, 0, z), Blocks.OAK_FENCE.getDefaultState(), chunkBox); placeBlock(world, origin.add(sx + 4, 0, z), Blocks.OAK_FENCE.getDefaultState(), chunkBox); } for (int x = sx; x <= sx + 4; x++) { for (int z = sz; z <= sz + 4; z++) { placeBlock(world, origin.add(x, 1, z), Blocks.OAK_SLAB.getDefaultState() .with(SlabBlock.TYPE, SlabType.TOP), chunkBox); } } placeBlock(world, origin.add(sx + 1, 0, sz + 1), Blocks.OAK_FENCE.getDefaultState(), chunkBox); placeBlock(world, origin.add(sx + 3, 0, sz + 1), Blocks.OAK_FENCE.getDefaultState(), chunkBox); BlockPos chestPos = origin.add(sx + 2, 0, sz + 2); placeBlock(world, chestPos, Blocks.CHEST.getDefaultState() .with(ChestBlock.FACING, Direction.NORTH), chunkBox); if (chunkBox.contains(chestPos)) { BlockEntity be = world.getBlockEntity(chestPos); if (be instanceof ChestBlockEntity chest) { fillMarketChest(chest, random); } } placeBlock(world, origin.add(sx, 2, sz), Blocks.LANTERN.getDefaultState(), chunkBox); } private void fillMarketChest(ChestBlockEntity chest, Random random) { ItemStack[] foods = { new ItemStack(Items.BREAD, 3 + random.nextInt(5)), new ItemStack(Items.APPLE, 2 + random.nextInt(4)), new ItemStack(Items.COOKED_BEEF, 2 + random.nextInt(3)), new ItemStack(Items.COOKED_CHICKEN, 2 + random.nextInt(3)), new ItemStack(Items.CARROT, 3 + random.nextInt(5)), new ItemStack(Items.POTATO, 3 + random.nextInt(5)), new ItemStack(Items.COOKED_PORKCHOP, 2 + random.nextInt(3)), new ItemStack(Items.PUMPKIN_PIE, 1 + random.nextInt(2)), new ItemStack(Items.GOLDEN_APPLE, 1), new ItemStack(Items.SWEET_BERRIES, 4 + random.nextInt(6)), }; List slots = buildSlotList(27); for (ItemStack food : foods) { if (slots.isEmpty()) break; chest.setStack(slots.remove(random.nextInt(slots.size())), food); } } private void generateKeep(StructureWorldAccess world, BlockPos origin, Random random, BlockBox chunkBox) { int kx = KEEP_X; int kz = KEEP_Z; int kw = KEEP_W; int kd = KEEP_D; int keepTowerExt = 7; if (!sectionOverlaps(chunkBox, origin, kx - keepTowerExt, 0, kz - keepTowerExt, kx + kw + keepTowerExt, KEEP_HEIGHT + 14, kz + kd + keepTowerExt)) return; for (int y = 0; y < KEEP_HEIGHT; y++) { for (int x = kx; x < kx + kw; x++) { for (int z = kz; z < kz + kd; z++) { boolean isWall = x == kx || x == kx + kw - 1 || z == kz || z == kz + kd - 1; if (isWall) { placeRunicKeepBlock(world, origin.add(x, y, z), random, chunkBox); } else if (y == 0) { placeBlock(world, origin.add(x, y, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); } else { placeBlock(world, origin.add(x, y, z), Blocks.AIR.getDefaultState(), chunkBox); } } } } generateKeepFloorSlabs(world, origin, kx, kz, kw, kd, chunkBox); generateKeepWindows(world, origin, kx, kz, kw, kd, chunkBox); generateKeepBattlements(world, origin, kx, kz, kw, kd, chunkBox); generateKeepEntrance(world, origin, kx, kz, kw, chunkBox); generateGrandStaircase(world, origin, kx, kz, kw, kd, chunkBox); generateKeepInteriorFurniture(world, origin, kx, kz, kw, kd, random, chunkBox); generateKeepLootChests(world, origin, kx, kz, kw, kd, random, chunkBox); generateKeepTowers(world, origin, kx, kz, kw, kd, random, chunkBox); } private void generateKeepFloorSlabs(StructureWorldAccess world, BlockPos origin, int kx, int kz, int kw, int kd, BlockBox chunkBox) { for (int floor = 1; floor < KEEP_FLOORS; floor++) { int fy = floor * KEEP_FLOOR_HEIGHT; for (int x = kx + 1; x < kx + kw - 1; x++) { for (int z = kz + 1; z < kz + kd - 1; z++) { boolean isStairArea = (x >= kx + kw - 7 && x < kx + kw - 1 && z >= kz + 1 && z < kz + 7); if (!isStairArea) { placeBlock(world, origin.add(x, fy, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); } } } for (int x = kx + 2; x < kx + kw - 2; x += 8) { placeBlock(world, origin.add(x, fy + 1, kz + 2), Blocks.LANTERN.getDefaultState(), chunkBox); placeBlock(world, origin.add(x, fy + 1, kz + kd - 3), Blocks.LANTERN.getDefaultState(), chunkBox); } } } private void generateKeepWindows(StructureWorldAccess world, BlockPos origin, int kx, int kz, int kw, int kd, BlockBox chunkBox) { for (int floor = 0; floor < KEEP_FLOORS; floor++) { int baseY = floor * KEEP_FLOOR_HEIGHT + 2; for (int x = kx + 3; x < kx + kw - 3; x += 7) { for (int wy = baseY; wy < baseY + 4; wy++) { placeBlock(world, origin.add(x, wy, kz), Blocks.GLASS_PANE.getDefaultState(), chunkBox); placeBlock(world, origin.add(x, wy, kz + kd - 1), Blocks.GLASS_PANE.getDefaultState(), chunkBox); } placeBlock(world, origin.add(x - 1, baseY + 4, kz), ModBlocks.RUNIC_STONE_BRICK_STAIRS.getDefaultState() .with(StairsBlock.FACING, Direction.SOUTH).with(StairsBlock.HALF, BlockHalf.TOP), chunkBox); placeBlock(world, origin.add(x, baseY + 4, kz), ModBlocks.RUNIC_STONE_BRICK_STAIRS.getDefaultState() .with(StairsBlock.FACING, Direction.SOUTH).with(StairsBlock.HALF, BlockHalf.TOP), chunkBox); placeBlock(world, origin.add(x + 1, baseY + 4, kz), ModBlocks.RUNIC_STONE_BRICK_STAIRS.getDefaultState() .with(StairsBlock.FACING, Direction.SOUTH).with(StairsBlock.HALF, BlockHalf.TOP), chunkBox); } for (int z = kz + 3; z < kz + kd - 3; z += 6) { for (int wy = baseY; wy < baseY + 3; wy++) { placeBlock(world, origin.add(kx, wy, z), Blocks.GLASS_PANE.getDefaultState(), chunkBox); placeBlock(world, origin.add(kx + kw - 1, wy, z), Blocks.GLASS_PANE.getDefaultState(), chunkBox); } } } } private void generateKeepBattlements(StructureWorldAccess world, BlockPos origin, int kx, int kz, int kw, int kd, BlockBox chunkBox) { int top = KEEP_HEIGHT; for (int x = kx; x < kx + kw; x++) { if (x % 2 == 0) { placeBlock(world, origin.add(x, top, kz), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); placeBlock(world, origin.add(x, top + 1, kz), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); placeBlock(world, origin.add(x, top, kz + kd - 1), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); placeBlock(world, origin.add(x, top + 1, kz + kd - 1), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); } else { placeBlock(world, origin.add(x, top, kz), ModBlocks.RUNIC_STONE_BRICK_SLAB.getDefaultState() .with(SlabBlock.TYPE, SlabType.TOP), chunkBox); placeBlock(world, origin.add(x, top, kz + kd - 1), ModBlocks.RUNIC_STONE_BRICK_SLAB.getDefaultState() .with(SlabBlock.TYPE, SlabType.TOP), chunkBox); } } for (int z = kz; z < kz + kd; z++) { if (z % 2 == 0) { placeBlock(world, origin.add(kx, top, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); placeBlock(world, origin.add(kx, top + 1, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); placeBlock(world, origin.add(kx + kw - 1, top, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); placeBlock(world, origin.add(kx + kw - 1, top + 1, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); } else { placeBlock(world, origin.add(kx, top, z), ModBlocks.RUNIC_STONE_BRICK_SLAB.getDefaultState() .with(SlabBlock.TYPE, SlabType.TOP), chunkBox); placeBlock(world, origin.add(kx + kw - 1, top, z), ModBlocks.RUNIC_STONE_BRICK_SLAB.getDefaultState() .with(SlabBlock.TYPE, SlabType.TOP), chunkBox); } } int rooftopY = top; for (int x = kx + 1; x < kx + kw - 1; x++) { for (int z = kz + 1; z < kz + kd - 1; z++) { placeBlock(world, origin.add(x, rooftopY, z), ModBlocks.RUNIC_STONE_BRICK_SLAB.getDefaultState() .with(SlabBlock.TYPE, SlabType.TOP), chunkBox); } } } private void generateKeepEntrance(StructureWorldAccess world, BlockPos origin, int kx, int kz, int kw, BlockBox chunkBox) { int ex = kx + kw / 2; if (!sectionOverlaps(chunkBox, origin, ex - 3, 0, kz - 1, ex + 3, WALL_HEIGHT, kz + 1)) return; for (int y = 0; y < 6; y++) { for (int x = ex - 2; x <= ex + 2; x++) { placeBlock(world, origin.add(x, y, kz), Blocks.AIR.getDefaultState(), chunkBox); } } placeBlock(world, origin.add(ex - 2, 0, kz), Blocks.OAK_DOOR.getDefaultState() .with(DoorBlock.FACING, Direction.NORTH).with(DoorBlock.HALF, DoubleBlockHalf.LOWER), chunkBox); placeBlock(world, origin.add(ex - 2, 1, kz), Blocks.OAK_DOOR.getDefaultState() .with(DoorBlock.FACING, Direction.NORTH).with(DoorBlock.HALF, DoubleBlockHalf.UPPER), chunkBox); placeBlock(world, origin.add(ex + 2, 0, kz), Blocks.OAK_DOOR.getDefaultState() .with(DoorBlock.FACING, Direction.NORTH).with(DoorBlock.HALF, DoubleBlockHalf.LOWER), chunkBox); placeBlock(world, origin.add(ex + 2, 1, kz), Blocks.OAK_DOOR.getDefaultState() .with(DoorBlock.FACING, Direction.NORTH).with(DoorBlock.HALF, DoubleBlockHalf.UPPER), chunkBox); for (int y = 0; y < 6; y++) { placeBlock(world, origin.add(ex - 1, y, kz), Blocks.IRON_BARS.getDefaultState(), chunkBox); placeBlock(world, origin.add(ex, y, kz), Blocks.IRON_BARS.getDefaultState(), chunkBox); placeBlock(world, origin.add(ex + 1, y, kz), Blocks.IRON_BARS.getDefaultState(), chunkBox); } placeBlock(world, origin.add(ex, 5, kz), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); placeBlock(world, origin.add(ex - 3, WALL_HEIGHT - 1, kz - 1), Blocks.LANTERN.getDefaultState(), chunkBox); placeBlock(world, origin.add(ex + 3, WALL_HEIGHT - 1, kz - 1), Blocks.LANTERN.getDefaultState(), chunkBox); } private void generateGrandStaircase(StructureWorldAccess world, BlockPos origin, int kx, int kz, int kw, int kd, BlockBox chunkBox) { int sx = kx + kw - 7; int sz = kz + 1; if (!sectionOverlaps(chunkBox, origin, sx - 1, 0, sz, sx + 7, KEEP_HEIGHT + 1, sz + 7)) return; for (int floor = 0; floor < KEEP_FLOORS - 1; floor++) { int baseY = floor * KEEP_FLOOR_HEIGHT; for (int y = 0; y < KEEP_FLOOR_HEIGHT; y++) { int stairX = sx + (y % 5); int stairZ = sz + (y / 5); placeBlock(world, origin.add(stairX, baseY + y, stairZ), ModBlocks.RUNIC_STONE_BRICK_STAIRS.getDefaultState() .with(StairsBlock.FACING, y % 5 < 4 ? Direction.EAST : Direction.NORTH) .with(StairsBlock.HALF, BlockHalf.BOTTOM), chunkBox); if (y % 5 == 0) { placeBlock(world, origin.add(stairX - 1, baseY + y, stairZ), ModBlocks.RUNIC_STONE_BRICK_WALL.getDefaultState(), chunkBox); placeBlock(world, origin.add(stairX - 1, baseY + y + 1, stairZ), Blocks.IRON_BARS.getDefaultState(), chunkBox); } } int platformY = (floor + 1) * KEEP_FLOOR_HEIGHT; for (int px = sx; px < sx + 6; px++) { for (int pz = sz; pz < sz + 6; pz++) { placeBlock(world, origin.add(px, platformY, pz), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); } } for (int px = sx; px < sx + 6; px++) { placeBlock(world, origin.add(px, platformY + 1, sz), ModBlocks.RUNIC_STONE_BRICK_SLAB.getDefaultState() .with(SlabBlock.TYPE, SlabType.TOP), chunkBox); } } } private void generateKeepInteriorFurniture(StructureWorldAccess world, BlockPos origin, int kx, int kz, int kw, int kd, Random random, BlockBox chunkBox) { if (!sectionOverlaps(chunkBox, origin, kx + 1, 1, kz + 1, kx + kw - 1, KEEP_HEIGHT - 1, kz + kd - 1)) return; for (int floor = 0; floor < KEEP_FLOORS; floor++) { int baseY = floor * KEEP_FLOOR_HEIGHT; int roomY = baseY + 1; if (floor == 0) { for (int x = kx + 2; x <= kx + 8; x++) { placeBlock(world, origin.add(x, roomY, kz + 3), Blocks.OAK_LOG.getDefaultState(), chunkBox); placeBlock(world, origin.add(x, roomY + 1, kz + 3), Blocks.OAK_LOG.getDefaultState(), chunkBox); } placeBlock(world, origin.add(kx + 2, roomY, kz + 4), Blocks.LANTERN.getDefaultState(), chunkBox); placeBlock(world, origin.add(kx + 8, roomY, kz + 4), Blocks.LANTERN.getDefaultState(), chunkBox); for (int z = kz + kd / 2 - 1; z <= kz + kd / 2 + 1; z++) { placeBlock(world, origin.add(kx + 2, roomY, z), Blocks.BOOKSHELF.getDefaultState(), chunkBox); placeBlock(world, origin.add(kx + 3, roomY, z), Blocks.BOOKSHELF.getDefaultState(), chunkBox); } for (int c = 0; c < 4; c++) { int cx = kx + 4 + c * 8; placeBlock(world, origin.add(cx, roomY, kz + 10), Blocks.OAK_FENCE.getDefaultState(), chunkBox); placeBlock(world, origin.add(cx, roomY, kz + 12), Blocks.OAK_FENCE.getDefaultState(), chunkBox); placeBlock(world, origin.add(cx, roomY + 1, kz + 10), Blocks.OAK_PRESSURE_PLATE.getDefaultState(), chunkBox); placeBlock(world, origin.add(cx, roomY + 1, kz + 12), Blocks.OAK_PRESSURE_PLATE.getDefaultState(), chunkBox); placeBlock(world, origin.add(cx + 2, roomY, kz + 11), Blocks.CRAFTING_TABLE.getDefaultState(), chunkBox); } } else if (floor == 1) { for (int z = kz + 3; z <= kz + kd - 4; z += 5) { placeBlock(world, origin.add(kx + 3, roomY, z), Blocks.OAK_FENCE.getDefaultState(), chunkBox); placeBlock(world, origin.add(kx + 4, roomY, z), Blocks.OAK_FENCE.getDefaultState(), chunkBox); placeBlock(world, origin.add(kx + kw - 5, roomY, z), Blocks.OAK_FENCE.getDefaultState(), chunkBox); } placeBlock(world, origin.add(kx + kw / 2, roomY, kz + kd / 2), Blocks.ENCHANTING_TABLE.getDefaultState(), chunkBox); for (int bx = kx + kw / 2 - 3; bx <= kx + kw / 2 + 3; bx++) { placeBlock(world, origin.add(bx, roomY, kz + kd / 2 - 2), Blocks.BOOKSHELF.getDefaultState(), chunkBox); placeBlock(world, origin.add(bx, roomY, kz + kd / 2 + 2), Blocks.BOOKSHELF.getDefaultState(), chunkBox); } } else if (floor == 2) { for (int bz = kz + 2; bz < kz + kd - 2; bz += 2) { placeBlock(world, origin.add(kx + 2, roomY, bz), Blocks.BARREL.getDefaultState(), chunkBox); placeBlock(world, origin.add(kx + kw - 3, roomY, bz), Blocks.BARREL.getDefaultState(), chunkBox); } placeBlock(world, origin.add(kx + kw / 2, roomY, kz + kd / 2), Blocks.BREWING_STAND.getDefaultState(), chunkBox); placeBlock(world, origin.add(kx + kw / 2 + 2, roomY, kz + kd / 2), Blocks.CAULDRON.getDefaultState(), chunkBox); } for (int lx = kx + 4; lx < kx + kw - 4; lx += 10) { placeBlock(world, origin.add(lx, roomY, kz + 2), Blocks.LANTERN.getDefaultState(), chunkBox); placeBlock(world, origin.add(lx, roomY, kz + kd - 3), Blocks.LANTERN.getDefaultState(), chunkBox); } } } private void generateKeepLootChests(StructureWorldAccess world, BlockPos origin, int kx, int kz, int kw, int kd, Random random, BlockBox chunkBox) { int lootFloor = KEEP_FLOORS - 1; int baseY = lootFloor * KEEP_FLOOR_HEIGHT + 1; if (!sectionOverlaps(chunkBox, origin, kx + 3, baseY, kz + 2, kx + 10, baseY + 2, kz + kd - 3)) return; BlockPos[] chestPositions = { origin.add(kx + 3, baseY, kz + 3), origin.add(kx + 6, baseY, kz + 3), origin.add(kx + 9, baseY, kz + 3), origin.add(kx + 3, baseY, kz + kd - 4), origin.add(kx + 6, baseY, kz + kd - 4), origin.add(kx + 9, baseY, kz + kd - 4), }; for (int i = 0; i < chestPositions.length; i++) { placeBlock(world, chestPositions[i], Blocks.CHEST.getDefaultState() .with(ChestBlock.FACING, Direction.NORTH), chunkBox); if (chunkBox.contains(chestPositions[i])) { BlockEntity be = world.getBlockEntity(chestPositions[i]); if (be instanceof ChestBlockEntity chest) { if (i < 3) { fillDiamondLootChest(chest, random); } else { fillNetheriteLootChest(chest, random); } } } } for (BlockPos cp : chestPositions) { placeBlock(world, cp.up(), Blocks.LANTERN.getDefaultState(), chunkBox); } } private void fillDiamondLootChest(ChestBlockEntity chest, Random random) { List slots = buildSlotList(27); ItemStack[] items = { new ItemStack(Items.DIAMOND_HELMET), new ItemStack(Items.DIAMOND_CHESTPLATE), new ItemStack(Items.DIAMOND_LEGGINGS), new ItemStack(Items.DIAMOND_BOOTS), new ItemStack(Items.DIAMOND_SWORD), new ItemStack(Items.DIAMOND, 3 + random.nextInt(5)), new ItemStack(Items.GOLDEN_APPLE, 1 + random.nextInt(2)), new ItemStack(Items.ENCHANTED_GOLDEN_APPLE), }; for (ItemStack it : items) { if (slots.isEmpty()) break; chest.setStack(slots.remove(random.nextInt(slots.size())), it); } } private void fillNetheriteLootChest(ChestBlockEntity chest, Random random) { List slots = buildSlotList(27); ItemStack[] items = { new ItemStack(Items.NETHERITE_HELMET), new ItemStack(Items.NETHERITE_CHESTPLATE), new ItemStack(Items.NETHERITE_LEGGINGS), new ItemStack(Items.NETHERITE_BOOTS), new ItemStack(Items.NETHERITE_SWORD), new ItemStack(Items.NETHERITE_INGOT, 1 + random.nextInt(2)), new ItemStack(Items.DIAMOND, 5 + random.nextInt(5)), new ItemStack(Items.ENCHANTED_GOLDEN_APPLE, 1 + random.nextInt(2)), new ItemStack(Items.GOLDEN_APPLE, 2 + random.nextInt(3)), }; for (ItemStack it : items) { if (slots.isEmpty()) break; chest.setStack(slots.remove(random.nextInt(slots.size())), it); } } private void generateKeepTowers(StructureWorldAccess world, BlockPos origin, int kx, int kz, int kw, int kd, Random random, BlockBox chunkBox) { int tt = 7; int th = KEEP_HEIGHT + 12; int[][] corners = { {kx - tt + 1, kz - tt + 1}, {kx + kw - 1, kz - tt + 1}, {kx - tt + 1, kz + kd - 1}, {kx + kw - 1, kz + kd - 1} }; for (int[] c : corners) { int tx = c[0], tz = c[1]; if (!sectionOverlaps(chunkBox, origin, tx, 0, tz, tx + tt, th + 2, tz + tt)) continue; for (int y = 0; y < th; y++) { for (int x = tx; x < tx + tt; x++) { for (int z = tz; z < tz + tt; z++) { boolean isWall = x == tx || x == tx + tt - 1 || z == tz || z == tz + tt - 1; if (isWall) { placeRunicKeepBlock(world, origin.add(x, y, z), random, chunkBox); } else if (y % KEEP_FLOOR_HEIGHT == 0) { placeBlock(world, origin.add(x, y, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); } else { placeBlock(world, origin.add(x, y, z), Blocks.AIR.getDefaultState(), chunkBox); } } } } for (int x = tx; x < tx + tt; x++) { for (int z = tz; z < tz + tt; z++) { boolean isWall = x == tx || x == tx + tt - 1 || z == tz || z == tz + tt - 1; if (isWall && (x + z) % 2 == 0) { placeBlock(world, origin.add(x, th, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); placeBlock(world, origin.add(x, th + 1, z), ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(), chunkBox); } } } placeBlock(world, origin.add(tx + tt / 2, th - 1, tz + tt / 2), Blocks.LANTERN.getDefaultState(), chunkBox); } } private void spawnMobs(StructureWorldAccess world, BlockPos origin, Random random) { int[][] spawnPositions = { {WIDTH / 2, 1, DEPTH / 2}, {10, 1, 15}, {WIDTH - 15, 1, 20}, {15, 1, DEPTH - 20}, {WIDTH - 20, 1, DEPTH - 25}, {KEEP_X + KEEP_W / 2, 1, KEEP_Z + 5}, {KEEP_X + 5, 1, KEEP_Z + KEEP_D / 2}, {30, 1, 40}, }; for (int[] sp : spawnPositions) { BlockPos spawnPos = origin.add(sp[0], sp[1], sp[2]); ModEntities.RUNIC_KNIGHT.spawn(world.toServerWorld(), spawnPos, SpawnReason.STRUCTURE); } } private void placeRunicBlock(StructureWorldAccess world, BlockPos pos, Random random, BlockBox chunkBox) { float r = random.nextFloat(); BlockState state; if (r < 0.60f) { state = ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(); } else if (r < 0.75f) { state = Blocks.MOSSY_STONE_BRICKS.getDefaultState(); } else if (r < 0.86f) { state = Blocks.CRACKED_STONE_BRICKS.getDefaultState(); } else if (r < 0.92f) { state = Blocks.COBBLESTONE.getDefaultState(); } else { state = ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(); } placeBlock(world, pos, state, chunkBox); } private void placeRunicKeepBlock(StructureWorldAccess world, BlockPos pos, Random random, BlockBox chunkBox) { float r = random.nextFloat(); BlockState state; if (r < 0.70f) { state = ModBlocks.RUNIC_STONE_BRICKS.getDefaultState(); } else if (r < 0.82f) { state = Blocks.CHISELED_STONE_BRICKS.getDefaultState(); } else if (r < 0.91f) { state = Blocks.MOSSY_STONE_BRICKS.getDefaultState(); } else { state = Blocks.CRACKED_STONE_BRICKS.getDefaultState(); } placeBlock(world, pos, state, chunkBox); } private List buildSlotList(int size) { List slots = new ArrayList<>(); for (int i = 0; i < size; i++) slots.add(i); return slots; } private void placeBlock(StructureWorldAccess world, BlockPos pos, BlockState state, BlockBox chunkBox) { if (chunkBox.contains(pos)) { world.setBlockState(pos, state, 2); } } }