From 712df89064332e03466b70732c9cea773eceb0d9 Mon Sep 17 00:00:00 2001 From: dfsek Date: Sat, 15 May 2021 21:24:58 -0700 Subject: [PATCH] convert to new expression switches --- .../com/dfsek/terra/CompilationConfig.kt | 2 +- .../noise/samplers/ExpressionSampler.java | 8 +- .../noise/samplers/noise/CellularSampler.java | 90 ++--- .../terra/api/platform/block/BlockFace.java | 80 ++-- .../terra/api/structures/loot/Entry.java | 15 +- .../terra/api/structures/parser/Parser.java | 34 +- .../api/structures/parser/ParserUtil.java | 16 +- .../parser/lang/variables/Declaration.java | 12 +- .../script/builders/BiomeFunctionBuilder.java | 12 +- .../script/builders/BlockFunctionBuilder.java | 18 +- .../builders/CheckBlockFunctionBuilder.java | 12 +- .../script/builders/CheckFunctionBuilder.java | 13 +- .../builders/EntityFunctionBuilder.java | 15 +- .../builders/GetMarkFunctionBuilder.java | 12 +- .../script/builders/LootFunctionBuilder.java | 15 +- .../script/builders/PullFunctionBuilder.java | 15 +- .../builders/SetMarkFunctionBuilder.java | 15 +- .../script/builders/StateFunctionBuilder.java | 15 +- .../builders/StructureFunctionBuilder.java | 12 +- .../api/structures/structure/Rotation.java | 37 +- .../structures/structure/RotationUtil.java | 233 ++++-------- .../terra/carving/UserDefinedCarver.java | 8 +- .../terra/config/factories/OreFactory.java | 11 +- .../biome/BiomeProviderBuilderLoader.java | 15 +- .../config/biome/StageBuilderLoader.java | 21 +- .../src/test/java/structure/ParserTest.java | 13 +- .../terra/bukkit/world/BukkitAdapter.java | 354 ++++++------------ .../dfsek/terra/bukkit/world/BukkitTree.java | 24 +- .../bukkit/world/block/data/BukkitWall.java | 30 +- .../world/block/state/BukkitMobSpawner.java | 35 +- .../fabric/block/data/FabricDirectional.java | 24 +- .../block/data/FabricMultipleFacing.java | 24 +- .../fabric/block/data/FabricRotatable.java | 123 ++---- .../state/MobSpawnerBlockEntityMixin.java | 35 +- .../terra/fabric/util/FabricAdapter.java | 175 +++------ .../com/dfsek/terra/forge/ForgeAdapter.java | 25 +- .../forge/block/data/ForgeDirectional.java | 24 +- .../forge/block/data/ForgeEnumAdapter.java | 174 +++------ .../forge/block/data/ForgeMultipleFacing.java | 24 +- .../forge/block/data/ForgeRotatable.java | 123 ++---- .../state/MobSpawnerTileEntityMixin.java | 35 +- 41 files changed, 639 insertions(+), 1339 deletions(-) diff --git a/buildSrc/src/main/kotlin/com/dfsek/terra/CompilationConfig.kt b/buildSrc/src/main/kotlin/com/dfsek/terra/CompilationConfig.kt index 0c16229e0..e9b6bc980 100644 --- a/buildSrc/src/main/kotlin/com/dfsek/terra/CompilationConfig.kt +++ b/buildSrc/src/main/kotlin/com/dfsek/terra/CompilationConfig.kt @@ -21,7 +21,7 @@ fun Project.configureCompilation() { tasks.withType { options.encoding = "UTF-8" doFirst { - options.compilerArgs.addAll(arrayOf("-Xlint:all", "--release", "8", "--enable-preview")) + options.compilerArgs.addAll(arrayOf("-Xlint:all", "--release", "8", "-Xplugin:jabel")) } } diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/ExpressionSampler.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/ExpressionSampler.java index 8ca8f2333..aeda5e050 100644 --- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/ExpressionSampler.java +++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/ExpressionSampler.java @@ -29,12 +29,8 @@ public class ExpressionSampler implements NoiseSampler { functions.forEach((id, noise) -> { switch(noise.getDimensions()) { - case 2: - parser.registerFunction(id, new NoiseFunction2(noise.apply(seed))); - break; - case 3: - parser.registerFunction(id, new NoiseFunction3(noise.apply(seed))); - break; + case 2 -> parser.registerFunction(id, new NoiseFunction2(noise.apply(seed))); + case 3 -> parser.registerFunction(id, new NoiseFunction3(noise.apply(seed))); } }); diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/CellularSampler.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/CellularSampler.java index b5488a8dd..d743670ff 100644 --- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/CellularSampler.java +++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/CellularSampler.java @@ -333,36 +333,21 @@ public class CellularSampler extends NoiseFunction { } } - switch(returnType) { - case CellValue: - return closestHash * (1 / 2147483648.0); - case Distance: - return distance0 - 1; - case Distance2: - return distance1 - 1; - case Distance2Add: - return (distance1 + distance0) * 0.5 - 1; - case Distance2Sub: - return distance1 - distance0 - 1; - case Distance2Mul: - return distance1 * distance0 * 0.5 - 1; - case Distance2Div: - return distance0 / distance1 - 1; - case NoiseLookup: - return noiseLookup.getNoise(center.getX(), center.getZ()); - case Distance3: - return distance2 - 1; - case Distance3Add: - return (distance2 + distance0) * 0.5 - 1; - case Distance3Sub: - return distance2 - distance0 - 1; - case Distance3Mul: - return distance2 * distance0 - 1; - case Distance3Div: - return distance0 / distance2 - 1; - default: - return 0; - } + return switch(returnType) { + case CellValue -> closestHash * (1 / 2147483648.0); + case Distance -> distance0 - 1; + case Distance2 -> distance1 - 1; + case Distance2Add -> (distance1 + distance0) * 0.5 - 1; + case Distance2Sub -> distance1 - distance0 - 1; + case Distance2Mul -> distance1 * distance0 * 0.5 - 1; + case Distance2Div -> distance0 / distance1 - 1; + case NoiseLookup -> noiseLookup.getNoise(center.getX(), center.getZ()); + case Distance3 -> distance2 - 1; + case Distance3Add -> (distance2 + distance0) * 0.5 - 1; + case Distance3Sub -> distance2 - distance0 - 1; + case Distance3Mul -> distance2 * distance0 - 1; + case Distance3Div -> distance0 / distance2 - 1; + }; } @Override @@ -507,36 +492,21 @@ public class CellularSampler extends NoiseFunction { } } - switch(returnType) { - case CellValue: - return closestHash * (1 / 2147483648.0); - case Distance: - return distance0 - 1; - case Distance2: - return distance1 - 1; - case Distance2Add: - return (distance1 + distance0) * 0.5 - 1; - case Distance2Sub: - return distance1 - distance0 - 1; - case Distance2Mul: - return distance1 * distance0 * 0.5 - 1; - case Distance2Div: - return distance0 / distance1 - 1; - case NoiseLookup: - return noiseLookup.getNoise(center.getX(), center.getY(), center.getZ()); - case Distance3: - return distance2 - 1; - case Distance3Add: - return (distance2 + distance0) * 0.5 - 1; - case Distance3Sub: - return distance2 - distance0 - 1; - case Distance3Mul: - return distance2 * distance0 - 1; - case Distance3Div: - return distance0 / distance2 - 1; - default: - return 0; - } + return switch(returnType) { + case CellValue -> closestHash * (1 / 2147483648.0); + case Distance -> distance0 - 1; + case Distance2 -> distance1 - 1; + case Distance2Add -> (distance1 + distance0) * 0.5 - 1; + case Distance2Sub -> distance1 - distance0 - 1; + case Distance2Mul -> distance1 * distance0 * 0.5 - 1; + case Distance2Div -> distance0 / distance1 - 1; + case NoiseLookup -> noiseLookup.getNoise(center.getX(), center.getY(), center.getZ()); + case Distance3 -> distance2 - 1; + case Distance3Add -> (distance2 + distance0) * 0.5 - 1; + case Distance3Sub -> distance2 - distance0 - 1; + case Distance3Mul -> distance2 * distance0 - 1; + case Distance3Div -> distance0 / distance2 - 1; + }; } public enum DistanceFunction { diff --git a/common/src/main/java/com/dfsek/terra/api/platform/block/BlockFace.java b/common/src/main/java/com/dfsek/terra/api/platform/block/BlockFace.java index 4f9bcb904..89997d383 100644 --- a/common/src/main/java/com/dfsek/terra/api/platform/block/BlockFace.java +++ b/common/src/main/java/com/dfsek/terra/api/platform/block/BlockFace.java @@ -83,66 +83,28 @@ public enum BlockFace { @NotNull public BlockFace getOppositeFace() { - switch(this) { - case NORTH: - return BlockFace.SOUTH; + return switch(this) { + case NORTH -> BlockFace.SOUTH; + case SOUTH -> BlockFace.NORTH; + case EAST -> BlockFace.WEST; + case WEST -> BlockFace.EAST; + case UP -> BlockFace.DOWN; + case DOWN -> BlockFace.UP; + case NORTH_EAST -> BlockFace.SOUTH_WEST; + case NORTH_WEST -> BlockFace.SOUTH_EAST; + case SOUTH_EAST -> BlockFace.NORTH_WEST; + case SOUTH_WEST -> BlockFace.NORTH_EAST; + case WEST_NORTH_WEST -> BlockFace.EAST_SOUTH_EAST; + case NORTH_NORTH_WEST -> BlockFace.SOUTH_SOUTH_EAST; + case NORTH_NORTH_EAST -> BlockFace.SOUTH_SOUTH_WEST; + case EAST_NORTH_EAST -> BlockFace.WEST_SOUTH_WEST; + case EAST_SOUTH_EAST -> BlockFace.WEST_NORTH_WEST; + case SOUTH_SOUTH_EAST -> BlockFace.NORTH_NORTH_WEST; + case SOUTH_SOUTH_WEST -> BlockFace.NORTH_NORTH_EAST; + case WEST_SOUTH_WEST -> BlockFace.EAST_NORTH_EAST; + case SELF -> BlockFace.SELF; + }; - case SOUTH: - return BlockFace.NORTH; - - case EAST: - return BlockFace.WEST; - - case WEST: - return BlockFace.EAST; - - case UP: - return BlockFace.DOWN; - - case DOWN: - return BlockFace.UP; - - case NORTH_EAST: - return BlockFace.SOUTH_WEST; - - case NORTH_WEST: - return BlockFace.SOUTH_EAST; - - case SOUTH_EAST: - return BlockFace.NORTH_WEST; - - case SOUTH_WEST: - return BlockFace.NORTH_EAST; - - case WEST_NORTH_WEST: - return BlockFace.EAST_SOUTH_EAST; - - case NORTH_NORTH_WEST: - return BlockFace.SOUTH_SOUTH_EAST; - - case NORTH_NORTH_EAST: - return BlockFace.SOUTH_SOUTH_WEST; - - case EAST_NORTH_EAST: - return BlockFace.WEST_SOUTH_WEST; - - case EAST_SOUTH_EAST: - return BlockFace.WEST_NORTH_WEST; - - case SOUTH_SOUTH_EAST: - return BlockFace.NORTH_NORTH_WEST; - - case SOUTH_SOUTH_WEST: - return BlockFace.NORTH_NORTH_EAST; - - case WEST_SOUTH_WEST: - return BlockFace.EAST_NORTH_EAST; - - case SELF: - return BlockFace.SELF; - } - - return BlockFace.SELF; } } diff --git a/common/src/main/java/com/dfsek/terra/api/structures/loot/Entry.java b/common/src/main/java/com/dfsek/terra/api/structures/loot/Entry.java index 81c48aab1..aa070e886 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/loot/Entry.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/loot/Entry.java @@ -43,8 +43,7 @@ public class Entry { if(entry.containsKey("functions")) { for(Object function : (JSONArray) entry.get("functions")) { switch(((String) ((JSONObject) function).get("function"))) { - case "minecraft:set_count": - case "set_count": + case "minecraft:set_count", "set_count" -> { Object loot = ((JSONObject) function).get("count"); long max, min; if(loot instanceof Long) { @@ -55,22 +54,20 @@ public class Entry { min = (long) ((JSONObject) loot).get("min"); } functions.add(new AmountFunction(FastMath.toIntExact(min), FastMath.toIntExact(max))); - break; - case "minecraft:set_damage": - case "set_damage": + } + case "minecraft:set_damage", "set_damage" -> { long maxDamage = (long) ((JSONObject) ((JSONObject) function).get("damage")).get("max"); long minDamage = (long) ((JSONObject) ((JSONObject) function).get("damage")).get("min"); functions.add(new DamageFunction(FastMath.toIntExact(minDamage), FastMath.toIntExact(maxDamage))); - break; - case "minecraft:enchant_with_levels": - case "enchant_with_levels": + } + case "minecraft:enchant_with_levels", "enchant_with_levels" -> { long maxEnchant = (long) ((JSONObject) ((JSONObject) function).get("levels")).get("max"); long minEnchant = (long) ((JSONObject) ((JSONObject) function).get("levels")).get("min"); JSONArray disabled = null; if(((JSONObject) function).containsKey("disabled_enchants")) disabled = (JSONArray) ((JSONObject) function).get("disabled_enchants"); functions.add(new EnchantFunction(FastMath.toIntExact(minEnchant), FastMath.toIntExact(maxEnchant), disabled, main)); - break; + } } } } diff --git a/common/src/main/java/com/dfsek/terra/api/structures/parser/Parser.java b/common/src/main/java/com/dfsek/terra/api/structures/parser/Parser.java index 9f4ff96db..bc6541fce 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/parser/Parser.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/parser/Parser.java @@ -96,16 +96,12 @@ public class Parser { ParserUtil.checkType(tokens.consume(), Token.Type.GROUP_BEGIN); - switch(identifier.getType()) { - case FOR_LOOP: - return parseForLoop(tokens, variableMap, identifier.getPosition()); - case IF_STATEMENT: - return parseIfStatement(tokens, variableMap, identifier.getPosition(), loop); - case WHILE_LOOP: - return parseWhileLoop(tokens, variableMap, identifier.getPosition()); - default: - throw new UnsupportedOperationException("Unknown keyword " + identifier.getContent() + ": " + identifier.getPosition()); - } + return switch(identifier.getType()) { + case FOR_LOOP -> parseForLoop(tokens, variableMap, identifier.getPosition()); + case IF_STATEMENT -> parseIfStatement(tokens, variableMap, identifier.getPosition(), loop); + case WHILE_LOOP -> parseWhileLoop(tokens, variableMap, identifier.getPosition()); + default -> throw new UnsupportedOperationException("Unknown keyword " + identifier.getContent() + ": " + identifier.getPosition()); + }; } private WhileKeyword parseWhileLoop(Tokenizer tokens, Map variableMap, Position start) throws ParseException { @@ -233,17 +229,13 @@ public class Parser { private ConstantExpression parseConstantExpression(Tokenizer tokens) throws ParseException { Token constantToken = tokens.consume(); Position position = constantToken.getPosition(); - switch(constantToken.getType()) { - case NUMBER: - String content = constantToken.getContent(); - return new NumericConstant(content.contains(".") ? Double.parseDouble(content) : Integer.parseInt(content), position); - case STRING: - return new StringConstant(constantToken.getContent(), position); - case BOOLEAN: - return new BooleanConstant(Boolean.parseBoolean(constantToken.getContent()), position); - default: - throw new UnsupportedOperationException("Unsupported constant token: " + constantToken.getType() + " at position: " + position); - } + String content = constantToken.getContent(); + return switch(constantToken.getType()) { + case NUMBER -> new NumericConstant(content.contains(".") ? Double.parseDouble(content) : Integer.parseInt(content), position); + case STRING -> new StringConstant(content, position); + case BOOLEAN -> new BooleanConstant(Boolean.parseBoolean(content), position); + default -> throw new UnsupportedOperationException("Unsupported constant token: " + constantToken.getType() + " at position: " + position); + }; } private Returnable parseGroup(Tokenizer tokens, Map variableMap) throws ParseException { diff --git a/common/src/main/java/com/dfsek/terra/api/structures/parser/ParserUtil.java b/common/src/main/java/com/dfsek/terra/api/structures/parser/ParserUtil.java index 724ac9099..1990bdc26 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/parser/ParserUtil.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/parser/ParserUtil.java @@ -79,16 +79,12 @@ public class ParserUtil { } public static Returnable.ReturnType getVariableReturnType(Token varToken) throws ParseException { - switch(varToken.getType()) { - case NUMBER_VARIABLE: - return Returnable.ReturnType.NUMBER; - case STRING_VARIABLE: - return Returnable.ReturnType.STRING; - case BOOLEAN_VARIABLE: - return Returnable.ReturnType.BOOLEAN; - default: - throw new ParseException("Unexpected token " + varToken.getType() + "; expected variable declaration", varToken.getPosition()); - } + return switch(varToken.getType()) { + case NUMBER_VARIABLE -> Returnable.ReturnType.NUMBER; + case STRING_VARIABLE -> Returnable.ReturnType.STRING; + case BOOLEAN_VARIABLE -> Returnable.ReturnType.BOOLEAN; + default -> throw new ParseException("Unexpected token " + varToken.getType() + "; expected variable declaration", varToken.getPosition()); + }; } public static boolean hasPrecedence(Token.Type first, Token.Type second) { diff --git a/common/src/main/java/com/dfsek/terra/api/structures/parser/lang/variables/Declaration.java b/common/src/main/java/com/dfsek/terra/api/structures/parser/lang/variables/Declaration.java index f919f13bb..b0e2603b1 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/parser/lang/variables/Declaration.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/parser/lang/variables/Declaration.java @@ -32,15 +32,9 @@ public class Declaration implements Item { public T apply(ImplementationArguments implementationArguments, Map> variableMap) { T result = value.apply(implementationArguments, variableMap); switch(type) { - case NUMBER: - variableMap.put(identifier, new NumberVariable((Number) result, position)); - break; - case BOOLEAN: - variableMap.put(identifier, new BooleanVariable((Boolean) result, position)); - break; - case STRING: - variableMap.put(identifier, new StringVariable((String) result, position)); - break; + case NUMBER -> variableMap.put(identifier, new NumberVariable((Number) result, position)); + case BOOLEAN -> variableMap.put(identifier, new BooleanVariable((Boolean) result, position)); + case STRING -> variableMap.put(identifier, new StringVariable((String) result, position)); } return result; } diff --git a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/BiomeFunctionBuilder.java b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/BiomeFunctionBuilder.java index 7c15c70b4..ccbd6fe21 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/BiomeFunctionBuilder.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/BiomeFunctionBuilder.java @@ -28,13 +28,9 @@ public class BiomeFunctionBuilder implements FunctionBuilder { @Override public Returnable.ReturnType getArgument(int position) { - switch(position) { - case 0: - case 1: - case 2: - return Returnable.ReturnType.NUMBER; - default: - return null; - } + return switch(position) { + case 0, 1, 2 -> Returnable.ReturnType.NUMBER; + default -> null; + }; } } diff --git a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/BlockFunctionBuilder.java b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/BlockFunctionBuilder.java index 0f05d2636..e0089919f 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/BlockFunctionBuilder.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/BlockFunctionBuilder.java @@ -39,17 +39,11 @@ public class BlockFunctionBuilder implements FunctionBuilder Returnable.ReturnType.NUMBER; + case 3 -> Returnable.ReturnType.STRING; + case 4 -> Returnable.ReturnType.BOOLEAN; + default -> null; + }; } } diff --git a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/CheckBlockFunctionBuilder.java b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/CheckBlockFunctionBuilder.java index 98eeb2665..219f0ad3d 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/CheckBlockFunctionBuilder.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/CheckBlockFunctionBuilder.java @@ -21,13 +21,9 @@ public class CheckBlockFunctionBuilder implements FunctionBuilder Returnable.ReturnType.NUMBER; + default -> null; + }; } } diff --git a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/CheckFunctionBuilder.java b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/CheckFunctionBuilder.java index 4ac870f49..80a9a2bf7 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/CheckFunctionBuilder.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/CheckFunctionBuilder.java @@ -6,7 +6,6 @@ import com.dfsek.terra.api.structures.parser.lang.Returnable; import com.dfsek.terra.api.structures.parser.lang.functions.FunctionBuilder; import com.dfsek.terra.api.structures.script.functions.CheckFunction; import com.dfsek.terra.api.structures.tokenizer.Position; -import com.dfsek.terra.world.generation.math.SamplerCache; import java.util.List; @@ -30,13 +29,9 @@ public class CheckFunctionBuilder implements FunctionBuilder { @Override public Returnable.ReturnType getArgument(int position) { - switch(position) { - case 0: - case 1: - case 2: - return Returnable.ReturnType.NUMBER; - default: - return null; - } + return switch(position) { + case 0, 1, 2 -> Returnable.ReturnType.NUMBER; + default -> null; + }; } } diff --git a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/EntityFunctionBuilder.java b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/EntityFunctionBuilder.java index dd66a3d84..3c6f6be57 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/EntityFunctionBuilder.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/EntityFunctionBuilder.java @@ -29,15 +29,10 @@ public class EntityFunctionBuilder implements FunctionBuilder { @Override public Returnable.ReturnType getArgument(int position) { - switch(position) { - case 0: - case 1: - case 2: - return Returnable.ReturnType.NUMBER; - case 3: - return Returnable.ReturnType.STRING; - default: - return null; - } + return switch(position) { + case 0, 1, 2 -> Returnable.ReturnType.NUMBER; + case 3 -> Returnable.ReturnType.STRING; + default -> null; + }; } } diff --git a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/GetMarkFunctionBuilder.java b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/GetMarkFunctionBuilder.java index e93fbdc2b..b790a676b 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/GetMarkFunctionBuilder.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/GetMarkFunctionBuilder.java @@ -25,13 +25,9 @@ public class GetMarkFunctionBuilder implements FunctionBuilder @Override public Returnable.ReturnType getArgument(int position) { - switch(position) { - case 0: - case 1: - case 2: - return Returnable.ReturnType.NUMBER; - default: - return null; - } + return switch(position) { + case 0, 1, 2 -> Returnable.ReturnType.NUMBER; + default -> null; + }; } } diff --git a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/LootFunctionBuilder.java b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/LootFunctionBuilder.java index d5e46d9d3..a4d3b1a83 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/LootFunctionBuilder.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/LootFunctionBuilder.java @@ -34,15 +34,10 @@ public class LootFunctionBuilder implements FunctionBuilder { @Override public Returnable.ReturnType getArgument(int position) { - switch(position) { - case 0: - case 1: - case 2: - return Returnable.ReturnType.NUMBER; - case 3: - return Returnable.ReturnType.STRING; - default: - return null; - } + return switch(position) { + case 0, 1, 2 -> Returnable.ReturnType.NUMBER; + case 3 -> Returnable.ReturnType.STRING; + default -> null; + }; } } diff --git a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/PullFunctionBuilder.java b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/PullFunctionBuilder.java index 9b55da244..c571c1a1f 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/PullFunctionBuilder.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/PullFunctionBuilder.java @@ -29,15 +29,10 @@ public class PullFunctionBuilder implements FunctionBuilder { @Override public Returnable.ReturnType getArgument(int position) { - switch(position) { - case 0: - case 1: - case 2: - return Returnable.ReturnType.NUMBER; - case 3: - return Returnable.ReturnType.STRING; - default: - return null; - } + return switch(position) { + case 0, 1, 2 -> Returnable.ReturnType.NUMBER; + case 3 -> Returnable.ReturnType.STRING; + default -> null; + }; } } diff --git a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/SetMarkFunctionBuilder.java b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/SetMarkFunctionBuilder.java index 76fc5ec39..0b2416e4c 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/SetMarkFunctionBuilder.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/SetMarkFunctionBuilder.java @@ -26,15 +26,10 @@ public class SetMarkFunctionBuilder implements FunctionBuilder @Override public Returnable.ReturnType getArgument(int position) { - switch(position) { - case 0: - case 1: - case 2: - return Returnable.ReturnType.NUMBER; - case 3: - return Returnable.ReturnType.STRING; - default: - return null; - } + return switch(position) { + case 0, 1, 2 -> Returnable.ReturnType.NUMBER; + case 3 -> Returnable.ReturnType.STRING; + default -> null; + }; } } diff --git a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/StateFunctionBuilder.java b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/StateFunctionBuilder.java index 56c9ab2e3..f6cd2c74a 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/StateFunctionBuilder.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/StateFunctionBuilder.java @@ -30,15 +30,10 @@ public class StateFunctionBuilder implements FunctionBuilder { @Override public Returnable.ReturnType getArgument(int position) { - switch(position) { - case 0: - case 1: - case 2: - return Returnable.ReturnType.NUMBER; - case 3: - return Returnable.ReturnType.STRING; - default: - return null; - } + return switch(position) { + case 0, 1, 2 -> Returnable.ReturnType.NUMBER; + case 3 -> Returnable.ReturnType.STRING; + default -> null; + }; } } diff --git a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/StructureFunctionBuilder.java b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/StructureFunctionBuilder.java index 2b0be8468..0af02fc8c 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/script/builders/StructureFunctionBuilder.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/script/builders/StructureFunctionBuilder.java @@ -36,13 +36,9 @@ public class StructureFunctionBuilder implements FunctionBuilder Returnable.ReturnType.NUMBER; + default -> Returnable.ReturnType.STRING; + }; } } diff --git a/common/src/main/java/com/dfsek/terra/api/structures/structure/Rotation.java b/common/src/main/java/com/dfsek/terra/api/structures/structure/Rotation.java index f81c8f63e..c5a05be61 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/structure/Rotation.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/structure/Rotation.java @@ -12,18 +12,13 @@ public enum Rotation { } public static Rotation fromDegrees(int deg) { - switch(FastMath.floorMod(deg, 360)) { - case 0: - return Rotation.NONE; - case 90: - return Rotation.CW_90; - case 180: - return Rotation.CW_180; - case 270: - return Rotation.CCW_90; - default: - throw new IllegalArgumentException(); - } + return switch(FastMath.floorMod(deg, 360)) { + case 0 -> Rotation.NONE; + case 90 -> Rotation.CW_90; + case 180 -> Rotation.CW_180; + case 270 -> Rotation.CCW_90; + default -> throw new IllegalArgumentException(); + }; } public int getDegrees() { @@ -31,18 +26,12 @@ public enum Rotation { } public Rotation inverse() { - switch(this) { - case NONE: - return NONE; - case CCW_90: - return CW_90; - case CW_90: - return CCW_90; - case CW_180: - return CW_180; - default: - throw new IllegalArgumentException(); - } + return switch(this) { + case NONE -> NONE; + case CCW_90 -> CW_90; + case CW_90 -> CCW_90; + case CW_180 -> CW_180; + }; } public Rotation rotate(Rotation rotation) { diff --git a/common/src/main/java/com/dfsek/terra/api/structures/structure/RotationUtil.java b/common/src/main/java/com/dfsek/terra/api/structures/structure/RotationUtil.java index 1d77977d3..36afba077 100644 --- a/common/src/main/java/com/dfsek/terra/api/structures/structure/RotationUtil.java +++ b/common/src/main/java/com/dfsek/terra/api/structures/structure/RotationUtil.java @@ -30,15 +30,9 @@ public class RotationUtil { public static void rotateVector(Vector2 orig, Rotation r) { Vector2 copy = orig.clone(); switch(r) { - case CW_90: - copy.setX(orig.getZ()).setZ(-orig.getX()); - break; - case CCW_90: - copy.setX(-orig.getZ()).setZ(orig.getX()); - break; - case CW_180: - copy.multiply(-1); - break; + case CW_90 -> copy.setX(orig.getZ()).setZ(-orig.getX()); + case CCW_90 -> copy.setX(-orig.getZ()).setZ(orig.getX()); + case CW_180 -> copy.multiply(-1); } orig.setX(copy.getX()); orig.setZ(copy.getZ()); @@ -68,42 +62,25 @@ public class RotationUtil { * @return integer representation of BlockFace */ public static int faceRotation(BlockFace f) { - switch(f) { - case NORTH: - return 0; - case NORTH_NORTH_EAST: - return 1; - case NORTH_EAST: - return 2; - case EAST_NORTH_EAST: - return 3; - case EAST: - return 4; - case EAST_SOUTH_EAST: - return 5; - case SOUTH_EAST: - return 6; - case SOUTH_SOUTH_EAST: - return 7; - case SOUTH: - return 8; - case SOUTH_SOUTH_WEST: - return 9; - case SOUTH_WEST: - return 10; - case WEST_SOUTH_WEST: - return 11; - case WEST: - return 12; - case WEST_NORTH_WEST: - return 13; - case NORTH_WEST: - return 14; - case NORTH_NORTH_WEST: - return 15; - default: - return -1; - } + return switch(f) { + case NORTH -> 0; + case NORTH_NORTH_EAST -> 1; + case NORTH_EAST -> 2; + case EAST_NORTH_EAST -> 3; + case EAST -> 4; + case EAST_SOUTH_EAST -> 5; + case SOUTH_EAST -> 6; + case SOUTH_SOUTH_EAST -> 7; + case SOUTH -> 8; + case SOUTH_SOUTH_WEST -> 9; + case SOUTH_WEST -> 10; + case WEST_SOUTH_WEST -> 11; + case WEST -> 12; + case WEST_NORTH_WEST -> 13; + case NORTH_WEST -> 14; + case NORTH_NORTH_WEST -> 15; + default -> -1; + }; } /** @@ -113,42 +90,25 @@ public class RotationUtil { * @return BlockFace represented by integer. */ public static BlockFace fromRotation(int r) { - switch(FastMath.floorMod(r, 16)) { - case 0: - return BlockFace.NORTH; - case 1: - return BlockFace.NORTH_NORTH_EAST; - case 2: - return BlockFace.NORTH_EAST; - case 3: - return BlockFace.EAST_NORTH_EAST; - case 4: - return BlockFace.EAST; - case 5: - return BlockFace.EAST_SOUTH_EAST; - case 6: - return BlockFace.SOUTH_EAST; - case 7: - return BlockFace.SOUTH_SOUTH_EAST; - case 8: - return BlockFace.SOUTH; - case 9: - return BlockFace.SOUTH_SOUTH_WEST; - case 10: - return BlockFace.SOUTH_WEST; - case 11: - return BlockFace.WEST_SOUTH_WEST; - case 12: - return BlockFace.WEST; - case 13: - return BlockFace.WEST_NORTH_WEST; - case 14: - return BlockFace.NORTH_WEST; - case 15: - return BlockFace.NORTH_NORTH_WEST; - default: - throw new IllegalArgumentException(); - } + return switch(FastMath.floorMod(r, 16)) { + case 0 -> BlockFace.NORTH; + case 1 -> BlockFace.NORTH_NORTH_EAST; + case 2 -> BlockFace.NORTH_EAST; + case 3 -> BlockFace.EAST_NORTH_EAST; + case 4 -> BlockFace.EAST; + case 5 -> BlockFace.EAST_SOUTH_EAST; + case 6 -> BlockFace.SOUTH_EAST; + case 7 -> BlockFace.SOUTH_SOUTH_EAST; + case 8 -> BlockFace.SOUTH; + case 9 -> BlockFace.SOUTH_SOUTH_WEST; + case 10 -> BlockFace.SOUTH_WEST; + case 11 -> BlockFace.WEST_SOUTH_WEST; + case 12 -> BlockFace.WEST; + case 13 -> BlockFace.WEST_NORTH_WEST; + case 14 -> BlockFace.NORTH_WEST; + case 15 -> BlockFace.NORTH_NORTH_WEST; + default -> throw new IllegalArgumentException(); + }; } public static Axis getRotatedAxis(Axis orig, Rotation r) { @@ -174,78 +134,45 @@ public class RotationUtil { */ @SuppressWarnings("fallthrough") public static Rail.Shape getRotatedRail(Rail.Shape orig, Rotation r) { - switch(r) { - case CCW_90: - switch(orig) { - case NORTH_WEST: - return Rail.Shape.SOUTH_WEST; - case NORTH_SOUTH: - return Rail.Shape.EAST_WEST; - case SOUTH_WEST: - return Rail.Shape.SOUTH_EAST; - case SOUTH_EAST: - return Rail.Shape.NORTH_EAST; - case EAST_WEST: - return Rail.Shape.NORTH_SOUTH; - case NORTH_EAST: - return Rail.Shape.NORTH_WEST; - case ASCENDING_EAST: - return Rail.Shape.ASCENDING_NORTH; - case ASCENDING_WEST: - return Rail.Shape.ASCENDING_SOUTH; - case ASCENDING_NORTH: - return Rail.Shape.ASCENDING_WEST; - case ASCENDING_SOUTH: - return Rail.Shape.ASCENDING_EAST; - } - case CW_90: - switch(orig) { - case NORTH_WEST: - return Rail.Shape.NORTH_EAST; - case NORTH_SOUTH: - return Rail.Shape.EAST_WEST; - case SOUTH_WEST: - return Rail.Shape.NORTH_WEST; - case SOUTH_EAST: - return Rail.Shape.SOUTH_WEST; - case EAST_WEST: - return Rail.Shape.NORTH_SOUTH; - case NORTH_EAST: - return Rail.Shape.SOUTH_EAST; - case ASCENDING_EAST: - return Rail.Shape.ASCENDING_SOUTH; - case ASCENDING_WEST: - return Rail.Shape.ASCENDING_NORTH; - case ASCENDING_NORTH: - return Rail.Shape.ASCENDING_EAST; - case ASCENDING_SOUTH: - return Rail.Shape.ASCENDING_WEST; - } - case CW_180: - switch(orig) { - case NORTH_WEST: - return Rail.Shape.SOUTH_EAST; - case NORTH_SOUTH: - return Rail.Shape.NORTH_SOUTH; - case SOUTH_WEST: - return Rail.Shape.NORTH_EAST; - case SOUTH_EAST: - return Rail.Shape.NORTH_WEST; - case EAST_WEST: - return Rail.Shape.EAST_WEST; - case NORTH_EAST: - return Rail.Shape.SOUTH_WEST; - case ASCENDING_EAST: - return Rail.Shape.ASCENDING_WEST; - case ASCENDING_WEST: - return Rail.Shape.ASCENDING_EAST; - case ASCENDING_NORTH: - return Rail.Shape.ASCENDING_SOUTH; - case ASCENDING_SOUTH: - return Rail.Shape.ASCENDING_NORTH; - } - } - return orig; + return switch(r) { + case CCW_90 -> switch(orig) { + case NORTH_WEST -> Rail.Shape.SOUTH_WEST; + case NORTH_SOUTH -> Rail.Shape.EAST_WEST; + case SOUTH_WEST -> Rail.Shape.SOUTH_EAST; + case SOUTH_EAST -> Rail.Shape.NORTH_EAST; + case EAST_WEST -> Rail.Shape.NORTH_SOUTH; + case NORTH_EAST -> Rail.Shape.NORTH_WEST; + case ASCENDING_EAST -> Rail.Shape.ASCENDING_NORTH; + case ASCENDING_WEST -> Rail.Shape.ASCENDING_SOUTH; + case ASCENDING_NORTH -> Rail.Shape.ASCENDING_WEST; + case ASCENDING_SOUTH -> Rail.Shape.ASCENDING_EAST; + }; + case CW_90 -> switch(orig) { + case NORTH_WEST -> Rail.Shape.NORTH_EAST; + case NORTH_SOUTH -> Rail.Shape.EAST_WEST; + case SOUTH_WEST -> Rail.Shape.NORTH_WEST; + case SOUTH_EAST -> Rail.Shape.SOUTH_WEST; + case EAST_WEST -> Rail.Shape.NORTH_SOUTH; + case NORTH_EAST -> Rail.Shape.SOUTH_EAST; + case ASCENDING_EAST -> Rail.Shape.ASCENDING_SOUTH; + case ASCENDING_WEST -> Rail.Shape.ASCENDING_NORTH; + case ASCENDING_NORTH -> Rail.Shape.ASCENDING_EAST; + case ASCENDING_SOUTH -> Rail.Shape.ASCENDING_WEST; + }; + case CW_180 -> switch(orig) { + case NORTH_WEST -> Rail.Shape.SOUTH_EAST; + case NORTH_SOUTH -> Rail.Shape.NORTH_SOUTH; + case SOUTH_WEST -> Rail.Shape.NORTH_EAST; + case SOUTH_EAST -> Rail.Shape.NORTH_WEST; + case EAST_WEST -> Rail.Shape.EAST_WEST; + case NORTH_EAST -> Rail.Shape.SOUTH_WEST; + case ASCENDING_EAST -> Rail.Shape.ASCENDING_WEST; + case ASCENDING_WEST -> Rail.Shape.ASCENDING_EAST; + case ASCENDING_NORTH -> Rail.Shape.ASCENDING_SOUTH; + case ASCENDING_SOUTH -> Rail.Shape.ASCENDING_NORTH; + }; + default -> orig; + }; } public static void rotateBlockData(BlockData data, Rotation r) { diff --git a/common/src/main/java/com/dfsek/terra/carving/UserDefinedCarver.java b/common/src/main/java/com/dfsek/terra/carving/UserDefinedCarver.java index 79bd897a4..c4ac4bdaf 100644 --- a/common/src/main/java/com/dfsek/terra/carving/UserDefinedCarver.java +++ b/common/src/main/java/com/dfsek/terra/carving/UserDefinedCarver.java @@ -60,12 +60,8 @@ public class UserDefinedCarver extends Carver { functions.forEach((id, noise) -> { switch(noise.getDimensions()) { - case 2: - p.registerFunction(id, new NoiseFunction2(noise.apply(hash))); - break; - case 3: - p.registerFunction(id, new NoiseFunction3(noise.apply(hash))); - break; + case 2 -> p.registerFunction(id, new NoiseFunction2(noise.apply(hash))); + case 3 -> p.registerFunction(id, new NoiseFunction3(noise.apply(hash))); } }); diff --git a/common/src/main/java/com/dfsek/terra/config/factories/OreFactory.java b/common/src/main/java/com/dfsek/terra/config/factories/OreFactory.java index fdbf6ea90..1700db468 100644 --- a/common/src/main/java/com/dfsek/terra/config/factories/OreFactory.java +++ b/common/src/main/java/com/dfsek/terra/config/factories/OreFactory.java @@ -11,12 +11,9 @@ public class OreFactory implements ConfigFactory { @Override public Ore build(OreTemplate config, TerraPlugin main) { BlockData m = config.getMaterial(); - switch(config.getType()) { - case SPHERE: - return new DeformedSphereOre(m, config.getReplaceable(), config.doPhysics(), config.getDeform(), config.getDeformFrequency(), config.getSize(), main); - case VANILLA: - return new VanillaOre(m, config.getReplaceable(), config.doPhysics(), config.getSize(), main); - } - return null; + return switch(config.getType()) { + case SPHERE -> new DeformedSphereOre(m, config.getReplaceable(), config.doPhysics(), config.getDeform(), config.getDeformFrequency(), config.getSize(), main); + case VANILLA -> new VanillaOre(m, config.getReplaceable(), config.doPhysics(), config.getSize(), main); + }; } } diff --git a/common/src/main/java/com/dfsek/terra/config/loaders/config/biome/BiomeProviderBuilderLoader.java b/common/src/main/java/com/dfsek/terra/config/loaders/config/biome/BiomeProviderBuilderLoader.java index 718d33907..e125c8d7d 100644 --- a/common/src/main/java/com/dfsek/terra/config/loaders/config/biome/BiomeProviderBuilderLoader.java +++ b/common/src/main/java/com/dfsek/terra/config/loaders/config/biome/BiomeProviderBuilderLoader.java @@ -21,15 +21,10 @@ public class BiomeProviderBuilderLoader implements TypeLoader map = (Map) c; - switch(loader.loadClass(BiomeProvider.Type.class, map.get("type"))) { - case IMAGE: - return loader.loadClass(ImageProviderTemplate.class, map); - case PIPELINE: - return loader.loadClass(BiomePipelineTemplate.class, map); - case SINGLE: - return loader.loadClass(SingleBiomeProviderTemplate.class, map); - } - - throw new LoadException("No such biome provider type: " + map.get("type")); + return switch(loader.loadClass(BiomeProvider.Type.class, map.get("type"))) { + case IMAGE -> loader.loadClass(ImageProviderTemplate.class, map); + case PIPELINE -> loader.loadClass(BiomePipelineTemplate.class, map); + case SINGLE -> loader.loadClass(SingleBiomeProviderTemplate.class, map); + }; } } diff --git a/common/src/main/java/com/dfsek/terra/config/loaders/config/biome/StageBuilderLoader.java b/common/src/main/java/com/dfsek/terra/config/loaders/config/biome/StageBuilderLoader.java index 58c464fde..17bac0000 100644 --- a/common/src/main/java/com/dfsek/terra/config/loaders/config/biome/StageBuilderLoader.java +++ b/common/src/main/java/com/dfsek/terra/config/loaders/config/biome/StageBuilderLoader.java @@ -38,20 +38,13 @@ public class StageBuilderLoader implements TypeLoader { return loader.loadClass(ExpanderStageTemplate.class, mutator); } else throw new LoadException("No such expander \"" + stageType + "\""); } else if(entry.getKey().equals("mutate")) { - switch(loader.loadClass(MutatorStage.Type.class, mutator.get("type"))) { - case SMOOTH: - return loader.loadClass(SmoothMutatorTemplate.class, mutator); - case REPLACE: - return loader.loadClass(ReplaceMutatorTemplate.class, mutator); - case REPLACE_LIST: - return loader.loadClass(ReplaceListMutatorTemplate.class, mutator); - case BORDER: - return loader.loadClass(BorderMutatorTemplate.class, mutator); - case BORDER_LIST: - return loader.loadClass(BorderListMutatorTemplate.class, mutator); - default: - throw new LoadException("No such mutator type \"" + mutator.get("type")); - } + return switch(loader.loadClass(MutatorStage.Type.class, mutator.get("type"))) { + case SMOOTH -> loader.loadClass(SmoothMutatorTemplate.class, mutator); + case REPLACE -> loader.loadClass(ReplaceMutatorTemplate.class, mutator); + case REPLACE_LIST -> loader.loadClass(ReplaceListMutatorTemplate.class, mutator); + case BORDER -> loader.loadClass(BorderMutatorTemplate.class, mutator); + case BORDER_LIST -> loader.loadClass(BorderListMutatorTemplate.class, mutator); + }; } throw new LoadException("No such mutator \"" + entry.getKey() + "\""); } diff --git a/common/src/test/java/structure/ParserTest.java b/common/src/test/java/structure/ParserTest.java index fd1ff30c1..bbd62151d 100644 --- a/common/src/test/java/structure/ParserTest.java +++ b/common/src/test/java/structure/ParserTest.java @@ -36,14 +36,11 @@ public class ParserTest { @Override public Returnable.ReturnType getArgument(int position) { - switch(position) { - case 0: - return Returnable.ReturnType.STRING; - case 1: - return Returnable.ReturnType.NUMBER; - default: - return null; - } + return switch(position) { + case 0 -> Returnable.ReturnType.STRING; + case 1 -> Returnable.ReturnType.NUMBER; + default -> null; + }; } }); diff --git a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/BukkitAdapter.java b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/BukkitAdapter.java index c50cd2711..c1e776aae 100644 --- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/BukkitAdapter.java +++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/BukkitAdapter.java @@ -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) { diff --git a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/BukkitTree.java b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/BukkitTree.java index 41445619f..f2801a23a 100644 --- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/BukkitTree.java +++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/BukkitTree.java @@ -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 diff --git a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitWall.java b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitWall.java index 2addb83b7..cf533ecdc 100644 --- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitWall.java +++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitWall.java @@ -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 diff --git a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitMobSpawner.java b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitMobSpawner.java index 526d1481d..ff020baff 100644 --- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitMobSpawner.java +++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitMobSpawner.java @@ -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); } }); } diff --git a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricDirectional.java b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricDirectional.java index be4eb316b..60d7eb2b5 100644 --- a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricDirectional.java +++ b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricDirectional.java @@ -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 diff --git a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricMultipleFacing.java b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricMultipleFacing.java index d1caae8e1..a6af6b4a8 100644 --- a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricMultipleFacing.java +++ b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricMultipleFacing.java @@ -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); } } diff --git a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricRotatable.java b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricRotatable.java index 4b7a971ea..dc166cc63 100644 --- a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricRotatable.java +++ b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricRotatable.java @@ -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); } } } diff --git a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/mixin/implementations/block/state/MobSpawnerBlockEntityMixin.java b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/mixin/implementations/block/state/MobSpawnerBlockEntityMixin.java index 8f664787e..0febd8696 100644 --- a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/mixin/implementations/block/state/MobSpawnerBlockEntityMixin.java +++ b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/mixin/implementations/block/state/MobSpawnerBlockEntityMixin.java @@ -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); } }); } diff --git a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/util/FabricAdapter.java b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/util/FabricAdapter.java index 8c197d573..d31374abc 100644 --- a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/util/FabricAdapter.java +++ b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/util/FabricAdapter.java @@ -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; + }; } } diff --git a/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgeAdapter.java b/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgeAdapter.java index 6b9f585d3..bd1c82b94 100644 --- a/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgeAdapter.java +++ b/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgeAdapter.java @@ -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); + }; } } diff --git a/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeDirectional.java b/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeDirectional.java index c4cc15636..2d08d0db7 100644 --- a/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeDirectional.java +++ b/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeDirectional.java @@ -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 diff --git a/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeEnumAdapter.java b/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeEnumAdapter.java index 16ba0bb8a..650cab909 100644 --- a/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeEnumAdapter.java +++ b/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeEnumAdapter.java @@ -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; + }; } } diff --git a/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeMultipleFacing.java b/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeMultipleFacing.java index 7e9510282..afa50de63 100644 --- a/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeMultipleFacing.java +++ b/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeMultipleFacing.java @@ -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); } } diff --git a/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeRotatable.java b/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeRotatable.java index b64727b59..9685b3482 100644 --- a/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeRotatable.java +++ b/platforms/forge/src/main/java/com/dfsek/terra/forge/block/data/ForgeRotatable.java @@ -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); } } } diff --git a/platforms/forge/src/main/java/com/dfsek/terra/forge/mixin/implementations/block/state/MobSpawnerTileEntityMixin.java b/platforms/forge/src/main/java/com/dfsek/terra/forge/mixin/implementations/block/state/MobSpawnerTileEntityMixin.java index 1f73b7583..8a945aaf4 100644 --- a/platforms/forge/src/main/java/com/dfsek/terra/forge/mixin/implementations/block/state/MobSpawnerTileEntityMixin.java +++ b/platforms/forge/src/main/java/com/dfsek/terra/forge/mixin/implementations/block/state/MobSpawnerTileEntityMixin.java @@ -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); } }); }