mirrors/Terra
1
0
Fork 0
mirror of https://github.com/PolyhedralDev/Terra.git synced 2025-07-01 23:47:50 +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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
buildSrc/src/main/kotlin/com/dfsek/terra/CompilationConfig.kt
View File

@ -21,7 +21,7 @@ fun Project.configureCompilation() {
tasks.withType<JavaCompile> { tasks.withType<JavaCompile> {
options.encoding = "UTF-8" options.encoding = "UTF-8"
doFirst { doFirst {
options.compilerArgs.addAll(arrayOf("-Xlint:all", "--release", "8", "--enable-preview")) options.compilerArgs.addAll(arrayOf("-Xlint:all", "--release", "8", "-Xplugin:jabel"))
} }
} }

8
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/ExpressionSampler.java
View File

@ -29,12 +29,8 @@ public class ExpressionSampler implements NoiseSampler {
functions.forEach((id, noise) -> { functions.forEach((id, noise) -> {
switch(noise.getDimensions()) { switch(noise.getDimensions()) {
case 2: case 2 -> parser.registerFunction(id, new NoiseFunction2(noise.apply(seed)));
parser.registerFunction(id, new NoiseFunction2(noise.apply(seed))); case 3 -> parser.registerFunction(id, new NoiseFunction3(noise.apply(seed)));
break;
case 3:
parser.registerFunction(id, new NoiseFunction3(noise.apply(seed)));
break;
} }
}); });

90
common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/CellularSampler.java
View File

@ -333,36 +333,21 @@ public class CellularSampler extends NoiseFunction {
} }
} }
switch(returnType) { return switch(returnType) {
case CellValue: case CellValue -> closestHash * (1 / 2147483648.0);
return closestHash * (1 / 2147483648.0); case Distance -> distance0 - 1;
case Distance: case Distance2 -> distance1 - 1;
return distance0 - 1; case Distance2Add -> (distance1 + distance0) * 0.5 - 1;
case Distance2: case Distance2Sub -> distance1 - distance0 - 1;
return distance1 - 1; case Distance2Mul -> distance1 * distance0 * 0.5 - 1;
case Distance2Add: case Distance2Div -> distance0 / distance1 - 1;
return (distance1 + distance0) * 0.5 - 1; case NoiseLookup -> noiseLookup.getNoise(center.getX(), center.getZ());
case Distance2Sub: case Distance3 -> distance2 - 1;
return distance1 - distance0 - 1; case Distance3Add -> (distance2 + distance0) * 0.5 - 1;
case Distance2Mul: case Distance3Sub -> distance2 - distance0 - 1;
return distance1 * distance0 * 0.5 - 1; case Distance3Mul -> distance2 * distance0 - 1;
case Distance2Div: case Distance3Div -> distance0 / distance2 - 1;
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;
}
} }
@Override @Override
@ -507,36 +492,21 @@ public class CellularSampler extends NoiseFunction {
} }
} }
switch(returnType) { return switch(returnType) {
case CellValue: case CellValue -> closestHash * (1 / 2147483648.0);
return closestHash * (1 / 2147483648.0); case Distance -> distance0 - 1;
case Distance: case Distance2 -> distance1 - 1;
return distance0 - 1; case Distance2Add -> (distance1 + distance0) * 0.5 - 1;
case Distance2: case Distance2Sub -> distance1 - distance0 - 1;
return distance1 - 1; case Distance2Mul -> distance1 * distance0 * 0.5 - 1;
case Distance2Add: case Distance2Div -> distance0 / distance1 - 1;
return (distance1 + distance0) * 0.5 - 1; case NoiseLookup -> noiseLookup.getNoise(center.getX(), center.getY(), center.getZ());
case Distance2Sub: case Distance3 -> distance2 - 1;
return distance1 - distance0 - 1; case Distance3Add -> (distance2 + distance0) * 0.5 - 1;
case Distance2Mul: case Distance3Sub -> distance2 - distance0 - 1;
return distance1 * distance0 * 0.5 - 1; case Distance3Mul -> distance2 * distance0 - 1;
case Distance2Div: case Distance3Div -> distance0 / distance2 - 1;
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;
}
} }
public enum DistanceFunction { public enum DistanceFunction {

80
common/src/main/java/com/dfsek/terra/api/platform/block/BlockFace.java
View File

@ -83,66 +83,28 @@ public enum BlockFace {
@NotNull @NotNull
public BlockFace getOppositeFace() { public BlockFace getOppositeFace() {
switch(this) { return switch(this) {
case NORTH: case NORTH -> BlockFace.SOUTH;
return 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;
} }
} }

15
common/src/main/java/com/dfsek/terra/api/structures/loot/Entry.java
View File

@ -43,8 +43,7 @@ public class Entry {
if(entry.containsKey("functions")) { if(entry.containsKey("functions")) {
for(Object function : (JSONArray) entry.get("functions")) { for(Object function : (JSONArray) entry.get("functions")) {
switch(((String) ((JSONObject) function).get("function"))) { switch(((String) ((JSONObject) function).get("function"))) {
case "minecraft:set_count": case "minecraft:set_count", "set_count" -> {
case "set_count":
Object loot = ((JSONObject) function).get("count"); Object loot = ((JSONObject) function).get("count");
long max, min; long max, min;
if(loot instanceof Long) { if(loot instanceof Long) {
@ -55,22 +54,20 @@ public class Entry {
min = (long) ((JSONObject) loot).get("min"); min = (long) ((JSONObject) loot).get("min");
} }
functions.add(new AmountFunction(FastMath.toIntExact(min), FastMath.toIntExact(max))); functions.add(new AmountFunction(FastMath.toIntExact(min), FastMath.toIntExact(max)));
break; }
case "minecraft:set_damage": case "minecraft:set_damage", "set_damage" -> {
case "set_damage":
long maxDamage = (long) ((JSONObject) ((JSONObject) function).get("damage")).get("max"); long maxDamage = (long) ((JSONObject) ((JSONObject) function).get("damage")).get("max");
long minDamage = (long) ((JSONObject) ((JSONObject) function).get("damage")).get("min"); long minDamage = (long) ((JSONObject) ((JSONObject) function).get("damage")).get("min");
functions.add(new DamageFunction(FastMath.toIntExact(minDamage), FastMath.toIntExact(maxDamage))); functions.add(new DamageFunction(FastMath.toIntExact(minDamage), FastMath.toIntExact(maxDamage)));
break; }
case "minecraft:enchant_with_levels": case "minecraft:enchant_with_levels", "enchant_with_levels" -> {
case "enchant_with_levels":
long maxEnchant = (long) ((JSONObject) ((JSONObject) function).get("levels")).get("max"); long maxEnchant = (long) ((JSONObject) ((JSONObject) function).get("levels")).get("max");
long minEnchant = (long) ((JSONObject) ((JSONObject) function).get("levels")).get("min"); long minEnchant = (long) ((JSONObject) ((JSONObject) function).get("levels")).get("min");
JSONArray disabled = null; JSONArray disabled = null;
if(((JSONObject) function).containsKey("disabled_enchants")) if(((JSONObject) function).containsKey("disabled_enchants"))
disabled = (JSONArray) ((JSONObject) function).get("disabled_enchants"); disabled = (JSONArray) ((JSONObject) function).get("disabled_enchants");
functions.add(new EnchantFunction(FastMath.toIntExact(minEnchant), FastMath.toIntExact(maxEnchant), disabled, main)); functions.add(new EnchantFunction(FastMath.toIntExact(minEnchant), FastMath.toIntExact(maxEnchant), disabled, main));
break; }
} }
} }
} }

34
common/src/main/java/com/dfsek/terra/api/structures/parser/Parser.java
View File

@ -96,16 +96,12 @@ public class Parser {
ParserUtil.checkType(tokens.consume(), Token.Type.GROUP_BEGIN); ParserUtil.checkType(tokens.consume(), Token.Type.GROUP_BEGIN);
switch(identifier.getType()) { return switch(identifier.getType()) {
case FOR_LOOP: case FOR_LOOP -> parseForLoop(tokens, variableMap, identifier.getPosition());
return parseForLoop(tokens, variableMap, identifier.getPosition()); case IF_STATEMENT -> parseIfStatement(tokens, variableMap, identifier.getPosition(), loop);
case IF_STATEMENT: case WHILE_LOOP -> parseWhileLoop(tokens, variableMap, identifier.getPosition());
return parseIfStatement(tokens, variableMap, identifier.getPosition(), loop); default -> throw new UnsupportedOperationException("Unknown keyword " + identifier.getContent() + ": " + identifier.getPosition());
case WHILE_LOOP: };
return parseWhileLoop(tokens, variableMap, identifier.getPosition());
default:
throw new UnsupportedOperationException("Unknown keyword " + identifier.getContent() + ": " + identifier.getPosition());
}
} }
private WhileKeyword parseWhileLoop(Tokenizer tokens, Map<String, Returnable.ReturnType> variableMap, Position start) throws ParseException { private WhileKeyword parseWhileLoop(Tokenizer tokens, Map<String, Returnable.ReturnType> variableMap, Position start) throws ParseException {
@ -233,17 +229,13 @@ public class Parser {
private ConstantExpression<?> parseConstantExpression(Tokenizer tokens) throws ParseException { private ConstantExpression<?> parseConstantExpression(Tokenizer tokens) throws ParseException {
Token constantToken = tokens.consume(); Token constantToken = tokens.consume();
Position position = constantToken.getPosition(); Position position = constantToken.getPosition();
switch(constantToken.getType()) { String content = constantToken.getContent();
case NUMBER: return switch(constantToken.getType()) {
String content = constantToken.getContent(); case NUMBER -> new NumericConstant(content.contains(".") ? Double.parseDouble(content) : Integer.parseInt(content), position);
return new NumericConstant(content.contains(".") ? Double.parseDouble(content) : Integer.parseInt(content), position); case STRING -> new StringConstant(content, position);
case STRING: case BOOLEAN -> new BooleanConstant(Boolean.parseBoolean(content), position);
return new StringConstant(constantToken.getContent(), position); default -> throw new UnsupportedOperationException("Unsupported constant token: " + constantToken.getType() + " at position: " + position);
case BOOLEAN: };
return new BooleanConstant(Boolean.parseBoolean(constantToken.getContent()), position);
default:
throw new UnsupportedOperationException("Unsupported constant token: " + constantToken.getType() + " at position: " + position);
}
} }
private Returnable<?> parseGroup(Tokenizer tokens, Map<String, Returnable.ReturnType> variableMap) throws ParseException { private Returnable<?> parseGroup(Tokenizer tokens, Map<String, Returnable.ReturnType> variableMap) throws ParseException {

16
common/src/main/java/com/dfsek/terra/api/structures/parser/ParserUtil.java
View File

@ -79,16 +79,12 @@ public class ParserUtil {
} }
public static Returnable.ReturnType getVariableReturnType(Token varToken) throws ParseException { public static Returnable.ReturnType getVariableReturnType(Token varToken) throws ParseException {
switch(varToken.getType()) { return switch(varToken.getType()) {
case NUMBER_VARIABLE: case NUMBER_VARIABLE -> Returnable.ReturnType.NUMBER;
return Returnable.ReturnType.NUMBER; case STRING_VARIABLE -> Returnable.ReturnType.STRING;
case STRING_VARIABLE: case BOOLEAN_VARIABLE -> Returnable.ReturnType.BOOLEAN;
return Returnable.ReturnType.STRING; default -> throw new ParseException("Unexpected token " + varToken.getType() + "; expected variable declaration", varToken.getPosition());
case BOOLEAN_VARIABLE: };
return 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) { public static boolean hasPrecedence(Token.Type first, Token.Type second) {

12
common/src/main/java/com/dfsek/terra/api/structures/parser/lang/variables/Declaration.java
View File

@ -32,15 +32,9 @@ public class Declaration<T> implements Item<T> {
public T apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) { public T apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
T result = value.apply(implementationArguments, variableMap); T result = value.apply(implementationArguments, variableMap);
switch(type) { switch(type) {
case NUMBER: case NUMBER -> variableMap.put(identifier, new NumberVariable((Number) result, position));
variableMap.put(identifier, new NumberVariable((Number) result, position)); case BOOLEAN -> variableMap.put(identifier, new BooleanVariable((Boolean) result, position));
break; case STRING -> variableMap.put(identifier, new StringVariable((String) result, position));
case BOOLEAN:
variableMap.put(identifier, new BooleanVariable((Boolean) result, position));
break;
case STRING:
variableMap.put(identifier, new StringVariable((String) result, position));
break;
} }
return result; return result;
} }

12
common/src/main/java/com/dfsek/terra/api/structures/script/builders/BiomeFunctionBuilder.java
View File

@ -28,13 +28,9 @@ public class BiomeFunctionBuilder implements FunctionBuilder<BiomeFunction> {
@Override @Override
public Returnable.ReturnType getArgument(int position) { public Returnable.ReturnType getArgument(int position) {
switch(position) { return switch(position) {
case 0: case 0, 1, 2 -> Returnable.ReturnType.NUMBER;
case 1: default -> null;
case 2: };
return Returnable.ReturnType.NUMBER;
default:
return null;
}
} }
} }

18
common/src/main/java/com/dfsek/terra/api/structures/script/builders/BlockFunctionBuilder.java
View File

@ -39,17 +39,11 @@ public class BlockFunctionBuilder implements FunctionBuilder<AbstractBlockFuncti
@Override @Override
public Returnable.ReturnType getArgument(int position) { public Returnable.ReturnType getArgument(int position) {
switch(position) { return switch(position) {
case 0: case 0, 1, 2 -> Returnable.ReturnType.NUMBER;
case 1: case 3 -> Returnable.ReturnType.STRING;
case 2: case 4 -> Returnable.ReturnType.BOOLEAN;
return Returnable.ReturnType.NUMBER; default -> null;
case 3: };
return Returnable.ReturnType.STRING;
case 4:
return Returnable.ReturnType.BOOLEAN;
default:
return null;
}
} }
} }

12
common/src/main/java/com/dfsek/terra/api/structures/script/builders/CheckBlockFunctionBuilder.java
View File

@ -21,13 +21,9 @@ public class CheckBlockFunctionBuilder implements FunctionBuilder<CheckBlockFunc
@Override @Override
public Returnable.ReturnType getArgument(int position) { public Returnable.ReturnType getArgument(int position) {
switch(position) { return switch(position) {
case 0: case 0, 1, 2 -> Returnable.ReturnType.NUMBER;
case 1: default -> null;
case 2: };
return Returnable.ReturnType.NUMBER;
default:
return null;
}
} }
} }

13
common/src/main/java/com/dfsek/terra/api/structures/script/builders/CheckFunctionBuilder.java
View File

@ -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.parser.lang.functions.FunctionBuilder;
import com.dfsek.terra.api.structures.script.functions.CheckFunction; import com.dfsek.terra.api.structures.script.functions.CheckFunction;
import com.dfsek.terra.api.structures.tokenizer.Position; import com.dfsek.terra.api.structures.tokenizer.Position;
import com.dfsek.terra.world.generation.math.SamplerCache;
import java.util.List; import java.util.List;
@ -30,13 +29,9 @@ public class CheckFunctionBuilder implements FunctionBuilder<CheckFunction> {
@Override @Override
public Returnable.ReturnType getArgument(int position) { public Returnable.ReturnType getArgument(int position) {
switch(position) { return switch(position) {
case 0: case 0, 1, 2 -> Returnable.ReturnType.NUMBER;
case 1: default -> null;
case 2: };
return Returnable.ReturnType.NUMBER;
default:
return null;
}
} }
} }

15
common/src/main/java/com/dfsek/terra/api/structures/script/builders/EntityFunctionBuilder.java
View File

@ -29,15 +29,10 @@ public class EntityFunctionBuilder implements FunctionBuilder<EntityFunction> {
@Override @Override
public Returnable.ReturnType getArgument(int position) { public Returnable.ReturnType getArgument(int position) {
switch(position) { return switch(position) {
case 0: case 0, 1, 2 -> Returnable.ReturnType.NUMBER;
case 1: case 3 -> Returnable.ReturnType.STRING;
case 2: default -> null;
return Returnable.ReturnType.NUMBER; };
case 3:
return Returnable.ReturnType.STRING;
default:
return null;
}
} }
} }

12
common/src/main/java/com/dfsek/terra/api/structures/script/builders/GetMarkFunctionBuilder.java
View File

@ -25,13 +25,9 @@ public class GetMarkFunctionBuilder implements FunctionBuilder<GetMarkFunction>
@Override @Override
public Returnable.ReturnType getArgument(int position) { public Returnable.ReturnType getArgument(int position) {
switch(position) { return switch(position) {
case 0: case 0, 1, 2 -> Returnable.ReturnType.NUMBER;
case 1: default -> null;
case 2: };
return Returnable.ReturnType.NUMBER;
default:
return null;
}
} }
} }

15
common/src/main/java/com/dfsek/terra/api/structures/script/builders/LootFunctionBuilder.java
View File

@ -34,15 +34,10 @@ public class LootFunctionBuilder implements FunctionBuilder<LootFunction> {
@Override @Override
public Returnable.ReturnType getArgument(int position) { public Returnable.ReturnType getArgument(int position) {
switch(position) { return switch(position) {
case 0: case 0, 1, 2 -> Returnable.ReturnType.NUMBER;
case 1: case 3 -> Returnable.ReturnType.STRING;
case 2: default -> null;
return Returnable.ReturnType.NUMBER; };
case 3:
return Returnable.ReturnType.STRING;
default:
return null;
}
} }
} }

15
common/src/main/java/com/dfsek/terra/api/structures/script/builders/PullFunctionBuilder.java
View File

@ -29,15 +29,10 @@ public class PullFunctionBuilder implements FunctionBuilder<PullFunction> {
@Override @Override
public Returnable.ReturnType getArgument(int position) { public Returnable.ReturnType getArgument(int position) {
switch(position) { return switch(position) {
case 0: case 0, 1, 2 -> Returnable.ReturnType.NUMBER;
case 1: case 3 -> Returnable.ReturnType.STRING;
case 2: default -> null;
return Returnable.ReturnType.NUMBER; };
case 3:
return Returnable.ReturnType.STRING;
default:
return null;
}
} }
} }

