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> {
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"))
}
}

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) -> {
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)));
}
});

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) {
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 {

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

@ -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;
}
}

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")) {
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;
}
}
}
}

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);
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<String, Returnable.ReturnType> 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<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 {
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) {

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) {
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;
}

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
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;
};
}
}

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
public Returnable.ReturnType getArgument(int position) {
switch(position) {
case 0:
case 1:
case 2:
return Returnable.ReturnType.NUMBER;
case 3:
return Returnable.ReturnType.STRING;
case 4:
return Returnable.ReturnType.BOOLEAN;
default:
return null;
}
return switch(position) {
case 0, 1, 2 -> Returnable.ReturnType.NUMBER;
case 3 -> Returnable.ReturnType.STRING;
case 4 -> Returnable.ReturnType.BOOLEAN;
default -> 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
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;
};
}
}

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.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<CheckFunction> {
@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;
};
}
}

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
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;
};
}
}

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
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;
};
}
}

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
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;
};
}
}

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
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;
};
}
}

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
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;
};
}
}

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
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;
};
}
}

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
public Returnable.ReturnType getArgument(int position) {
switch(position) {
case 0:
case 1:
case 2:
return Returnable.ReturnType.NUMBER;
default:
return Returnable.ReturnType.STRING;
}
return switch(position) {
case 0, 1, 2 -> Returnable.ReturnType.NUMBER;
default -> 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) {
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) {

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) {
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) {

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) -> {
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)));
}
});

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
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);
};
}
}

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
Map<String, Object> map = (Map<String, Object>) 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);
};
}
}

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);
} 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() + "\"");
}

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

@ -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;
};
}
});

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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