mirrors/Terra
1
0
Fork 0
mirror of https://github.com/PolyhedralDev/Terra.git synced 2026-04-20 07:10:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

convert to new expression switches

Browse Source
This commit is contained in:
dfsek
2021-05-15 21:24:58 -07:00
parent ad41c9bd7d
commit 712df89064
41 changed files with 639 additions and 1339 deletions
Download Patch File Download Diff File Expand all files Collapse all files

354
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/BukkitAdapter.java
View File

@@ -50,20 +50,13 @@ public final class BukkitAdapter {
public static Stairs.Shape adapt(org.bukkit.block.data.type.Stairs.Shape shape) {
switch(shape) {
case STRAIGHT:
return Stairs.Shape.STRAIGHT;
case INNER_LEFT:
return Stairs.Shape.INNER_LEFT;
case OUTER_LEFT:
return Stairs.Shape.OUTER_LEFT;
case INNER_RIGHT:
return Stairs.Shape.INNER_RIGHT;
case OUTER_RIGHT:
return Stairs.Shape.OUTER_RIGHT;
default:
throw new IllegalStateException();
}
return switch(shape) {
case STRAIGHT -> Stairs.Shape.STRAIGHT;
case INNER_LEFT -> Stairs.Shape.INNER_LEFT;
case OUTER_LEFT -> Stairs.Shape.OUTER_LEFT;
case INNER_RIGHT -> Stairs.Shape.INNER_RIGHT;
case OUTER_RIGHT -> Stairs.Shape.OUTER_RIGHT;
};
}
public static BlockData adapt(org.bukkit.block.data.BlockData data) {
@@ -75,265 +68,154 @@ public final class BukkitAdapter {
}
public static Axis adapt(org.bukkit.Axis axis) {
switch(axis) {
case X:
return Axis.X;
case Y:
return Axis.Y;
case Z:
return Axis.Z;
default:
throw new IllegalStateException();
}
return switch(axis) {
case X -> Axis.X;
case Y -> Axis.Y;
case Z -> Axis.Z;
};
}
public static Bisected.Half adapt(org.bukkit.block.data.Bisected.Half half) {
switch(half) {
case BOTTOM:
return Bisected.Half.BOTTOM;
case TOP:
return Bisected.Half.TOP;
default:
throw new IllegalStateException();
}
return switch(half) {
case BOTTOM -> Bisected.Half.BOTTOM;
case TOP -> Bisected.Half.TOP;
};
}
public static BlockFace adapt(org.bukkit.block.BlockFace face) {
switch(face) {
case DOWN:
return BlockFace.DOWN;
case UP:
return BlockFace.UP;
case NORTH_WEST:
return BlockFace.NORTH_WEST;
case NORTH_EAST:
return BlockFace.NORTH_EAST;
case SOUTH_EAST:
return BlockFace.SOUTH_EAST;
case SOUTH_WEST:
return BlockFace.SOUTH_WEST;
case NORTH_NORTH_WEST:
return BlockFace.NORTH_NORTH_WEST;
case WEST_NORTH_WEST:
return BlockFace.WEST_NORTH_WEST;
case WEST_SOUTH_WEST:
return BlockFace.WEST_SOUTH_WEST;
case SOUTH_SOUTH_WEST:
return BlockFace.SOUTH_SOUTH_WEST;
case EAST_NORTH_EAST:
return BlockFace.EAST_NORTH_EAST;
case WEST:
return BlockFace.WEST;
case SOUTH:
return BlockFace.SOUTH;
case EAST:
return BlockFace.EAST;
case NORTH:
return BlockFace.NORTH;
case SELF:
return BlockFace.SELF;
case EAST_SOUTH_EAST:
return BlockFace.EAST_SOUTH_EAST;
case NORTH_NORTH_EAST:
return BlockFace.NORTH_NORTH_EAST;
case SOUTH_SOUTH_EAST:
return BlockFace.SOUTH_SOUTH_EAST;
default:
throw new IllegalStateException();
}
return switch(face) {
case DOWN -> BlockFace.DOWN;
case UP -> BlockFace.UP;
case NORTH_WEST -> BlockFace.NORTH_WEST;
case NORTH_EAST -> BlockFace.NORTH_EAST;
case SOUTH_EAST -> BlockFace.SOUTH_EAST;
case SOUTH_WEST -> BlockFace.SOUTH_WEST;
case NORTH_NORTH_WEST -> BlockFace.NORTH_NORTH_WEST;
case WEST_NORTH_WEST -> BlockFace.WEST_NORTH_WEST;
case WEST_SOUTH_WEST -> BlockFace.WEST_SOUTH_WEST;
case SOUTH_SOUTH_WEST -> BlockFace.SOUTH_SOUTH_WEST;
case EAST_NORTH_EAST -> BlockFace.EAST_NORTH_EAST;
case WEST -> BlockFace.WEST;
case SOUTH -> BlockFace.SOUTH;
case EAST -> BlockFace.EAST;
case NORTH -> BlockFace.NORTH;
case SELF -> BlockFace.SELF;
case EAST_SOUTH_EAST -> BlockFace.EAST_SOUTH_EAST;
case NORTH_NORTH_EAST -> BlockFace.NORTH_NORTH_EAST;
case SOUTH_SOUTH_EAST -> BlockFace.SOUTH_SOUTH_EAST;
};
}
public static Slab.Type adapt(org.bukkit.block.data.type.Slab.Type type) {
switch(type) {
case BOTTOM:
return Slab.Type.BOTTOM;
case TOP:
return Slab.Type.TOP;
case DOUBLE:
return Slab.Type.DOUBLE;
default:
throw new IllegalStateException();
}
return switch(type) {
case BOTTOM -> Slab.Type.BOTTOM;
case TOP -> Slab.Type.TOP;
case DOUBLE -> Slab.Type.DOUBLE;
};
}
public static RedstoneWire.Connection adapt(org.bukkit.block.data.type.RedstoneWire.Connection connection) {
switch(connection) {
case NONE:
return RedstoneWire.Connection.NONE;
case UP:
return RedstoneWire.Connection.UP;
case SIDE:
return RedstoneWire.Connection.SIDE;
default:
throw new IllegalStateException();
}
return switch(connection) {
case NONE -> RedstoneWire.Connection.NONE;
case UP -> RedstoneWire.Connection.UP;
case SIDE -> RedstoneWire.Connection.SIDE;
};
}
public static org.bukkit.block.data.type.RedstoneWire.Connection adapt(RedstoneWire.Connection connection) {
switch(connection) {
case SIDE:
return org.bukkit.block.data.type.RedstoneWire.Connection.SIDE;
case UP:
return org.bukkit.block.data.type.RedstoneWire.Connection.UP;
case NONE:
return org.bukkit.block.data.type.RedstoneWire.Connection.NONE;
default:
throw new IllegalStateException();
}
return switch(connection) {
case SIDE -> org.bukkit.block.data.type.RedstoneWire.Connection.SIDE;
case UP -> org.bukkit.block.data.type.RedstoneWire.Connection.UP;
case NONE -> org.bukkit.block.data.type.RedstoneWire.Connection.NONE;
};
}
public static org.bukkit.block.data.type.Stairs.Shape adapt(Stairs.Shape shape) {
switch(shape) {
case STRAIGHT:
return org.bukkit.block.data.type.Stairs.Shape.STRAIGHT;
case INNER_LEFT:
return org.bukkit.block.data.type.Stairs.Shape.INNER_LEFT;
case OUTER_LEFT:
return org.bukkit.block.data.type.Stairs.Shape.OUTER_LEFT;
case INNER_RIGHT:
return org.bukkit.block.data.type.Stairs.Shape.INNER_RIGHT;
case OUTER_RIGHT:
return org.bukkit.block.data.type.Stairs.Shape.OUTER_RIGHT;
default:
throw new IllegalStateException();
}
return switch(shape) {
case STRAIGHT -> org.bukkit.block.data.type.Stairs.Shape.STRAIGHT;
case INNER_LEFT -> org.bukkit.block.data.type.Stairs.Shape.INNER_LEFT;
case OUTER_LEFT -> org.bukkit.block.data.type.Stairs.Shape.OUTER_LEFT;
case INNER_RIGHT -> org.bukkit.block.data.type.Stairs.Shape.INNER_RIGHT;
case OUTER_RIGHT -> org.bukkit.block.data.type.Stairs.Shape.OUTER_RIGHT;
};
}
public static Rail.Shape adapt(org.bukkit.block.data.Rail.Shape shape) {
switch(shape) {
case SOUTH_WEST:
return Rail.Shape.SOUTH_WEST;
case SOUTH_EAST:
return Rail.Shape.SOUTH_EAST;
case NORTH_EAST:
return Rail.Shape.NORTH_EAST;
case NORTH_WEST:
return Rail.Shape.NORTH_WEST;
case ASCENDING_EAST:
return Rail.Shape.ASCENDING_EAST;
case ASCENDING_WEST:
return Rail.Shape.ASCENDING_WEST;
case ASCENDING_SOUTH:
return Rail.Shape.ASCENDING_SOUTH;
case ASCENDING_NORTH:
return Rail.Shape.ASCENDING_NORTH;
case NORTH_SOUTH:
return Rail.Shape.NORTH_SOUTH;
case EAST_WEST:
return Rail.Shape.EAST_WEST;
default:
throw new IllegalStateException();
}
return switch(shape) {
case SOUTH_WEST -> Rail.Shape.SOUTH_WEST;
case SOUTH_EAST -> Rail.Shape.SOUTH_EAST;
case NORTH_EAST -> Rail.Shape.NORTH_EAST;
case NORTH_WEST -> Rail.Shape.NORTH_WEST;
case ASCENDING_EAST -> Rail.Shape.ASCENDING_EAST;
case ASCENDING_WEST -> Rail.Shape.ASCENDING_WEST;
case ASCENDING_SOUTH -> Rail.Shape.ASCENDING_SOUTH;
case ASCENDING_NORTH -> Rail.Shape.ASCENDING_NORTH;
case NORTH_SOUTH -> Rail.Shape.NORTH_SOUTH;
case EAST_WEST -> Rail.Shape.EAST_WEST;
};
}
public static org.bukkit.block.data.Rail.Shape adapt(Rail.Shape shape) {
switch(shape) {
case EAST_WEST:
return org.bukkit.block.data.Rail.Shape.EAST_WEST;
case NORTH_SOUTH:
return org.bukkit.block.data.Rail.Shape.NORTH_SOUTH;
case ASCENDING_NORTH:
return org.bukkit.block.data.Rail.Shape.ASCENDING_NORTH;
case ASCENDING_SOUTH:
return org.bukkit.block.data.Rail.Shape.ASCENDING_SOUTH;
case ASCENDING_WEST:
return org.bukkit.block.data.Rail.Shape.ASCENDING_WEST;
case ASCENDING_EAST:
return org.bukkit.block.data.Rail.Shape.ASCENDING_EAST;
case NORTH_WEST:
return org.bukkit.block.data.Rail.Shape.NORTH_WEST;
case NORTH_EAST:
return org.bukkit.block.data.Rail.Shape.NORTH_EAST;
case SOUTH_EAST:
return org.bukkit.block.data.Rail.Shape.SOUTH_EAST;
case SOUTH_WEST:
return org.bukkit.block.data.Rail.Shape.SOUTH_WEST;
default:
throw new IllegalStateException();
}
return switch(shape) {
case EAST_WEST -> org.bukkit.block.data.Rail.Shape.EAST_WEST;
case NORTH_SOUTH -> org.bukkit.block.data.Rail.Shape.NORTH_SOUTH;
case ASCENDING_NORTH -> org.bukkit.block.data.Rail.Shape.ASCENDING_NORTH;
case ASCENDING_SOUTH -> org.bukkit.block.data.Rail.Shape.ASCENDING_SOUTH;
case ASCENDING_WEST -> org.bukkit.block.data.Rail.Shape.ASCENDING_WEST;
case ASCENDING_EAST -> org.bukkit.block.data.Rail.Shape.ASCENDING_EAST;
case NORTH_WEST -> org.bukkit.block.data.Rail.Shape.NORTH_WEST;
case NORTH_EAST -> org.bukkit.block.data.Rail.Shape.NORTH_EAST;
case SOUTH_EAST -> org.bukkit.block.data.Rail.Shape.SOUTH_EAST;
case SOUTH_WEST -> org.bukkit.block.data.Rail.Shape.SOUTH_WEST;
};
}
public static org.bukkit.block.data.Bisected.Half adapt(Bisected.Half half) {
switch(half) {
case TOP:
return org.bukkit.block.data.Bisected.Half.TOP;
case BOTTOM:
return org.bukkit.block.data.Bisected.Half.BOTTOM;
default:
throw new IllegalStateException();
}
return switch(half) {
case TOP -> org.bukkit.block.data.Bisected.Half.TOP;
case BOTTOM -> org.bukkit.block.data.Bisected.Half.BOTTOM;
};
}
public static org.bukkit.Axis adapt(Axis axis) {
switch(axis) {
case Z:
return org.bukkit.Axis.Z;
case Y:
return org.bukkit.Axis.Y;
case X:
return org.bukkit.Axis.X;
default:
throw new IllegalStateException();
}
return switch(axis) {
case Z -> org.bukkit.Axis.Z;
case Y -> org.bukkit.Axis.Y;
case X -> org.bukkit.Axis.X;
};
}
public static org.bukkit.block.BlockFace adapt(BlockFace face) {
switch(face) {
case DOWN:
return org.bukkit.block.BlockFace.DOWN;
case UP:
return org.bukkit.block.BlockFace.UP;
case NORTH_WEST:
return org.bukkit.block.BlockFace.NORTH_WEST;
case NORTH_EAST:
return org.bukkit.block.BlockFace.NORTH_EAST;
case SOUTH_EAST:
return org.bukkit.block.BlockFace.SOUTH_EAST;
case SOUTH_WEST:
return org.bukkit.block.BlockFace.SOUTH_WEST;
case NORTH_NORTH_WEST:
return org.bukkit.block.BlockFace.NORTH_NORTH_WEST;
case WEST_NORTH_WEST:
return org.bukkit.block.BlockFace.WEST_NORTH_WEST;
case WEST_SOUTH_WEST:
return org.bukkit.block.BlockFace.WEST_SOUTH_WEST;
case SOUTH_SOUTH_WEST:
return org.bukkit.block.BlockFace.SOUTH_SOUTH_WEST;
case EAST_NORTH_EAST:
return org.bukkit.block.BlockFace.EAST_NORTH_EAST;
case WEST:
return org.bukkit.block.BlockFace.WEST;
case SOUTH:
return org.bukkit.block.BlockFace.SOUTH;
case EAST:
return org.bukkit.block.BlockFace.EAST;
case NORTH:
return org.bukkit.block.BlockFace.NORTH;
case SELF:
return org.bukkit.block.BlockFace.SELF;
case EAST_SOUTH_EAST:
return org.bukkit.block.BlockFace.EAST_SOUTH_EAST;
case NORTH_NORTH_EAST:
return org.bukkit.block.BlockFace.NORTH_NORTH_EAST;
case SOUTH_SOUTH_EAST:
return org.bukkit.block.BlockFace.SOUTH_SOUTH_EAST;
default:
throw new IllegalStateException();
}
return switch(face) {
case DOWN -> org.bukkit.block.BlockFace.DOWN;
case UP -> org.bukkit.block.BlockFace.UP;
case NORTH_WEST -> org.bukkit.block.BlockFace.NORTH_WEST;
case NORTH_EAST -> org.bukkit.block.BlockFace.NORTH_EAST;
case SOUTH_EAST -> org.bukkit.block.BlockFace.SOUTH_EAST;
case SOUTH_WEST -> org.bukkit.block.BlockFace.SOUTH_WEST;
case NORTH_NORTH_WEST -> org.bukkit.block.BlockFace.NORTH_NORTH_WEST;
case WEST_NORTH_WEST -> org.bukkit.block.BlockFace.WEST_NORTH_WEST;
case WEST_SOUTH_WEST -> org.bukkit.block.BlockFace.WEST_SOUTH_WEST;
case SOUTH_SOUTH_WEST -> org.bukkit.block.BlockFace.SOUTH_SOUTH_WEST;
case EAST_NORTH_EAST -> org.bukkit.block.BlockFace.EAST_NORTH_EAST;
case WEST -> org.bukkit.block.BlockFace.WEST;
case SOUTH -> org.bukkit.block.BlockFace.SOUTH;
case EAST -> org.bukkit.block.BlockFace.EAST;
case NORTH -> org.bukkit.block.BlockFace.NORTH;
case SELF -> org.bukkit.block.BlockFace.SELF;
case EAST_SOUTH_EAST -> org.bukkit.block.BlockFace.EAST_SOUTH_EAST;
case NORTH_NORTH_EAST -> org.bukkit.block.BlockFace.NORTH_NORTH_EAST;
case SOUTH_SOUTH_EAST -> org.bukkit.block.BlockFace.SOUTH_SOUTH_EAST;
};
}
public static org.bukkit.block.data.type.Slab.Type adapt(Slab.Type type) {
switch(type) {
case TOP:
return org.bukkit.block.data.type.Slab.Type.TOP;
case DOUBLE:
return org.bukkit.block.data.type.Slab.Type.DOUBLE;
case BOTTOM:
return org.bukkit.block.data.type.Slab.Type.BOTTOM;
default:
throw new IllegalStateException();
}
return switch(type) {
case TOP -> org.bukkit.block.data.type.Slab.Type.TOP;
case DOUBLE -> org.bukkit.block.data.type.Slab.Type.DOUBLE;
case BOTTOM -> org.bukkit.block.data.type.Slab.Type.BOTTOM;
};
}
public static Location adapt(com.dfsek.terra.api.math.vector.Location location) {

24
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/BukkitTree.java
View File

@@ -24,21 +24,15 @@ public class BukkitTree implements Tree {
private MaterialSet getSpawnable(TreeType type) {
WorldHandle handle = main.getWorldHandle();
switch(type) {
case CRIMSON_FUNGUS:
return MaterialSet.get(handle.createBlockData("minecraft:crimson_nylium"));
case WARPED_FUNGUS:
return MaterialSet.get(handle.createBlockData("minecraft:warped_nylium"));
case BROWN_MUSHROOM:
case RED_MUSHROOM:
return MaterialSet.get(handle.createBlockData("minecraft:mycelium"), handle.createBlockData("minecraft:grass_block"),
handle.createBlockData("minecraft:podzol"));
case CHORUS_PLANT:
return MaterialSet.get(handle.createBlockData("minecraft:end_stone"));
default:
return MaterialSet.get(handle.createBlockData("minecraft:grass_block"), handle.createBlockData("minecraft:dirt"),
handle.createBlockData("minecraft:podzol"));
}
return switch(type) {
case CRIMSON_FUNGUS -> MaterialSet.get(handle.createBlockData("minecraft:crimson_nylium"));
case WARPED_FUNGUS -> MaterialSet.get(handle.createBlockData("minecraft:warped_nylium"));
case BROWN_MUSHROOM, RED_MUSHROOM -> MaterialSet.get(handle.createBlockData("minecraft:mycelium"), handle.createBlockData("minecraft:grass_block"),
handle.createBlockData("minecraft:podzol"));
case CHORUS_PLANT -> MaterialSet.get(handle.createBlockData("minecraft:end_stone"));
default -> MaterialSet.get(handle.createBlockData("minecraft:grass_block"), handle.createBlockData("minecraft:dirt"),
handle.createBlockData("minecraft:podzol"));
};
}
@Override

30
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitWall.java
View File

@@ -20,29 +20,19 @@ public class BukkitWall extends BukkitWaterlogged implements Wall {
}
public static org.bukkit.block.data.type.Wall.Height adapt(com.dfsek.terra.api.platform.block.data.Wall.Height height) {
switch(height) {
case NONE:
return org.bukkit.block.data.type.Wall.Height.NONE;
case LOW:
return org.bukkit.block.data.type.Wall.Height.LOW;
case TALL:
return org.bukkit.block.data.type.Wall.Height.TALL;
default:
throw new IllegalStateException();
}
return switch(height) {
case NONE -> org.bukkit.block.data.type.Wall.Height.NONE;
case LOW -> org.bukkit.block.data.type.Wall.Height.LOW;
case TALL -> org.bukkit.block.data.type.Wall.Height.TALL;
};
}
public static com.dfsek.terra.api.platform.block.data.Wall.Height adapt(org.bukkit.block.data.type.Wall.Height height) {
switch(height) {
case TALL:
return com.dfsek.terra.api.platform.block.data.Wall.Height.TALL;
case LOW:
return com.dfsek.terra.api.platform.block.data.Wall.Height.LOW;
case NONE:
return com.dfsek.terra.api.platform.block.data.Wall.Height.NONE;
default:
throw new IllegalStateException();
}
return switch(height) {
case TALL -> Height.TALL;
case LOW -> Height.LOW;
case NONE -> Height.NONE;
};
}
@Override

35
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitMobSpawner.java
View File

@@ -96,32 +96,15 @@ public class BukkitMobSpawner extends BukkitBlockState implements MobSpawner {
public void applyState(String state) {
SerialState.parse(state).forEach((k, v) -> {
switch(k) {
case "type":
setSpawnedType(new BukkitEntityType(org.bukkit.entity.EntityType.valueOf(v.toUpperCase())));
return;
case "delay":
setDelay(Integer.parseInt(v));
return;
case "min_delay":
setMinSpawnDelay(Integer.parseInt(v));
return;
case "max_delay":
setMaxSpawnDelay(Integer.parseInt(v));
return;
case "spawn_count":
setSpawnCount(Integer.parseInt(v));
return;
case "spawn_range":
setSpawnRange(Integer.parseInt(v));
return;
case "max_nearby":
setMaxNearbyEntities(Integer.parseInt(v));
return;
case "required_player_range":
setRequiredPlayerRange(Integer.parseInt(v));
return;
default:
throw new IllegalArgumentException("Invalid property: " + k);
case "type" -> setSpawnedType(new BukkitEntityType(org.bukkit.entity.EntityType.valueOf(v.toUpperCase())));
case "delay" -> setDelay(Integer.parseInt(v));
case "min_delay" -> setMinSpawnDelay(Integer.parseInt(v));
case "max_delay" -> setMaxSpawnDelay(Integer.parseInt(v));
case "spawn_count" -> setSpawnCount(Integer.parseInt(v));
case "spawn_range" -> setSpawnRange(Integer.parseInt(v));
case "max_nearby" -> setMaxNearbyEntities(Integer.parseInt(v));
case "required_player_range" -> setRequiredPlayerRange(Integer.parseInt(v));
default -> throw new IllegalArgumentException("Invalid property: " + k);
}
});
}

24
platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricDirectional.java
View File

@@ -17,22 +17,14 @@ public class FabricDirectional extends FabricBlockData implements Directional {
@Override
public BlockFace getFacing() {
switch(delegate.get(property)) {
case SOUTH:
return BlockFace.SOUTH;
case DOWN:
return BlockFace.DOWN;
case UP:
return BlockFace.UP;
case EAST:
return BlockFace.EAST;
case WEST:
return BlockFace.WEST;
case NORTH:
return BlockFace.NORTH;
default:
throw new IllegalStateException();
}
return switch(delegate.get(property)) {
case SOUTH -> BlockFace.SOUTH;
case DOWN -> BlockFace.DOWN;
case UP -> BlockFace.UP;
case EAST -> BlockFace.EAST;
case WEST -> BlockFace.WEST;
case NORTH -> BlockFace.NORTH;
};
}
@Override

24
platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricMultipleFacing.java
View File

@@ -29,24 +29,12 @@ public class FabricMultipleFacing extends FabricBlockData implements MultipleFac
@Override
public void setFace(BlockFace face, boolean facing) {
switch(face) {
case NORTH:
delegate = delegate.with(Properties.NORTH, facing);
break;
case SOUTH:
delegate = delegate.with(Properties.SOUTH, facing);
break;
case EAST:
delegate = delegate.with(Properties.EAST, facing);
break;
case WEST:
delegate = delegate.with(Properties.WEST, facing);
break;
case UP:
delegate = delegate.with(Properties.UP, facing);
break;
case DOWN:
delegate = delegate.with(Properties.DOWN, facing);
break;
case NORTH -> delegate = delegate.with(Properties.NORTH, facing);
case SOUTH -> delegate = delegate.with(Properties.SOUTH, facing);
case EAST -> delegate = delegate.with(Properties.EAST, facing);
case WEST -> delegate = delegate.with(Properties.WEST, facing);
case UP -> delegate = delegate.with(Properties.UP, facing);
case DOWN -> delegate = delegate.with(Properties.DOWN, facing);
}
}

123
platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricRotatable.java
View File

@@ -14,98 +14,47 @@ public class FabricRotatable extends FabricBlockData implements Rotatable {
@Override
public BlockFace getRotation() {
int r = delegate.get(Properties.ROTATION);
switch(r) {
case 0:
return BlockFace.SOUTH;
case 1:
return BlockFace.SOUTH_SOUTH_WEST;
case 2:
return BlockFace.SOUTH_WEST;
case 3:
return BlockFace.WEST_SOUTH_WEST;
case 4:
return BlockFace.WEST;
case 5:
return BlockFace.WEST_NORTH_WEST;
case 6:
return BlockFace.NORTH_WEST;
case 7:
return BlockFace.NORTH_NORTH_WEST;
case 8:
return BlockFace.NORTH;
case 9:
return BlockFace.NORTH_NORTH_EAST;
case 10:
return BlockFace.NORTH_EAST;
case 11:
return BlockFace.EAST_NORTH_EAST;
case 12:
return BlockFace.EAST;
case 13:
return BlockFace.EAST_SOUTH_EAST;
case 14:
return BlockFace.SOUTH_EAST;
case 15:
return BlockFace.SOUTH_SOUTH_EAST;
default:
throw new IllegalArgumentException("Unknown rotation " + r);
}
return switch(r) {
case 0 -> BlockFace.SOUTH;
case 1 -> BlockFace.SOUTH_SOUTH_WEST;
case 2 -> BlockFace.SOUTH_WEST;
case 3 -> BlockFace.WEST_SOUTH_WEST;
case 4 -> BlockFace.WEST;
case 5 -> BlockFace.WEST_NORTH_WEST;
case 6 -> BlockFace.NORTH_WEST;
case 7 -> BlockFace.NORTH_NORTH_WEST;
case 8 -> BlockFace.NORTH;
case 9 -> BlockFace.NORTH_NORTH_EAST;
case 10 -> BlockFace.NORTH_EAST;
case 11 -> BlockFace.EAST_NORTH_EAST;
case 12 -> BlockFace.EAST;
case 13 -> BlockFace.EAST_SOUTH_EAST;
case 14 -> BlockFace.SOUTH_EAST;
case 15 -> BlockFace.SOUTH_SOUTH_EAST;
default -> throw new IllegalArgumentException("Unknown rotation " + r);
};
}
@Override
public void setRotation(BlockFace face) {
switch(face) {
case UP:
case DOWN:
throw new IllegalArgumentException("Illegal rotation " + face);
case SOUTH:
delegate = delegate.with(Properties.ROTATION, 0);
return;
case SOUTH_SOUTH_WEST:
delegate = delegate.with(Properties.ROTATION, 1);
return;
case SOUTH_WEST:
delegate = delegate.with(Properties.ROTATION, 2);
return;
case WEST_SOUTH_WEST:
delegate = delegate.with(Properties.ROTATION, 3);
return;
case WEST:
delegate = delegate.with(Properties.ROTATION, 4);
return;
case WEST_NORTH_WEST:
delegate = delegate.with(Properties.ROTATION, 5);
return;
case NORTH_WEST:
delegate = delegate.with(Properties.ROTATION, 6);
return;
case NORTH_NORTH_WEST:
delegate = delegate.with(Properties.ROTATION, 7);
return;
case NORTH:
delegate = delegate.with(Properties.ROTATION, 8);
return;
case NORTH_NORTH_EAST:
delegate = delegate.with(Properties.ROTATION, 9);
return;
case NORTH_EAST:
delegate = delegate.with(Properties.ROTATION, 10);
return;
case EAST_NORTH_EAST:
delegate = delegate.with(Properties.ROTATION, 11);
return;
case EAST:
delegate = delegate.with(Properties.ROTATION, 12);
return;
case EAST_SOUTH_EAST:
delegate = delegate.with(Properties.ROTATION, 13);
return;
case SOUTH_EAST:
delegate = delegate.with(Properties.ROTATION, 14);
return;
case SOUTH_SOUTH_EAST:
delegate = delegate.with(Properties.ROTATION, 15);
return;
case UP, DOWN -> throw new IllegalArgumentException("Illegal rotation " + face);
case SOUTH -> delegate = delegate.with(Properties.ROTATION, 0);
case SOUTH_SOUTH_WEST -> delegate = delegate.with(Properties.ROTATION, 1);
case SOUTH_WEST -> delegate = delegate.with(Properties.ROTATION, 2);
case WEST_SOUTH_WEST -> delegate = delegate.with(Properties.ROTATION, 3);
case WEST -> delegate = delegate.with(Properties.ROTATION, 4);
case WEST_NORTH_WEST -> delegate = delegate.with(Properties.ROTATION, 5);
case NORTH_WEST -> delegate = delegate.with(Properties.ROTATION, 6);
case NORTH_NORTH_WEST -> delegate = delegate.with(Properties.ROTATION, 7);
case NORTH -> delegate = delegate.with(Properties.ROTATION, 8);
case NORTH_NORTH_EAST -> delegate = delegate.with(Properties.ROTATION, 9);
case NORTH_EAST -> delegate = delegate.with(Properties.ROTATION, 10);
case EAST_NORTH_EAST -> delegate = delegate.with(Properties.ROTATION, 11);
case EAST -> delegate = delegate.with(Properties.ROTATION, 12);
case EAST_SOUTH_EAST -> delegate = delegate.with(Properties.ROTATION, 13);
case SOUTH_EAST -> delegate = delegate.with(Properties.ROTATION, 14);
case SOUTH_SOUTH_EAST -> delegate = delegate.with(Properties.ROTATION, 15);
}
}
}

35
platforms/fabric/src/main/java/com/dfsek/terra/fabric/mixin/implementations/block/state/MobSpawnerBlockEntityMixin.java
View File

@@ -87,32 +87,15 @@ public abstract class MobSpawnerBlockEntityMixin {
public void terra$applyState(String state) {
SerialState.parse(state).forEach((k, v) -> {
switch(k) {
case "type":
terra$setSpawnedType(TerraFabricPlugin.getInstance().getWorldHandle().getEntity(v));
return;
case "delay":
terra$setDelay(Integer.parseInt(v));
return;
case "min_delay":
terra$setMinSpawnDelay(Integer.parseInt(v));
return;
case "max_delay":
terra$setMaxSpawnDelay(Integer.parseInt(v));
return;
case "spawn_count":
terra$setSpawnCount(Integer.parseInt(v));
return;
case "spawn_range":
terra$setSpawnRange(Integer.parseInt(v));
return;
case "max_nearby":
terra$setMaxNearbyEntities(Integer.parseInt(v));
return;
case "required_player_range":
terra$setRequiredPlayerRange(Integer.parseInt(v));
return;
default:
throw new IllegalArgumentException("Invalid property: " + k);
case "type" -> terra$setSpawnedType(TerraFabricPlugin.getInstance().getWorldHandle().getEntity(v));
case "delay" -> terra$setDelay(Integer.parseInt(v));
case "min_delay" -> terra$setMinSpawnDelay(Integer.parseInt(v));
case "max_delay" -> terra$setMaxSpawnDelay(Integer.parseInt(v));
case "spawn_count" -> terra$setSpawnCount(Integer.parseInt(v));
case "spawn_range" -> terra$setSpawnRange(Integer.parseInt(v));
case "max_nearby" -> terra$setMaxNearbyEntities(Integer.parseInt(v));
case "required_player_range" -> terra$setRequiredPlayerRange(Integer.parseInt(v));
default -> throw new IllegalArgumentException("Invalid property: " + k);
}
});
}

175
platforms/fabric/src/main/java/com/dfsek/terra/fabric/util/FabricAdapter.java
View File

@@ -62,22 +62,15 @@ public final class FabricAdapter {
}
public static Direction adapt(BlockFace face) {
switch(face) {
case NORTH:
return Direction.NORTH;
case WEST:
return Direction.WEST;
case SOUTH:
return Direction.SOUTH;
case EAST:
return Direction.EAST;
case UP:
return Direction.UP;
case DOWN:
return Direction.DOWN;
default:
throw new IllegalArgumentException("Illegal direction: " + face);
}
return switch(face) {
case NORTH -> Direction.NORTH;
case WEST -> Direction.WEST;
case SOUTH -> Direction.SOUTH;
case EAST -> Direction.EAST;
case UP -> Direction.UP;
case DOWN -> Direction.DOWN;
default -> throw new IllegalArgumentException("Illegal direction: " + face);
};
}
@@ -96,129 +89,79 @@ public final class FabricAdapter {
}
public static Stairs.Shape adapt(StairShape shape) {
switch(shape) {
case OUTER_RIGHT:
return Stairs.Shape.OUTER_RIGHT;
case INNER_RIGHT:
return Stairs.Shape.INNER_RIGHT;
case OUTER_LEFT:
return Stairs.Shape.OUTER_LEFT;
case INNER_LEFT:
return Stairs.Shape.INNER_LEFT;
case STRAIGHT:
return Stairs.Shape.STRAIGHT;
default:
throw new IllegalStateException();
}
return switch(shape) {
case OUTER_RIGHT -> Stairs.Shape.OUTER_RIGHT;
case INNER_RIGHT -> Stairs.Shape.INNER_RIGHT;
case OUTER_LEFT -> Stairs.Shape.OUTER_LEFT;
case INNER_LEFT -> Stairs.Shape.INNER_LEFT;
case STRAIGHT -> Stairs.Shape.STRAIGHT;
};
}
public static Bisected.Half adapt(BlockHalf half) {
switch(half) {
case BOTTOM:
return Bisected.Half.BOTTOM;
case TOP:
return Bisected.Half.TOP;
default:
throw new IllegalStateException();
}
return switch(half) {
case BOTTOM -> Bisected.Half.BOTTOM;
case TOP -> Bisected.Half.TOP;
};
}
public static BlockFace adapt(Direction direction) {
switch(direction) {
case DOWN:
return BlockFace.DOWN;
case UP:
return BlockFace.UP;
case WEST:
return BlockFace.WEST;
case EAST:
return BlockFace.EAST;
case NORTH:
return BlockFace.NORTH;
case SOUTH:
return BlockFace.SOUTH;
default:
throw new IllegalStateException();
}
return switch(direction) {
case DOWN -> BlockFace.DOWN;
case UP -> BlockFace.UP;
case WEST -> BlockFace.WEST;
case EAST -> BlockFace.EAST;
case NORTH -> BlockFace.NORTH;
case SOUTH -> BlockFace.SOUTH;
};
}
public static Slab.Type adapt(SlabType type) {
switch(type) {
case BOTTOM:
return Slab.Type.BOTTOM;
case TOP:
return Slab.Type.TOP;
case DOUBLE:
return Slab.Type.DOUBLE;
default:
throw new IllegalStateException();
}
return switch(type) {
case BOTTOM -> Slab.Type.BOTTOM;
case TOP -> Slab.Type.TOP;
case DOUBLE -> Slab.Type.DOUBLE;
};
}
public static StairShape adapt(Stairs.Shape shape) {
switch(shape) {
case STRAIGHT:
return StairShape.STRAIGHT;
case INNER_LEFT:
return StairShape.INNER_LEFT;
case OUTER_LEFT:
return StairShape.OUTER_LEFT;
case INNER_RIGHT:
return StairShape.INNER_RIGHT;
case OUTER_RIGHT:
return StairShape.OUTER_RIGHT;
default:
throw new IllegalStateException();
}
return switch(shape) {
case STRAIGHT -> StairShape.STRAIGHT;
case INNER_LEFT -> StairShape.INNER_LEFT;
case OUTER_LEFT -> StairShape.OUTER_LEFT;
case INNER_RIGHT -> StairShape.INNER_RIGHT;
case OUTER_RIGHT -> StairShape.OUTER_RIGHT;
};
}
public static BlockHalf adapt(Bisected.Half half) {
switch(half) {
case TOP:
return BlockHalf.TOP;
case BOTTOM:
return BlockHalf.BOTTOM;
default:
throw new IllegalStateException();
}
return switch(half) {
case TOP -> BlockHalf.TOP;
case BOTTOM -> BlockHalf.BOTTOM;
};
}
public static SlabType adapt(Slab.Type type) {
switch(type) {
case DOUBLE:
return SlabType.DOUBLE;
case TOP:
return SlabType.TOP;
case BOTTOM:
return SlabType.BOTTOM;
default:
throw new IllegalStateException();
}
return switch(type) {
case DOUBLE -> SlabType.DOUBLE;
case TOP -> SlabType.TOP;
case BOTTOM -> SlabType.BOTTOM;
};
}
public static Axis adapt(Direction.Axis axis) {
switch(axis) {
case X:
return Axis.X;
case Y:
return Axis.Y;
case Z:
return Axis.Z;
default:
throw new IllegalStateException();
}
return switch(axis) {
case X -> Axis.X;
case Y -> Axis.Y;
case Z -> Axis.Z;
};
}
public static Direction.Axis adapt(Axis axis) {
switch(axis) {
case Z:
return Direction.Axis.Z;
case Y:
return Direction.Axis.Y;
case X:
return Direction.Axis.X;
default:
throw new IllegalStateException();
}
return switch(axis) {
case Z -> Direction.Axis.Z;
case Y -> Direction.Axis.Y;
case X -> Direction.Axis.X;
};
}
}

25
platforms/forge/src/main/java/com/dfsek/terra/forge/ForgeAdapter.java
View File

@@ -70,21 +70,14 @@ public final class ForgeAdapter {
}
public static Direction adapt(BlockFace face) {
switch(face) {
case NORTH:
return Direction.NORTH;
case WEST:
return Direction.WEST;
case SOUTH:
return Direction.SOUTH;
case EAST:
return Direction.EAST;
case UP:
return Direction.UP;
case DOWN:
return Direction.DOWN;
default:
throw new IllegalArgumentException("Illegal direction: " + face);
}
return switch(face) {
case NORTH -> Direction.NORTH;
case WEST -> Direction.WEST;
case SOUTH -> Direction.SOUTH;
case EAST -> Direction.EAST;
case UP -> Direction.UP;
case DOWN -> Direction.DOWN;
default -> throw new IllegalArgumentException("Illegal direction: " + face);
};
}
}

24
platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeDirectional.java
View File

@@ -17,22 +17,14 @@ public class ForgeDirectional extends ForgeBlockData implements Directional {
@Override
public BlockFace getFacing() {
switch(delegate.getValue(property)) {
case SOUTH:
return BlockFace.SOUTH;
case DOWN:
return BlockFace.DOWN;
case UP:
return BlockFace.UP;
case EAST:
return BlockFace.EAST;
case WEST:
return BlockFace.WEST;
case NORTH:
return BlockFace.NORTH;
default:
throw new IllegalStateException();
}
return switch(delegate.getValue(property)) {
case SOUTH -> BlockFace.SOUTH;
case DOWN -> BlockFace.DOWN;
case UP -> BlockFace.UP;
case EAST -> BlockFace.EAST;
case WEST -> BlockFace.WEST;
case NORTH -> BlockFace.NORTH;
};
}
@Override

174
platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeEnumAdapter.java
View File

@@ -12,148 +12,90 @@ import net.minecraft.util.Direction;
public final class ForgeEnumAdapter {
public static Stairs.Shape adapt(StairsShape shape) {
switch(shape) {
case OUTER_RIGHT:
return Stairs.Shape.OUTER_RIGHT;
case INNER_RIGHT:
return Stairs.Shape.INNER_RIGHT;
case OUTER_LEFT:
return Stairs.Shape.OUTER_LEFT;
case INNER_LEFT:
return Stairs.Shape.INNER_LEFT;
case STRAIGHT:
return Stairs.Shape.STRAIGHT;
default:
throw new IllegalStateException();
}
return switch(shape) {
case OUTER_RIGHT -> Stairs.Shape.OUTER_RIGHT;
case INNER_RIGHT -> Stairs.Shape.INNER_RIGHT;
case OUTER_LEFT -> Stairs.Shape.OUTER_LEFT;
case INNER_LEFT -> Stairs.Shape.INNER_LEFT;
case STRAIGHT -> Stairs.Shape.STRAIGHT;
};
}
public static Bisected.Half adapt(Half half) {
switch(half) {
case BOTTOM:
return Bisected.Half.BOTTOM;
case TOP:
return Bisected.Half.TOP;
default:
throw new IllegalStateException();
}
return switch(half) {
case BOTTOM -> Bisected.Half.BOTTOM;
case TOP -> Bisected.Half.TOP;
};
}
public static BlockFace adapt(Direction direction) {
switch(direction) {
case DOWN:
return BlockFace.DOWN;
case UP:
return BlockFace.UP;
case WEST:
return BlockFace.WEST;
case EAST:
return BlockFace.EAST;
case NORTH:
return BlockFace.NORTH;
case SOUTH:
return BlockFace.SOUTH;
default:
throw new IllegalStateException();
}
return switch(direction) {
case DOWN -> BlockFace.DOWN;
case UP -> BlockFace.UP;
case WEST -> BlockFace.WEST;
case EAST -> BlockFace.EAST;
case NORTH -> BlockFace.NORTH;
case SOUTH -> BlockFace.SOUTH;
};
}
public static Slab.Type adapt(SlabType type) {
switch(type) {
case BOTTOM:
return Slab.Type.BOTTOM;
case TOP:
return Slab.Type.TOP;
case DOUBLE:
return Slab.Type.DOUBLE;
default:
throw new IllegalStateException();
}
return switch(type) {
case BOTTOM -> Slab.Type.BOTTOM;
case TOP -> Slab.Type.TOP;
case DOUBLE -> Slab.Type.DOUBLE;
};
}
public static StairsShape adapt(Stairs.Shape shape) {
switch(shape) {
case STRAIGHT:
return StairsShape.STRAIGHT;
case INNER_LEFT:
return StairsShape.INNER_LEFT;
case OUTER_LEFT:
return StairsShape.OUTER_LEFT;
case INNER_RIGHT:
return StairsShape.INNER_RIGHT;
case OUTER_RIGHT:
return StairsShape.OUTER_RIGHT;
default:
throw new IllegalStateException();
}
return switch(shape) {
case STRAIGHT -> StairsShape.STRAIGHT;
case INNER_LEFT -> StairsShape.INNER_LEFT;
case OUTER_LEFT -> StairsShape.OUTER_LEFT;
case INNER_RIGHT -> StairsShape.INNER_RIGHT;
case OUTER_RIGHT -> StairsShape.OUTER_RIGHT;
};
}
public static Half adapt(Bisected.Half half) {
switch(half) {
case TOP:
return Half.TOP;
case BOTTOM:
return Half.BOTTOM;
default:
throw new IllegalStateException();
}
return switch(half) {
case TOP -> Half.TOP;
case BOTTOM -> Half.BOTTOM;
};
}
public static Direction adapt(BlockFace face) {
switch(face) {
case SOUTH:
return Direction.SOUTH;
case NORTH:
return Direction.NORTH;
case EAST:
return Direction.EAST;
case WEST:
return Direction.WEST;
case UP:
return Direction.UP;
case DOWN:
return Direction.DOWN;
default:
throw new IllegalArgumentException();
}
return switch(face) {
case SOUTH -> Direction.SOUTH;
case NORTH -> Direction.NORTH;
case EAST -> Direction.EAST;
case WEST -> Direction.WEST;
case UP -> Direction.UP;
case DOWN -> Direction.DOWN;
};
}
public static SlabType adapt(Slab.Type type) {
switch(type) {
case DOUBLE:
return SlabType.DOUBLE;
case TOP:
return SlabType.TOP;
case BOTTOM:
return SlabType.BOTTOM;
default:
throw new IllegalStateException();
}
return switch(type) {
case DOUBLE -> SlabType.DOUBLE;
case TOP -> SlabType.TOP;
case BOTTOM -> SlabType.BOTTOM;
};
}
public static Axis adapt(Direction.Axis axis) {
switch(axis) {
case X:
return Axis.X;
case Y:
return Axis.Y;
case Z:
return Axis.Z;
default:
throw new IllegalStateException();
}
return switch(axis) {
case X -> Axis.X;
case Y -> Axis.Y;
case Z -> Axis.Z;
};
}
public static Direction.Axis adapt(Axis axis) {
switch(axis) {
case Z:
return Direction.Axis.Z;
case Y:
return Direction.Axis.Y;
case X:
return Direction.Axis.X;
default:
throw new IllegalStateException();
}
return switch(axis) {
case Z -> Direction.Axis.Z;
case Y -> Direction.Axis.Y;
case X -> Direction.Axis.X;
};
}
}

24
platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeMultipleFacing.java
View File

@@ -29,24 +29,12 @@ public class ForgeMultipleFacing extends ForgeBlockData implements MultipleFacin
@Override
public void setFace(BlockFace face, boolean facing) {
switch(face) {
case NORTH:
delegate = delegate.setValue(BlockStateProperties.NORTH, facing);
break;
case SOUTH:
delegate = delegate.setValue(BlockStateProperties.SOUTH, facing);
break;
case EAST:
delegate = delegate.setValue(BlockStateProperties.EAST, facing);
break;
case WEST:
delegate = delegate.setValue(BlockStateProperties.WEST, facing);
break;
case UP:
delegate = delegate.setValue(BlockStateProperties.UP, facing);
break;
case DOWN:
delegate = delegate.setValue(BlockStateProperties.DOWN, facing);
break;
case NORTH -> delegate = delegate.setValue(BlockStateProperties.NORTH, facing);
case SOUTH -> delegate = delegate.setValue(BlockStateProperties.SOUTH, facing);
case EAST -> delegate = delegate.setValue(BlockStateProperties.EAST, facing);
case WEST -> delegate = delegate.setValue(BlockStateProperties.WEST, facing);
case UP -> delegate = delegate.setValue(BlockStateProperties.UP, facing);
case DOWN -> delegate = delegate.setValue(BlockStateProperties.DOWN, facing);
}
}

123
platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeRotatable.java
View File

@@ -14,98 +14,47 @@ public class ForgeRotatable extends ForgeBlockData implements Rotatable {
@Override
public BlockFace getRotation() {
int r = delegate.getValue(BlockStateProperties.ROTATION_16);
switch(r) {
case 0:
return BlockFace.SOUTH;
case 1:
return BlockFace.SOUTH_SOUTH_WEST;
case 2:
return BlockFace.SOUTH_WEST;
case 3:
return BlockFace.WEST_SOUTH_WEST;
case 4:
return BlockFace.WEST;
case 5:
return BlockFace.WEST_NORTH_WEST;
case 6:
return BlockFace.NORTH_WEST;
case 7:
return BlockFace.NORTH_NORTH_WEST;
case 8:
return BlockFace.NORTH;
case 9:
return BlockFace.NORTH_NORTH_EAST;
case 10:
return BlockFace.NORTH_EAST;
case 11:
return BlockFace.EAST_NORTH_EAST;
case 12:
return BlockFace.EAST;
case 13:
return BlockFace.EAST_SOUTH_EAST;
case 14:
return BlockFace.SOUTH_EAST;
case 15:
return BlockFace.SOUTH_SOUTH_EAST;
default:
throw new IllegalArgumentException("Unknown rotation " + r);
}
return switch(r) {
case 0 -> BlockFace.SOUTH;
case 1 -> BlockFace.SOUTH_SOUTH_WEST;
case 2 -> BlockFace.SOUTH_WEST;
case 3 -> BlockFace.WEST_SOUTH_WEST;
case 4 -> BlockFace.WEST;
case 5 -> BlockFace.WEST_NORTH_WEST;
case 6 -> BlockFace.NORTH_WEST;
case 7 -> BlockFace.NORTH_NORTH_WEST;
case 8 -> BlockFace.NORTH;
case 9 -> BlockFace.NORTH_NORTH_EAST;
case 10 -> BlockFace.NORTH_EAST;
case 11 -> BlockFace.EAST_NORTH_EAST;
case 12 -> BlockFace.EAST;
case 13 -> BlockFace.EAST_SOUTH_EAST;
case 14 -> BlockFace.SOUTH_EAST;
case 15 -> BlockFace.SOUTH_SOUTH_EAST;
default -> throw new IllegalArgumentException("Unknown rotation " + r);
};
}
@Override
public void setRotation(BlockFace face) {
switch(face) {
case UP:
case DOWN:
throw new IllegalArgumentException("Illegal rotation " + face);
case SOUTH:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 0);
return;
case SOUTH_SOUTH_WEST:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 1);
return;
case SOUTH_WEST:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 2);
return;
case WEST_SOUTH_WEST:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 3);
return;
case WEST:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 4);
return;
case WEST_NORTH_WEST:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 5);
return;
case NORTH_WEST:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 6);
return;
case NORTH_NORTH_WEST:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 7);
return;
case NORTH:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 8);
return;
case NORTH_NORTH_EAST:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 9);
return;
case NORTH_EAST:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 10);
return;
case EAST_NORTH_EAST:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 11);
return;
case EAST:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 12);
return;
case EAST_SOUTH_EAST:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 13);
return;
case SOUTH_EAST:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 14);
return;
case SOUTH_SOUTH_EAST:
delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 15);
return;
case UP, DOWN -> throw new IllegalArgumentException("Illegal rotation " + face);
case SOUTH -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 0);
case SOUTH_SOUTH_WEST -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 1);
case SOUTH_WEST -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 2);
case WEST_SOUTH_WEST -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 3);
case WEST -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 4);
case WEST_NORTH_WEST -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 5);
case NORTH_WEST -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 6);
case NORTH_NORTH_WEST -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 7);
case NORTH -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 8);
case NORTH_NORTH_EAST -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 9);
case NORTH_EAST -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 10);
case EAST_NORTH_EAST -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 11);
case EAST -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 12);
case EAST_SOUTH_EAST -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 13);
case SOUTH_EAST -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 14);
case SOUTH_SOUTH_EAST -> delegate = delegate.setValue(BlockStateProperties.ROTATION_16, 15);
}
}
}