15
common/src/main/java/com/dfsek/terra/api/structures/script/builders/SetMarkFunctionBuilder.java
View File

@ -26,15 +26,10 @@ public class SetMarkFunctionBuilder implements FunctionBuilder<SetMarkFunction>
@Override @Override
public Returnable.ReturnType getArgument(int position) { public Returnable.ReturnType getArgument(int position) {
switch(position) { return switch(position) {
case 0: case 0, 1, 2 -> Returnable.ReturnType.NUMBER;
case 1: case 3 -> Returnable.ReturnType.STRING;
case 2: default -> null;
return Returnable.ReturnType.NUMBER; };
case 3:
return Returnable.ReturnType.STRING;
default:
return null;
}
} }
} }

15
common/src/main/java/com/dfsek/terra/api/structures/script/builders/StateFunctionBuilder.java
View File

@ -30,15 +30,10 @@ public class StateFunctionBuilder implements FunctionBuilder<StateFunction> {
@Override @Override
public Returnable.ReturnType getArgument(int position) { public Returnable.ReturnType getArgument(int position) {
switch(position) { return switch(position) {
case 0: case 0, 1, 2 -> Returnable.ReturnType.NUMBER;
case 1: case 3 -> Returnable.ReturnType.STRING;
case 2: default -> null;
return Returnable.ReturnType.NUMBER; };
case 3:
return Returnable.ReturnType.STRING;
default:
return null;
}
} }
} }

