1261 lines
53 KiB
Java
1261 lines
53 KiB
Java
package net.minecraft.world.level.levelgen.structure.structures;
|
|
|
|
import com.google.common.collect.Lists;
|
|
import it.unimi.dsi.fastutil.objects.ObjectArrayList;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import net.minecraft.Util;
|
|
import net.minecraft.core.BlockPos;
|
|
import net.minecraft.core.Direction;
|
|
import net.minecraft.nbt.CompoundTag;
|
|
import net.minecraft.resources.ResourceLocation;
|
|
import net.minecraft.util.RandomSource;
|
|
import net.minecraft.util.Tuple;
|
|
import net.minecraft.world.entity.EntitySpawnReason;
|
|
import net.minecraft.world.entity.EntityType;
|
|
import net.minecraft.world.entity.Mob;
|
|
import net.minecraft.world.level.ServerLevelAccessor;
|
|
import net.minecraft.world.level.block.Blocks;
|
|
import net.minecraft.world.level.block.ChestBlock;
|
|
import net.minecraft.world.level.block.Mirror;
|
|
import net.minecraft.world.level.block.Rotation;
|
|
import net.minecraft.world.level.block.state.BlockState;
|
|
import net.minecraft.world.level.levelgen.structure.BoundingBox;
|
|
import net.minecraft.world.level.levelgen.structure.TemplateStructurePiece;
|
|
import net.minecraft.world.level.levelgen.structure.pieces.StructurePieceSerializationContext;
|
|
import net.minecraft.world.level.levelgen.structure.pieces.StructurePieceType;
|
|
import net.minecraft.world.level.levelgen.structure.templatesystem.BlockIgnoreProcessor;
|
|
import net.minecraft.world.level.levelgen.structure.templatesystem.StructurePlaceSettings;
|
|
import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplate;
|
|
import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplateManager;
|
|
import net.minecraft.world.level.storage.loot.BuiltInLootTables;
|
|
import org.jetbrains.annotations.Nullable;
|
|
|
|
public class WoodlandMansionPieces {
|
|
public static void generateMansion(
|
|
StructureTemplateManager structureTemplateManager,
|
|
BlockPos pos,
|
|
Rotation rotation,
|
|
List<WoodlandMansionPieces.WoodlandMansionPiece> pieces,
|
|
RandomSource random
|
|
) {
|
|
WoodlandMansionPieces.MansionGrid mansionGrid = new WoodlandMansionPieces.MansionGrid(random);
|
|
WoodlandMansionPieces.MansionPiecePlacer mansionPiecePlacer = new WoodlandMansionPieces.MansionPiecePlacer(structureTemplateManager, random);
|
|
mansionPiecePlacer.createMansion(pos, rotation, pieces, mansionGrid);
|
|
}
|
|
|
|
static class FirstFloorRoomCollection extends WoodlandMansionPieces.FloorRoomCollection {
|
|
@Override
|
|
public String get1x1(RandomSource random) {
|
|
return "1x1_a" + (random.nextInt(5) + 1);
|
|
}
|
|
|
|
@Override
|
|
public String get1x1Secret(RandomSource random) {
|
|
return "1x1_as" + (random.nextInt(4) + 1);
|
|
}
|
|
|
|
@Override
|
|
public String get1x2SideEntrance(RandomSource random, boolean isStairs) {
|
|
return "1x2_a" + (random.nextInt(9) + 1);
|
|
}
|
|
|
|
@Override
|
|
public String get1x2FrontEntrance(RandomSource random, boolean isStairs) {
|
|
return "1x2_b" + (random.nextInt(5) + 1);
|
|
}
|
|
|
|
@Override
|
|
public String get1x2Secret(RandomSource random) {
|
|
return "1x2_s" + (random.nextInt(2) + 1);
|
|
}
|
|
|
|
@Override
|
|
public String get2x2(RandomSource random) {
|
|
return "2x2_a" + (random.nextInt(4) + 1);
|
|
}
|
|
|
|
@Override
|
|
public String get2x2Secret(RandomSource random) {
|
|
return "2x2_s1";
|
|
}
|
|
}
|
|
|
|
abstract static class FloorRoomCollection {
|
|
public abstract String get1x1(RandomSource random);
|
|
|
|
public abstract String get1x1Secret(RandomSource random);
|
|
|
|
public abstract String get1x2SideEntrance(RandomSource random, boolean isStairs);
|
|
|
|
public abstract String get1x2FrontEntrance(RandomSource random, boolean isStairs);
|
|
|
|
public abstract String get1x2Secret(RandomSource random);
|
|
|
|
public abstract String get2x2(RandomSource random);
|
|
|
|
public abstract String get2x2Secret(RandomSource random);
|
|
}
|
|
|
|
static class MansionGrid {
|
|
private static final int DEFAULT_SIZE = 11;
|
|
private static final int CLEAR = 0;
|
|
private static final int CORRIDOR = 1;
|
|
private static final int ROOM = 2;
|
|
private static final int START_ROOM = 3;
|
|
private static final int TEST_ROOM = 4;
|
|
private static final int BLOCKED = 5;
|
|
private static final int ROOM_1x1 = 65536;
|
|
private static final int ROOM_1x2 = 131072;
|
|
private static final int ROOM_2x2 = 262144;
|
|
private static final int ROOM_ORIGIN_FLAG = 1048576;
|
|
private static final int ROOM_DOOR_FLAG = 2097152;
|
|
private static final int ROOM_STAIRS_FLAG = 4194304;
|
|
private static final int ROOM_CORRIDOR_FLAG = 8388608;
|
|
private static final int ROOM_TYPE_MASK = 983040;
|
|
private static final int ROOM_ID_MASK = 65535;
|
|
private final RandomSource random;
|
|
final WoodlandMansionPieces.SimpleGrid baseGrid;
|
|
final WoodlandMansionPieces.SimpleGrid thirdFloorGrid;
|
|
final WoodlandMansionPieces.SimpleGrid[] floorRooms;
|
|
final int entranceX;
|
|
final int entranceY;
|
|
|
|
public MansionGrid(RandomSource random) {
|
|
this.random = random;
|
|
int i = 11;
|
|
this.entranceX = 7;
|
|
this.entranceY = 4;
|
|
this.baseGrid = new WoodlandMansionPieces.SimpleGrid(11, 11, 5);
|
|
this.baseGrid.set(this.entranceX, this.entranceY, this.entranceX + 1, this.entranceY + 1, 3);
|
|
this.baseGrid.set(this.entranceX - 1, this.entranceY, this.entranceX - 1, this.entranceY + 1, 2);
|
|
this.baseGrid.set(this.entranceX + 2, this.entranceY - 2, this.entranceX + 3, this.entranceY + 3, 5);
|
|
this.baseGrid.set(this.entranceX + 1, this.entranceY - 2, this.entranceX + 1, this.entranceY - 1, 1);
|
|
this.baseGrid.set(this.entranceX + 1, this.entranceY + 2, this.entranceX + 1, this.entranceY + 3, 1);
|
|
this.baseGrid.set(this.entranceX - 1, this.entranceY - 1, 1);
|
|
this.baseGrid.set(this.entranceX - 1, this.entranceY + 2, 1);
|
|
this.baseGrid.set(0, 0, 11, 1, 5);
|
|
this.baseGrid.set(0, 9, 11, 11, 5);
|
|
this.recursiveCorridor(this.baseGrid, this.entranceX, this.entranceY - 2, Direction.WEST, 6);
|
|
this.recursiveCorridor(this.baseGrid, this.entranceX, this.entranceY + 3, Direction.WEST, 6);
|
|
this.recursiveCorridor(this.baseGrid, this.entranceX - 2, this.entranceY - 1, Direction.WEST, 3);
|
|
this.recursiveCorridor(this.baseGrid, this.entranceX - 2, this.entranceY + 2, Direction.WEST, 3);
|
|
|
|
while (this.cleanEdges(this.baseGrid)) {
|
|
}
|
|
|
|
this.floorRooms = new WoodlandMansionPieces.SimpleGrid[3];
|
|
this.floorRooms[0] = new WoodlandMansionPieces.SimpleGrid(11, 11, 5);
|
|
this.floorRooms[1] = new WoodlandMansionPieces.SimpleGrid(11, 11, 5);
|
|
this.floorRooms[2] = new WoodlandMansionPieces.SimpleGrid(11, 11, 5);
|
|
this.identifyRooms(this.baseGrid, this.floorRooms[0]);
|
|
this.identifyRooms(this.baseGrid, this.floorRooms[1]);
|
|
this.floorRooms[0].set(this.entranceX + 1, this.entranceY, this.entranceX + 1, this.entranceY + 1, 8388608);
|
|
this.floorRooms[1].set(this.entranceX + 1, this.entranceY, this.entranceX + 1, this.entranceY + 1, 8388608);
|
|
this.thirdFloorGrid = new WoodlandMansionPieces.SimpleGrid(this.baseGrid.width, this.baseGrid.height, 5);
|
|
this.setupThirdFloor();
|
|
this.identifyRooms(this.thirdFloorGrid, this.floorRooms[2]);
|
|
}
|
|
|
|
public static boolean isHouse(WoodlandMansionPieces.SimpleGrid layout, int x, int y) {
|
|
int i = layout.get(x, y);
|
|
return i == 1 || i == 2 || i == 3 || i == 4;
|
|
}
|
|
|
|
public boolean isRoomId(WoodlandMansionPieces.SimpleGrid layout, int x, int y, int floor, int roomId) {
|
|
return (this.floorRooms[floor].get(x, y) & 65535) == roomId;
|
|
}
|
|
|
|
@Nullable
|
|
public Direction get1x2RoomDirection(WoodlandMansionPieces.SimpleGrid layout, int x, int y, int floor, int roomId) {
|
|
for (Direction direction : Direction.Plane.HORIZONTAL) {
|
|
if (this.isRoomId(layout, x + direction.getStepX(), y + direction.getStepZ(), floor, roomId)) {
|
|
return direction;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private void recursiveCorridor(WoodlandMansionPieces.SimpleGrid layout, int x, int y, Direction direction, int length) {
|
|
if (length > 0) {
|
|
layout.set(x, y, 1);
|
|
layout.setif(x + direction.getStepX(), y + direction.getStepZ(), 0, 1);
|
|
|
|
for (int i = 0; i < 8; i++) {
|
|
Direction direction2 = Direction.from2DDataValue(this.random.nextInt(4));
|
|
if (direction2 != direction.getOpposite() && (direction2 != Direction.EAST || !this.random.nextBoolean())) {
|
|
int j = x + direction.getStepX();
|
|
int k = y + direction.getStepZ();
|
|
if (layout.get(j + direction2.getStepX(), k + direction2.getStepZ()) == 0
|
|
&& layout.get(j + direction2.getStepX() * 2, k + direction2.getStepZ() * 2) == 0) {
|
|
this.recursiveCorridor(
|
|
layout, x + direction.getStepX() + direction2.getStepX(), y + direction.getStepZ() + direction2.getStepZ(), direction2, length - 1
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Direction direction3 = direction.getClockWise();
|
|
Direction direction2 = direction.getCounterClockWise();
|
|
layout.setif(x + direction3.getStepX(), y + direction3.getStepZ(), 0, 2);
|
|
layout.setif(x + direction2.getStepX(), y + direction2.getStepZ(), 0, 2);
|
|
layout.setif(x + direction.getStepX() + direction3.getStepX(), y + direction.getStepZ() + direction3.getStepZ(), 0, 2);
|
|
layout.setif(x + direction.getStepX() + direction2.getStepX(), y + direction.getStepZ() + direction2.getStepZ(), 0, 2);
|
|
layout.setif(x + direction.getStepX() * 2, y + direction.getStepZ() * 2, 0, 2);
|
|
layout.setif(x + direction3.getStepX() * 2, y + direction3.getStepZ() * 2, 0, 2);
|
|
layout.setif(x + direction2.getStepX() * 2, y + direction2.getStepZ() * 2, 0, 2);
|
|
}
|
|
}
|
|
|
|
private boolean cleanEdges(WoodlandMansionPieces.SimpleGrid grid) {
|
|
boolean bl = false;
|
|
|
|
for (int i = 0; i < grid.height; i++) {
|
|
for (int j = 0; j < grid.width; j++) {
|
|
if (grid.get(j, i) == 0) {
|
|
int k = 0;
|
|
k += isHouse(grid, j + 1, i) ? 1 : 0;
|
|
k += isHouse(grid, j - 1, i) ? 1 : 0;
|
|
k += isHouse(grid, j, i + 1) ? 1 : 0;
|
|
k += isHouse(grid, j, i - 1) ? 1 : 0;
|
|
if (k >= 3) {
|
|
grid.set(j, i, 2);
|
|
bl = true;
|
|
} else if (k == 2) {
|
|
int l = 0;
|
|
l += isHouse(grid, j + 1, i + 1) ? 1 : 0;
|
|
l += isHouse(grid, j - 1, i + 1) ? 1 : 0;
|
|
l += isHouse(grid, j + 1, i - 1) ? 1 : 0;
|
|
l += isHouse(grid, j - 1, i - 1) ? 1 : 0;
|
|
if (l <= 1) {
|
|
grid.set(j, i, 2);
|
|
bl = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return bl;
|
|
}
|
|
|
|
private void setupThirdFloor() {
|
|
List<Tuple<Integer, Integer>> list = Lists.<Tuple<Integer, Integer>>newArrayList();
|
|
WoodlandMansionPieces.SimpleGrid simpleGrid = this.floorRooms[1];
|
|
|
|
for (int i = 0; i < this.thirdFloorGrid.height; i++) {
|
|
for (int j = 0; j < this.thirdFloorGrid.width; j++) {
|
|
int k = simpleGrid.get(j, i);
|
|
int l = k & 983040;
|
|
if (l == 131072 && (k & 2097152) == 2097152) {
|
|
list.add(new Tuple<>(j, i));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (list.isEmpty()) {
|
|
this.thirdFloorGrid.set(0, 0, this.thirdFloorGrid.width, this.thirdFloorGrid.height, 5);
|
|
} else {
|
|
Tuple<Integer, Integer> tuple = (Tuple<Integer, Integer>)list.get(this.random.nextInt(list.size()));
|
|
int jx = simpleGrid.get(tuple.getA(), tuple.getB());
|
|
simpleGrid.set(tuple.getA(), tuple.getB(), jx | 4194304);
|
|
Direction direction = this.get1x2RoomDirection(this.baseGrid, tuple.getA(), tuple.getB(), 1, jx & 65535);
|
|
int l = tuple.getA() + direction.getStepX();
|
|
int m = tuple.getB() + direction.getStepZ();
|
|
|
|
for (int n = 0; n < this.thirdFloorGrid.height; n++) {
|
|
for (int o = 0; o < this.thirdFloorGrid.width; o++) {
|
|
if (!isHouse(this.baseGrid, o, n)) {
|
|
this.thirdFloorGrid.set(o, n, 5);
|
|
} else if (o == tuple.getA() && n == tuple.getB()) {
|
|
this.thirdFloorGrid.set(o, n, 3);
|
|
} else if (o == l && n == m) {
|
|
this.thirdFloorGrid.set(o, n, 3);
|
|
this.floorRooms[2].set(o, n, 8388608);
|
|
}
|
|
}
|
|
}
|
|
|
|
List<Direction> list2 = Lists.<Direction>newArrayList();
|
|
|
|
for (Direction direction2 : Direction.Plane.HORIZONTAL) {
|
|
if (this.thirdFloorGrid.get(l + direction2.getStepX(), m + direction2.getStepZ()) == 0) {
|
|
list2.add(direction2);
|
|
}
|
|
}
|
|
|
|
if (list2.isEmpty()) {
|
|
this.thirdFloorGrid.set(0, 0, this.thirdFloorGrid.width, this.thirdFloorGrid.height, 5);
|
|
simpleGrid.set(tuple.getA(), tuple.getB(), jx);
|
|
} else {
|
|
Direction direction3 = (Direction)list2.get(this.random.nextInt(list2.size()));
|
|
this.recursiveCorridor(this.thirdFloorGrid, l + direction3.getStepX(), m + direction3.getStepZ(), direction3, 4);
|
|
|
|
while (this.cleanEdges(this.thirdFloorGrid)) {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void identifyRooms(WoodlandMansionPieces.SimpleGrid grid, WoodlandMansionPieces.SimpleGrid floorRooms) {
|
|
ObjectArrayList<Tuple<Integer, Integer>> objectArrayList = new ObjectArrayList<>();
|
|
|
|
for (int i = 0; i < grid.height; i++) {
|
|
for (int j = 0; j < grid.width; j++) {
|
|
if (grid.get(j, i) == 2) {
|
|
objectArrayList.add(new Tuple<>(j, i));
|
|
}
|
|
}
|
|
}
|
|
|
|
Util.shuffle(objectArrayList, this.random);
|
|
int i = 10;
|
|
|
|
for (Tuple<Integer, Integer> tuple : objectArrayList) {
|
|
int k = tuple.getA();
|
|
int l = tuple.getB();
|
|
if (floorRooms.get(k, l) == 0) {
|
|
int m = k;
|
|
int n = k;
|
|
int o = l;
|
|
int p = l;
|
|
int q = 65536;
|
|
if (floorRooms.get(k + 1, l) == 0
|
|
&& floorRooms.get(k, l + 1) == 0
|
|
&& floorRooms.get(k + 1, l + 1) == 0
|
|
&& grid.get(k + 1, l) == 2
|
|
&& grid.get(k, l + 1) == 2
|
|
&& grid.get(k + 1, l + 1) == 2) {
|
|
n = k + 1;
|
|
p = l + 1;
|
|
q = 262144;
|
|
} else if (floorRooms.get(k - 1, l) == 0
|
|
&& floorRooms.get(k, l + 1) == 0
|
|
&& floorRooms.get(k - 1, l + 1) == 0
|
|
&& grid.get(k - 1, l) == 2
|
|
&& grid.get(k, l + 1) == 2
|
|
&& grid.get(k - 1, l + 1) == 2) {
|
|
m = k - 1;
|
|
p = l + 1;
|
|
q = 262144;
|
|
} else if (floorRooms.get(k - 1, l) == 0
|
|
&& floorRooms.get(k, l - 1) == 0
|
|
&& floorRooms.get(k - 1, l - 1) == 0
|
|
&& grid.get(k - 1, l) == 2
|
|
&& grid.get(k, l - 1) == 2
|
|
&& grid.get(k - 1, l - 1) == 2) {
|
|
m = k - 1;
|
|
o = l - 1;
|
|
q = 262144;
|
|
} else if (floorRooms.get(k + 1, l) == 0 && grid.get(k + 1, l) == 2) {
|
|
n = k + 1;
|
|
q = 131072;
|
|
} else if (floorRooms.get(k, l + 1) == 0 && grid.get(k, l + 1) == 2) {
|
|
p = l + 1;
|
|
q = 131072;
|
|
} else if (floorRooms.get(k - 1, l) == 0 && grid.get(k - 1, l) == 2) {
|
|
m = k - 1;
|
|
q = 131072;
|
|
} else if (floorRooms.get(k, l - 1) == 0 && grid.get(k, l - 1) == 2) {
|
|
o = l - 1;
|
|
q = 131072;
|
|
}
|
|
|
|
int r = this.random.nextBoolean() ? m : n;
|
|
int s = this.random.nextBoolean() ? o : p;
|
|
int t = 2097152;
|
|
if (!grid.edgesTo(r, s, 1)) {
|
|
r = r == m ? n : m;
|
|
s = s == o ? p : o;
|
|
if (!grid.edgesTo(r, s, 1)) {
|
|
s = s == o ? p : o;
|
|
if (!grid.edgesTo(r, s, 1)) {
|
|
r = r == m ? n : m;
|
|
s = s == o ? p : o;
|
|
if (!grid.edgesTo(r, s, 1)) {
|
|
t = 0;
|
|
r = m;
|
|
s = o;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int u = o; u <= p; u++) {
|
|
for (int v = m; v <= n; v++) {
|
|
if (v == r && u == s) {
|
|
floorRooms.set(v, u, 1048576 | t | q | i);
|
|
} else {
|
|
floorRooms.set(v, u, q | i);
|
|
}
|
|
}
|
|
}
|
|
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static class MansionPiecePlacer {
|
|
private final StructureTemplateManager structureTemplateManager;
|
|
private final RandomSource random;
|
|
private int startX;
|
|
private int startY;
|
|
|
|
public MansionPiecePlacer(StructureTemplateManager structureTemplateManager, RandomSource random) {
|
|
this.structureTemplateManager = structureTemplateManager;
|
|
this.random = random;
|
|
}
|
|
|
|
public void createMansion(BlockPos pos, Rotation rotation, List<WoodlandMansionPieces.WoodlandMansionPiece> pieces, WoodlandMansionPieces.MansionGrid grid) {
|
|
WoodlandMansionPieces.PlacementData placementData = new WoodlandMansionPieces.PlacementData();
|
|
placementData.position = pos;
|
|
placementData.rotation = rotation;
|
|
placementData.wallType = "wall_flat";
|
|
WoodlandMansionPieces.PlacementData placementData2 = new WoodlandMansionPieces.PlacementData();
|
|
this.entrance(pieces, placementData);
|
|
placementData2.position = placementData.position.above(8);
|
|
placementData2.rotation = placementData.rotation;
|
|
placementData2.wallType = "wall_window";
|
|
if (!pieces.isEmpty()) {
|
|
}
|
|
|
|
WoodlandMansionPieces.SimpleGrid simpleGrid = grid.baseGrid;
|
|
WoodlandMansionPieces.SimpleGrid simpleGrid2 = grid.thirdFloorGrid;
|
|
this.startX = grid.entranceX + 1;
|
|
this.startY = grid.entranceY + 1;
|
|
int i = grid.entranceX + 1;
|
|
int j = grid.entranceY;
|
|
this.traverseOuterWalls(pieces, placementData, simpleGrid, Direction.SOUTH, this.startX, this.startY, i, j);
|
|
this.traverseOuterWalls(pieces, placementData2, simpleGrid, Direction.SOUTH, this.startX, this.startY, i, j);
|
|
WoodlandMansionPieces.PlacementData placementData3 = new WoodlandMansionPieces.PlacementData();
|
|
placementData3.position = placementData.position.above(19);
|
|
placementData3.rotation = placementData.rotation;
|
|
placementData3.wallType = "wall_window";
|
|
boolean bl = false;
|
|
|
|
for (int k = 0; k < simpleGrid2.height && !bl; k++) {
|
|
for (int l = simpleGrid2.width - 1; l >= 0 && !bl; l--) {
|
|
if (WoodlandMansionPieces.MansionGrid.isHouse(simpleGrid2, l, k)) {
|
|
placementData3.position = placementData3.position.relative(rotation.rotate(Direction.SOUTH), 8 + (k - this.startY) * 8);
|
|
placementData3.position = placementData3.position.relative(rotation.rotate(Direction.EAST), (l - this.startX) * 8);
|
|
this.traverseWallPiece(pieces, placementData3);
|
|
this.traverseOuterWalls(pieces, placementData3, simpleGrid2, Direction.SOUTH, l, k, l, k);
|
|
bl = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
this.createRoof(pieces, pos.above(16), rotation, simpleGrid, simpleGrid2);
|
|
this.createRoof(pieces, pos.above(27), rotation, simpleGrid2, null);
|
|
if (!pieces.isEmpty()) {
|
|
}
|
|
|
|
WoodlandMansionPieces.FloorRoomCollection[] floorRoomCollections = new WoodlandMansionPieces.FloorRoomCollection[]{
|
|
new WoodlandMansionPieces.FirstFloorRoomCollection(),
|
|
new WoodlandMansionPieces.SecondFloorRoomCollection(),
|
|
new WoodlandMansionPieces.ThirdFloorRoomCollection()
|
|
};
|
|
|
|
for (int lx = 0; lx < 3; lx++) {
|
|
BlockPos blockPos = pos.above(8 * lx + (lx == 2 ? 3 : 0));
|
|
WoodlandMansionPieces.SimpleGrid simpleGrid3 = grid.floorRooms[lx];
|
|
WoodlandMansionPieces.SimpleGrid simpleGrid4 = lx == 2 ? simpleGrid2 : simpleGrid;
|
|
String string = lx == 0 ? "carpet_south_1" : "carpet_south_2";
|
|
String string2 = lx == 0 ? "carpet_west_1" : "carpet_west_2";
|
|
|
|
for (int m = 0; m < simpleGrid4.height; m++) {
|
|
for (int n = 0; n < simpleGrid4.width; n++) {
|
|
if (simpleGrid4.get(n, m) == 1) {
|
|
BlockPos blockPos2 = blockPos.relative(rotation.rotate(Direction.SOUTH), 8 + (m - this.startY) * 8);
|
|
blockPos2 = blockPos2.relative(rotation.rotate(Direction.EAST), (n - this.startX) * 8);
|
|
pieces.add(new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, "corridor_floor", blockPos2, rotation));
|
|
if (simpleGrid4.get(n, m - 1) == 1 || (simpleGrid3.get(n, m - 1) & 8388608) == 8388608) {
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, "carpet_north", blockPos2.relative(rotation.rotate(Direction.EAST), 1).above(), rotation
|
|
)
|
|
);
|
|
}
|
|
|
|
if (simpleGrid4.get(n + 1, m) == 1 || (simpleGrid3.get(n + 1, m) & 8388608) == 8388608) {
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager,
|
|
"carpet_east",
|
|
blockPos2.relative(rotation.rotate(Direction.SOUTH), 1).relative(rotation.rotate(Direction.EAST), 5).above(),
|
|
rotation
|
|
)
|
|
);
|
|
}
|
|
|
|
if (simpleGrid4.get(n, m + 1) == 1 || (simpleGrid3.get(n, m + 1) & 8388608) == 8388608) {
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, string, blockPos2.relative(rotation.rotate(Direction.SOUTH), 5).relative(rotation.rotate(Direction.WEST), 1), rotation
|
|
)
|
|
);
|
|
}
|
|
|
|
if (simpleGrid4.get(n - 1, m) == 1 || (simpleGrid3.get(n - 1, m) & 8388608) == 8388608) {
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager,
|
|
string2,
|
|
blockPos2.relative(rotation.rotate(Direction.WEST), 1).relative(rotation.rotate(Direction.NORTH), 1),
|
|
rotation
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
String string3 = lx == 0 ? "indoors_wall_1" : "indoors_wall_2";
|
|
String string4 = lx == 0 ? "indoors_door_1" : "indoors_door_2";
|
|
List<Direction> list = Lists.<Direction>newArrayList();
|
|
|
|
for (int o = 0; o < simpleGrid4.height; o++) {
|
|
for (int p = 0; p < simpleGrid4.width; p++) {
|
|
boolean bl2 = lx == 2 && simpleGrid4.get(p, o) == 3;
|
|
if (simpleGrid4.get(p, o) == 2 || bl2) {
|
|
int q = simpleGrid3.get(p, o);
|
|
int r = q & 983040;
|
|
int s = q & 65535;
|
|
bl2 = bl2 && (q & 8388608) == 8388608;
|
|
list.clear();
|
|
if ((q & 2097152) == 2097152) {
|
|
for (Direction direction : Direction.Plane.HORIZONTAL) {
|
|
if (simpleGrid4.get(p + direction.getStepX(), o + direction.getStepZ()) == 1) {
|
|
list.add(direction);
|
|
}
|
|
}
|
|
}
|
|
|
|
Direction direction2 = null;
|
|
if (!list.isEmpty()) {
|
|
direction2 = (Direction)list.get(this.random.nextInt(list.size()));
|
|
} else if ((q & 1048576) == 1048576) {
|
|
direction2 = Direction.UP;
|
|
}
|
|
|
|
BlockPos blockPos3 = blockPos.relative(rotation.rotate(Direction.SOUTH), 8 + (o - this.startY) * 8);
|
|
blockPos3 = blockPos3.relative(rotation.rotate(Direction.EAST), -1 + (p - this.startX) * 8);
|
|
if (WoodlandMansionPieces.MansionGrid.isHouse(simpleGrid4, p - 1, o) && !grid.isRoomId(simpleGrid4, p - 1, o, lx, s)) {
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, direction2 == Direction.WEST ? string4 : string3, blockPos3, rotation)
|
|
);
|
|
}
|
|
|
|
if (simpleGrid4.get(p + 1, o) == 1 && !bl2) {
|
|
BlockPos blockPos4 = blockPos3.relative(rotation.rotate(Direction.EAST), 8);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, direction2 == Direction.EAST ? string4 : string3, blockPos4, rotation)
|
|
);
|
|
}
|
|
|
|
if (WoodlandMansionPieces.MansionGrid.isHouse(simpleGrid4, p, o + 1) && !grid.isRoomId(simpleGrid4, p, o + 1, lx, s)) {
|
|
BlockPos blockPos4 = blockPos3.relative(rotation.rotate(Direction.SOUTH), 7);
|
|
blockPos4 = blockPos4.relative(rotation.rotate(Direction.EAST), 7);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, direction2 == Direction.SOUTH ? string4 : string3, blockPos4, rotation.getRotated(Rotation.CLOCKWISE_90)
|
|
)
|
|
);
|
|
}
|
|
|
|
if (simpleGrid4.get(p, o - 1) == 1 && !bl2) {
|
|
BlockPos blockPos4 = blockPos3.relative(rotation.rotate(Direction.NORTH), 1);
|
|
blockPos4 = blockPos4.relative(rotation.rotate(Direction.EAST), 7);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, direction2 == Direction.NORTH ? string4 : string3, blockPos4, rotation.getRotated(Rotation.CLOCKWISE_90)
|
|
)
|
|
);
|
|
}
|
|
|
|
if (r == 65536) {
|
|
this.addRoom1x1(pieces, blockPos3, rotation, direction2, floorRoomCollections[lx]);
|
|
} else if (r == 131072 && direction2 != null) {
|
|
Direction direction3 = grid.get1x2RoomDirection(simpleGrid4, p, o, lx, s);
|
|
boolean bl3 = (q & 4194304) == 4194304;
|
|
this.addRoom1x2(pieces, blockPos3, rotation, direction3, direction2, floorRoomCollections[lx], bl3);
|
|
} else if (r == 262144 && direction2 != null && direction2 != Direction.UP) {
|
|
Direction direction3 = direction2.getClockWise();
|
|
if (!grid.isRoomId(simpleGrid4, p + direction3.getStepX(), o + direction3.getStepZ(), lx, s)) {
|
|
direction3 = direction3.getOpposite();
|
|
}
|
|
|
|
this.addRoom2x2(pieces, blockPos3, rotation, direction3, direction2, floorRoomCollections[lx]);
|
|
} else if (r == 262144 && direction2 == Direction.UP) {
|
|
this.addRoom2x2Secret(pieces, blockPos3, rotation, floorRoomCollections[lx]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void traverseOuterWalls(
|
|
List<WoodlandMansionPieces.WoodlandMansionPiece> pieces,
|
|
WoodlandMansionPieces.PlacementData data,
|
|
WoodlandMansionPieces.SimpleGrid layout,
|
|
Direction direction,
|
|
int startX,
|
|
int startY,
|
|
int entranceX,
|
|
int entranceY
|
|
) {
|
|
int i = startX;
|
|
int j = startY;
|
|
Direction direction2 = direction;
|
|
|
|
do {
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, i + direction.getStepX(), j + direction.getStepZ())) {
|
|
this.traverseTurn(pieces, data);
|
|
direction = direction.getClockWise();
|
|
if (i != entranceX || j != entranceY || direction2 != direction) {
|
|
this.traverseWallPiece(pieces, data);
|
|
}
|
|
} else if (WoodlandMansionPieces.MansionGrid.isHouse(layout, i + direction.getStepX(), j + direction.getStepZ())
|
|
&& WoodlandMansionPieces.MansionGrid.isHouse(
|
|
layout, i + direction.getStepX() + direction.getCounterClockWise().getStepX(), j + direction.getStepZ() + direction.getCounterClockWise().getStepZ()
|
|
)) {
|
|
this.traverseInnerTurn(pieces, data);
|
|
i += direction.getStepX();
|
|
j += direction.getStepZ();
|
|
direction = direction.getCounterClockWise();
|
|
} else {
|
|
i += direction.getStepX();
|
|
j += direction.getStepZ();
|
|
if (i != entranceX || j != entranceY || direction2 != direction) {
|
|
this.traverseWallPiece(pieces, data);
|
|
}
|
|
}
|
|
} while (i != entranceX || j != entranceY || direction2 != direction);
|
|
}
|
|
|
|
private void createRoof(
|
|
List<WoodlandMansionPieces.WoodlandMansionPiece> pieces,
|
|
BlockPos pos,
|
|
Rotation rotation,
|
|
WoodlandMansionPieces.SimpleGrid layout,
|
|
@Nullable WoodlandMansionPieces.SimpleGrid nextFloorLayout
|
|
) {
|
|
for (int i = 0; i < layout.height; i++) {
|
|
for (int j = 0; j < layout.width; j++) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.SOUTH), 8 + (i - this.startY) * 8);
|
|
blockPos = blockPos.relative(rotation.rotate(Direction.EAST), (j - this.startX) * 8);
|
|
boolean bl = nextFloorLayout != null && WoodlandMansionPieces.MansionGrid.isHouse(nextFloorLayout, j, i);
|
|
if (WoodlandMansionPieces.MansionGrid.isHouse(layout, j, i) && !bl) {
|
|
pieces.add(new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, "roof", blockPos.above(3), rotation));
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, j + 1, i)) {
|
|
BlockPos blockPos2 = blockPos.relative(rotation.rotate(Direction.EAST), 6);
|
|
pieces.add(new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, "roof_front", blockPos2, rotation));
|
|
}
|
|
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, j - 1, i)) {
|
|
BlockPos blockPos2 = blockPos.relative(rotation.rotate(Direction.EAST), 0);
|
|
blockPos2 = blockPos2.relative(rotation.rotate(Direction.SOUTH), 7);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, "roof_front", blockPos2, rotation.getRotated(Rotation.CLOCKWISE_180))
|
|
);
|
|
}
|
|
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, j, i - 1)) {
|
|
BlockPos blockPos2 = blockPos.relative(rotation.rotate(Direction.WEST), 1);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, "roof_front", blockPos2, rotation.getRotated(Rotation.COUNTERCLOCKWISE_90)
|
|
)
|
|
);
|
|
}
|
|
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, j, i + 1)) {
|
|
BlockPos blockPos2 = blockPos.relative(rotation.rotate(Direction.EAST), 6);
|
|
blockPos2 = blockPos2.relative(rotation.rotate(Direction.SOUTH), 6);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, "roof_front", blockPos2, rotation.getRotated(Rotation.CLOCKWISE_90))
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nextFloorLayout != null) {
|
|
for (int i = 0; i < layout.height; i++) {
|
|
for (int jx = 0; jx < layout.width; jx++) {
|
|
BlockPos var17 = pos.relative(rotation.rotate(Direction.SOUTH), 8 + (i - this.startY) * 8);
|
|
var17 = var17.relative(rotation.rotate(Direction.EAST), (jx - this.startX) * 8);
|
|
boolean bl = WoodlandMansionPieces.MansionGrid.isHouse(nextFloorLayout, jx, i);
|
|
if (WoodlandMansionPieces.MansionGrid.isHouse(layout, jx, i) && bl) {
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jx + 1, i)) {
|
|
BlockPos blockPos2 = var17.relative(rotation.rotate(Direction.EAST), 7);
|
|
pieces.add(new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, "small_wall", blockPos2, rotation));
|
|
}
|
|
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jx - 1, i)) {
|
|
BlockPos blockPos2 = var17.relative(rotation.rotate(Direction.WEST), 1);
|
|
blockPos2 = blockPos2.relative(rotation.rotate(Direction.SOUTH), 6);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, "small_wall", blockPos2, rotation.getRotated(Rotation.CLOCKWISE_180))
|
|
);
|
|
}
|
|
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jx, i - 1)) {
|
|
BlockPos blockPos2 = var17.relative(rotation.rotate(Direction.WEST), 0);
|
|
blockPos2 = blockPos2.relative(rotation.rotate(Direction.NORTH), 1);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, "small_wall", blockPos2, rotation.getRotated(Rotation.COUNTERCLOCKWISE_90)
|
|
)
|
|
);
|
|
}
|
|
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jx, i + 1)) {
|
|
BlockPos blockPos2 = var17.relative(rotation.rotate(Direction.EAST), 6);
|
|
blockPos2 = blockPos2.relative(rotation.rotate(Direction.SOUTH), 7);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, "small_wall", blockPos2, rotation.getRotated(Rotation.CLOCKWISE_90))
|
|
);
|
|
}
|
|
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jx + 1, i)) {
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jx, i - 1)) {
|
|
BlockPos blockPos2 = var17.relative(rotation.rotate(Direction.EAST), 7);
|
|
blockPos2 = blockPos2.relative(rotation.rotate(Direction.NORTH), 2);
|
|
pieces.add(new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, "small_wall_corner", blockPos2, rotation));
|
|
}
|
|
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jx, i + 1)) {
|
|
BlockPos blockPos2 = var17.relative(rotation.rotate(Direction.EAST), 8);
|
|
blockPos2 = blockPos2.relative(rotation.rotate(Direction.SOUTH), 7);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, "small_wall_corner", blockPos2, rotation.getRotated(Rotation.CLOCKWISE_90)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jx - 1, i)) {
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jx, i - 1)) {
|
|
BlockPos blockPos2 = var17.relative(rotation.rotate(Direction.WEST), 2);
|
|
blockPos2 = blockPos2.relative(rotation.rotate(Direction.NORTH), 1);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, "small_wall_corner", blockPos2, rotation.getRotated(Rotation.COUNTERCLOCKWISE_90)
|
|
)
|
|
);
|
|
}
|
|
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jx, i + 1)) {
|
|
BlockPos blockPos2 = var17.relative(rotation.rotate(Direction.WEST), 1);
|
|
blockPos2 = blockPos2.relative(rotation.rotate(Direction.SOUTH), 8);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, "small_wall_corner", blockPos2, rotation.getRotated(Rotation.CLOCKWISE_180)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < layout.height; i++) {
|
|
for (int jxx = 0; jxx < layout.width; jxx++) {
|
|
BlockPos var19 = pos.relative(rotation.rotate(Direction.SOUTH), 8 + (i - this.startY) * 8);
|
|
var19 = var19.relative(rotation.rotate(Direction.EAST), (jxx - this.startX) * 8);
|
|
boolean bl = nextFloorLayout != null && WoodlandMansionPieces.MansionGrid.isHouse(nextFloorLayout, jxx, i);
|
|
if (WoodlandMansionPieces.MansionGrid.isHouse(layout, jxx, i) && !bl) {
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jxx + 1, i)) {
|
|
BlockPos blockPos2 = var19.relative(rotation.rotate(Direction.EAST), 6);
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jxx, i + 1)) {
|
|
BlockPos blockPos3 = blockPos2.relative(rotation.rotate(Direction.SOUTH), 6);
|
|
pieces.add(new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, "roof_corner", blockPos3, rotation));
|
|
} else if (WoodlandMansionPieces.MansionGrid.isHouse(layout, jxx + 1, i + 1)) {
|
|
BlockPos blockPos3 = blockPos2.relative(rotation.rotate(Direction.SOUTH), 5);
|
|
pieces.add(new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, "roof_inner_corner", blockPos3, rotation));
|
|
}
|
|
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jxx, i - 1)) {
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, "roof_corner", blockPos2, rotation.getRotated(Rotation.COUNTERCLOCKWISE_90)
|
|
)
|
|
);
|
|
} else if (WoodlandMansionPieces.MansionGrid.isHouse(layout, jxx + 1, i - 1)) {
|
|
BlockPos blockPos3 = var19.relative(rotation.rotate(Direction.EAST), 9);
|
|
blockPos3 = blockPos3.relative(rotation.rotate(Direction.NORTH), 2);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, "roof_inner_corner", blockPos3, rotation.getRotated(Rotation.CLOCKWISE_90)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jxx - 1, i)) {
|
|
BlockPos blockPos2x = var19.relative(rotation.rotate(Direction.EAST), 0);
|
|
blockPos2x = blockPos2x.relative(rotation.rotate(Direction.SOUTH), 0);
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jxx, i + 1)) {
|
|
BlockPos blockPos3 = blockPos2x.relative(rotation.rotate(Direction.SOUTH), 6);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, "roof_corner", blockPos3, rotation.getRotated(Rotation.CLOCKWISE_90))
|
|
);
|
|
} else if (WoodlandMansionPieces.MansionGrid.isHouse(layout, jxx - 1, i + 1)) {
|
|
BlockPos blockPos3 = blockPos2x.relative(rotation.rotate(Direction.SOUTH), 8);
|
|
blockPos3 = blockPos3.relative(rotation.rotate(Direction.WEST), 3);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, "roof_inner_corner", blockPos3, rotation.getRotated(Rotation.COUNTERCLOCKWISE_90)
|
|
)
|
|
);
|
|
}
|
|
|
|
if (!WoodlandMansionPieces.MansionGrid.isHouse(layout, jxx, i - 1)) {
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, "roof_corner", blockPos2x, rotation.getRotated(Rotation.CLOCKWISE_180))
|
|
);
|
|
} else if (WoodlandMansionPieces.MansionGrid.isHouse(layout, jxx - 1, i - 1)) {
|
|
BlockPos blockPos3 = blockPos2x.relative(rotation.rotate(Direction.SOUTH), 1);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, "roof_inner_corner", blockPos3, rotation.getRotated(Rotation.CLOCKWISE_180)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void entrance(List<WoodlandMansionPieces.WoodlandMansionPiece> pieces, WoodlandMansionPieces.PlacementData data) {
|
|
Direction direction = data.rotation.rotate(Direction.WEST);
|
|
pieces.add(new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, "entrance", data.position.relative(direction, 9), data.rotation));
|
|
data.position = data.position.relative(data.rotation.rotate(Direction.SOUTH), 16);
|
|
}
|
|
|
|
private void traverseWallPiece(List<WoodlandMansionPieces.WoodlandMansionPiece> pieces, WoodlandMansionPieces.PlacementData data) {
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, data.wallType, data.position.relative(data.rotation.rotate(Direction.EAST), 7), data.rotation
|
|
)
|
|
);
|
|
data.position = data.position.relative(data.rotation.rotate(Direction.SOUTH), 8);
|
|
}
|
|
|
|
private void traverseTurn(List<WoodlandMansionPieces.WoodlandMansionPiece> pieces, WoodlandMansionPieces.PlacementData data) {
|
|
data.position = data.position.relative(data.rotation.rotate(Direction.SOUTH), -1);
|
|
pieces.add(new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, "wall_corner", data.position, data.rotation));
|
|
data.position = data.position.relative(data.rotation.rotate(Direction.SOUTH), -7);
|
|
data.position = data.position.relative(data.rotation.rotate(Direction.WEST), -6);
|
|
data.rotation = data.rotation.getRotated(Rotation.CLOCKWISE_90);
|
|
}
|
|
|
|
private void traverseInnerTurn(List<WoodlandMansionPieces.WoodlandMansionPiece> pieces, WoodlandMansionPieces.PlacementData data) {
|
|
data.position = data.position.relative(data.rotation.rotate(Direction.SOUTH), 6);
|
|
data.position = data.position.relative(data.rotation.rotate(Direction.EAST), 8);
|
|
data.rotation = data.rotation.getRotated(Rotation.COUNTERCLOCKWISE_90);
|
|
}
|
|
|
|
private void addRoom1x1(
|
|
List<WoodlandMansionPieces.WoodlandMansionPiece> pieces,
|
|
BlockPos pos,
|
|
Rotation rotation,
|
|
Direction direction,
|
|
WoodlandMansionPieces.FloorRoomCollection floorRooms
|
|
) {
|
|
Rotation rotation2 = Rotation.NONE;
|
|
String string = floorRooms.get1x1(this.random);
|
|
if (direction != Direction.EAST) {
|
|
if (direction == Direction.NORTH) {
|
|
rotation2 = rotation2.getRotated(Rotation.COUNTERCLOCKWISE_90);
|
|
} else if (direction == Direction.WEST) {
|
|
rotation2 = rotation2.getRotated(Rotation.CLOCKWISE_180);
|
|
} else if (direction == Direction.SOUTH) {
|
|
rotation2 = rotation2.getRotated(Rotation.CLOCKWISE_90);
|
|
} else {
|
|
string = floorRooms.get1x1Secret(this.random);
|
|
}
|
|
}
|
|
|
|
BlockPos blockPos = StructureTemplate.getZeroPositionWithTransform(new BlockPos(1, 0, 0), Mirror.NONE, rotation2, 7, 7);
|
|
rotation2 = rotation2.getRotated(rotation);
|
|
blockPos = blockPos.rotate(rotation);
|
|
BlockPos blockPos2 = pos.offset(blockPos.getX(), 0, blockPos.getZ());
|
|
pieces.add(new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, string, blockPos2, rotation2));
|
|
}
|
|
|
|
private void addRoom1x2(
|
|
List<WoodlandMansionPieces.WoodlandMansionPiece> pieces,
|
|
BlockPos pos,
|
|
Rotation rotation,
|
|
Direction frontDirection,
|
|
Direction sideDirection,
|
|
WoodlandMansionPieces.FloorRoomCollection floorRooms,
|
|
boolean isStairs
|
|
) {
|
|
if (sideDirection == Direction.EAST && frontDirection == Direction.SOUTH) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.EAST), 1);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, floorRooms.get1x2SideEntrance(this.random, isStairs), blockPos, rotation)
|
|
);
|
|
} else if (sideDirection == Direction.EAST && frontDirection == Direction.NORTH) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.EAST), 1);
|
|
blockPos = blockPos.relative(rotation.rotate(Direction.SOUTH), 6);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, floorRooms.get1x2SideEntrance(this.random, isStairs), blockPos, rotation, Mirror.LEFT_RIGHT
|
|
)
|
|
);
|
|
} else if (sideDirection == Direction.WEST && frontDirection == Direction.NORTH) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.EAST), 7);
|
|
blockPos = blockPos.relative(rotation.rotate(Direction.SOUTH), 6);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, floorRooms.get1x2SideEntrance(this.random, isStairs), blockPos, rotation.getRotated(Rotation.CLOCKWISE_180)
|
|
)
|
|
);
|
|
} else if (sideDirection == Direction.WEST && frontDirection == Direction.SOUTH) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.EAST), 7);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, floorRooms.get1x2SideEntrance(this.random, isStairs), blockPos, rotation, Mirror.FRONT_BACK
|
|
)
|
|
);
|
|
} else if (sideDirection == Direction.SOUTH && frontDirection == Direction.EAST) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.EAST), 1);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager,
|
|
floorRooms.get1x2SideEntrance(this.random, isStairs),
|
|
blockPos,
|
|
rotation.getRotated(Rotation.CLOCKWISE_90),
|
|
Mirror.LEFT_RIGHT
|
|
)
|
|
);
|
|
} else if (sideDirection == Direction.SOUTH && frontDirection == Direction.WEST) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.EAST), 7);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, floorRooms.get1x2SideEntrance(this.random, isStairs), blockPos, rotation.getRotated(Rotation.CLOCKWISE_90)
|
|
)
|
|
);
|
|
} else if (sideDirection == Direction.NORTH && frontDirection == Direction.WEST) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.EAST), 7);
|
|
blockPos = blockPos.relative(rotation.rotate(Direction.SOUTH), 6);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager,
|
|
floorRooms.get1x2SideEntrance(this.random, isStairs),
|
|
blockPos,
|
|
rotation.getRotated(Rotation.CLOCKWISE_90),
|
|
Mirror.FRONT_BACK
|
|
)
|
|
);
|
|
} else if (sideDirection == Direction.NORTH && frontDirection == Direction.EAST) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.EAST), 1);
|
|
blockPos = blockPos.relative(rotation.rotate(Direction.SOUTH), 6);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, floorRooms.get1x2SideEntrance(this.random, isStairs), blockPos, rotation.getRotated(Rotation.COUNTERCLOCKWISE_90)
|
|
)
|
|
);
|
|
} else if (sideDirection == Direction.SOUTH && frontDirection == Direction.NORTH) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.EAST), 1);
|
|
blockPos = blockPos.relative(rotation.rotate(Direction.NORTH), 8);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, floorRooms.get1x2FrontEntrance(this.random, isStairs), blockPos, rotation)
|
|
);
|
|
} else if (sideDirection == Direction.NORTH && frontDirection == Direction.SOUTH) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.EAST), 7);
|
|
blockPos = blockPos.relative(rotation.rotate(Direction.SOUTH), 14);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, floorRooms.get1x2FrontEntrance(this.random, isStairs), blockPos, rotation.getRotated(Rotation.CLOCKWISE_180)
|
|
)
|
|
);
|
|
} else if (sideDirection == Direction.WEST && frontDirection == Direction.EAST) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.EAST), 15);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, floorRooms.get1x2FrontEntrance(this.random, isStairs), blockPos, rotation.getRotated(Rotation.CLOCKWISE_90)
|
|
)
|
|
);
|
|
} else if (sideDirection == Direction.EAST && frontDirection == Direction.WEST) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.WEST), 7);
|
|
blockPos = blockPos.relative(rotation.rotate(Direction.SOUTH), 6);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, floorRooms.get1x2FrontEntrance(this.random, isStairs), blockPos, rotation.getRotated(Rotation.COUNTERCLOCKWISE_90)
|
|
)
|
|
);
|
|
} else if (sideDirection == Direction.UP && frontDirection == Direction.EAST) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.EAST), 15);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(
|
|
this.structureTemplateManager, floorRooms.get1x2Secret(this.random), blockPos, rotation.getRotated(Rotation.CLOCKWISE_90)
|
|
)
|
|
);
|
|
} else if (sideDirection == Direction.UP && frontDirection == Direction.SOUTH) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.EAST), 1);
|
|
blockPos = blockPos.relative(rotation.rotate(Direction.NORTH), 0);
|
|
pieces.add(new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, floorRooms.get1x2Secret(this.random), blockPos, rotation));
|
|
}
|
|
}
|
|
|
|
private void addRoom2x2(
|
|
List<WoodlandMansionPieces.WoodlandMansionPiece> pieces,
|
|
BlockPos pos,
|
|
Rotation rotation,
|
|
Direction frontDirection,
|
|
Direction sideDirection,
|
|
WoodlandMansionPieces.FloorRoomCollection floorRooms
|
|
) {
|
|
int i = 0;
|
|
int j = 0;
|
|
Rotation rotation2 = rotation;
|
|
Mirror mirror = Mirror.NONE;
|
|
if (sideDirection == Direction.EAST && frontDirection == Direction.SOUTH) {
|
|
i = -7;
|
|
} else if (sideDirection == Direction.EAST && frontDirection == Direction.NORTH) {
|
|
i = -7;
|
|
j = 6;
|
|
mirror = Mirror.LEFT_RIGHT;
|
|
} else if (sideDirection == Direction.NORTH && frontDirection == Direction.EAST) {
|
|
i = 1;
|
|
j = 14;
|
|
rotation2 = rotation.getRotated(Rotation.COUNTERCLOCKWISE_90);
|
|
} else if (sideDirection == Direction.NORTH && frontDirection == Direction.WEST) {
|
|
i = 7;
|
|
j = 14;
|
|
rotation2 = rotation.getRotated(Rotation.COUNTERCLOCKWISE_90);
|
|
mirror = Mirror.LEFT_RIGHT;
|
|
} else if (sideDirection == Direction.SOUTH && frontDirection == Direction.WEST) {
|
|
i = 7;
|
|
j = -8;
|
|
rotation2 = rotation.getRotated(Rotation.CLOCKWISE_90);
|
|
} else if (sideDirection == Direction.SOUTH && frontDirection == Direction.EAST) {
|
|
i = 1;
|
|
j = -8;
|
|
rotation2 = rotation.getRotated(Rotation.CLOCKWISE_90);
|
|
mirror = Mirror.LEFT_RIGHT;
|
|
} else if (sideDirection == Direction.WEST && frontDirection == Direction.NORTH) {
|
|
i = 15;
|
|
j = 6;
|
|
rotation2 = rotation.getRotated(Rotation.CLOCKWISE_180);
|
|
} else if (sideDirection == Direction.WEST && frontDirection == Direction.SOUTH) {
|
|
i = 15;
|
|
mirror = Mirror.FRONT_BACK;
|
|
}
|
|
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.EAST), i);
|
|
blockPos = blockPos.relative(rotation.rotate(Direction.SOUTH), j);
|
|
pieces.add(new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, floorRooms.get2x2(this.random), blockPos, rotation2, mirror));
|
|
}
|
|
|
|
private void addRoom2x2Secret(
|
|
List<WoodlandMansionPieces.WoodlandMansionPiece> pieces, BlockPos pos, Rotation rotation, WoodlandMansionPieces.FloorRoomCollection floorRooms
|
|
) {
|
|
BlockPos blockPos = pos.relative(rotation.rotate(Direction.EAST), 1);
|
|
pieces.add(
|
|
new WoodlandMansionPieces.WoodlandMansionPiece(this.structureTemplateManager, floorRooms.get2x2Secret(this.random), blockPos, rotation, Mirror.NONE)
|
|
);
|
|
}
|
|
}
|
|
|
|
static class PlacementData {
|
|
public Rotation rotation;
|
|
public BlockPos position;
|
|
public String wallType;
|
|
}
|
|
|
|
static class SecondFloorRoomCollection extends WoodlandMansionPieces.FloorRoomCollection {
|
|
@Override
|
|
public String get1x1(RandomSource random) {
|
|
return "1x1_b" + (random.nextInt(4) + 1);
|
|
}
|
|
|
|
@Override
|
|
public String get1x1Secret(RandomSource random) {
|
|
return "1x1_as" + (random.nextInt(4) + 1);
|
|
}
|
|
|
|
@Override
|
|
public String get1x2SideEntrance(RandomSource random, boolean isStairs) {
|
|
return isStairs ? "1x2_c_stairs" : "1x2_c" + (random.nextInt(4) + 1);
|
|
}
|
|
|
|
@Override
|
|
public String get1x2FrontEntrance(RandomSource random, boolean isStairs) {
|
|
return isStairs ? "1x2_d_stairs" : "1x2_d" + (random.nextInt(5) + 1);
|
|
}
|
|
|
|
@Override
|
|
public String get1x2Secret(RandomSource random) {
|
|
return "1x2_se" + (random.nextInt(1) + 1);
|
|
}
|
|
|
|
@Override
|
|
public String get2x2(RandomSource random) {
|
|
return "2x2_b" + (random.nextInt(5) + 1);
|
|
}
|
|
|
|
@Override
|
|
public String get2x2Secret(RandomSource random) {
|
|
return "2x2_s1";
|
|
}
|
|
}
|
|
|
|
static class SimpleGrid {
|
|
private final int[][] grid;
|
|
final int width;
|
|
final int height;
|
|
private final int valueIfOutside;
|
|
|
|
public SimpleGrid(int width, int height, int valueIfOutside) {
|
|
this.width = width;
|
|
this.height = height;
|
|
this.valueIfOutside = valueIfOutside;
|
|
this.grid = new int[width][height];
|
|
}
|
|
|
|
public void set(int x, int y, int value) {
|
|
if (x >= 0 && x < this.width && y >= 0 && y < this.height) {
|
|
this.grid[x][y] = value;
|
|
}
|
|
}
|
|
|
|
public void set(int minX, int minY, int maxX, int maxY, int value) {
|
|
for (int i = minY; i <= maxY; i++) {
|
|
for (int j = minX; j <= maxX; j++) {
|
|
this.set(j, i, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public int get(int x, int y) {
|
|
return x >= 0 && x < this.width && y >= 0 && y < this.height ? this.grid[x][y] : this.valueIfOutside;
|
|
}
|
|
|
|
public void setif(int x, int y, int oldValue, int newValue) {
|
|
if (this.get(x, y) == oldValue) {
|
|
this.set(x, y, newValue);
|
|
}
|
|
}
|
|
|
|
public boolean edgesTo(int x, int y, int expectedValue) {
|
|
return this.get(x - 1, y) == expectedValue
|
|
|| this.get(x + 1, y) == expectedValue
|
|
|| this.get(x, y + 1) == expectedValue
|
|
|| this.get(x, y - 1) == expectedValue;
|
|
}
|
|
}
|
|
|
|
static class ThirdFloorRoomCollection extends WoodlandMansionPieces.SecondFloorRoomCollection {
|
|
}
|
|
|
|
public static class WoodlandMansionPiece extends TemplateStructurePiece {
|
|
public WoodlandMansionPiece(StructureTemplateManager structureTemplateManager, String templateName, BlockPos templatePosition, Rotation rotation) {
|
|
this(structureTemplateManager, templateName, templatePosition, rotation, Mirror.NONE);
|
|
}
|
|
|
|
public WoodlandMansionPiece(
|
|
StructureTemplateManager structureTemplateManager, String templateName, BlockPos templatePosition, Rotation rotation, Mirror mirror
|
|
) {
|
|
super(
|
|
StructurePieceType.WOODLAND_MANSION_PIECE,
|
|
0,
|
|
structureTemplateManager,
|
|
makeLocation(templateName),
|
|
templateName,
|
|
makeSettings(mirror, rotation),
|
|
templatePosition
|
|
);
|
|
}
|
|
|
|
public WoodlandMansionPiece(StructureTemplateManager structureTemplateManager, CompoundTag tag) {
|
|
super(
|
|
StructurePieceType.WOODLAND_MANSION_PIECE,
|
|
tag,
|
|
structureTemplateManager,
|
|
resourceLocation -> makeSettings((Mirror)tag.read("Mi", Mirror.LEGACY_CODEC).orElseThrow(), (Rotation)tag.read("Rot", Rotation.LEGACY_CODEC).orElseThrow())
|
|
);
|
|
}
|
|
|
|
@Override
|
|
protected ResourceLocation makeTemplateLocation() {
|
|
return makeLocation(this.templateName);
|
|
}
|
|
|
|
private static ResourceLocation makeLocation(String name) {
|
|
return ResourceLocation.withDefaultNamespace("woodland_mansion/" + name);
|
|
}
|
|
|
|
private static StructurePlaceSettings makeSettings(Mirror mirror, Rotation rotation) {
|
|
return new StructurePlaceSettings().setIgnoreEntities(true).setRotation(rotation).setMirror(mirror).addProcessor(BlockIgnoreProcessor.STRUCTURE_BLOCK);
|
|
}
|
|
|
|
@Override
|
|
protected void addAdditionalSaveData(StructurePieceSerializationContext context, CompoundTag tag) {
|
|
super.addAdditionalSaveData(context, tag);
|
|
tag.store("Rot", Rotation.LEGACY_CODEC, this.placeSettings.getRotation());
|
|
tag.store("Mi", Mirror.LEGACY_CODEC, this.placeSettings.getMirror());
|
|
}
|
|
|
|
@Override
|
|
protected void handleDataMarker(String name, BlockPos pos, ServerLevelAccessor level, RandomSource random, BoundingBox box) {
|
|
if (name.startsWith("Chest")) {
|
|
Rotation rotation = this.placeSettings.getRotation();
|
|
BlockState blockState = Blocks.CHEST.defaultBlockState();
|
|
if ("ChestWest".equals(name)) {
|
|
blockState = blockState.setValue(ChestBlock.FACING, rotation.rotate(Direction.WEST));
|
|
} else if ("ChestEast".equals(name)) {
|
|
blockState = blockState.setValue(ChestBlock.FACING, rotation.rotate(Direction.EAST));
|
|
} else if ("ChestSouth".equals(name)) {
|
|
blockState = blockState.setValue(ChestBlock.FACING, rotation.rotate(Direction.SOUTH));
|
|
} else if ("ChestNorth".equals(name)) {
|
|
blockState = blockState.setValue(ChestBlock.FACING, rotation.rotate(Direction.NORTH));
|
|
}
|
|
|
|
this.createChest(level, box, random, pos, BuiltInLootTables.WOODLAND_MANSION, blockState);
|
|
} else {
|
|
List<Mob> list = new ArrayList();
|
|
switch (name) {
|
|
case "Mage":
|
|
list.add(EntityType.EVOKER.create(level.getLevel(), EntitySpawnReason.STRUCTURE));
|
|
break;
|
|
case "Warrior":
|
|
list.add(EntityType.VINDICATOR.create(level.getLevel(), EntitySpawnReason.STRUCTURE));
|
|
break;
|
|
case "Group of Allays":
|
|
int i = level.getRandom().nextInt(3) + 1;
|
|
|
|
for (int j = 0; j < i; j++) {
|
|
list.add(EntityType.ALLAY.create(level.getLevel(), EntitySpawnReason.STRUCTURE));
|
|
}
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
for (Mob mob : list) {
|
|
if (mob != null) {
|
|
mob.setPersistenceRequired();
|
|
mob.snapTo(pos, 0.0F, 0.0F);
|
|
mob.finalizeSpawn(level, level.getCurrentDifficultyAt(mob.blockPosition()), EntitySpawnReason.STRUCTURE, null);
|
|
level.addFreshEntityWithPassengers(mob);
|
|
level.setBlock(pos, Blocks.AIR.defaultBlockState(), 2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|