35
platforms/forge/src/main/java/com/dfsek/terra/forge/mixin/implementations/block/state/MobSpawnerTileEntityMixin.java
View File

@@ -88,32 +88,15 @@ public abstract class MobSpawnerTileEntityMixin extends TileEntityMixin {
public void terra$applyState(String state) {
SerialState.parse(state).forEach((k, v) -> {
switch(k) {
case "type":
terra$setSpawnedType(TerraForgePlugin.getInstance().getWorldHandle().getEntity(v));
return;
case "delay":
terra$setDelay(Integer.parseInt(v));
return;
case "min_delay":
terra$setMinSpawnDelay(Integer.parseInt(v));
return;
case "max_delay":
terra$setMaxSpawnDelay(Integer.parseInt(v));
return;
case "spawn_count":
terra$setSpawnCount(Integer.parseInt(v));
return;
case "spawn_range":
terra$setSpawnRange(Integer.parseInt(v));
return;
case "max_nearby":
terra$setMaxNearbyEntities(Integer.parseInt(v));
return;
case "required_player_range":
terra$setRequiredPlayerRange(Integer.parseInt(v));
return;
default:
throw new IllegalArgumentException("Invalid property: " + k);
case "type" -> terra$setSpawnedType(TerraForgePlugin.getInstance().getWorldHandle().getEntity(v));
case "delay" -> terra$setDelay(Integer.parseInt(v));
case "min_delay" -> terra$setMinSpawnDelay(Integer.parseInt(v));
case "max_delay" -> terra$setMaxSpawnDelay(Integer.parseInt(v));
case "spawn_count" -> terra$setSpawnCount(Integer.parseInt(v));
case "spawn_range" -> terra$setSpawnRange(Integer.parseInt(v));
case "max_nearby" -> terra$setMaxNearbyEntities(Integer.parseInt(v));
case "required_player_range" -> terra$setRequiredPlayerRange(Integer.parseInt(v));
default -> throw new IllegalArgumentException("Invalid property: " + k);
}
});
}