12
common/src/main/java/com/dfsek/terra/api/structures/script/builders/StructureFunctionBuilder.java
View File

@ -36,13 +36,9 @@ public class StructureFunctionBuilder implements FunctionBuilder<StructureFuncti
@Override @Override
public Returnable.ReturnType getArgument(int position) { public Returnable.ReturnType getArgument(int position) {
switch(position) { return switch(position) {
case 0: case 0, 1, 2 -> Returnable.ReturnType.NUMBER;
case 1: default -> Returnable.ReturnType.STRING;
case 2: };
return Returnable.ReturnType.NUMBER;
default:
return Returnable.ReturnType.STRING;
}
} }
} }

37
common/src/main/java/com/dfsek/terra/api/structures/structure/Rotation.java
View File

@ -12,18 +12,13 @@ public enum Rotation {
} }
public static Rotation fromDegrees(int deg) { public static Rotation fromDegrees(int deg) {
switch(FastMath.floorMod(deg, 360)) { return switch(FastMath.floorMod(deg, 360)) {
case 0: case 0 -> Rotation.NONE;
return Rotation.NONE; case 90 -> Rotation.CW_90;
case 90: case 180 -> Rotation.CW_180;
return Rotation.CW_90; case 270 -> Rotation.CCW_90;
case 180: default -> throw new IllegalArgumentException();
return Rotation.CW_180; };
case 270:
return Rotation.CCW_90;
default:
throw new IllegalArgumentException();
}
} }
public int getDegrees() { public int getDegrees() {
@ -31,18 +26,12 @@ public enum Rotation {
} }
public Rotation inverse() { public Rotation inverse() {
switch(this) { return switch(this) {
case NONE: case NONE -> NONE;
return NONE; case CCW_90 -> CW_90;
case CCW_90: case CW_90 -> CCW_90;
return CW_90; case CW_180 -> CW_180;
case CW_90: };
return CCW_90;
case CW_180:
return CW_180;
default:
throw new IllegalArgumentException();
}
} }
public Rotation rotate(Rotation rotation) { public Rotation rotate(Rotation rotation) {

233
common/src/main/java/com/dfsek/terra/api/structures/structure/RotationUtil.java
View File

@ -30,15 +30,9 @@ public class RotationUtil {
public static void rotateVector(Vector2 orig, Rotation r) { public static void rotateVector(Vector2 orig, Rotation r) {
Vector2 copy = orig.clone(); Vector2 copy = orig.clone();
switch(r) { switch(r) {
case CW_90: case CW_90 -> copy.setX(orig.getZ()).setZ(-orig.getX());
copy.setX(orig.getZ()).setZ(-orig.getX()); case CCW_90 -> copy.setX(-orig.getZ()).setZ(orig.getX());
break; case CW_180 -> copy.multiply(-1);
case CCW_90:
copy.setX(-orig.getZ()).setZ(orig.getX());
break;
case CW_180:
copy.multiply(-1);
break;
} }
orig.setX(copy.getX()); orig.setX(copy.getX());
orig.setZ(copy.getZ()); orig.setZ(copy.getZ());
@ -68,42 +62,25 @@ public class RotationUtil {
* @return integer representation of BlockFace * @return integer representation of BlockFace
*/ */
public static int faceRotation(BlockFace f) { public static int faceRotation(BlockFace f) {
switch(f) { return switch(f) {
case NORTH: case NORTH -> 0;
return 0; case NORTH_NORTH_EAST -> 1;
case NORTH_NORTH_EAST: case NORTH_EAST -> 2;
return 1; case EAST_NORTH_EAST -> 3;
case NORTH_EAST: case EAST -> 4;
return 2; case EAST_SOUTH_EAST -> 5;
case EAST_NORTH_EAST: case SOUTH_EAST -> 6;
return 3; case SOUTH_SOUTH_EAST -> 7;
case EAST: case SOUTH -> 8;
return 4; case SOUTH_SOUTH_WEST -> 9;
case EAST_SOUTH_EAST: case SOUTH_WEST -> 10;
return 5; case WEST_SOUTH_WEST -> 11;
case SOUTH_EAST: case WEST -> 12;
return 6; case WEST_NORTH_WEST -> 13;
case SOUTH_SOUTH_EAST: case NORTH_WEST -> 14;
return 7; case NORTH_NORTH_WEST -> 15;
case SOUTH: default -> -1;
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;
}
} }
/** /**
@ -113,42 +90,25 @@ public class RotationUtil {
* @return BlockFace represented by integer. * @return BlockFace represented by integer.
*/ */
public static BlockFace fromRotation(int r) { public static BlockFace fromRotation(int r) {
switch(FastMath.floorMod(r, 16)) { return switch(FastMath.floorMod(r, 16)) {
case 0: case 0 -> BlockFace.NORTH;
return BlockFace.NORTH; case 1 -> BlockFace.NORTH_NORTH_EAST;
case 1: case 2 -> BlockFace.NORTH_EAST;
return BlockFace.NORTH_NORTH_EAST; case 3 -> BlockFace.EAST_NORTH_EAST;
case 2: case 4 -> BlockFace.EAST;
return BlockFace.NORTH_EAST; case 5 -> BlockFace.EAST_SOUTH_EAST;
case 3: case 6 -> BlockFace.SOUTH_EAST;
return BlockFace.EAST_NORTH_EAST; case 7 -> BlockFace.SOUTH_SOUTH_EAST;
case 4: case 8 -> BlockFace.SOUTH;
return BlockFace.EAST; case 9 -> BlockFace.SOUTH_SOUTH_WEST;
case 5: case 10 -> BlockFace.SOUTH_WEST;
return BlockFace.EAST_SOUTH_EAST; case 11 -> BlockFace.WEST_SOUTH_WEST;
case 6: case 12 -> BlockFace.WEST;
return BlockFace.SOUTH_EAST; case 13 -> BlockFace.WEST_NORTH_WEST;
case 7: case 14 -> BlockFace.NORTH_WEST;
return BlockFace.SOUTH_SOUTH_EAST; case 15 -> BlockFace.NORTH_NORTH_WEST;
case 8: default -> throw new IllegalArgumentException();
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();
}
} }
public static Axis getRotatedAxis(Axis orig, Rotation r) { public static Axis getRotatedAxis(Axis orig, Rotation r) {
@ -174,78 +134,45 @@ public class RotationUtil {
*/ */
@SuppressWarnings("fallthrough") @SuppressWarnings("fallthrough")
public static Rail.Shape getRotatedRail(Rail.Shape orig, Rotation r) { public static Rail.Shape getRotatedRail(Rail.Shape orig, Rotation r) {
switch(r) { return switch(r) {
case CCW_90: case CCW_90 -> switch(orig) {
switch(orig) { case NORTH_WEST -> Rail.Shape.SOUTH_WEST;
case NORTH_WEST: case NORTH_SOUTH -> Rail.Shape.EAST_WEST;
return Rail.Shape.SOUTH_WEST; case SOUTH_WEST -> Rail.Shape.SOUTH_EAST;
case NORTH_SOUTH: case SOUTH_EAST -> Rail.Shape.NORTH_EAST;
return Rail.Shape.EAST_WEST; case EAST_WEST -> Rail.Shape.NORTH_SOUTH;
case SOUTH_WEST: case NORTH_EAST -> Rail.Shape.NORTH_WEST;
return Rail.Shape.SOUTH_EAST; case ASCENDING_EAST -> Rail.Shape.ASCENDING_NORTH;
case SOUTH_EAST: case ASCENDING_WEST -> Rail.Shape.ASCENDING_SOUTH;
return Rail.Shape.NORTH_EAST; case ASCENDING_NORTH -> Rail.Shape.ASCENDING_WEST;
case EAST_WEST: case ASCENDING_SOUTH -> Rail.Shape.ASCENDING_EAST;
return Rail.Shape.NORTH_SOUTH; };
case NORTH_EAST: case CW_90 -> switch(orig) {
return Rail.Shape.NORTH_WEST; case NORTH_WEST -> Rail.Shape.NORTH_EAST;
case ASCENDING_EAST: case NORTH_SOUTH -> Rail.Shape.EAST_WEST;
return Rail.Shape.ASCENDING_NORTH; case SOUTH_WEST -> Rail.Shape.NORTH_WEST;
case ASCENDING_WEST: case SOUTH_EAST -> Rail.Shape.SOUTH_WEST;
return Rail.Shape.ASCENDING_SOUTH; case EAST_WEST -> Rail.Shape.NORTH_SOUTH;
case ASCENDING_NORTH: case NORTH_EAST -> Rail.Shape.SOUTH_EAST;
return Rail.Shape.ASCENDING_WEST; case ASCENDING_EAST -> Rail.Shape.ASCENDING_SOUTH;
case ASCENDING_SOUTH: case ASCENDING_WEST -> Rail.Shape.ASCENDING_NORTH;
return Rail.Shape.ASCENDING_EAST; case ASCENDING_NORTH -> Rail.Shape.ASCENDING_EAST;
} case ASCENDING_SOUTH -> Rail.Shape.ASCENDING_WEST;
case CW_90: };
switch(orig) { case CW_180 -> switch(orig) {
case NORTH_WEST: case NORTH_WEST -> Rail.Shape.SOUTH_EAST;
return Rail.Shape.NORTH_EAST; case NORTH_SOUTH -> Rail.Shape.NORTH_SOUTH;
case NORTH_SOUTH: case SOUTH_WEST -> Rail.Shape.NORTH_EAST;
return Rail.Shape.EAST_WEST; case SOUTH_EAST -> Rail.Shape.NORTH_WEST;
case SOUTH_WEST: case EAST_WEST -> Rail.Shape.EAST_WEST;
return Rail.Shape.NORTH_WEST; case NORTH_EAST -> Rail.Shape.SOUTH_WEST;
case SOUTH_EAST: case ASCENDING_EAST -> Rail.Shape.ASCENDING_WEST;
return Rail.Shape.SOUTH_WEST; case ASCENDING_WEST -> Rail.Shape.ASCENDING_EAST;
case EAST_WEST: case ASCENDING_NORTH -> Rail.Shape.ASCENDING_SOUTH;
return Rail.Shape.NORTH_SOUTH; case ASCENDING_SOUTH -> Rail.Shape.ASCENDING_NORTH;
case NORTH_EAST: };
return Rail.Shape.SOUTH_EAST; default -> orig;
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;
} }
public static void rotateBlockData(BlockData data, Rotation r) { public static void rotateBlockData(BlockData data, Rotation r) {

8
common/src/main/java/com/dfsek/terra/carving/UserDefinedCarver.java
View File

@ -60,12 +60,8 @@ public class UserDefinedCarver extends Carver {
functions.forEach((id, noise) -> { functions.forEach((id, noise) -> {
switch(noise.getDimensions()) { switch(noise.getDimensions()) {
case 2: case 2 -> p.registerFunction(id, new NoiseFunction2(noise.apply(hash)));
p.registerFunction(id, new NoiseFunction2(noise.apply(hash))); case 3 -> p.registerFunction(id, new NoiseFunction3(noise.apply(hash)));
break;
case 3:
p.registerFunction(id, new NoiseFunction3(noise.apply(hash)));
break;
} }
}); });

11
common/src/main/java/com/dfsek/terra/config/factories/OreFactory.java
View File

@ -11,12 +11,9 @@ public class OreFactory implements ConfigFactory<OreTemplate, Ore> {
@Override @Override
public Ore build(OreTemplate config, TerraPlugin main) { public Ore build(OreTemplate config, TerraPlugin main) {
BlockData m = config.getMaterial(); BlockData m = config.getMaterial();
switch(config.getType()) { return switch(config.getType()) {
case SPHERE: case SPHERE -> new DeformedSphereOre(m, config.getReplaceable(), config.doPhysics(), config.getDeform(), config.getDeformFrequency(), config.getSize(), main);
return 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);
case VANILLA: };
return new VanillaOre(m, config.getReplaceable(), config.doPhysics(), config.getSize(), main);
}
return null;
} }
} }

15
common/src/main/java/com/dfsek/terra/config/loaders/config/biome/BiomeProviderBuilderLoader.java
View File

@ -21,15 +21,10 @@ public class BiomeProviderBuilderLoader implements TypeLoader<BiomeProvider.Biom
public BiomeProvider.BiomeProviderBuilder load(Type t, Object c, ConfigLoader loader) throws LoadException { // TODO: clean this up public BiomeProvider.BiomeProviderBuilder load(Type t, Object c, ConfigLoader loader) throws LoadException { // TODO: clean this up
Map<String, Object> map = (Map<String, Object>) c; Map<String, Object> map = (Map<String, Object>) c;
switch(loader.loadClass(BiomeProvider.Type.class, map.get("type"))) { return switch(loader.loadClass(BiomeProvider.Type.class, map.get("type"))) {
case IMAGE: case IMAGE -> loader.loadClass(ImageProviderTemplate.class, map);
return loader.loadClass(ImageProviderTemplate.class, map); case PIPELINE -> loader.loadClass(BiomePipelineTemplate.class, map);
case PIPELINE: case SINGLE -> loader.loadClass(SingleBiomeProviderTemplate.class, map);
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"));
} }
} }

21
common/src/main/java/com/dfsek/terra/config/loaders/config/biome/StageBuilderLoader.java
View File

@ -38,20 +38,13 @@ public class StageBuilderLoader implements TypeLoader<StageSeeded> {
return loader.loadClass(ExpanderStageTemplate.class, mutator); return loader.loadClass(ExpanderStageTemplate.class, mutator);
} else throw new LoadException("No such expander \"" + stageType + "\""); } else throw new LoadException("No such expander \"" + stageType + "\"");
} else if(entry.getKey().equals("mutate")) { } else if(entry.getKey().equals("mutate")) {
switch(loader.loadClass(MutatorStage.Type.class, mutator.get("type"))) { return switch(loader.loadClass(MutatorStage.Type.class, mutator.get("type"))) {
case SMOOTH: case SMOOTH -> loader.loadClass(SmoothMutatorTemplate.class, mutator);
return loader.loadClass(SmoothMutatorTemplate.class, mutator); case REPLACE -> loader.loadClass(ReplaceMutatorTemplate.class, mutator);
case REPLACE: case REPLACE_LIST -> loader.loadClass(ReplaceListMutatorTemplate.class, mutator);
return loader.loadClass(ReplaceMutatorTemplate.class, mutator); case BORDER -> loader.loadClass(BorderMutatorTemplate.class, mutator);
case REPLACE_LIST: case BORDER_LIST -> loader.loadClass(BorderListMutatorTemplate.class, mutator);
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"));
}
} }
throw new LoadException("No such mutator \"" + entry.getKey() + "\""); throw new LoadException("No such mutator \"" + entry.getKey() + "\"");
} }

13
common/src/test/java/structure/ParserTest.java
View File

@ -36,14 +36,11 @@ public class ParserTest {
@Override @Override
public Returnable.ReturnType getArgument(int position) { public Returnable.ReturnType getArgument(int position) {
switch(position) { return switch(position) {
case 0: case 0 -> Returnable.ReturnType.STRING;
return Returnable.ReturnType.STRING; case 1 -> Returnable.ReturnType.NUMBER;
case 1: default -> null;
return Returnable.ReturnType.NUMBER; };
default:
return null;
}
} }
}); });

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) { public static Stairs.Shape adapt(org.bukkit.block.data.type.Stairs.Shape shape) {
switch(shape) { return switch(shape) {
case STRAIGHT: case STRAIGHT -> Stairs.Shape.STRAIGHT;
return Stairs.Shape.STRAIGHT; case INNER_LEFT -> Stairs.Shape.INNER_LEFT;
case INNER_LEFT: case OUTER_LEFT -> Stairs.Shape.OUTER_LEFT;
return Stairs.Shape.INNER_LEFT; case INNER_RIGHT -> Stairs.Shape.INNER_RIGHT;
case OUTER_LEFT: case OUTER_RIGHT -> Stairs.Shape.OUTER_RIGHT;
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();
}
} }
public static BlockData adapt(org.bukkit.block.data.BlockData data) { 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) { public static Axis adapt(org.bukkit.Axis axis) {
switch(axis) { return switch(axis) {
case X: case X -> Axis.X;
return Axis.X; case Y -> Axis.Y;
case Y: case Z -> Axis.Z;
return Axis.Y; };
case Z:
return Axis.Z;
default:
throw new IllegalStateException();
}
} }
public static Bisected.Half adapt(org.bukkit.block.data.Bisected.Half half) { public static Bisected.Half adapt(org.bukkit.block.data.Bisected.Half half) {
switch(half) { return switch(half) {
case BOTTOM: case BOTTOM -> Bisected.Half.BOTTOM;
return Bisected.Half.BOTTOM; case TOP -> Bisected.Half.TOP;
case TOP: };
return Bisected.Half.TOP;
default:
throw new IllegalStateException();
}
} }
public static BlockFace adapt(org.bukkit.block.BlockFace face) { public static BlockFace adapt(org.bukkit.block.BlockFace face) {
switch(face) { return switch(face) {
case DOWN: case DOWN -> BlockFace.DOWN;
return BlockFace.DOWN; case UP -> BlockFace.UP;
case UP: case NORTH_WEST -> BlockFace.NORTH_WEST;
return BlockFace.UP; case NORTH_EAST -> BlockFace.NORTH_EAST;
case NORTH_WEST: case SOUTH_EAST -> BlockFace.SOUTH_EAST;
return BlockFace.NORTH_WEST; case SOUTH_WEST -> BlockFace.SOUTH_WEST;
case NORTH_EAST: case NORTH_NORTH_WEST -> BlockFace.NORTH_NORTH_WEST;
return BlockFace.NORTH_EAST; case WEST_NORTH_WEST -> BlockFace.WEST_NORTH_WEST;
case SOUTH_EAST: case WEST_SOUTH_WEST -> BlockFace.WEST_SOUTH_WEST;
return BlockFace.SOUTH_EAST; case SOUTH_SOUTH_WEST -> BlockFace.SOUTH_SOUTH_WEST;
case SOUTH_WEST: case EAST_NORTH_EAST -> BlockFace.EAST_NORTH_EAST;
return BlockFace.SOUTH_WEST; case WEST -> BlockFace.WEST;
case NORTH_NORTH_WEST: case SOUTH -> BlockFace.SOUTH;
return BlockFace.NORTH_NORTH_WEST; case EAST -> BlockFace.EAST;
case WEST_NORTH_WEST: case NORTH -> BlockFace.NORTH;
return BlockFace.WEST_NORTH_WEST; case SELF -> BlockFace.SELF;
case WEST_SOUTH_WEST: case EAST_SOUTH_EAST -> BlockFace.EAST_SOUTH_EAST;
return BlockFace.WEST_SOUTH_WEST; case NORTH_NORTH_EAST -> BlockFace.NORTH_NORTH_EAST;
case SOUTH_SOUTH_WEST: case SOUTH_SOUTH_EAST -> BlockFace.SOUTH_SOUTH_EAST;
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();
}
} }
public static Slab.Type adapt(org.bukkit.block.data.type.Slab.Type type) { public static Slab.Type adapt(org.bukkit.block.data.type.Slab.Type type) {
switch(type) { return switch(type) {
case BOTTOM: case BOTTOM -> Slab.Type.BOTTOM;
return Slab.Type.BOTTOM; case TOP -> Slab.Type.TOP;
case TOP: case DOUBLE -> Slab.Type.DOUBLE;
return Slab.Type.TOP; };
case DOUBLE:
return Slab.Type.DOUBLE;
default:
throw new IllegalStateException();
}
} }
public static RedstoneWire.Connection adapt(org.bukkit.block.data.type.RedstoneWire.Connection connection) { public static RedstoneWire.Connection adapt(org.bukkit.block.data.type.RedstoneWire.Connection connection) {
switch(connection) { return switch(connection) {
case NONE: case NONE -> RedstoneWire.Connection.NONE;
return RedstoneWire.Connection.NONE; case UP -> RedstoneWire.Connection.UP;
case UP: case SIDE -> RedstoneWire.Connection.SIDE;
return RedstoneWire.Connection.UP; };
case SIDE:
return RedstoneWire.Connection.SIDE;
default:
throw new IllegalStateException();
}
} }
public static org.bukkit.block.data.type.RedstoneWire.Connection adapt(RedstoneWire.Connection connection) { public static org.bukkit.block.data.type.RedstoneWire.Connection adapt(RedstoneWire.Connection connection) {
switch(connection) { return switch(connection) {
case SIDE: case SIDE -> org.bukkit.block.data.type.RedstoneWire.Connection.SIDE;
return org.bukkit.block.data.type.RedstoneWire.Connection.SIDE; case UP -> org.bukkit.block.data.type.RedstoneWire.Connection.UP;
case UP: case NONE -> org.bukkit.block.data.type.RedstoneWire.Connection.NONE;
return org.bukkit.block.data.type.RedstoneWire.Connection.UP; };
case NONE:
return org.bukkit.block.data.type.RedstoneWire.Connection.NONE;
default:
throw new IllegalStateException();
}
} }
public static org.bukkit.block.data.type.Stairs.Shape adapt(Stairs.Shape shape) { public static org.bukkit.block.data.type.Stairs.Shape adapt(Stairs.Shape shape) {
switch(shape) { return switch(shape) {
case STRAIGHT: case STRAIGHT -> org.bukkit.block.data.type.Stairs.Shape.STRAIGHT;
return org.bukkit.block.data.type.Stairs.Shape.STRAIGHT; case INNER_LEFT -> org.bukkit.block.data.type.Stairs.Shape.INNER_LEFT;
case INNER_LEFT: case OUTER_LEFT -> org.bukkit.block.data.type.Stairs.Shape.OUTER_LEFT;
return org.bukkit.block.data.type.Stairs.Shape.INNER_LEFT; case INNER_RIGHT -> org.bukkit.block.data.type.Stairs.Shape.INNER_RIGHT;
case OUTER_LEFT: case OUTER_RIGHT -> org.bukkit.block.data.type.Stairs.Shape.OUTER_RIGHT;
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();
}
} }
public static Rail.Shape adapt(org.bukkit.block.data.Rail.Shape shape) { public static Rail.Shape adapt(org.bukkit.block.data.Rail.Shape shape) {
switch(shape) { return switch(shape) {
case SOUTH_WEST: case SOUTH_WEST -> Rail.Shape.SOUTH_WEST;
return Rail.Shape.SOUTH_WEST; case SOUTH_EAST -> Rail.Shape.SOUTH_EAST;
case SOUTH_EAST: case NORTH_EAST -> Rail.Shape.NORTH_EAST;
return Rail.Shape.SOUTH_EAST; case NORTH_WEST -> Rail.Shape.NORTH_WEST;
case NORTH_EAST: case ASCENDING_EAST -> Rail.Shape.ASCENDING_EAST;
return Rail.Shape.NORTH_EAST; case ASCENDING_WEST -> Rail.Shape.ASCENDING_WEST;
case NORTH_WEST: case ASCENDING_SOUTH -> Rail.Shape.ASCENDING_SOUTH;
return Rail.Shape.NORTH_WEST; case ASCENDING_NORTH -> Rail.Shape.ASCENDING_NORTH;
case ASCENDING_EAST: case NORTH_SOUTH -> Rail.Shape.NORTH_SOUTH;
return Rail.Shape.ASCENDING_EAST; case EAST_WEST -> Rail.Shape.EAST_WEST;
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();
}
} }
public static org.bukkit.block.data.Rail.Shape adapt(Rail.Shape shape) { public static org.bukkit.block.data.Rail.Shape adapt(Rail.Shape shape) {
switch(shape) { return switch(shape) {
case EAST_WEST: case EAST_WEST -> org.bukkit.block.data.Rail.Shape.EAST_WEST;
return org.bukkit.block.data.Rail.Shape.EAST_WEST; case NORTH_SOUTH -> org.bukkit.block.data.Rail.Shape.NORTH_SOUTH;
case NORTH_SOUTH: case ASCENDING_NORTH -> org.bukkit.block.data.Rail.Shape.ASCENDING_NORTH;
return org.bukkit.block.data.Rail.Shape.NORTH_SOUTH; case ASCENDING_SOUTH -> org.bukkit.block.data.Rail.Shape.ASCENDING_SOUTH;
case ASCENDING_NORTH: case ASCENDING_WEST -> org.bukkit.block.data.Rail.Shape.ASCENDING_WEST;
return org.bukkit.block.data.Rail.Shape.ASCENDING_NORTH; case ASCENDING_EAST -> org.bukkit.block.data.Rail.Shape.ASCENDING_EAST;
case ASCENDING_SOUTH: case NORTH_WEST -> org.bukkit.block.data.Rail.Shape.NORTH_WEST;
return org.bukkit.block.data.Rail.Shape.ASCENDING_SOUTH; case NORTH_EAST -> org.bukkit.block.data.Rail.Shape.NORTH_EAST;
case ASCENDING_WEST: case SOUTH_EAST -> org.bukkit.block.data.Rail.Shape.SOUTH_EAST;
return org.bukkit.block.data.Rail.Shape.ASCENDING_WEST; case SOUTH_WEST -> org.bukkit.block.data.Rail.Shape.SOUTH_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();
}
} }
public static org.bukkit.block.data.Bisected.Half adapt(Bisected.Half half) { public static org.bukkit.block.data.Bisected.Half adapt(Bisected.Half half) {
switch(half) { return switch(half) {
case TOP: case TOP -> org.bukkit.block.data.Bisected.Half.TOP;
return org.bukkit.block.data.Bisected.Half.TOP; case BOTTOM -> org.bukkit.block.data.Bisected.Half.BOTTOM;
case BOTTOM: };
return org.bukkit.block.data.Bisected.Half.BOTTOM;
default:
throw new IllegalStateException();
}
} }
public static org.bukkit.Axis adapt(Axis axis) { public static org.bukkit.Axis adapt(Axis axis) {
switch(axis) { return switch(axis) {
case Z: case Z -> org.bukkit.Axis.Z;
return org.bukkit.Axis.Z; case Y -> org.bukkit.Axis.Y;
case Y: case X -> org.bukkit.Axis.X;
return org.bukkit.Axis.Y; };
case X:
return org.bukkit.Axis.X;
default:
throw new IllegalStateException();
}
} }
public static org.bukkit.block.BlockFace adapt(BlockFace face) { public static org.bukkit.block.BlockFace adapt(BlockFace face) {
switch(face) { return switch(face) {
case DOWN: case DOWN -> org.bukkit.block.BlockFace.DOWN;
return org.bukkit.block.BlockFace.DOWN; case UP -> org.bukkit.block.BlockFace.UP;
case UP: case NORTH_WEST -> org.bukkit.block.BlockFace.NORTH_WEST;
return org.bukkit.block.BlockFace.UP; case NORTH_EAST -> org.bukkit.block.BlockFace.NORTH_EAST;
case NORTH_WEST: case SOUTH_EAST -> org.bukkit.block.BlockFace.SOUTH_EAST;
return org.bukkit.block.BlockFace.NORTH_WEST; case SOUTH_WEST -> org.bukkit.block.BlockFace.SOUTH_WEST;
case NORTH_EAST: case NORTH_NORTH_WEST -> org.bukkit.block.BlockFace.NORTH_NORTH_WEST;
return org.bukkit.block.BlockFace.NORTH_EAST; case WEST_NORTH_WEST -> org.bukkit.block.BlockFace.WEST_NORTH_WEST;
case SOUTH_EAST: case WEST_SOUTH_WEST -> org.bukkit.block.BlockFace.WEST_SOUTH_WEST;
return org.bukkit.block.BlockFace.SOUTH_EAST; case SOUTH_SOUTH_WEST -> org.bukkit.block.BlockFace.SOUTH_SOUTH_WEST;
case SOUTH_WEST: case EAST_NORTH_EAST -> org.bukkit.block.BlockFace.EAST_NORTH_EAST;
return org.bukkit.block.BlockFace.SOUTH_WEST; case WEST -> org.bukkit.block.BlockFace.WEST;
case NORTH_NORTH_WEST: case SOUTH -> org.bukkit.block.BlockFace.SOUTH;
return org.bukkit.block.BlockFace.NORTH_NORTH_WEST; case EAST -> org.bukkit.block.BlockFace.EAST;
case WEST_NORTH_WEST: case NORTH -> org.bukkit.block.BlockFace.NORTH;
return org.bukkit.block.BlockFace.WEST_NORTH_WEST; case SELF -> org.bukkit.block.BlockFace.SELF;
case WEST_SOUTH_WEST: case EAST_SOUTH_EAST -> org.bukkit.block.BlockFace.EAST_SOUTH_EAST;
return org.bukkit.block.BlockFace.WEST_SOUTH_WEST; case NORTH_NORTH_EAST -> org.bukkit.block.BlockFace.NORTH_NORTH_EAST;
case SOUTH_SOUTH_WEST: case SOUTH_SOUTH_EAST -> org.bukkit.block.BlockFace.SOUTH_SOUTH_EAST;
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();
}
} }
public static org.bukkit.block.data.type.Slab.Type adapt(Slab.Type type) { public static org.bukkit.block.data.type.Slab.Type adapt(Slab.Type type) {
switch(type) { return switch(type) {
case TOP: case TOP -> org.bukkit.block.data.type.Slab.Type.TOP;
return org.bukkit.block.data.type.Slab.Type.TOP; case DOUBLE -> org.bukkit.block.data.type.Slab.Type.DOUBLE;
case DOUBLE: case BOTTOM -> org.bukkit.block.data.type.Slab.Type.BOTTOM;
return org.bukkit.block.data.type.Slab.Type.DOUBLE; };
case BOTTOM:
return org.bukkit.block.data.type.Slab.Type.BOTTOM;
default:
throw new IllegalStateException();
}
} }
public static Location adapt(com.dfsek.terra.api.math.vector.Location location) { 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) { private MaterialSet getSpawnable(TreeType type) {
WorldHandle handle = main.getWorldHandle(); WorldHandle handle = main.getWorldHandle();
switch(type) { return switch(type) {
case CRIMSON_FUNGUS: case CRIMSON_FUNGUS -> MaterialSet.get(handle.createBlockData("minecraft:crimson_nylium"));
return MaterialSet.get(handle.createBlockData("minecraft:crimson_nylium")); case WARPED_FUNGUS -> MaterialSet.get(handle.createBlockData("minecraft:warped_nylium"));
case WARPED_FUNGUS: case BROWN_MUSHROOM, RED_MUSHROOM -> MaterialSet.get(handle.createBlockData("minecraft:mycelium"), handle.createBlockData("minecraft:grass_block"),
return MaterialSet.get(handle.createBlockData("minecraft:warped_nylium")); handle.createBlockData("minecraft:podzol"));
case BROWN_MUSHROOM: case CHORUS_PLANT -> MaterialSet.get(handle.createBlockData("minecraft:end_stone"));
case RED_MUSHROOM: default -> MaterialSet.get(handle.createBlockData("minecraft:grass_block"), handle.createBlockData("minecraft:dirt"),
return MaterialSet.get(handle.createBlockData("minecraft:mycelium"), handle.createBlockData("minecraft:grass_block"), handle.createBlockData("minecraft:podzol"));
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"));
}
} }
@Override @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) { public static org.bukkit.block.data.type.Wall.Height adapt(com.dfsek.terra.api.platform.block.data.Wall.Height height) {
switch(height) { return switch(height) {
case NONE: case NONE -> org.bukkit.block.data.type.Wall.Height.NONE;
return org.bukkit.block.data.type.Wall.Height.NONE; case LOW -> org.bukkit.block.data.type.Wall.Height.LOW;
case LOW: case TALL -> org.bukkit.block.data.type.Wall.Height.TALL;
return org.bukkit.block.data.type.Wall.Height.LOW; };
case TALL:
return org.bukkit.block.data.type.Wall.Height.TALL;
default:
throw new IllegalStateException();
}
} }
public static com.dfsek.terra.api.platform.block.data.Wall.Height adapt(org.bukkit.block.data.type.Wall.Height height) { public static com.dfsek.terra.api.platform.block.data.Wall.Height adapt(org.bukkit.block.data.type.Wall.Height height) {
switch(height) { return switch(height) {
case TALL: case TALL -> Height.TALL;
return com.dfsek.terra.api.platform.block.data.Wall.Height.TALL; case LOW -> Height.LOW;
case LOW: case NONE -> Height.NONE;
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();
}
} }
@Override @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) { public void applyState(String state) {
SerialState.parse(state).forEach((k, v) -> { SerialState.parse(state).forEach((k, v) -> {
switch(k) { switch(k) {
case "type": case "type" -> setSpawnedType(new BukkitEntityType(org.bukkit.entity.EntityType.valueOf(v.toUpperCase())));
setSpawnedType(new BukkitEntityType(org.bukkit.entity.EntityType.valueOf(v.toUpperCase()))); case "delay" -> setDelay(Integer.parseInt(v));
return; case "min_delay" -> setMinSpawnDelay(Integer.parseInt(v));
case "delay": case "max_delay" -> setMaxSpawnDelay(Integer.parseInt(v));
setDelay(Integer.parseInt(v)); case "spawn_count" -> setSpawnCount(Integer.parseInt(v));
return; case "spawn_range" -> setSpawnRange(Integer.parseInt(v));
case "min_delay": case "max_nearby" -> setMaxNearbyEntities(Integer.parseInt(v));
setMinSpawnDelay(Integer.parseInt(v)); case "required_player_range" -> setRequiredPlayerRange(Integer.parseInt(v));
return; default -> throw new IllegalArgumentException("Invalid property: " + k);
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);
} }
}); });
} }

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 @Override
public BlockFace getFacing() { public BlockFace getFacing() {
switch(delegate.get(property)) { return switch(delegate.get(property)) {
case SOUTH: case SOUTH -> BlockFace.SOUTH;
return BlockFace.SOUTH; case DOWN -> BlockFace.DOWN;
case DOWN: case UP -> BlockFace.UP;
return BlockFace.DOWN; case EAST -> BlockFace.EAST;
case UP: case WEST -> BlockFace.WEST;
return BlockFace.UP; case NORTH -> BlockFace.NORTH;
case EAST: };
return BlockFace.EAST;
case WEST:
return BlockFace.WEST;
case NORTH:
return BlockFace.NORTH;
default:
throw new IllegalStateException();
}
} }
@Override @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 @Override
public void setFace(BlockFace face, boolean facing) { public void setFace(BlockFace face, boolean facing) {
switch(face) { switch(face) {
case NORTH: case NORTH -> delegate = delegate.with(Properties.NORTH, facing);
delegate = delegate.with(Properties.NORTH, facing); case SOUTH -> delegate = delegate.with(Properties.SOUTH, facing);
break; case EAST -> delegate = delegate.with(Properties.EAST, facing);
case SOUTH: case WEST -> delegate = delegate.with(Properties.WEST, facing);
delegate = delegate.with(Properties.SOUTH, facing); case UP -> delegate = delegate.with(Properties.UP, facing);
break; case DOWN -> delegate = delegate.with(Properties.DOWN, facing);
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;
} }
} }

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

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

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

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) { public static Direction adapt(BlockFace face) {
switch(face) { return switch(face) {
case NORTH: case NORTH -> Direction.NORTH;
return Direction.NORTH; case WEST -> Direction.WEST;
case WEST: case SOUTH -> Direction.SOUTH;
return Direction.WEST; case EAST -> Direction.EAST;
case SOUTH: case UP -> Direction.UP;
return Direction.SOUTH; case DOWN -> Direction.DOWN;
case EAST: default -> throw new IllegalArgumentException("Illegal direction: " + face);
return Direction.EAST; };
case UP:
return Direction.UP;
case DOWN:
return 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 @Override
public BlockFace getFacing() { public BlockFace getFacing() {
switch(delegate.getValue(property)) { return switch(delegate.getValue(property)) {
case SOUTH: case SOUTH -> BlockFace.SOUTH;
return BlockFace.SOUTH; case DOWN -> BlockFace.DOWN;
case DOWN: case UP -> BlockFace.UP;
return BlockFace.DOWN; case EAST -> BlockFace.EAST;
case UP: case WEST -> BlockFace.WEST;
return BlockFace.UP; case NORTH -> BlockFace.NORTH;
case EAST: };
return BlockFace.EAST;
case WEST:
return BlockFace.WEST;
case NORTH:
return BlockFace.NORTH;
default:
throw new IllegalStateException();
}
} }
@Override @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 final class ForgeEnumAdapter {
public static Stairs.Shape adapt(StairsShape shape) { public static Stairs.Shape adapt(StairsShape shape) {
switch(shape) { return switch(shape) {
case OUTER_RIGHT: case OUTER_RIGHT -> Stairs.Shape.OUTER_RIGHT;
return Stairs.Shape.OUTER_RIGHT; case INNER_RIGHT -> Stairs.Shape.INNER_RIGHT;
case INNER_RIGHT: case OUTER_LEFT -> Stairs.Shape.OUTER_LEFT;
return Stairs.Shape.INNER_RIGHT; case INNER_LEFT -> Stairs.Shape.INNER_LEFT;
case OUTER_LEFT: case STRAIGHT -> Stairs.Shape.STRAIGHT;
return Stairs.Shape.OUTER_LEFT; };
case INNER_LEFT:
return Stairs.Shape.INNER_LEFT;
case STRAIGHT:
return Stairs.Shape.STRAIGHT;
default:
throw new IllegalStateException();
}
} }
public static Bisected.Half adapt(Half half) { public static Bisected.Half adapt(Half half) {
switch(half) { return switch(half) {
case BOTTOM: case BOTTOM -> Bisected.Half.BOTTOM;
return Bisected.Half.BOTTOM; case TOP -> Bisected.Half.TOP;
case TOP: };
return Bisected.Half.TOP;
default:
throw new IllegalStateException();
}
} }
public static BlockFace adapt(Direction direction) { public static BlockFace adapt(Direction direction) {
switch(direction) { return switch(direction) {
case DOWN: case DOWN -> BlockFace.DOWN;
return BlockFace.DOWN; case UP -> BlockFace.UP;
case UP: case WEST -> BlockFace.WEST;
return BlockFace.UP; case EAST -> BlockFace.EAST;
case WEST: case NORTH -> BlockFace.NORTH;
return BlockFace.WEST; case SOUTH -> BlockFace.SOUTH;
case EAST: };
return BlockFace.EAST;
case NORTH:
return BlockFace.NORTH;
case SOUTH:
return BlockFace.SOUTH;
default:
throw new IllegalStateException();
}
} }
public static Slab.Type adapt(SlabType type) { public static Slab.Type adapt(SlabType type) {
switch(type) { return switch(type) {
case BOTTOM: case BOTTOM -> Slab.Type.BOTTOM;
return Slab.Type.BOTTOM; case TOP -> Slab.Type.TOP;
case TOP: case DOUBLE -> Slab.Type.DOUBLE;
return Slab.Type.TOP; };
case DOUBLE:
return Slab.Type.DOUBLE;
default:
throw new IllegalStateException();
}
} }
public static StairsShape adapt(Stairs.Shape shape) { public static StairsShape adapt(Stairs.Shape shape) {
switch(shape) { return switch(shape) {
case STRAIGHT: case STRAIGHT -> StairsShape.STRAIGHT;
return StairsShape.STRAIGHT; case INNER_LEFT -> StairsShape.INNER_LEFT;
case INNER_LEFT: case OUTER_LEFT -> StairsShape.OUTER_LEFT;
return StairsShape.INNER_LEFT; case INNER_RIGHT -> StairsShape.INNER_RIGHT;
case OUTER_LEFT: case OUTER_RIGHT -> StairsShape.OUTER_RIGHT;
return StairsShape.OUTER_LEFT; };
case INNER_RIGHT:
return StairsShape.INNER_RIGHT;
case OUTER_RIGHT:
return StairsShape.OUTER_RIGHT;
default:
throw new IllegalStateException();
}
} }
public static Half adapt(Bisected.Half half) { public static Half adapt(Bisected.Half half) {
switch(half) { return switch(half) {
case TOP: case TOP -> Half.TOP;
return Half.TOP; case BOTTOM -> Half.BOTTOM;
case BOTTOM: };
return Half.BOTTOM;
default:
throw new IllegalStateException();
}
} }
public static Direction adapt(BlockFace face) { public static Direction adapt(BlockFace face) {
switch(face) { return switch(face) {
case SOUTH: case SOUTH -> Direction.SOUTH;
return Direction.SOUTH; case NORTH -> Direction.NORTH;
case NORTH: case EAST -> Direction.EAST;
return Direction.NORTH; case WEST -> Direction.WEST;
case EAST: case UP -> Direction.UP;
return Direction.EAST; case DOWN -> Direction.DOWN;
case WEST: };
return Direction.WEST;
case UP:
return Direction.UP;
case DOWN:
return Direction.DOWN;
default:
throw new IllegalArgumentException();
}
} }
public static SlabType adapt(Slab.Type type) { public static SlabType adapt(Slab.Type type) {
switch(type) { return switch(type) {
case DOUBLE: case DOUBLE -> SlabType.DOUBLE;
return SlabType.DOUBLE; case TOP -> SlabType.TOP;
case TOP: case BOTTOM -> SlabType.BOTTOM;
return SlabType.TOP; };
case BOTTOM:
return SlabType.BOTTOM;
default:
throw new IllegalStateException();
}
} }
public static Axis adapt(Direction.Axis axis) { public static Axis adapt(Direction.Axis axis) {
switch(axis) { return switch(axis) {
case X: case X -> Axis.X;
return Axis.X; case Y -> Axis.Y;
case Y: case Z -> Axis.Z;
return Axis.Y; };
case Z:
return Axis.Z;
default:
throw new IllegalStateException();
}
} }
public static Direction.Axis adapt(Axis axis) { public static Direction.Axis adapt(Axis axis) {
switch(axis) { return switch(axis) {
case Z: case Z -> Direction.Axis.Z;
return Direction.Axis.Z; case Y -> Direction.Axis.Y;
case Y: case X -> Direction.Axis.X;
return Direction.Axis.Y; };
case X:
return Direction.Axis.X;
default:
throw new IllegalStateException();
}
} }
} }

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 @Override
public void setFace(BlockFace face, boolean facing) { public void setFace(BlockFace face, boolean facing) {
switch(face) { switch(face) {
case NORTH: case NORTH -> delegate = delegate.setValue(BlockStateProperties.NORTH, facing);
delegate = delegate.setValue(BlockStateProperties.NORTH, facing); case SOUTH -> delegate = delegate.setValue(BlockStateProperties.SOUTH, facing);
break; case EAST -> delegate = delegate.setValue(BlockStateProperties.EAST, facing);
case SOUTH: case WEST -> delegate = delegate.setValue(BlockStateProperties.WEST, facing);
delegate = delegate.setValue(BlockStateProperties.SOUTH, facing); case UP -> delegate = delegate.setValue(BlockStateProperties.UP, facing);
break; case DOWN -> delegate = delegate.setValue(BlockStateProperties.DOWN, facing);
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;
} }
} }

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

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) { public void terra$applyState(String state) {
SerialState.parse(state).forEach((k, v) -> { SerialState.parse(state).forEach((k, v) -> {
switch(k) { switch(k) {
case "type": case "type" -> terra$setSpawnedType(TerraForgePlugin.getInstance().getWorldHandle().getEntity(v));
terra$setSpawnedType(TerraForgePlugin.getInstance().getWorldHandle().getEntity(v)); case "delay" -> terra$setDelay(Integer.parseInt(v));
return; case "min_delay" -> terra$setMinSpawnDelay(Integer.parseInt(v));
case "delay": case "max_delay" -> terra$setMaxSpawnDelay(Integer.parseInt(v));
terra$setDelay(Integer.parseInt(v)); case "spawn_count" -> terra$setSpawnCount(Integer.parseInt(v));
return; case "spawn_range" -> terra$setSpawnRange(Integer.parseInt(v));
case "min_delay": case "max_nearby" -> terra$setMaxNearbyEntities(Integer.parseInt(v));
terra$setMinSpawnDelay(Integer.parseInt(v)); case "required_player_range" -> terra$setRequiredPlayerRange(Integer.parseInt(v));
return; default -> throw new IllegalArgumentException("Invalid property: " + k);
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);
} }
}); });
} }