From 9d83dfd1648ee439ea79791def9addc358a6ad96 Mon Sep 17 00:00:00 2001 From: Astrash Date: Sun, 16 Jul 2023 11:49:14 +1000 Subject: [PATCH 01/83] Bump version to 6.3.2 --- build.gradle.kts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/build.gradle.kts b/build.gradle.kts index e4a533f8c..db6c27c15 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1,8 +1,8 @@ preRelease(true) -versionProjects(":common:api", version("6.3.1")) -versionProjects(":common:implementation", version("6.3.1")) -versionProjects(":platforms", version("6.3.1")) +versionProjects(":common:api", version("6.3.2")) +versionProjects(":common:implementation", version("6.3.2")) +versionProjects(":platforms", version("6.3.2")) allprojects { From fcbf51d80bd633ee24c24edc9ca3650fd1997945 Mon Sep 17 00:00:00 2001 From: Astrash Date: Sun, 16 Jul 2023 11:51:51 +1000 Subject: [PATCH 02/83] Allow Range keys to be meta annotated --- .../dfsek/terra/config/GenericLoaders.java | 2 ++ .../terra/config/loaders/RangeLoader.java | 27 +++++++++++++++++-- 2 files changed, 27 insertions(+), 2 deletions(-) diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/GenericLoaders.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/GenericLoaders.java index f4f5c6cfd..67874694f 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/GenericLoaders.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/GenericLoaders.java @@ -35,6 +35,7 @@ import com.dfsek.terra.config.loaders.LinkedHashMapLoader; import com.dfsek.terra.config.loaders.MaterialSetLoader; import com.dfsek.terra.config.loaders.ProbabilityCollectionLoader; import com.dfsek.terra.config.loaders.RangeLoader; +import com.dfsek.terra.config.loaders.RangeLoader.RangeMap; import com.dfsek.terra.config.loaders.VersionLoader; import com.dfsek.terra.config.loaders.VersionRangeLoader; @@ -50,6 +51,7 @@ public class GenericLoaders implements LoaderRegistrar { public void register(TypeRegistry registry) { registry.registerLoader(ProbabilityCollection.class, new ProbabilityCollectionLoader()) .registerLoader(Range.class, new RangeLoader()) + .registerLoader(RangeMap.class, RangeLoader.RangeMapTemplate::new) // Needed to use ObjectTemplates in TypeLoaders .registerLoader(Version.class, new VersionLoader()) .registerLoader(MaterialSet.class, new MaterialSetLoader()) .registerLoader(VersionRange.class, new VersionRangeLoader()) diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java index b4e55f935..c4463bfbb 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java @@ -17,14 +17,20 @@ package com.dfsek.terra.config.loaders; +import com.dfsek.tectonic.api.config.template.annotations.Value; +import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; import com.dfsek.tectonic.api.depth.DepthTracker; import com.dfsek.tectonic.api.exception.LoadException; import com.dfsek.tectonic.api.loader.ConfigLoader; import com.dfsek.tectonic.api.loader.type.TypeLoader; + +import com.dfsek.terra.api.config.meta.Meta; + import org.jetbrains.annotations.NotNull; import java.lang.reflect.AnnotatedType; import java.util.Map; +import java.util.function.Supplier; import com.dfsek.terra.api.util.ConstantRange; import com.dfsek.terra.api.util.Range; @@ -36,11 +42,28 @@ public class RangeLoader implements TypeLoader { public Range load(@NotNull AnnotatedType type, @NotNull Object o, @NotNull ConfigLoader configLoader, DepthTracker depthTracker) throws LoadException { if(o instanceof Map) { - Map map = (Map) o; - return new ConstantRange(map.get("min"), map.get("max")); + return configLoader.loadType(RangeMap.class, o, depthTracker).get(); } else { int h = configLoader.loadType(Integer.class, o, depthTracker); return new ConstantRange(h, h + 1); } } + + public interface RangeMap extends Supplier {} + + /* + * Template needed so keys can be meta annotated, otherwise the loader could just grab keys directly from the object + */ + public static class RangeMapTemplate implements ObjectTemplate { + @Value("min") + private @Meta int min; + + @Value("max") + private @Meta int max; + + @Override + public RangeMap get() { + return () -> new ConstantRange(min, max); + } + } } From 379fa601a3d2e64b1bb8866c5789fd342a9d9bbf Mon Sep 17 00:00:00 2001 From: Astrash Date: Sun, 16 Jul 2023 17:04:51 +1000 Subject: [PATCH 03/83] Meta annotate LINEAR_HEIGHTMAP sampler --- .../config/templates/LinearHeightmapSamplerTemplate.java | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/LinearHeightmapSamplerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/LinearHeightmapSamplerTemplate.java index 3185ea9c3..d4339968e 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/LinearHeightmapSamplerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/LinearHeightmapSamplerTemplate.java @@ -4,6 +4,7 @@ import com.dfsek.tectonic.api.config.template.annotations.Default; import com.dfsek.tectonic.api.config.template.annotations.Value; import com.dfsek.terra.addons.noise.samplers.LinearHeightmapSampler; +import com.dfsek.terra.api.config.meta.Meta; import com.dfsek.terra.api.noise.NoiseSampler; @@ -11,14 +12,14 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class LinearHeightmapSamplerTemplate extends SamplerTemplate { @Value("sampler") @Default - private NoiseSampler sampler = NoiseSampler.zero(); + private @Meta NoiseSampler sampler = NoiseSampler.zero(); @Value("base") - private double base; + private @Meta double base; @Value("scale") @Default - private double scale = 1; + private @Meta double scale = 1; @Override public NoiseSampler get() { From 34c0895c1f4588711241fbdff467ef93a8899c33 Mon Sep 17 00:00:00 2001 From: Astrash Date: Sun, 16 Jul 2023 22:46:23 +1000 Subject: [PATCH 04/83] Make metalist injection error more user friendly --- .../terra/config/preprocessor/MetaListLikePreprocessor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaListLikePreprocessor.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaListLikePreprocessor.java index 38f754cf7..59e335ab4 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaListLikePreprocessor.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaListLikePreprocessor.java @@ -68,7 +68,7 @@ public class MetaListLikePreprocessor extends MetaPreprocessor { if(!(metaValue instanceof List)) { throw new LoadException( - "MetaList/Set injection candidate must be list, is type " + metaValue.getClass().getCanonicalName(), + "Meta list / set injection (via <<) must point to a list. '" + meta + "' points to type " + metaValue.getClass().getCanonicalName(), depthTracker); } From 1a784b51ace5f66b6a1b8641c1c3a047c931afb4 Mon Sep 17 00:00:00 2001 From: Astrash Date: Tue, 18 Jul 2023 14:25:07 +1000 Subject: [PATCH 05/83] Implement expression normalizer sampler --- .../dfsek/terra/addons/noise/NoiseAddon.java | 3 +- .../noise/ExpressionFunctionTemplate.java | 45 +++---------- .../ExpressionNormalizerTemplate.java | 63 +++++++++++++++++++ .../normalizer/ExpressionNormalizer.java | 33 ++++++++++ .../addons/noise/paralithic/FunctionUtil.java | 31 +++++++++ 5 files changed, 138 insertions(+), 37 deletions(-) create mode 100644 common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java create mode 100644 common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ExpressionNormalizer.java create mode 100644 common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java index 86743f2cc..1c226711a 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java @@ -30,6 +30,7 @@ import com.dfsek.terra.addons.noise.config.templates.noise.fractal.BrownianMotio import com.dfsek.terra.addons.noise.config.templates.noise.fractal.PingPongTemplate; import com.dfsek.terra.addons.noise.config.templates.noise.fractal.RidgedFractalTemplate; import com.dfsek.terra.addons.noise.config.templates.normalizer.ClampNormalizerTemplate; +import com.dfsek.terra.addons.noise.config.templates.normalizer.ExpressionNormalizerTemplate; import com.dfsek.terra.addons.noise.config.templates.normalizer.LinearNormalizerTemplate; import com.dfsek.terra.addons.noise.config.templates.normalizer.NormalNormalizerTemplate; import com.dfsek.terra.addons.noise.config.templates.normalizer.PosterizationNormalizerTemplate; @@ -134,7 +135,7 @@ public class NoiseAddon implements AddonInitializer { Map packSamplers = new LinkedHashMap<>(); Map packFunctions = new LinkedHashMap<>(); noiseRegistry.register(addon.key("EXPRESSION"), () -> new ExpressionFunctionTemplate(packSamplers, packFunctions)); - + noiseRegistry.register(addon.key("EXPRESSION_NORMALIZER"), () -> new ExpressionNormalizerTemplate(packSamplers, packFunctions)); NoiseConfigPackTemplate template = event.loadTemplate(new NoiseConfigPackTemplate()); packSamplers.putAll(template.getSamplers()); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java index a15cc8e61..e401aa0cf 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java @@ -8,7 +8,6 @@ package com.dfsek.terra.addons.noise.config.templates.noise; import com.dfsek.paralithic.eval.tokenizer.ParseException; -import com.dfsek.paralithic.functions.Function; import com.dfsek.tectonic.api.config.template.annotations.Default; import com.dfsek.tectonic.api.config.template.annotations.Value; @@ -19,17 +18,16 @@ import java.util.Map; import com.dfsek.terra.addons.noise.config.DimensionApplicableNoiseSampler; import com.dfsek.terra.addons.noise.config.templates.FunctionTemplate; import com.dfsek.terra.addons.noise.config.templates.SamplerTemplate; -import com.dfsek.terra.addons.noise.paralithic.defined.UserDefinedFunction; -import com.dfsek.terra.addons.noise.paralithic.noise.NoiseFunction2; -import com.dfsek.terra.addons.noise.paralithic.noise.NoiseFunction3; import com.dfsek.terra.addons.noise.samplers.noise.ExpressionFunction; import com.dfsek.terra.api.config.meta.Meta; import com.dfsek.terra.api.noise.NoiseSampler; +import static com.dfsek.terra.addons.noise.paralithic.FunctionUtil.convertFunctionsAndSamplers; + @SuppressWarnings({ "FieldMayBeFinal", "unused" }) public class ExpressionFunctionTemplate extends SamplerTemplate { - private final Map otherFunctions; + private final Map globalSamplers; private final Map globalFunctions; @Value("variables") @Default @@ -43,44 +41,19 @@ public class ExpressionFunctionTemplate extends SamplerTemplate functions = new LinkedHashMap<>(); - public ExpressionFunctionTemplate(Map otherFunctions, Map samplers) { - this.otherFunctions = otherFunctions; - this.globalFunctions = samplers; + public ExpressionFunctionTemplate(Map globalSamplers, Map globalFunctions) { + this.globalSamplers = globalSamplers; + this.globalFunctions = globalFunctions; } @Override public NoiseSampler get() { + var mergedFunctions = new HashMap<>(globalFunctions); mergedFunctions.putAll(functions); + var mergedSamplers = new HashMap<>(globalSamplers); mergedSamplers.putAll(samplers); try { - Map noiseFunctionMap = generateFunctions(); - return new ExpressionFunction(noiseFunctionMap, expression, vars); + return new ExpressionFunction(convertFunctionsAndSamplers(mergedFunctions, mergedSamplers), expression, vars); } catch(ParseException e) { throw new RuntimeException("Failed to parse expression.", e); } } - - private Map generateFunctions() throws ParseException { - Map noiseFunctionMap = new HashMap<>(); - - for(Map.Entry entry : globalFunctions.entrySet()) { - noiseFunctionMap.put(entry.getKey(), UserDefinedFunction.newInstance(entry.getValue())); - } - - for(Map.Entry entry : functions.entrySet()) { - noiseFunctionMap.put(entry.getKey(), UserDefinedFunction.newInstance(entry.getValue())); - } - - otherFunctions.forEach((id, function) -> { - if(function.getDimensions() == 2) { - noiseFunctionMap.put(id, new NoiseFunction2(function.getSampler())); - } else noiseFunctionMap.put(id, new NoiseFunction3(function.getSampler())); - }); - - samplers.forEach((id, function) -> { - if(function.getDimensions() == 2) { - noiseFunctionMap.put(id, new NoiseFunction2(function.getSampler())); - } else noiseFunctionMap.put(id, new NoiseFunction3(function.getSampler())); - }); - - return noiseFunctionMap; - } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java new file mode 100644 index 000000000..97318d388 --- /dev/null +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.noise.config.templates.normalizer; + +import com.dfsek.paralithic.eval.tokenizer.ParseException; +import com.dfsek.tectonic.api.config.template.annotations.Default; +import com.dfsek.tectonic.api.config.template.annotations.Value; + +import com.dfsek.terra.addons.noise.config.DimensionApplicableNoiseSampler; +import com.dfsek.terra.addons.noise.config.templates.FunctionTemplate; +import com.dfsek.terra.addons.noise.normalizer.ExpressionNormalizer; +import com.dfsek.terra.api.config.meta.Meta; +import com.dfsek.terra.api.noise.NoiseSampler; + +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.Map; + +import static com.dfsek.terra.addons.noise.paralithic.FunctionUtil.convertFunctionsAndSamplers; + + +@SuppressWarnings({ "unused", "FieldMayBeFinal" }) +public class ExpressionNormalizerTemplate extends NormalizerTemplate { + + private final Map globalSamplers; + private final Map globalFunctions; + + @Value("expression") + private @Meta String expression; + + @Value("variables") + @Default + private @Meta Map vars = new HashMap<>(); + + @Value("samplers") + @Default + private @Meta LinkedHashMap samplers = new LinkedHashMap<>(); + + @Value("functions") + @Default + private @Meta LinkedHashMap functions = new LinkedHashMap<>(); + + public ExpressionNormalizerTemplate(Map globalSamplers, Map globalFunctions) { + this.globalSamplers = globalSamplers; + this.globalFunctions = globalFunctions; + } + + @Override + public NoiseSampler get() { + var mergedFunctions = new HashMap<>(globalFunctions); mergedFunctions.putAll(functions); + var mergedSamplers = new HashMap<>(globalSamplers); mergedSamplers.putAll(samplers); + try { + return new ExpressionNormalizer(function, convertFunctionsAndSamplers(mergedFunctions, mergedSamplers), expression, vars); + } catch(ParseException e) { + throw new RuntimeException("Failed to parse expression.", e); + } + } +} diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ExpressionNormalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ExpressionNormalizer.java new file mode 100644 index 000000000..95c607f76 --- /dev/null +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ExpressionNormalizer.java @@ -0,0 +1,33 @@ +package com.dfsek.terra.addons.noise.normalizer; + +import com.dfsek.paralithic.Expression; +import com.dfsek.paralithic.eval.parser.Parser; +import com.dfsek.paralithic.eval.parser.Scope; +import com.dfsek.paralithic.eval.tokenizer.ParseException; +import com.dfsek.paralithic.functions.Function; + +import com.dfsek.terra.api.noise.NoiseSampler; + +import java.util.Map; + + +public class ExpressionNormalizer extends Normalizer { + + private final Expression expression; + + public ExpressionNormalizer(NoiseSampler sampler, Map functions, String eq, Map vars) + throws ParseException { + super(sampler); + Parser p = new Parser(); + Scope scope = new Scope(); + scope.addInvocationVariable("in"); + vars.forEach(scope::create); + functions.forEach(p::registerFunction); + expression = p.parse(eq, scope); + } + + @Override + public double normalize(double in) { + return expression.evaluate(in); + } +} diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java new file mode 100644 index 000000000..f968f5bad --- /dev/null +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java @@ -0,0 +1,31 @@ +package com.dfsek.terra.addons.noise.paralithic; + +import com.dfsek.paralithic.eval.tokenizer.ParseException; +import com.dfsek.paralithic.functions.Function; + +import com.dfsek.terra.addons.noise.config.DimensionApplicableNoiseSampler; +import com.dfsek.terra.addons.noise.config.templates.FunctionTemplate; +import com.dfsek.terra.addons.noise.paralithic.defined.UserDefinedFunction; +import com.dfsek.terra.addons.noise.paralithic.noise.NoiseFunction2; +import com.dfsek.terra.addons.noise.paralithic.noise.NoiseFunction3; + +import java.util.HashMap; +import java.util.Map; + + +public class FunctionUtil { + private FunctionUtil() {} + + public static Map convertFunctionsAndSamplers(Map functions, + Map samplers) throws ParseException { + Map functionMap = new HashMap<>(); + for(Map.Entry entry : functions.entrySet()) { + functionMap.put(entry.getKey(), UserDefinedFunction.newInstance(entry.getValue())); + } + samplers.forEach((id, sampler) -> functionMap.put(id, + sampler.getDimensions() == 2 ? + new NoiseFunction2(sampler.getSampler()) : + new NoiseFunction3(sampler.getSampler()))); + return functionMap; + } +} From 00aeb984197a576c3b0598de0c96f2c943ea4780 Mon Sep 17 00:00:00 2001 From: Astrash Date: Tue, 18 Jul 2023 14:27:36 +1000 Subject: [PATCH 06/83] Implement translation sampler --- .../dfsek/terra/addons/noise/NoiseAddon.java | 4 +++ .../templates/TranslateSamplerTemplate.java | 32 +++++++++++++++++++ .../noise/samplers/TranslateSampler.java | 27 ++++++++++++++++ 3 files changed, 63 insertions(+) create mode 100644 common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/TranslateSamplerTemplate.java create mode 100644 common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/TranslateSampler.java diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java index 1c226711a..2417921e7 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java @@ -21,6 +21,7 @@ import com.dfsek.terra.addons.noise.config.templates.FunctionTemplate; import com.dfsek.terra.addons.noise.config.templates.ImageSamplerTemplate; import com.dfsek.terra.addons.noise.config.templates.KernelTemplate; import com.dfsek.terra.addons.noise.config.templates.LinearHeightmapSamplerTemplate; +import com.dfsek.terra.addons.noise.config.templates.TranslateSamplerTemplate; import com.dfsek.terra.addons.noise.config.templates.noise.CellularNoiseTemplate; import com.dfsek.terra.addons.noise.config.templates.noise.ConstantNoiseTemplate; import com.dfsek.terra.addons.noise.config.templates.noise.ExpressionFunctionTemplate; @@ -117,12 +118,15 @@ public class NoiseAddon implements AddonInitializer { noiseRegistry.register(addon.key("WHITE_NOISE"), () -> new SimpleNoiseTemplate(WhiteNoiseSampler::new)); noiseRegistry.register(addon.key("POSITIVE_WHITE_NOISE"), () -> new SimpleNoiseTemplate(PositiveWhiteNoiseSampler::new)); noiseRegistry.register(addon.key("GAUSSIAN"), () -> new SimpleNoiseTemplate(GaussianNoiseSampler::new)); + + noiseRegistry.register(addon.key("DISTANCE"), DistanceSamplerTemplate::new); noiseRegistry.register(addon.key("CONSTANT"), ConstantNoiseTemplate::new); noiseRegistry.register(addon.key("KERNEL"), KernelTemplate::new); noiseRegistry.register(addon.key("LINEAR_HEIGHTMAP"), LinearHeightmapSamplerTemplate::new); + noiseRegistry.register(addon.key("TRANSLATE"), TranslateSamplerTemplate::new); noiseRegistry.register(addon.key("ADD"), () -> new BinaryArithmeticTemplate<>(AdditionSampler::new)); noiseRegistry.register(addon.key("SUB"), () -> new BinaryArithmeticTemplate<>(SubtractionSampler::new)); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/TranslateSamplerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/TranslateSamplerTemplate.java new file mode 100644 index 000000000..c08a8253f --- /dev/null +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/TranslateSamplerTemplate.java @@ -0,0 +1,32 @@ +package com.dfsek.terra.addons.noise.config.templates; + +import com.dfsek.tectonic.api.config.template.annotations.Default; +import com.dfsek.tectonic.api.config.template.annotations.Value; + +import com.dfsek.terra.addons.noise.samplers.TranslateSampler; +import com.dfsek.terra.api.config.meta.Meta; +import com.dfsek.terra.api.noise.NoiseSampler; + + +public class TranslateSamplerTemplate extends SamplerTemplate { + + @Value("sampler") + private NoiseSampler sampler; + + @Value("x") + @Default + private @Meta double x = 0; + + @Value("y") + @Default + private @Meta double y = 0; + + @Value("z") + @Default + private @Meta double z = 0; + + @Override + public NoiseSampler get() { + return new TranslateSampler(sampler, x, y ,z); + } +} diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/TranslateSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/TranslateSampler.java new file mode 100644 index 000000000..b634da5dc --- /dev/null +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/TranslateSampler.java @@ -0,0 +1,27 @@ +package com.dfsek.terra.addons.noise.samplers; + +import com.dfsek.terra.api.noise.NoiseSampler; + + +public class TranslateSampler implements NoiseSampler { + + private final NoiseSampler sampler; + private final double dx, dy, dz; + + public TranslateSampler(NoiseSampler sampler, double dx, double dy, double dz) { + this.sampler = sampler; + this.dx = dx; + this.dy = dy; + this.dz = dz; + } + + @Override + public double noise(long seed, double x, double y) { + return sampler.noise(seed, x - dx, y - dz); + } + + @Override + public double noise(long seed, double x, double y, double z) { + return sampler.noise(seed, x - dx, y - dy, z - dz); + } +} From 02198e1b881f25704c4763d9009b760037dd2f44 Mon Sep 17 00:00:00 2001 From: Astrash Date: Tue, 18 Jul 2023 14:29:28 +1000 Subject: [PATCH 07/83] Implement distance sampler --- .../dfsek/terra/addons/noise/NoiseAddon.java | 4 ++ .../noise/DistanceSamplerTemplate.java | 42 ++++++++++++ .../noise/samplers/noise/DistanceSampler.java | 66 +++++++++++++++++++ 3 files changed, 112 insertions(+) create mode 100644 common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/DistanceSamplerTemplate.java create mode 100644 common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java index 2417921e7..b002f29a4 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java @@ -24,6 +24,7 @@ import com.dfsek.terra.addons.noise.config.templates.LinearHeightmapSamplerTempl import com.dfsek.terra.addons.noise.config.templates.TranslateSamplerTemplate; import com.dfsek.terra.addons.noise.config.templates.noise.CellularNoiseTemplate; import com.dfsek.terra.addons.noise.config.templates.noise.ConstantNoiseTemplate; +import com.dfsek.terra.addons.noise.config.templates.noise.DistanceSamplerTemplate; import com.dfsek.terra.addons.noise.config.templates.noise.ExpressionFunctionTemplate; import com.dfsek.terra.addons.noise.config.templates.noise.GaborNoiseTemplate; import com.dfsek.terra.addons.noise.config.templates.noise.SimpleNoiseTemplate; @@ -44,6 +45,7 @@ import com.dfsek.terra.addons.noise.samplers.arithmetic.MinSampler; import com.dfsek.terra.addons.noise.samplers.arithmetic.MultiplicationSampler; import com.dfsek.terra.addons.noise.samplers.arithmetic.SubtractionSampler; import com.dfsek.terra.addons.noise.samplers.noise.CellularSampler; +import com.dfsek.terra.addons.noise.samplers.noise.DistanceSampler; import com.dfsek.terra.addons.noise.samplers.noise.random.GaussianNoiseSampler; import com.dfsek.terra.addons.noise.samplers.noise.random.PositiveWhiteNoiseSampler; import com.dfsek.terra.addons.noise.samplers.noise.random.WhiteNoiseSampler; @@ -85,6 +87,8 @@ public class NoiseAddon implements AddonInitializer { (type, o, loader, depthTracker) -> CellularSampler.DistanceFunction.valueOf((String) o)) .applyLoader(CellularSampler.ReturnType.class, (type, o, loader, depthTracker) -> CellularSampler.ReturnType.valueOf((String) o)) + .applyLoader(DistanceSampler.DistanceFunction.class, + (type, o, loader, depthTracker) -> DistanceSampler.DistanceFunction.valueOf((String) o)) .applyLoader(DimensionApplicableNoiseSampler.class, DimensionApplicableNoiseSampler::new) .applyLoader(FunctionTemplate.class, FunctionTemplate::new); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/DistanceSamplerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/DistanceSamplerTemplate.java new file mode 100644 index 000000000..1bd6fb2dc --- /dev/null +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/DistanceSamplerTemplate.java @@ -0,0 +1,42 @@ +package com.dfsek.terra.addons.noise.config.templates.noise; + +import com.dfsek.tectonic.api.config.template.annotations.Default; +import com.dfsek.tectonic.api.config.template.annotations.Value; + +import com.dfsek.terra.addons.noise.config.templates.SamplerTemplate; +import com.dfsek.terra.addons.noise.samplers.noise.DistanceSampler; +import com.dfsek.terra.addons.noise.samplers.noise.DistanceSampler.DistanceFunction; +import com.dfsek.terra.api.config.meta.Meta; + + +public class DistanceSamplerTemplate extends SamplerTemplate { + + @Value("distance-function") + @Default + private DistanceSampler.@Meta DistanceFunction distanceFunction = DistanceFunction.Euclidean; + + @Value("point.x") + @Default + private @Meta double x = 0; + + @Value("point.y") + @Default + private @Meta double y = 0; + + @Value("point.z") + @Default + private @Meta double z = 0; + + @Value("normalize") + @Default + private @Meta boolean normalize = false; + + @Value("radius") + @Default + private @Meta double normalizeRadius = 100; + + @Override + public DistanceSampler get() { + return new DistanceSampler(distanceFunction, x, y, z, normalize, normalizeRadius); + } +} diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java new file mode 100644 index 000000000..1e083fb86 --- /dev/null +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java @@ -0,0 +1,66 @@ +package com.dfsek.terra.addons.noise.samplers.noise; + + +public class DistanceSampler extends NoiseFunction { + + private final DistanceFunction distanceFunction; + private final double ox, oy, oz; + private final boolean normalize; + private final double radius; + + private final double distanceAtRadius; + + public DistanceSampler(DistanceFunction distanceFunction, double ox, double oy, double oz, boolean normalize, double radius) { + frequency = 1; + this.distanceFunction = distanceFunction; + this.ox = ox; + this.oy = oy; + this.oz = oz; + this.normalize = normalize; + this.radius = radius; + this.distanceAtRadius = distance2d(distanceFunction, radius, 0); // distance2d and distance3d should return the same value + } + + @Override + public double getNoiseRaw(long seed, double x, double y) { + double dx = x - ox; + double dy = y - oz; + if (normalize && (fastAbs(dx) > radius || fastAbs(dy) > radius)) return 1; + double dist = distance2d(distanceFunction, dx, dy); + if (normalize) return fastMin(((2*dist)/distanceAtRadius)-1, 1); + return dist; + } + + @Override + public double getNoiseRaw(long seed, double x, double y, double z) { + double dx = x - ox; + double dy = y - oy; + double dz = z - oz; + if(normalize && (fastAbs(dx) > radius || fastAbs(dy) > radius || fastAbs(dz) > radius)) return 1; + double dist = distance3d(distanceFunction, dx, dy, dz); + if (normalize) return fastMin(((2*dist)/distanceAtRadius)-1, 1); + return dist; + } + + private static double distance2d(DistanceFunction distanceFunction, double x, double z) { + return switch(distanceFunction) { + case Euclidean -> fastSqrt(x*x + z*z); + case EuclideanSq -> x*x + z*z; + case Manhattan -> fastAbs(x) + fastAbs(z); + }; + } + + private static double distance3d(DistanceFunction distanceFunction, double x, double y, double z) { + return switch(distanceFunction) { + case Euclidean -> fastSqrt(x*x + y*y + z*z); + case EuclideanSq -> x*x + y*y + z*z; + case Manhattan -> fastAbs(x) + fastAbs(y) + fastAbs(z); + }; + } + + public enum DistanceFunction { + Euclidean, + EuclideanSq, + Manhattan + } +} From 0e3a7560114bd3b481c5e67e2f8c3060578ac0b4 Mon Sep 17 00:00:00 2001 From: Astrash Date: Tue, 18 Jul 2023 14:29:54 +1000 Subject: [PATCH 08/83] Bump config-noise-function to v1.1.0 --- common/addons/config-noise-function/build.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common/addons/config-noise-function/build.gradle.kts b/common/addons/config-noise-function/build.gradle.kts index f51d5e878..02054f08b 100644 --- a/common/addons/config-noise-function/build.gradle.kts +++ b/common/addons/config-noise-function/build.gradle.kts @@ -1,6 +1,6 @@ import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar -version = version("1.0.0") +version = version("1.1.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) From aab28ff4f9339e67771ffe70f52bc605c6c98b8c Mon Sep 17 00:00:00 2001 From: Astrash Date: Tue, 18 Jul 2023 14:32:12 +1000 Subject: [PATCH 09/83] Bump version to 6.4.0 --- build.gradle.kts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/build.gradle.kts b/build.gradle.kts index db6c27c15..0d71e84fc 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1,8 +1,8 @@ preRelease(true) -versionProjects(":common:api", version("6.3.2")) -versionProjects(":common:implementation", version("6.3.2")) -versionProjects(":platforms", version("6.3.2")) +versionProjects(":common:api", version("6.4.0")) +versionProjects(":common:implementation", version("6.4.0")) +versionProjects(":platforms", version("6.4.0")) allprojects { From 81e354f91cc6f2503e890159b173a85f7aa392d5 Mon Sep 17 00:00:00 2001 From: Astrash Date: Tue, 18 Jul 2023 22:06:08 +1000 Subject: [PATCH 10/83] Use tectonic properly --- .../java/com/dfsek/terra/config/GenericLoaders.java | 2 -- .../com/dfsek/terra/config/loaders/RangeLoader.java | 13 ++++++------- 2 files changed, 6 insertions(+), 9 deletions(-) diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/GenericLoaders.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/GenericLoaders.java index 67874694f..f4f5c6cfd 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/GenericLoaders.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/GenericLoaders.java @@ -35,7 +35,6 @@ import com.dfsek.terra.config.loaders.LinkedHashMapLoader; import com.dfsek.terra.config.loaders.MaterialSetLoader; import com.dfsek.terra.config.loaders.ProbabilityCollectionLoader; import com.dfsek.terra.config.loaders.RangeLoader; -import com.dfsek.terra.config.loaders.RangeLoader.RangeMap; import com.dfsek.terra.config.loaders.VersionLoader; import com.dfsek.terra.config.loaders.VersionRangeLoader; @@ -51,7 +50,6 @@ public class GenericLoaders implements LoaderRegistrar { public void register(TypeRegistry registry) { registry.registerLoader(ProbabilityCollection.class, new ProbabilityCollectionLoader()) .registerLoader(Range.class, new RangeLoader()) - .registerLoader(RangeMap.class, RangeLoader.RangeMapTemplate::new) // Needed to use ObjectTemplates in TypeLoaders .registerLoader(Version.class, new VersionLoader()) .registerLoader(MaterialSet.class, new MaterialSetLoader()) .registerLoader(VersionRange.class, new VersionRangeLoader()) diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java index c4463bfbb..ca40d6b90 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java @@ -24,13 +24,14 @@ import com.dfsek.tectonic.api.exception.LoadException; import com.dfsek.tectonic.api.loader.ConfigLoader; import com.dfsek.tectonic.api.loader.type.TypeLoader; +import com.dfsek.tectonic.impl.MapConfiguration; + import com.dfsek.terra.api.config.meta.Meta; import org.jetbrains.annotations.NotNull; import java.lang.reflect.AnnotatedType; import java.util.Map; -import java.util.function.Supplier; import com.dfsek.terra.api.util.ConstantRange; import com.dfsek.terra.api.util.Range; @@ -42,19 +43,17 @@ public class RangeLoader implements TypeLoader { public Range load(@NotNull AnnotatedType type, @NotNull Object o, @NotNull ConfigLoader configLoader, DepthTracker depthTracker) throws LoadException { if(o instanceof Map) { - return configLoader.loadType(RangeMap.class, o, depthTracker).get(); + return configLoader.load(new RangeMapTemplate(), new MapConfiguration((Map) o), depthTracker).get(); } else { int h = configLoader.loadType(Integer.class, o, depthTracker); return new ConstantRange(h, h + 1); } } - public interface RangeMap extends Supplier {} - /* * Template needed so keys can be meta annotated, otherwise the loader could just grab keys directly from the object */ - public static class RangeMapTemplate implements ObjectTemplate { + public static class RangeMapTemplate implements ObjectTemplate { @Value("min") private @Meta int min; @@ -62,8 +61,8 @@ public class RangeLoader implements TypeLoader { private @Meta int max; @Override - public RangeMap get() { - return () -> new ConstantRange(min, max); + public Range get() { + return new ConstantRange(min, max); } } } From 5eeb5af6c40d70182f6dbdce2663a797904b3b6d Mon Sep 17 00:00:00 2001 From: David W Date: Fri, 22 Sep 2023 00:23:49 +0200 Subject: [PATCH 11/83] Add cell center offset return to CELLULAR sampler (#407) * Add offset lookup return to cellular sampler * bump noise function plugin version * revert version to 1.1.0 * rename OffsetNoiseLookup, switch axis orientation * rename return type aswell in cellcampler --- .../terra/addons/noise/samplers/noise/CellularSampler.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java index f31f81a3f..603722420 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java @@ -351,6 +351,7 @@ public class CellularSampler extends NoiseFunction { case Distance2Mul -> distance1 * distance0 * 0.5 - 1; case Distance2Div -> distance0 / distance1 - 1; case NoiseLookup -> noiseLookup.noise(sl, centerX, centerY); + case LocalNoiseLookup -> noiseLookup.noise(sl, x / frequency - centerX, y / frequency - centerY); case Distance3 -> distance2 - 1; case Distance3Add -> (distance2 + distance0) * 0.5 - 1; case Distance3Sub -> distance2 - distance0 - 1; @@ -514,6 +515,7 @@ public class CellularSampler extends NoiseFunction { case Distance2Mul -> distance1 * distance0 * 0.5 - 1; case Distance2Div -> distance0 / distance1 - 1; case NoiseLookup -> noiseLookup.noise(sl, centerX, centerY, centerZ); + case LocalNoiseLookup -> noiseLookup.noise(sl, x / frequency - centerX, y / frequency - centerY, z / frequency - centerZ); case Distance3 -> distance2 - 1; case Distance3Add -> (distance2 + distance0) * 0.5 - 1; case Distance3Sub -> distance2 - distance0 - 1; @@ -540,6 +542,7 @@ public class CellularSampler extends NoiseFunction { Distance2Mul, Distance2Div, NoiseLookup, + LocalNoiseLookup, Distance3, Distance3Add, Distance3Sub, From 3f9ead0d6661ff871b28ff711b32036e8781c3ad Mon Sep 17 00:00:00 2001 From: Astrash Date: Wed, 27 Sep 2023 13:39:51 +1000 Subject: [PATCH 12/83] Remove repeated code in cellular sampler --- .../noise/samplers/noise/CellularSampler.java | 265 +++++------------- 1 file changed, 65 insertions(+), 200 deletions(-) diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java index 603722420..cdd40990d 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java @@ -240,99 +240,37 @@ public class CellularSampler extends NoiseFunction { double centerX = x; double centerY = y; - switch(distanceFunction) { - default: - case Euclidean: - case EuclideanSq: - for(int xi = xr - 1; xi <= xr + 1; xi++) { - int yPrimed = yPrimedBase; - - for(int yi = yr - 1; yi <= yr + 1; yi++) { - int hash = hash(seed, xPrimed, yPrimed); - int idx = hash & (255 << 1); - - double vecX = (xi - x) + RAND_VECS_2D[idx] * cellularJitter; - double vecY = (yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter; - - double newDistance = vecX * vecX + vecY * vecY; - - distance1 = fastMax(fastMin(distance1, newDistance), distance0); - if(newDistance < distance0) { - distance0 = newDistance; - closestHash = hash; - centerX = ((xi + RAND_VECS_2D[idx] * cellularJitter) / frequency); - centerY = ((yi + RAND_VECS_2D[idx | 1] * cellularJitter) / frequency); - } else if(newDistance < distance1) { - distance2 = distance1; - distance1 = newDistance; - } else if(newDistance < distance2) { - distance2 = newDistance; - } - yPrimed += PRIME_Y; - } - xPrimed += PRIME_X; + for(int xi = xr - 1; xi <= xr + 1; xi++) { + int yPrimed = yPrimedBase; + + for(int yi = yr - 1; yi <= yr + 1; yi++) { + int hash = hash(seed, xPrimed, yPrimed); + int idx = hash & (255 << 1); + + double vecX = (xi - x) + RAND_VECS_2D[idx] * cellularJitter; + double vecY = (yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter; + + double newDistance = switch(distanceFunction) { + case Manhattan -> fastAbs(vecX) + fastAbs(vecY); + case Hybrid -> (fastAbs(vecX) + fastAbs(vecY)) + (vecX * vecX + vecY * vecY); + default -> vecX * vecX + vecY * vecY; + }; + + distance1 = fastMax(fastMin(distance1, newDistance), distance0); + if(newDistance < distance0) { + distance0 = newDistance; + closestHash = hash; + centerX = ((xi + RAND_VECS_2D[idx] * cellularJitter) / frequency); + centerY = ((yi + RAND_VECS_2D[idx | 1] * cellularJitter) / frequency); + } else if(newDistance < distance1) { + distance2 = distance1; + distance1 = newDistance; + } else if(newDistance < distance2) { + distance2 = newDistance; } - break; - case Manhattan: - for(int xi = xr - 1; xi <= xr + 1; xi++) { - int yPrimed = yPrimedBase; - - for(int yi = yr - 1; yi <= yr + 1; yi++) { - int hash = hash(seed, xPrimed, yPrimed); - int idx = hash & (255 << 1); - - double vecX = (xi - x) + RAND_VECS_2D[idx] * cellularJitter; - double vecY = (yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter; - - double newDistance = fastAbs(vecX) + fastAbs(vecY); - - distance1 = fastMax(fastMin(distance1, newDistance), distance0); - if(newDistance < distance0) { - distance0 = newDistance; - closestHash = hash; - centerX = ((xi + RAND_VECS_2D[idx] * cellularJitter) / frequency); - centerY = ((yi + RAND_VECS_2D[idx | 1] * cellularJitter) / frequency); - } else if(newDistance < distance1) { - distance2 = distance1; - distance1 = newDistance; - } else if(newDistance < distance2) { - distance2 = newDistance; - } - yPrimed += PRIME_Y; - } - xPrimed += PRIME_X; - } - break; - case Hybrid: - for(int xi = xr - 1; xi <= xr + 1; xi++) { - int yPrimed = yPrimedBase; - - for(int yi = yr - 1; yi <= yr + 1; yi++) { - int hash = hash(seed, xPrimed, yPrimed); - int idx = hash & (255 << 1); - - double vecX = (xi - x) + RAND_VECS_2D[idx] * cellularJitter; - double vecY = (yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter; - - double newDistance = (fastAbs(vecX) + fastAbs(vecY)) + (vecX * vecX + vecY * vecY); - - distance1 = fastMax(fastMin(distance1, newDistance), distance0); - if(newDistance < distance0) { - distance0 = newDistance; - closestHash = hash; - centerX = ((xi + RAND_VECS_2D[idx] * cellularJitter) / frequency); - centerY = ((yi + RAND_VECS_2D[idx | 1] * cellularJitter) / frequency); - } else if(newDistance < distance1) { - distance2 = distance1; - distance1 = newDistance; - } else if(newDistance < distance2) { - distance2 = newDistance; - } - yPrimed += PRIME_Y; - } - xPrimed += PRIME_X; - } - break; + yPrimed += PRIME_Y; + } + xPrimed += PRIME_X; } if(distanceFunction == DistanceFunction.Euclidean && returnType != ReturnType.CellValue) { @@ -383,120 +321,47 @@ public class CellularSampler extends NoiseFunction { double centerY = y; double centerZ = z; - switch(distanceFunction) { - case Euclidean: - case EuclideanSq: - for(int xi = xr - 1; xi <= xr + 1; xi++) { - int yPrimed = yPrimedBase; + for(int xi = xr - 1; xi <= xr + 1; xi++) { + int yPrimed = yPrimedBase; + + for(int yi = yr - 1; yi <= yr + 1; yi++) { + int zPrimed = zPrimedBase; + + for(int zi = zr - 1; zi <= zr + 1; zi++) { + int hash = hash(seed, xPrimed, yPrimed, zPrimed); + int idx = hash & (255 << 2); - for(int yi = yr - 1; yi <= yr + 1; yi++) { - int zPrimed = zPrimedBase; - - for(int zi = zr - 1; zi <= zr + 1; zi++) { - int hash = hash(seed, xPrimed, yPrimed, zPrimed); - int idx = hash & (255 << 2); - - double vecX = (xi - x) + RAND_VECS_3D[idx] * cellularJitter; - double vecY = (yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter; - double vecZ = (zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter; - - double newDistance = vecX * vecX + vecY * vecY + vecZ * vecZ; - - if(newDistance < distance0) { - distance0 = newDistance; - closestHash = hash; - centerX = ((xi + RAND_VECS_3D[idx] * cellularJitter) / frequency); - centerY = ((yi + RAND_VECS_3D[idx | 1] * cellularJitter) / frequency); - centerZ = ((zi + RAND_VECS_3D[idx | 2] * cellularJitter) / frequency); - } else if(newDistance < distance1) { - distance2 = distance1; - distance1 = newDistance; - } else if(newDistance < distance2) { - distance2 = newDistance; - } - zPrimed += PRIME_Z; - } - yPrimed += PRIME_Y; - } - xPrimed += PRIME_X; - } - break; - case Manhattan: - for(int xi = xr - 1; xi <= xr + 1; xi++) { - int yPrimed = yPrimedBase; + double vecX = (xi - x) + RAND_VECS_3D[idx] * cellularJitter; + double vecY = (yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter; + double vecZ = (zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter; - for(int yi = yr - 1; yi <= yr + 1; yi++) { - int zPrimed = zPrimedBase; - - for(int zi = zr - 1; zi <= zr + 1; zi++) { - int hash = hash(seed, xPrimed, yPrimed, zPrimed); - int idx = hash & (255 << 2); - - double vecX = (xi - x) + RAND_VECS_3D[idx] * cellularJitter; - double vecY = (yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter; - double vecZ = (zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter; - - double newDistance = fastAbs(vecX) + fastAbs(vecY) + fastAbs(vecZ); - - if(newDistance < distance0) { - distance0 = newDistance; - closestHash = hash; - centerX = ((xi + RAND_VECS_3D[idx] * cellularJitter) / frequency); - centerY = ((yi + RAND_VECS_3D[idx | 1] * cellularJitter) / frequency); - centerZ = ((zi + RAND_VECS_3D[idx | 2] * cellularJitter) / frequency); - } else if(newDistance < distance1) { - distance2 = distance1; - distance1 = newDistance; - } else if(newDistance < distance2) { - distance2 = newDistance; - } - zPrimed += PRIME_Z; - } - yPrimed += PRIME_Y; - } - xPrimed += PRIME_X; - } - break; - case Hybrid: - for(int xi = xr - 1; xi <= xr + 1; xi++) { - int yPrimed = yPrimedBase; - - for(int yi = yr - 1; yi <= yr + 1; yi++) { - int zPrimed = zPrimedBase; - - for(int zi = zr - 1; zi <= zr + 1; zi++) { - int hash = hash(seed, xPrimed, yPrimed, zPrimed); - int idx = hash & (255 << 2); - - double vecX = (xi - x) + RAND_VECS_3D[idx] * cellularJitter; - double vecY = (yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter; - double vecZ = (zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter; - - double newDistance = (fastAbs(vecX) + fastAbs(vecY) + fastAbs(vecZ)) + - (vecX * vecX + vecY * vecY + vecZ * vecZ); - + double newDistance = 0; + switch(distanceFunction) { + case Euclidean, EuclideanSq -> newDistance = vecX * vecX + vecY * vecY + vecZ * vecZ; + case Manhattan -> newDistance = fastAbs(vecX) + fastAbs(vecY) + fastAbs(vecZ); + case Hybrid -> { + newDistance = (fastAbs(vecX) + fastAbs(vecY) + fastAbs(vecZ)) + (vecX * vecX + vecY * vecY + vecZ * vecZ); distance1 = fastMax(fastMin(distance1, newDistance), distance0); - if(newDistance < distance0) { - distance0 = newDistance; - closestHash = hash; - centerX = ((xi + RAND_VECS_3D[idx] * cellularJitter) / frequency); - centerY = ((yi + RAND_VECS_3D[idx | 1] * cellularJitter) / frequency); - centerZ = ((zi + RAND_VECS_3D[idx | 2] * cellularJitter) / frequency); - } else if(newDistance < distance1) { - distance2 = distance1; - distance1 = newDistance; - } else if(newDistance < distance2) { - distance2 = newDistance; - } - zPrimed += PRIME_Z; } - yPrimed += PRIME_Y; } - xPrimed += PRIME_X; + + if(newDistance < distance0) { + distance0 = newDistance; + closestHash = hash; + centerX = ((xi + RAND_VECS_3D[idx] * cellularJitter) / frequency); + centerY = ((yi + RAND_VECS_3D[idx | 1] * cellularJitter) / frequency); + centerZ = ((zi + RAND_VECS_3D[idx | 2] * cellularJitter) / frequency); + } else if(newDistance < distance1) { + distance2 = distance1; + distance1 = newDistance; + } else if(newDistance < distance2) { + distance2 = newDistance; + } + zPrimed += PRIME_Z; } - break; - default: - break; + yPrimed += PRIME_Y; + } + xPrimed += PRIME_X; } if(distanceFunction == DistanceFunction.Euclidean && returnType != ReturnType.CellValue) { From 0e37a839fea80266288f07c784388bc118ab0915 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Wed, 13 Sep 2023 16:03:15 -0600 Subject: [PATCH 13/83] We do a little commonifying --- gradle.properties | 1 - .../dfsek/terra/fabric/FabricEntryPoint.java | 25 ++------------ .../dfsek/terra/fabric/FabricPlatform.java | 25 ++------------ platforms/mixin-lifecycle/build.gradle.kts | 5 +++ .../terra/lifecycle/LifecycleEntryPoint.java | 34 +++++++++++++++++++ .../terra/lifecycle/LifecyclePlatform.java | 20 +++++++++-- .../dfsek/terra/quilt/QuiltEntryPoint.java | 27 +++------------ .../com/dfsek/terra/quilt/QuiltPlatform.java | 24 ++----------- 8 files changed, 69 insertions(+), 92 deletions(-) create mode 100644 platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java diff --git a/gradle.properties b/gradle.properties index 76e5fa68b..3e8017f71 100644 --- a/gradle.properties +++ b/gradle.properties @@ -8,5 +8,4 @@ terra.license=MIT # Gradle options org.gradle.jvmargs=-Xmx4096M -XX:MaxMetaspaceSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 -XX:+UseParallelGC org.gradle.warning.mode=all -#org.gradle.parallel=true diff --git a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java index 54d03961e..d316b1a3a 100644 --- a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java +++ b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java @@ -17,35 +17,16 @@ package com.dfsek.terra.fabric; -import cloud.commandframework.execution.CommandExecutionCoordinator; -import cloud.commandframework.fabric.FabricServerCommandManager; import net.fabricmc.api.ModInitializer; -import net.minecraft.server.command.ServerCommandSource; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import com.dfsek.terra.api.command.CommandSender; -import com.dfsek.terra.api.event.events.platform.CommandRegistrationEvent; +import com.dfsek.terra.lifecycle.LifecycleEntryPoint; -public class FabricEntryPoint implements ModInitializer { - private static final Logger logger = LoggerFactory.getLogger(FabricEntryPoint.class); - +public class FabricEntryPoint extends LifecycleEntryPoint implements ModInitializer { private static final FabricPlatform TERRA_PLUGIN = new FabricPlatform(); @Override public void onInitialize() { - logger.info("Initializing Terra Fabric mod..."); - - FabricServerCommandManager manager = new FabricServerCommandManager<>( - CommandExecutionCoordinator.simpleCoordinator(), - serverCommandSource -> (CommandSender) serverCommandSource, - commandSender -> (ServerCommandSource) commandSender - ); - - - manager.brigadierManager().setNativeNumberSuggestions(false); - - TERRA_PLUGIN.getEventManager().callEvent(new CommandRegistrationEvent(manager)); + initialize("Fabric", TERRA_PLUGIN); } } diff --git a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricPlatform.java b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricPlatform.java index 2c85b86ee..1501b736d 100644 --- a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricPlatform.java +++ b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricPlatform.java @@ -17,43 +17,24 @@ package com.dfsek.terra.fabric; -import ca.solostudios.strata.Versions; -import ca.solostudios.strata.parser.tokenizer.ParseException; -import ca.solostudios.strata.version.Version; import net.fabricmc.loader.api.FabricLoader; import org.jetbrains.annotations.NotNull; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; import java.io.File; import java.util.Collection; import java.util.stream.Collectors; -import java.util.stream.Stream; -import com.dfsek.terra.addon.EphemeralAddon; import com.dfsek.terra.api.addon.BaseAddon; import com.dfsek.terra.lifecycle.LifecyclePlatform; public class FabricPlatform extends LifecyclePlatform { - private static final Logger LOGGER = LoggerFactory.getLogger(FabricPlatform.class); @Override protected Collection getPlatformMods() { - return FabricLoader.getInstance().getAllMods().stream().flatMap(mod -> { - String id = mod.getMetadata().getId(); - if(id.equals("terra") || id.equals("minecraft") || id.equals("java")) return Stream.empty(); - try { - Version version = Versions.parseVersion(mod.getMetadata().getVersion().getFriendlyString()); - return Stream.of(new EphemeralAddon(version, "fabric:" + id)); - } catch(ParseException e) { - LOGGER.warn( - "Mod {}, version {} does not follow semantic versioning specification, Terra addons will be unable to depend on " + - "it.", - id, mod.getMetadata().getVersion().getFriendlyString()); - } - return Stream.empty(); - }).collect(Collectors.toList()); + return FabricLoader.getInstance().getAllMods().stream().flatMap( + mod -> parseModData(mod.getMetadata().getId(), mod.getMetadata().getVersion().getFriendlyString())).collect( + Collectors.toList()); } @Override diff --git a/platforms/mixin-lifecycle/build.gradle.kts b/platforms/mixin-lifecycle/build.gradle.kts index 0a9e71d7c..e8b852dc5 100644 --- a/platforms/mixin-lifecycle/build.gradle.kts +++ b/platforms/mixin-lifecycle/build.gradle.kts @@ -15,6 +15,11 @@ dependencies { minecraft("com.mojang:minecraft:${Versions.Mod.minecraft}") mappings("net.fabricmc:yarn:${Versions.Mod.yarn}:v2") + + modImplementation("cloud.commandframework", "cloud-fabric", Versions.Libraries.cloud) { + exclude("net.fabricmc") + exclude("net.fabricmc.fabric-api") + } } loom { diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java new file mode 100644 index 000000000..12260088a --- /dev/null +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java @@ -0,0 +1,34 @@ +package com.dfsek.terra.lifecycle; + +import cloud.commandframework.execution.CommandExecutionCoordinator; + +import cloud.commandframework.fabric.FabricServerCommandManager; + +import com.dfsek.terra.api.command.CommandSender; +import com.dfsek.terra.api.event.events.platform.CommandRegistrationEvent; + +import com.dfsek.terra.mod.MinecraftAddon; + +import net.minecraft.server.command.ServerCommandSource; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + +public class LifecycleEntryPoint { + private static final Logger logger = LoggerFactory.getLogger(LifecycleEntryPoint.class); + + protected static void initialize(String modName, LifecyclePlatform platform) { + logger.info("Initializing Terra %s mod...", modName); + + FabricServerCommandManager manager = new FabricServerCommandManager<>( + CommandExecutionCoordinator.simpleCoordinator(), + serverCommandSource -> (CommandSender) serverCommandSource, + commandSender -> (ServerCommandSource) commandSender + ); + + + manager.brigadierManager().setNativeNumberSuggestions(false); + + platform.getEventManager().callEvent(new CommandRegistrationEvent(manager)); + } +} diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java index 81ebcae8a..bafd0a02e 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java @@ -2,6 +2,7 @@ package com.dfsek.terra.lifecycle; import ca.solostudios.strata.Versions; import ca.solostudios.strata.parser.tokenizer.ParseException; +import ca.solostudios.strata.version.Version; import com.dfsek.terra.lifecycle.util.BiomeUtil; @@ -20,6 +21,7 @@ import org.slf4j.LoggerFactory; import java.util.ArrayList; import java.util.Collection; import java.util.List; +import java.util.stream.Stream; import java.util.concurrent.atomic.AtomicReference; import com.dfsek.terra.addon.EphemeralAddon; @@ -103,12 +105,26 @@ public abstract class LifecyclePlatform extends ModPlatform { LOGGER.warn("Failed to parse Minecraft version", e); } } - + addons.addAll(getPlatformMods()); - + return addons; } + protected Stream parseModData(String id, String modVersion) { + if(id.equals("terra") || id.equals("minecraft") || id.equals("java")) return Stream.empty(); + try { + Version version = Versions.parseVersion(modVersion); + return Stream.of(new EphemeralAddon(version, "quilt:" + id)); + } catch(ParseException e) { + LOGGER.warn( + "Mod {}, version {} does not follow semantic versioning specification, Terra addons will be unable to depend on " + + "it.", + id, modVersion); + } + return Stream.empty(); + } + @Override public Registry dimensionTypeRegistry() { return DIMENSIONS.get(); diff --git a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltEntryPoint.java b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltEntryPoint.java index 88f676daf..5b8688962 100644 --- a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltEntryPoint.java +++ b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltEntryPoint.java @@ -17,36 +17,17 @@ package com.dfsek.terra.quilt; -import cloud.commandframework.execution.CommandExecutionCoordinator; -import cloud.commandframework.fabric.FabricServerCommandManager; -import net.minecraft.server.command.ServerCommandSource; import org.quiltmc.loader.api.ModContainer; import org.quiltmc.qsl.base.api.entrypoint.ModInitializer; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import com.dfsek.terra.api.command.CommandSender; -import com.dfsek.terra.api.event.events.platform.CommandRegistrationEvent; +import com.dfsek.terra.lifecycle.LifecycleEntryPoint; -public class QuiltEntryPoint implements ModInitializer { - private static final Logger logger = LoggerFactory.getLogger(QuiltEntryPoint.class); - +public class QuiltEntryPoint extends LifecycleEntryPoint implements ModInitializer { private static final QuiltPlatform TERRA_PLUGIN = new QuiltPlatform(); - + @Override public void onInitialize(ModContainer container) { - logger.info("Initializing Terra Quilt mod..."); - - FabricServerCommandManager manager = new FabricServerCommandManager<>( - CommandExecutionCoordinator.simpleCoordinator(), - serverCommandSource -> (CommandSender) serverCommandSource, - commandSender -> (ServerCommandSource) commandSender - ); - - - manager.brigadierManager().setNativeNumberSuggestions(false); - - TERRA_PLUGIN.getEventManager().callEvent(new CommandRegistrationEvent(manager)); + initialize("Quilt", TERRA_PLUGIN); } } diff --git a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java index dfc1a7a18..0aa2e4323 100644 --- a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java +++ b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java @@ -17,43 +17,23 @@ package com.dfsek.terra.quilt; -import ca.solostudios.strata.Versions; -import ca.solostudios.strata.parser.tokenizer.ParseException; -import ca.solostudios.strata.version.Version; import org.jetbrains.annotations.NotNull; import org.quiltmc.loader.api.QuiltLoader; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; import java.io.File; import java.util.Collection; import java.util.stream.Collectors; -import java.util.stream.Stream; -import com.dfsek.terra.addon.EphemeralAddon; import com.dfsek.terra.api.addon.BaseAddon; import com.dfsek.terra.lifecycle.LifecyclePlatform; public class QuiltPlatform extends LifecyclePlatform { - private static final Logger LOGGER = LoggerFactory.getLogger(QuiltPlatform.class); @Override protected Collection getPlatformMods() { - return QuiltLoader.getAllMods().stream().flatMap(mod -> { - String id = mod.metadata().id(); - if(id.equals("terra") || id.equals("minecraft") || id.equals("java")) return Stream.empty(); - try { - Version version = Versions.parseVersion(mod.metadata().version().raw()); - return Stream.of(new EphemeralAddon(version, "quilt:" + id)); - } catch(ParseException e) { - LOGGER.warn( - "Mod {}, version {} does not follow semantic versioning specification, Terra addons will be unable to depend on " + - "it.", - id, mod.metadata().version().raw()); - } - return Stream.empty(); - }).collect(Collectors.toList()); + return QuiltLoader.getAllMods().stream().flatMap(mod -> parseModData(mod.metadata().id(), mod.metadata().version().raw())).collect( + Collectors.toList()); } @Override From f0c602d7e7e6fbb87db9ed7d50f051ad1c822d66 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Fri, 29 Sep 2023 22:10:03 -0600 Subject: [PATCH 14/83] implement physics on the api side we will see if platform changes are needed --- .../script/builders/BlockFunctionBuilder.java | 8 +++++--- .../terrascript/script/functions/BlockFunction.java | 10 ++++++---- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java index daa001ca9..7d3805f3d 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java @@ -30,12 +30,14 @@ public class BlockFunctionBuilder implements FunctionBuilder { @Override public BlockFunction build(List> argumentList, Position position) { if(argumentList.size() < 4) throw new ParseException("Expected data", position); - Returnable booleanReturnable = new BooleanConstant(true, position); - if(argumentList.size() == 5) booleanReturnable = (Returnable) argumentList.get(4); + Returnable overwrite = new BooleanConstant(true, position); + if(argumentList.size() >= 5) overwrite = (Returnable) argumentList.get(4); + Returnable physics = new BooleanConstant(true, position); + if(argumentList.size() == 6) physics = (Returnable) argumentList.get(5); if(argumentList.get(3) instanceof StringConstant) { return new BlockFunction.Constant((Returnable) argumentList.get(0), (Returnable) argumentList.get(1), (Returnable) argumentList.get(2), (StringConstant) argumentList.get(3), - booleanReturnable, platform, position); + overwrite, physics, platform, position); } return new BlockFunction((Returnable) argumentList.get(0), (Returnable) argumentList.get(1), (Returnable) argumentList.get(2), (Returnable) argumentList.get(3), booleanReturnable, diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java index 63d754975..7997a15aa 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java @@ -35,10 +35,11 @@ public class BlockFunction implements Function { protected final Platform platform; private final Map data = new HashMap<>(); private final Returnable overwrite; + private final Returnable physics; private final Position position; public BlockFunction(Returnable x, Returnable y, Returnable z, Returnable blockData, - Returnable overwrite, Platform platform, Position position) { + Returnable overwrite, Returnable physics, Platform platform, Position position) { this.x = x; this.y = y; this.z = z; @@ -46,6 +47,7 @@ public class BlockFunction implements Function { this.overwrite = overwrite; this.platform = platform; this.position = position; + this.physics = physics; } @Override @@ -76,7 +78,7 @@ public class BlockFunction implements Function { FastMath.roundToInt(xz.getZ())).mutable().add(arguments.getOrigin()); BlockState current = arguments.getWorld().getBlockState(set); if(overwrite.apply(implementationArguments, scope) || current.isAir()) { - arguments.getWorld().setBlockState(set, rot); + arguments.getWorld().setBlockState(set, rot, physics.apply(implementationArguments, scope)); } } catch(RuntimeException e) { logger.error("Failed to place block at location {}", arguments.getOrigin(), e); @@ -92,8 +94,8 @@ public class BlockFunction implements Function { private final BlockState state; public Constant(Returnable x, Returnable y, Returnable z, StringConstant blockData, - Returnable overwrite, Platform platform, Position position) { - super(x, y, z, blockData, overwrite, platform, position); + Returnable overwrite, Returnable physics, Platform platform, Position position) { + super(x, y, z, blockData, overwrite, physics, platform, position); this.state = platform.getWorldHandle().createBlockState(blockData.getConstant()); } From 33d654dc8eb5ad75a00926ecc0b2d9cb924f0152 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Fri, 29 Sep 2023 23:05:05 -0600 Subject: [PATCH 15/83] impl fabric --- .../script/builders/BlockFunctionBuilder.java | 4 ++-- .../terra/chunk/WorldChunkMixin.java | 18 +++++++++++++++++- 2 files changed, 19 insertions(+), 3 deletions(-) diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java index 7d3805f3d..7069b0b69 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java @@ -32,7 +32,7 @@ public class BlockFunctionBuilder implements FunctionBuilder { if(argumentList.size() < 4) throw new ParseException("Expected data", position); Returnable overwrite = new BooleanConstant(true, position); if(argumentList.size() >= 5) overwrite = (Returnable) argumentList.get(4); - Returnable physics = new BooleanConstant(true, position); + Returnable physics = new BooleanConstant(false, position); if(argumentList.size() == 6) physics = (Returnable) argumentList.get(5); if(argumentList.get(3) instanceof StringConstant) { return new BlockFunction.Constant((Returnable) argumentList.get(0), (Returnable) argumentList.get(1), @@ -40,7 +40,7 @@ public class BlockFunctionBuilder implements FunctionBuilder { overwrite, physics, platform, position); } return new BlockFunction((Returnable) argumentList.get(0), (Returnable) argumentList.get(1), - (Returnable) argumentList.get(2), (Returnable) argumentList.get(3), booleanReturnable, + (Returnable) argumentList.get(2), (Returnable) argumentList.get(3), overwrite, physics, platform, position); } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java index 3fb01104d..2cf8123ea 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java @@ -17,8 +17,11 @@ package com.dfsek.terra.mod.mixin.implementations.terra.chunk; +import net.minecraft.block.Block; import net.minecraft.util.math.BlockPos; +import net.minecraft.world.chunk.Chunk.TickSchedulers; import net.minecraft.world.chunk.WorldChunk; +import net.minecraft.world.tick.OrderedTick; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.spongepowered.asm.mixin.Final; @@ -47,8 +50,21 @@ public abstract class WorldChunkMixin { @Nullable public abstract net.minecraft.block.BlockState setBlockState(BlockPos pos, net.minecraft.block.BlockState state, boolean moved); + @Shadow + public abstract TickSchedulers getTickSchedulers(); + public void terra$setBlock(int x, int y, int z, BlockState data, boolean physics) { - setBlockState(new BlockPos(x, y, z), (net.minecraft.block.BlockState) data, false); + BlockPos blockPos = new BlockPos(x, y, z); + setBlockState(blockPos, (net.minecraft.block.BlockState) data, false); + if (physics) { + net.minecraft.block.BlockState state = ((net.minecraft.block.BlockState) data); + if (state.isLiquid()) { + world.getFluidTickScheduler().scheduleTick(OrderedTick.create(state.getFluidState().getFluid(), blockPos)); + } else { + world.getBlockTickScheduler().scheduleTick(OrderedTick.create(state.getBlock(), blockPos)); + } + + } } public void terra$setBlock(int x, int y, int z, @NotNull BlockState blockState) { From 5c0c833b70fa0b5de9e3d2d8785723285230413a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB?= Date: Thu, 14 Jul 2022 00:45:52 -0700 Subject: [PATCH 16/83] Update LifecycleEntryPoint.java --- .../java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java index 12260088a..4350f31c0 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java @@ -18,7 +18,7 @@ public class LifecycleEntryPoint { private static final Logger logger = LoggerFactory.getLogger(LifecycleEntryPoint.class); protected static void initialize(String modName, LifecyclePlatform platform) { - logger.info("Initializing Terra %s mod...", modName); + logger.info("Initializing Terra {} mod...", modName); FabricServerCommandManager manager = new FabricServerCommandManager<>( CommandExecutionCoordinator.simpleCoordinator(), From 89651597c289d71b758a672ce6c3c257d00d9c3e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Fri, 29 Sep 2023 23:32:40 -0600 Subject: [PATCH 17/83] default to info logging --- platforms/fabric/build.gradle.kts | 4 ++-- platforms/forge/build.gradle.kts | 4 ++-- platforms/quilt/build.gradle.kts | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/platforms/fabric/build.gradle.kts b/platforms/fabric/build.gradle.kts index d8848e908..72abe20f9 100644 --- a/platforms/fabric/build.gradle.kts +++ b/platforms/fabric/build.gradle.kts @@ -50,10 +50,10 @@ loom { launches { named("client") { - property("fabric.log.level", "debug") + property("fabric.log.level", "info") } named("server") { - property("fabric.log.level", "debug") + property("fabric.log.level", "info") } } } diff --git a/platforms/forge/build.gradle.kts b/platforms/forge/build.gradle.kts index 7cfddab1d..328d9d481 100644 --- a/platforms/forge/build.gradle.kts +++ b/platforms/forge/build.gradle.kts @@ -39,11 +39,11 @@ loom { launches { named("client") { - property("fabric.log.level", "debug") + property("fabric.log.level", "info") property("mixin.env.disableRefMap", "true") } named("server") { - property("fabric.log.level", "debug") + property("fabric.log.level", "info") property("mixin.env.disableRefMap", "true") } } diff --git a/platforms/quilt/build.gradle.kts b/platforms/quilt/build.gradle.kts index 4cff5a427..b8933e76e 100644 --- a/platforms/quilt/build.gradle.kts +++ b/platforms/quilt/build.gradle.kts @@ -50,10 +50,10 @@ loom { launches { named("client") { - property("fabric.log.level", "debug") + property("fabric.log.level", "info") } named("server") { - property("fabric.log.level", "debug") + property("fabric.log.level", "info") } } } From 23f47de10a73e522df4c1c592bf122687f7ac590 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Fri, 29 Sep 2023 23:35:17 -0600 Subject: [PATCH 18/83] fix pack loading error --- .../terrascript/script/builders/BlockFunctionBuilder.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java index 7069b0b69..c2b6dc965 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java @@ -54,7 +54,7 @@ public class BlockFunctionBuilder implements FunctionBuilder { return switch(position) { case 0, 1, 2 -> Returnable.ReturnType.NUMBER; case 3 -> Returnable.ReturnType.STRING; - case 4 -> Returnable.ReturnType.BOOLEAN; + case 4, 5 -> Returnable.ReturnType.BOOLEAN; default -> null; }; } From 8e0d64dccd89315de6ac6a709770a3857f8f13f9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Sat, 30 Sep 2023 10:49:28 -0600 Subject: [PATCH 19/83] Make bukkit work --- .../com/dfsek/terra/bukkit/util/BukkitUtils.java | 12 ++++++++++++ .../dfsek/terra/bukkit/world/BukkitProtoWorld.java | 12 ++++++++++-- 2 files changed, 22 insertions(+), 2 deletions(-) create mode 100644 platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/BukkitUtils.java diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/BukkitUtils.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/BukkitUtils.java new file mode 100644 index 000000000..cc2fa78ef --- /dev/null +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/BukkitUtils.java @@ -0,0 +1,12 @@ +package com.dfsek.terra.bukkit.util; + +import org.bukkit.Material; +import org.bukkit.block.data.BlockData; + + +public class BukkitUtils { + public static boolean isLiquid(BlockData blockState) { + Material material = blockState.getMaterial(); + return material == Material.WATER || material == Material.LAVA; + } +} diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java index 52b3c5855..d6316325d 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java @@ -1,6 +1,9 @@ package com.dfsek.terra.bukkit.world; +import com.dfsek.terra.bukkit.util.BukkitUtils; + import org.bukkit.Location; +import org.bukkit.block.data.BlockData; import org.bukkit.generator.LimitedRegion; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -47,9 +50,14 @@ public class BukkitProtoWorld implements ProtoWorld { @Override public void setBlockState(int x, int y, int z, BlockState data, boolean physics) { access(x, y, z, () -> { - delegate.setBlockData(x, y, z, BukkitAdapter.adapt(data)); + BlockData bukkitData = BukkitAdapter.adapt(data); + delegate.setBlockData(x, y, z, bukkitData); if(physics) { - delegate.scheduleBlockUpdate(x, y, z); + if (BukkitUtils.isLiquid(bukkitData)) { + delegate.scheduleFluidUpdate(x, y, z); + } else { + delegate.scheduleBlockUpdate(x, y, z); + } } }); } From e51e025e9ca8b3c6662d5e87aaccd23d7b5a0c0f Mon Sep 17 00:00:00 2001 From: Astrash Date: Mon, 2 Oct 2023 11:14:43 +1100 Subject: [PATCH 20/83] Implement cubic spline sampler --- .../dfsek/terra/addons/noise/NoiseAddon.java | 7 +- .../config/CubicSplinePointTemplate.java | 25 ++++++ .../CubicSplineNormalizerTemplate.java | 23 +++++ .../terra/addons/noise/math/CubicSpline.java | 89 +++++++++++++++++++ .../normalizer/CubicSplineNoiseSampler.java | 20 +++++ 5 files changed, 163 insertions(+), 1 deletion(-) create mode 100644 common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/CubicSplinePointTemplate.java create mode 100644 common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/CubicSplineNormalizerTemplate.java create mode 100644 common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java create mode 100644 common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/CubicSplineNoiseSampler.java diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java index b002f29a4..7783ca5b7 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java @@ -14,6 +14,7 @@ import java.util.Map; import java.util.function.Supplier; import com.dfsek.terra.addons.manifest.api.AddonInitializer; +import com.dfsek.terra.addons.noise.config.CubicSplinePointTemplate; import com.dfsek.terra.addons.noise.config.DimensionApplicableNoiseSampler; import com.dfsek.terra.addons.noise.config.templates.BinaryArithmeticTemplate; import com.dfsek.terra.addons.noise.config.templates.DomainWarpTemplate; @@ -32,12 +33,14 @@ import com.dfsek.terra.addons.noise.config.templates.noise.fractal.BrownianMotio import com.dfsek.terra.addons.noise.config.templates.noise.fractal.PingPongTemplate; import com.dfsek.terra.addons.noise.config.templates.noise.fractal.RidgedFractalTemplate; import com.dfsek.terra.addons.noise.config.templates.normalizer.ClampNormalizerTemplate; +import com.dfsek.terra.addons.noise.config.templates.normalizer.CubicSplineNormalizerTemplate; import com.dfsek.terra.addons.noise.config.templates.normalizer.ExpressionNormalizerTemplate; import com.dfsek.terra.addons.noise.config.templates.normalizer.LinearNormalizerTemplate; import com.dfsek.terra.addons.noise.config.templates.normalizer.NormalNormalizerTemplate; import com.dfsek.terra.addons.noise.config.templates.normalizer.PosterizationNormalizerTemplate; import com.dfsek.terra.addons.noise.config.templates.normalizer.ProbabilityNormalizerTemplate; import com.dfsek.terra.addons.noise.config.templates.normalizer.ScaleNormalizerTemplate; +import com.dfsek.terra.addons.noise.math.CubicSpline; import com.dfsek.terra.addons.noise.samplers.arithmetic.AdditionSampler; import com.dfsek.terra.addons.noise.samplers.arithmetic.DivisionSampler; import com.dfsek.terra.addons.noise.samplers.arithmetic.MaxSampler; @@ -90,7 +93,8 @@ public class NoiseAddon implements AddonInitializer { .applyLoader(DistanceSampler.DistanceFunction.class, (type, o, loader, depthTracker) -> DistanceSampler.DistanceFunction.valueOf((String) o)) .applyLoader(DimensionApplicableNoiseSampler.class, DimensionApplicableNoiseSampler::new) - .applyLoader(FunctionTemplate.class, FunctionTemplate::new); + .applyLoader(FunctionTemplate.class, FunctionTemplate::new) + .applyLoader(CubicSpline.Point.class, CubicSplinePointTemplate::new); noiseRegistry.register(addon.key("LINEAR"), LinearNormalizerTemplate::new); noiseRegistry.register(addon.key("NORMAL"), NormalNormalizerTemplate::new); @@ -98,6 +102,7 @@ public class NoiseAddon implements AddonInitializer { noiseRegistry.register(addon.key("PROBABILITY"), ProbabilityNormalizerTemplate::new); noiseRegistry.register(addon.key("SCALE"), ScaleNormalizerTemplate::new); noiseRegistry.register(addon.key("POSTERIZATION"), PosterizationNormalizerTemplate::new); + noiseRegistry.register(addon.key("CUBIC_SPLINE"), CubicSplineNormalizerTemplate::new); noiseRegistry.register(addon.key("IMAGE"), ImageSamplerTemplate::new); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/CubicSplinePointTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/CubicSplinePointTemplate.java new file mode 100644 index 000000000..d7dea18e5 --- /dev/null +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/CubicSplinePointTemplate.java @@ -0,0 +1,25 @@ +package com.dfsek.terra.addons.noise.config; + +import com.dfsek.tectonic.api.config.template.annotations.Value; +import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; + +import com.dfsek.terra.addons.noise.math.CubicSpline.Point; +import com.dfsek.terra.api.config.meta.Meta; + + +public class CubicSplinePointTemplate implements ObjectTemplate { + + @Value("from") + private @Meta double from; + + @Value("to") + private @Meta double to; + + @Value("gradient") + private @Meta double gradient; + + @Override + public Point get() { + return new Point(from, to, gradient); + } +} diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/CubicSplineNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/CubicSplineNormalizerTemplate.java new file mode 100644 index 000000000..7e70dcc3c --- /dev/null +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/CubicSplineNormalizerTemplate.java @@ -0,0 +1,23 @@ +package com.dfsek.terra.addons.noise.config.templates.normalizer; + +import com.dfsek.tectonic.api.config.template.annotations.Value; + +import com.dfsek.terra.addons.noise.math.CubicSpline; +import com.dfsek.terra.addons.noise.math.CubicSpline.Point; +import com.dfsek.terra.addons.noise.normalizer.CubicSplineNoiseSampler; +import com.dfsek.terra.api.config.meta.Meta; +import com.dfsek.terra.api.noise.NoiseSampler; + +import java.util.List; + + +public class CubicSplineNormalizerTemplate extends NormalizerTemplate { + + @Value("points") + private @Meta List<@Meta Point> points; + + @Override + public NoiseSampler get() { + return new CubicSplineNoiseSampler(function, new CubicSpline(points)); + } +} diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java new file mode 100644 index 000000000..ff86bfa10 --- /dev/null +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java @@ -0,0 +1,89 @@ +package com.dfsek.terra.addons.noise.math; + +import org.jetbrains.annotations.NotNull; + +import java.util.Collections; +import java.util.List; + + +public class CubicSpline { + + private final double[] fromValues; + private final double[] toValues; + private final double[] gradients; + + public CubicSpline(List points) { + Collections.sort(points); + + this.fromValues = new double[points.size()]; + this.toValues = new double[points.size()]; + this.gradients = new double[points.size()]; + + for(int i = 0; i < points.size(); i++) { + fromValues[i] = points.get(i).from; + toValues[i] = points.get(i).to; + gradients[i] = points.get(i).gradient; + } + } + + public double apply(double in) { + return calculate(in, fromValues, toValues, gradients); + } + + public static double calculate(double in, double[] fromValues, double[] toValues, double[] gradients) { + int pointIdx = floorBinarySearch(in, fromValues) - 1; + + int pointIdxLast = fromValues.length - 1; + + if (pointIdx < 0) { // If to left of first point return linear function intersecting said point using point's gradient + return gradients[0] * (in - fromValues[0]) + toValues[0]; + } else if (pointIdx == pointIdxLast) { // Do same if to right of last point + return gradients[pointIdxLast] * (in - fromValues[pointIdxLast]) + toValues[pointIdxLast]; + } else { + double fromLeft = fromValues[pointIdx]; + double fromRight = fromValues[pointIdx + 1]; + + double toLeft = toValues[pointIdx]; + double toRight = toValues[pointIdx + 1]; + + double gradientLeft = gradients[pointIdx]; + double gradientRight = gradients[pointIdx + 1]; + + double fromDelta = fromRight - fromLeft; + double toDelta = toRight - toLeft; + + double t = (in - fromLeft) / fromDelta; + + return lerp(t, toLeft, toRight) + t * (1.0F - t) * lerp(t, gradientLeft * fromDelta - toDelta, -gradientRight * fromDelta + toDelta); + } + } + + private static int floorBinarySearch(double targetValue, double[] values) { + int left = 0; + int right = values.length; + int idx = right - left; + while (idx > 0) { + int halfDelta = idx / 2; + int mid = left + halfDelta; + if (targetValue < values[mid]) { + idx = halfDelta; + } else { + left = mid + 1; + idx -= halfDelta + 1; + } + } + return left; + } + + private static double lerp(double t, double a, double b) { + return a + t * (b - a); + } + + public record Point(double from, double to, double gradient) implements Comparable { + + @Override + public int compareTo(@NotNull CubicSpline.Point o) { + return Double.compare(from, o.from); + } + } +} diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/CubicSplineNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/CubicSplineNoiseSampler.java new file mode 100644 index 000000000..24af8e351 --- /dev/null +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/CubicSplineNoiseSampler.java @@ -0,0 +1,20 @@ +package com.dfsek.terra.addons.noise.normalizer; + +import com.dfsek.terra.addons.noise.math.CubicSpline; +import com.dfsek.terra.api.noise.NoiseSampler; + + +public class CubicSplineNoiseSampler extends Normalizer { + + private final CubicSpline spline; + + public CubicSplineNoiseSampler(NoiseSampler sampler, CubicSpline spline) { + super(sampler); + this.spline = spline; + } + + @Override + public double normalize(double in) { + return spline.apply(in); + } +} From 0a7cdb82a3b3cff852023c3ef183d1d6f0d2f496 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Sun, 1 Oct 2023 22:18:54 -0600 Subject: [PATCH 21/83] update deps + 1.20.2 --- buildSrc/build.gradle.kts | 22 +- buildSrc/src/main/kotlin/Versions.kt | 48 +-- gradle/wrapper/gradle-wrapper.jar | Bin 59203 -> 63721 bytes gradle/wrapper/gradle-wrapper.properties | 5 +- gradlew | 294 +++++++++++------- gradlew.bat | 15 +- platforms/bukkit/build.gradle.kts | 3 +- platforms/bukkit/common/build.gradle.kts | 8 +- .../bukkit/nms/v1_18_R2/build.gradle.kts | 2 +- .../bukkit/nms/v1_19_R1/build.gradle.kts | 2 +- .../bukkit/nms/v1_19_R2/build.gradle.kts | 2 +- .../bukkit/nms/v1_19_R3/build.gradle.kts | 2 +- .../bukkit/nms/v1_20_R1/build.gradle.kts | 4 +- .../bukkit/nms/v1_20_R2/build.gradle.kts | 17 + .../bukkit/nms/v1_20_R1/AwfulBukkitHacks.java | 101 ++++++ .../bukkit/nms/v1_20_R1/NMSBiomeInfo.java | 10 + .../bukkit/nms/v1_20_R1/NMSBiomeInjector.java | 83 +++++ .../bukkit/nms/v1_20_R1/NMSBiomeProvider.java | 47 +++ .../v1_20_R1/NMSChunkGeneratorDelegate.java | 170 ++++++++++ .../bukkit/nms/v1_20_R1/NMSInitializer.java | 15 + .../nms/v1_20_R1/NMSInjectListener.java | 48 +++ .../nms/v1_20_R1/NMSWorldProperties.java | 36 +++ .../terra/bukkit/nms/v1_20_R1/Reflection.java | 50 +++ .../bukkit/nms/v1_20_R1/RegistryFetcher.java | 24 ++ platforms/cli/build.gradle.kts | 4 +- platforms/fabric/build.gradle.kts | 14 +- platforms/forge/build.gradle.kts | 22 +- platforms/mixin-common/build.gradle.kts | 2 +- platforms/mixin-lifecycle/build.gradle.kts | 2 +- platforms/quilt/build.gradle.kts | 11 +- 30 files changed, 853 insertions(+), 210 deletions(-) create mode 100644 platforms/bukkit/nms/v1_20_R2/build.gradle.kts create mode 100644 platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/AwfulBukkitHacks.java create mode 100644 platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInfo.java create mode 100644 platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java create mode 100644 platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java create mode 100644 platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java create mode 100644 platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInitializer.java create mode 100644 platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInjectListener.java create mode 100644 platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSWorldProperties.java create mode 100644 platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/Reflection.java create mode 100644 platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/RegistryFetcher.java diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts index d6fbe2a8f..84d964d5c 100644 --- a/buildSrc/build.gradle.kts +++ b/buildSrc/build.gradle.kts @@ -3,15 +3,6 @@ plugins { kotlin("jvm") version embeddedKotlinVersion } -buildscript { - configurations.all { - resolutionStrategy { - force("org.ow2.asm:asm:9.3") // TODO: remove when ShadowJar updates ASM version - force("org.ow2.asm:asm-commons:9.3") - } - } -} - repositories { mavenCentral() gradlePluginPortal() @@ -24,11 +15,12 @@ repositories { } dependencies { - implementation("gradle.plugin.com.github.jengelman.gradle.plugins:shadow:+") - implementation("io.papermc.paperweight.userdev:io.papermc.paperweight.userdev.gradle.plugin:1.3.5") + //TODO Allow pulling from Versions.kt + implementation("com.github.johnrengelman", "shadow", "8.1.1") + implementation("io.papermc.paperweight.userdev", "io.papermc.paperweight.userdev.gradle.plugin","1.5.6") - implementation("org.ow2.asm:asm:9.3") - implementation("org.ow2.asm:asm-tree:9.3") - implementation("com.dfsek.tectonic:common:4.2.0") - implementation("org.yaml:snakeyaml:1.27") + implementation("org.ow2.asm", "asm", "9.5") + implementation("org.ow2.asm", "asm-tree", "9.5") + implementation("com.dfsek.tectonic", "common", "4.2.0") + implementation("org.yaml", "snakeyaml", "2.2") } \ No newline at end of file diff --git a/buildSrc/src/main/kotlin/Versions.kt b/buildSrc/src/main/kotlin/Versions.kt index 6c9e8a888..529d15726 100644 --- a/buildSrc/src/main/kotlin/Versions.kt +++ b/buildSrc/src/main/kotlin/Versions.kt @@ -4,53 +4,57 @@ object Versions { const val paralithic = "0.7.0" const val strata = "1.1.1" - const val cloud = "1.8.0" + const val cloud = "1.8.4" - const val slf4j = "1.7.36" - const val log4j_slf4j_impl = "2.14.1" + const val slf4j = "2.0.9" + const val log4j_slf4j_impl = "2.20.0" object Internal { - const val apacheText = "1.9" + const val shadow = "8.1.1" + const val apacheText = "1.10.0" const val jafama = "2.3.2" - const val apacheIO = "2.6" - const val fastutil = "8.5.6" + const val apacheIO = "2.14.0" + const val guava = "32.1.2-jre" + const val asm = "9.5" + const val snakeYml = "2.2" } } object Fabric { - const val fabricLoader = "0.14.8" - const val fabricAPI = "0.83.1+1.20.1" + const val fabricAPI = "0.89.3+${Mod.minecraft}" } object Quilt { - const val quiltLoader = "0.17.0" - const val fabricApi = "6.0.0-beta.3+0.76.0-1.19.4" + const val quiltLoader = "0.20.2" + const val fabricApi = "7.3.1+0.89.3-1.20.1" } object Mod { - const val mixin = "0.11.2+mixin.0.8.5" + const val mixin = "0.12.5+mixin.0.8.5" - const val minecraft = "1.20.1" + const val minecraft = "1.20.2" const val yarn = "$minecraft+build.2" - const val fabricLoader = "0.14.21" + const val fabricLoader = "0.14.22" - const val architecuryLoom = "0.12.0.290" - const val architecturyPlugin = "3.4-SNAPSHOT" + const val architecuryLoom = "1.3.357" + const val architecturyPlugin = "3.4.146" - const val loomQuiltflower = "1.7.1" + const val loomVineflower = "1.11.0" } object Forge { - const val forge = "${Mod.minecraft}-47.0.3" - const val burningwave = "12.53.0" + const val forge = "${Mod.minecraft}-48.0.13" + const val burningwave = "12.63.0" } object Bukkit { const val paper = "1.18.2-R0.1-SNAPSHOT" const val paperLib = "1.0.5" - const val minecraft = "1.20.1" + const val minecraft = "1.20.2" const val reflectionRemapper = "0.1.0-SNAPSHOT" - const val paperDevBundle = "1.20.1-R0.1-SNAPSHOT" + const val paperDevBundle = "1.20.2-R0.1-SNAPSHOT" + const val runPaper = "2.2.0" + const val paperWeight = "1.5.6" } object Sponge { @@ -61,8 +65,6 @@ object Versions { object CLI { const val nbt = "6.1" - const val logback = "1.2.9" - const val commonsIO = "2.7" - const val guava = "31.0.1-jre" + const val logback = "1.4.11" } } \ No newline at end of file diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar index e708b1c023ec8b20f512888fe07c5bd3ff77bb8f..7f93135c49b765f8051ef9d0a6055ff8e46073d8 100644 GIT binary patch delta 44866 zcmZ6yV~{3M)92l`t*d+5wmogzwr%${jcMDqZQHiZY1^EgclU{V_kKTAoQ$fhi29Iu z@>iMvGdKf&b_WirC<6|Gk*MT`8IOk!ijf$wgc~oR`Oo-w2N?nc1jNDFf)O0#|9Y)s z{-1}55TF2T3=j|)n14<}AR(u#9+Yq(Ao|!KAT){jCRmAAYuLbSO=w^IWx%&S-N(_x zu*i%umUPxo11kb-zz{5K%+(qcIZ{gEQgDLqWh6bxS=J)8yrq>4cDCz0sOy3dXTAtW z8|cOYsGU{54|2y#PSUfFM?;mWY&Xuph_swB`6Qom&H7|#Cr5YxX)8BD+UVA(U8sP*+u8?shKi4yhV*4yh93bXZq z1G2SJ^C)n)>_E=5(ewkWy-SV3LB$DrhauJD^-f-Jr}#j=OXqi=4@Q?p|A%T-|A!je z9ypvpS%FeR2e=0{*U9KMO~xHDCeet*(W=C8Li}VK5jxO+tFQp=W#X$SB6hzk;={2w z0{YeoGq;Ztldo(~g+}|%3X}7I)!$bgjqhl55Ke$nP>>P1H}3$|w;s-5pb(BQG0h-_ z4)zyW#vh#g|ha_79S)BJH#{K2`f^Wkouea2r_va7i zY=3Qs@C)GheoC3$aKa!j#Gls8@uX_XD-mx#JD6bUFdHH0Jp%CR#GL>v+MIo z-Xwe;xhN*D$#`0~Odj2qt7PA*J(7~P99at6b1C{LVx@r~A!kv-pFBdrA|2-TSunq6 zNjma624n3(`oRoC+-W7Sq=C_(j;3vQg)=BCW> z;2eU45kg1Du`=g5*>|sk-L0AKn~h_~GE(N?r&XrDJ0v%o0~PhbP1f@vKP_5|10I zs5-!ov1UfQ(F6KLN2}7wiyz5X9OzArB=$(iGG?h>V#Ego2{jb(XM83IC3cCgHeI*K z*v8|cMS}7}A&V&ta%h$r0ag4&$xYwHE_Aq@Ps9Pq`lkGVbr;;78P=eX3l7L#Gqh6? zk>P7|(Se;9YT3|%?5V2ceG*Nl?SrDvRewybjPbMEuu2SpJ2%mW7UQ$k`*uJ5FwjM2iN*lz#sVY zFSZ9L#g#4(qKMFvHnyEf1_EbHojThmilFjsTL{r1g z{>kg_Km+SnO#f-R4EY&*e)fSM)~|^Em3tm|{;`6VT;V6yT+z&kPJ9aeMC_liz?EC< z&t$zpHN&V1y|O(AyzdyGB=on6VL4FaZtM*u7Q4gc{Pvf9Y*Vqacp$Z@6vf|!Np!Gi z!ZDvUY84L71+OWA)ehjH6ezu5xn-_QyH&@!bjx3*Fsk6R(r^}W?N`xu3K~)F%tdxt zG@Iz3Y69Vk!MUyl%BU3-6~QH8Zy9A+>=9+lqS-K11^VdlL&6lR2*;wWvXnqc10JhU zH1TW2dxN6zVP*JTSen{!auTY#N<9S%IbJr?xiN@CT)ZSPE@|Lz`80K^i$s)C+0$S% z3gIAvu+gU^RBPQ#>n+u|r0&sLRwz3;I?TzUw&MuR{P5%hFtK2^dbribt0~>93{Cn8 z%=x@qG7xO`*h^W(Y4jZm)ri5qPisM&xc{xgolZ}KB4eO{Z z$m1D5!*nZp71hC*PuC1YKmOjOrX z(G|x!A=th#)?@$qx`m*fp%4KBVWd52TbpUl%o&T43}Z9)4&_Sd-&FkH8Xxz<$<-5e zFZj=CR@s*pCQOShE~94jO`#TP-o>~|aA)y^T|f9Xvky0LkEc8V_dN8LXE7kdj(n4j z1b5PA3aHm}w|ozH;4#1~CB#+zwEy2ukt&PE;v#>%HC`LnB!fu1da*Vy z&GgMiloIKh+wHtD(Ya$at;VSNHU>sE^@!Ka0Tzd3? z*iLZrhC;_a(KS`OMO-$qw0r$7vR$n&(iCnA#+Dcl)7OF^(vXKZX8GbLET9?E$R%@KjV{uDz>V{wrh^&O8HVMSbs@U#lL-IJsA+5fc>%X>z_ugEd~RXgp)Z zWgkqvlQe2>m*qn1;O-eEe<2H9N-#noIdUSaZ5brDuD0DwZmv2KO>eFa%sL2=w-J&Q z{q7CyJ)S;H^JoonPP6$9j<9c~%Z?2S-j>mu%oS)8CT0x014+(MSTjMVimb~0+j<#B|wgOd@CZa7tCijsPTvRY<5ixOcu+7%rR zHg&@;YsL<*{lZ)ei>!y;Zi@qL3(MIEG+BcKPu)Xk*e{!0ru8}Ybct6NbjzsfNPMI6VMWX+Etux0FQ3?au}C*h%QHrw_}eykN8CG zVGJ<7!gths*nawtF=kND_?Jfw6{*hyOT)w+&e(x%jF=9VL;X^st@i8Rfj+T-X} z(c$6C0xOoCvoG#mYy}+(s@q+79RMZ7JTkyQybPh!U z0gatF&+muyceQ`D)bInnOx4k(Od?-VO`y0D3Ylviq{)(!WcrLc|Lc;My)_Rp;OXWDtDLV#j4Li#0x{#!Er4gM{O z(>u707{BPC{+U7{=Scq-a)-i+O%l07m4F0mSX5M)H({7(klsQNbY;Js5UQfoobJZbVF z=PB@v(X>&MQ6vU}K)3dBj@oG12GO|0xvrg}q;L0nAYhTX2%V!?+0ts4gnx|8Wdj$Y zb=fS&Y`n-brYq;A{9II4R+KAB=qAL4m=jF-E37NLa*aAx*FPQLWxCYOQxOgU`1qBM%0tl{*hY9S!i_j*WysEXN27jWEgzAOD!>$Ef?>f!qAY3L)g)hQ;8by z(xsv@Wj`8Yb|gR=J{u?0CUjv>jt4TaU1*OaA+mOxRdkFnkI$Lc+G!NA!Cr_tSnK)I zOFT5BM4HQrEIW@&OUKisE0 zQF9S8+h$2&agE}&vJ5{_P=vJMpdkck&oE2kc3YYzQ>zul_70R7Y$an~aRE<$Bij+g zcBc)njYeTNdJfDTyRsvY#)#(F;Aiwy0}_$5msRz3M=*tKbI{i3`*krrf$U-i(Xi%} zD9P$?>T}vCA{j=vxz<%FX|}P4n+^E{(d8K=PVWWzTOKn7=!tzC1$>E(TE&Vm2%}Uo z(AHE@d3q&cD$^3>6{5cZs6a*T6O6?C(k_!Cjn(9;c3_L{P`#wzg`}lJ>;=1pV$88z z>B>QNW%C-a1d*cGCkMTG#0)MLX-BK7f5E(CcR_379b50Ip=$xWj7sC+(bc-a5Fo7fROZZn|KP8iojOk(# zCf8O(4nTbON8Xxlx)!bfUIeM+-jw$5s@Gu}+3TUNXDytsHpvHwcDsBFbxNt4dEagN z{gz+1>-WN*0(~%{qH;vu=vqq55L~jT0rGAA-Kk zk7`^k%xXI7OQYyyZEVaE2gB z%u)|dnEP#~D7<#aq?nM`4s5fe#w>`KEbKbsA*}P(`sxUHU-0HAo;RSh=sJ598YNm^ z#S(<$k`ad%eo$ZdW&<@_HT)R9O5*c@RgW3Hhbfa{)7nqPq}K3IeeYS)cT7=2a zwnNWL**WNql_tEhixA|--~F0T9A?8kH)TCImJjL5nC9_9>WCVRry===c!R!lU*(>p zT`vWL%ZP+cMaENSZ8^YU#3@!;!g5etiWui-ghmMm#CP9Ag=C|qD{ zZz4R3jnKat_By)nzFy7V4wI=}Q`>SMzp(S7!1zh8Z#Q!rH;kh<(X$i3ets{_pyP z*Af5ul{gpAr%vt_^n^ouq(d-k! zwTKrG6A>SQSs>uXMXQ+@I|%xb;uw9{u}0@o1=Gxq3uLi(+(IzSK1_+)d{rDl;o!Pw z8CW}_a@;b*Y3i-vC~!eQ_gbtdqDkpcSya)k&d_GRa9ds**FgNLv1WIrmDtdz6kpai z*35lY2dWLC-ZY&Zo44Q;skum4aFIe}PJ3&$UY8%^Ney_ZsMzRKs9}DjD55#yimN|{ zmK5(+0ksi3*XUYpS*ThOMOxKutPArKwKvdBn@Wiz*vbGE&p%3eu|kL!sWvLiun9NS z7WZD$jMnrzdrs#lbT${?B+falD@yQ^Rp(nO#K~9b)9*rd%rco?)hbEKE*d0uXIvk{ z$vpN6=UV3K<(@8H`)(ca)qbbM9yW|GqXwf|1MOa7-q+sR2*g6RR}(aLh^KhlPkeYN zL%f*jm_$F?M}J^XmlP|_gas2^Eu>>^(Q?HyLl$z4I>i!uk;o4pf55fe!j6{0Nw1lQ zdES-pfeM(6d3tv^T;lyfFO)FP5j>adhm?g;HDDQvb+5Bk%W&JSbKqNkR43H6Opj`E z29jx!c86vDiZ34@S)vm;WzvE_mgq2d@h$!-rscVWgT*hh!9|iczXLtMfEh{qx0>q_ ze9W!=Q?&U}{-*?hF6*;-k@P`+)dYQ1&3Ns!lH}>5%v5dhQJgd*r*PD*Jobg}@ZEZ2 zSvw*kfC>QsR$+~~ZQizqv^brV>ai&n3WQ++>o*mIY2gl=HH7ZmeKtO3Ps(`?+-5Az z*N9i-E?ugs6qPA~o`D`^byMt+@ZQ4w{=TKCeqh|wyZ*~~jz(D@0rMnJy5wB1D2d^q z{kD(ZOn~69aE*2K#YS8I8hbl@5YGSFTiT86Fz>0IRnG>c2_=*=yh(;%%(^hj1zZnl zEYOx_33+j>H+y1qM3}3(7NHqNw?zietS8#@iRmALcO>!``9T{k)oZeYnfs2k?>AP= zWf#P}ppkQBQidTw{}shb4s3WO$md7++Y#$X%}vq0@Tuks%c0EMtBakbx2igHyEU>mq&*vXh>3D6|= zY+*$Ad})`!&ZOB~LV4ZCw)2>#umGdX8pnOirC6_7hiQiigE^XdBOf!X?FVa`L!E53 zKYki8$?U(O6niP7`8i`bS%;nkmn(u4DCqw_4Qy-!pI5NBi$5AXVFMD61O9^j_s;OA z=%=&{7zoJCzhC~McFEDGb6{{MczXa(A%K(nB{$+};h_>FW^*8NGPA|~vgIRh(fjrK3E9Ws{@|!M zZX(XeL3n-~ALN$3Bh^qWZ9 zFpB+<(3SF=Nl^b(7e}C#BMetZ3ICB$&xf9^Ic_+Ipb)Bi$EAv3PYV-l{mvHwf!Spl zYQ2Yuaq}^7@wPyENsav8ae-e$l24;Tg^wW5$UTp9fq#YWKf<324bCXWLBYC=wH!RC z8PXrK!U~FGaFfu`!zW;FsH$=b9O`3Nx~@0RNS5KX=bCS68nEKX6+v1~1l)ID;V9>(Is z-n_+$=v8S?8w~`%e_H?h-I%(jB7^|1L2ay=d5tyb`z((%xbg!gdF~4rh*j&!`u=+= zW*(t(@pK$9w1=spz+omZ->)E1hBB6<&~jCv|5Xwn98%kb$BId}v^x`wDHKhtgnlXl zGoL=9`27#$)Yma`UFz)94o_)SI#V*+08>0G-4P;w%|2OGa}$fna;I2QqCELlQMM3k zTifr=p~fWnM*st@Kdl|PSGx;^9c}DNpcfY2#L;uOo19N9sJT7 zdV<=JuQJ+4Gv5cj682kQCE*o>GvN)fp;KBf#ZhB0l2s7&zr)Sqkt`np8U(}>6$FI; zf5MFvIIVf%fw_$NH~Z+%%(Q7A3R$wE5lwJ#CN?ai7aO~1(wJP`5EQ98?lmAGATynd zl@nBlXlX@4Cs{ys?j8+JyF4(#aOhpTvZ=Y!{cZSfU-KuvE}h#=dVB5BfZXd*s>{q} zqrpk*i@?X$#~J6pj(i^CAxp|WD6SG8l~HLFP}%ZWbbVMPD-;5m2e~ud?dO0YL`X0{ z3zkW36daisJ4S#ODE#2mV_X!^+UJ?1F2ht=9)<*Ow_|&HyN^LgOhbnm_Hn2UrCAC0@$<#YTu!48KfLH8;jP z@RCJt`&!mIrjQqmo_Uhc61T2dRM{b%GCD=x#!`|Moq2HSX2n*bHT7ts78~XR3&OrV zq>NEy3-gYy{#Td3PwA5w-XQNhK;%KOui?#jFo&tNL|uX ze?SNpi1PaKB6t$v((3J{)!@L5T+P>XR~HzXtQ)#G_w(0_HZ^a}u92f*W$7)O3lG)W zFQSKAiGcR?^Xoc0JHb>ghcBsqV6|pt9wH5birLEs!)! zii@VMgKA?tdN7{Xgd;Yw+bPw18{q3%dPiP062 zh$c_{N-Iyx6(jyeS$3A^Jf?}B^)ecXWy+bd~>DmI) zsk^c#V8exfU;#u+`q&c^u6EbaQ)lvy>P%0CdTkp!j2iq7QT@}SQK z^C;2QJwk=eZqo`n0xIUGI4djHy&#R5T)( z9#YzBPKA%==gB*=R|}ct$-;(!YMDAhBfN5O^x|wP=rajb+-aG@0}|5aYPlebn{!Bb5u{_Q7EbfUKLqhb1!I~XBULb{qjUi@XY1|g3AnRHAQmH zlkeQiD_#M0X0!63J@(}9?O3ZtsI;2mR`l9vZ{15z_!VWIi=4JRaURz1Ap(L1)7)T} zzoPDuXO4N9Gh-PU^0cFbiv2jMUL(K;Gx_!N(c<+51DZK9(y7rjc{9W1(#{UP2*l!l z#_zR;Ffu-)wGbEh^{)|%+r(5h6UK2Sn+04Vzo`TNocx>!8N4YN+0{aM!2FCOv^Z>A z*SSQytD55OHJO>b=d`j4vnVK3iQ+5DcEAA8ifJ(f4w5}Hwz3)-5F$I{T(#B!xcdP zJ9+{ot&5Op@q`6U6izdeVGV~^u&wIo@ckN=9pdfCbD8SMJeN1||ljm#t z=yN<+`B4{So3!Vza5Fo9*^eSls>?S2O_RZ{5&AldjE#TxL8xwkoA2tu4E7Bi9=;K| z_xSJXY5Q>2S^5vw9-%-$`2GWHj9CESuEL@s#%Qkx{`LwcE=`zVI=Y!)9HQt?Mf71J zW_h-L!$1Y>m8p#Dlr8tNyJ2jDM}s>dG(b4=H|V$0h|4C+s3wbMitEW%&I7mL=J(sj z1?Mjj`PeC-*HYm9&RnCmbUJh;^N0!ra#^FRNL_uDHqxWSU+yYwKbQG zZ|FL_m8s8o{?=I~P;~DRijAuQckTiD4ee#gD|}M+lW&M2RH^LAyZM<2K`~sv)=mRY z!LDjQs3od+j0IKC`+RRaCc8b-f zFXdf3pIB5Pln@e@fs&1o_?*@R^HmCGiySX}M_JHWBtAx9N=QBn1+|9c`ixY1YRkqn zYL&1j12=i<0cAq$N*!zs{B4Y0??9g;{?aed;?#sCF{qXGz}-Ynd_p~3iom4#8eoYI zK3q=GbOUHp5MV&ZX>kl9mY3p@LQP;a=7ZRUMVF;vI>xyP_P3v8UJsaYThk!2fCvF)K+G6OM!Ek*S12_2+~>}l5O0Uc*TQK#;Lw#&bC6*$ zUv!gRm=Qo{%$CIxmG&N(%nbJQMRSODrUfZU`ThUn!G3qt*hJ7=w8WQv`a2M(cm(0>1YJ4;Z*`4ZK7u&ZrT2Br$%VKS5#RD^so=Y+22!ZR>C zLN=B7$#k=kz{e~U-k|!(DfZyK!!FafxnFOUY)jZMC4EQsv1XhCsKY#twj&T?M5W_9 zZ1CV4wE5&aj-H}tFu`vDj7C#9@D+Q1`TmXI=*uwhMjdc&-P)Zvh6+9`UPi2 zUP@l^Cxbj%b@hz8yo@xUC}uHjaUK|}!eei&IouVaqp4V5W&%5j;1ZBt)paXdZw|Xk z+f3u1W>lA|Q?YHH#z%PK-(42qT}sVu`TR#=O(i58SY92`iD1(2l9O&V>$K#I+>wQZ z=X;JiLNCqAY*80&MRctp-ker*4e5 ziw8PMX9%S7_(_W3Bt0OKB|0CBqlXBKuz`fInqtDDmatnz-2~!Z(h83ZF%0B>Hs&>A zSeVRdV!@^iqP!_%6tXtuKyUDtqms$VHjKH89@(GBZhq;Z!e@ITz|h zo;v*ZF8gekiJl1#0wVQKI>h-u5+e&|BU9VNZhzFoyaNC*S#8^SQ5@rYC52RsYM3ir zWP#{Mu(q^u7KF5ARtfB%*=i?CIS~<^wCHN)f{3Gd(~|B}{97=;z#Yd${8ANj9^ID! z93FbWj5Lj$3F;!Q&+PU3&F6J%Wq8lB3obElW+s7;Ga!&14x|ZSL5ss<_+;Vo1K)WPKoe zNRz!Svm|D#84E$RR*cro^>x|~eUC{Zg@#M!*3Ll=`AWSq+_jE?hQ)^-Y{5+JlCGfz%-4}_7<*3wE0?lfJVcokLW&OI@`S*)iY(0LBa3+65 zQ;P(&pTcWb$G2a#$N4)~HmhEHp7^ZQx`IOtN)5q^)+1tFLZQ@<;(L#x1864t=JO#X|w>hW- zc3pjG>j*Qx!gFzc%{k(EAlsR!w)agl(R~ANe4cY_M4Jq8WDX$p()+VW^_!-DzzJjj zO|!o|)EqZDKj`l<8q3XGqY+(XBQV4ZShQlsNc4R!H-3-HM{E0gYbUGVswa7yhEfQO zfb{N-4KhmTK}S2+ftZ`F|{T(t1Kxt`IB zjQx}&;uo1&lplpy6Bppb#>1%!hoyk!q4lFl3OrTBjLs&r%oE=~1HPmbh7Dc=x?ya1 zh>iiPWabvP{+cJG7?vpmR6U_cLB5!V#wq4#e=LCr3-C*3RF68Pz4byO?m-VFm;3 ziaDdy35!X8A+BnNO{>Rz#5CNF1dL@spgu?IfQGeBtqzoad zgc{i-GpRhJfD*+{Ar66#5%ibgs)WwoBXfKBwD1+;`?u(i|1XLYfd z$x3g(%Iy^df~O5PvUwX>l9jNTDx#Tl|F%NpG^$9O&nqAk6$@L(xDH?A#za=-GYxa< z?T^y|?)=GZKXYs~s`=e>#qkF>L7%pXKQ#$*vw2V~WL(%nx3siv2Bp^9Ei&I>-MumN!Mq z#kTRBJ#(u%63wBVNYnq@RDeCsN^>8c*OL1acme02oK5@NxK-R|RapPyF{G6YfEkOU zoWI(mewViY^!r^P*FbDW{Edb5-}h^Ue2U%UczafxLkjh+7oDC;s7oM$3-is-hte@Krn*g;1Q@;2T|WRe%XNBUN;Q|9;0qC=0&7ix zs>5g^Z^~V`4S(-6I9sc=Jty2S*!{l|&Z@D8UYma$`Q!N34bq47Gi1{H7g5gY&`(yQ zZ`*?cYRW9|&eps{nZyNq5x!h8@hGPgnzC@1vtiHhLHJc0IL0F8*DVN0%w?}g?USDS zpH0v6WFx`p!nsu9&8bZ_@kEY@Y)XxQIIAG#;ViP&1#!YWcBC}ulK7fT{y%bL2!6aF z7WU@Z6OfQkvAy8}pyzr_j!p|smWCOQN6AWy`iwh{@>`uq2{}(Ih0{H27l_c&Z%9ZC z7pTF|M?fF953e^QzbNC-?24*RKi!kMq}>j|*3)PJ!t1<=HDj)Y0B1fF%)@!%pQ>B& z;HcV!=wW6mZIR81scDZRUW&Jqb{D=ifsjDa?YUFWkw;Z!cTg*4s zXFz7B8?$RD2@yji4>=0C+SsQEN?^QXDZ_LC?i%A%tk*m>xiwk5%?{^?r0-{}qRiCX z+TnU6SbG{mBcx{^&OL8=pKjVW9smIF2EjSAhN^n2_p~uEV3Cd&?6VFTat4>YDeI25 ziFFbK+o{tzu!41;TTjUo2->6(WoNcM?o{%@XE3c+BV*1UC5pwY`l{7r>mHyCt*Mg0 z;Jv;Fk%9VDL9mIE^L)!LZ;}|^MSZKTMh{E&f&b5axeg=12T6xUX8i3!EM%)U5BL4T zeG$`0=DhBXlB0UgeJc0B&ULm&s`#;E^&Wr4L?gbOI;KuVk}OJw{ulk zUqwg2F_gPyuI4tUaRaoldlm~*2m(;#-D3yA=C4;k4Mya!F;2HUeaJt#FoYi3sB`AN z(4*~XiQE%UkeIgz4-V96a>bsqW&{*9%Q#Czcsu;9$B`q#d`6O#z%RBpafCj^s01_R zoSFSuMJi-l?AiP>hrDu!e45OMUhzunXN>nW?+^$Fi`gQdh~SNHkSEB_p9Mh4Q`5`{ zDy2i%ciUg3Ok>dT$0BL_R!474(!LOrzH}r_Xq;Cl2|IFI5t8UQJ~4mj+qCp4`1u&8R<=I9@|+w3VIzz zQ|P~fe=3bUwAeNX1+rPqO5{Fdon*CseVv>zfKu4Op)xUhfaL-BiRD+_;ngmk^-_1hFO-@5rpgOZ6qk{7`6I)fmxG zDIac%UDZahjZW_;)j1VOEsBQbJhB6BxU&uUu$;?y$=sUD?>X|BungWABxrbeV!M8# zO*~zvzmgFcjKwcTCQ(XUjldFL{7#KaQY5W*hLX^PJ;KQR4V9nvy6T!cWyMl@b>L(U zY||29hzkwq!uT-X;gh+cj#G(ib+$B0ty3|Wdg!W--FW?sQv4ud>%WG?w%+S`cr34- zHq`dc;G;8zRsV8ZTXSHiXM0!^nI8}^a!6nIYyxg_pXas*g*n!JZon=N59-;Z5J1i{ zVa@NU0=tvN5X^rAs}UZ}`sZjt_OT>@NIJ%uJ71uO_`FcI{^qU;6Jzzc3Lv%`poz(O zIOxf16l8WaENpI#N$*Gx7l;{8Y3B3+WNh^w&>ljvnj>Fno&fwTO1?Jb)hLr52b#?+ zWpP+DAr*lPj2=T9*^vxt28A;zgEOf^=A0q3WSrjcOlGo zKtL$|=M^X*gNdz?i%Yham7&gZ^1s3O+4wADCORdmDXLc3l_zXK+K^T@B-4<5A924H zOvINhtvVU$I9W(t@XvK>nS43TOe|%pCc1tpM_4AabY(cRJe7eav$S*;nMqlr1yJFX zw`;!yx^*~?uY8Z2&X+8gS^i0nSwHW?wFhVr+0-wfm*rsT`CYpAXKlDQ0n4ohx;+8Q z9q@JQ=oTBQhs}|T2>LD=7F|O2XumALgaYc&v*#xnkq?;!zcZp!`Wl0Mt*0yk_8>}a zxKhFirb_ooWoR)KRQhRBzdmk(cu2)46T9+W^8S*TxM%TPTs#HEA&N$dQb-hsQm}~r zU41ezap}->m|2{Ega-65Y3uHMU&GtFN9F#mK~@o&*|Z>BI^A^46rJ^0Rip$*+0?iN zBeN_4O^j_hP8t2d3X+;tsoI>Tcq!qY6onpTcm z#k^vNPNd?#Uf0~mEQZ)c%_B$Ktw#fkYPk~F-Jsab$YNR_zMMoaBf6H@cnaCvxa{0O zY~gcE(Ap-ed`tHp5Qa|}i!k}BCvO?xC~L` zglFr_w-U0D5ux=rY3AU}(fv<0bBT+?fHu1^yc*9P*gq?9A!fMxlvGuSBgVQL>D4hU zr_|TQ9o+U3+4E_{*zn?~@r{A=nq566;7=PEFq}$#!kye`%|6li4FYDr&Zh&)vg@zO z13#kzK(J+7Qw(1lj%lq^maA(kYxEj`{$5WJm@*7y=&vdE2)bBhr(w_{m`a_)JIeKZ zD5dKA>#C+sa(+((#WE|DT&V_iM^$*<#eMs*kOTCXF|KIH+Cz53;QOx=Kg$N6C!qS{ z!W!3qXG;M>imKJ|Eh%;M{p!dG!aPK+^2yU1UEUcQ+0g9DEyJNQgx$qVs5Ik&b<+!m zYwjGpK7?jS@WI0I)6M<#?kWRYvMwFoZG^M8oE9Mp%JZ1Z4v|6ieIapjl%9Ve2K!(6 zgzS~>qyub}ipJI7U5YzmpQLPYy)u9T6o^o(phjoII`1Wm<+_J>Xwy!EE zxf(6ycE7M*Qu5X_7LF8!{Y_?pw5^F^QGL1%#q;tZ`h|w(N_c9BU)2~yYtAX^Tt-^` zxL@|p%DH^`7_k6*WBWN~c7#Al7UefW44jz{E3!zklyO9=1Jw1VlEF=%i}c~w^=D)2 z5z)Yum)^uF{-~)(KMS9Qzw1$%u__p7hK9NQlmWX9y` zfa~#SDKS3?vq)7Hck<7Q3na9o>2nF~7=? z*0|9E!i-|ZM7u~6?BA8Lq*3Q2&-$$skCuCXY)+|Sj6U}8a zDbjS81mQ3q*k;yQszY5$4*2|jWcksA6@_U@2YVo`X9aCm#kz{(Yl%~f60S=qwM;QWo1=p@fgRD%XBsrWQVJjs> z71wW^5}Q#}w^UD+WeU(5$ru1Bx)hn=RNdJY<5Mef`+Am79or_(yos)I##@QRD6Ku?Q^9wEgtGI-iTf2sU2^UA+VvqDP_Hp>IvEKS} zm0G^g9`%M&QOVV`j7D3fpc)M*I%v`21u0uaNrcOs^nv*l$;<DO;7IPtQ8Jnk`42_xvl0T87HQBeSfZ9VFJ9kCl5( zpz1&QIg!nP8-Vlr#e|Qe?;{HIHC+3~OtgT}DuTS*ofm)%VH`ATi!vY@iU*U0l}!2z z>l?PW@rbxx4n&49vX@DGu9p(eH@wX(`(pfCDvE8M(8znh#AVKdwk65tow&rs#LBg9lg9nSw zOBJ%k#@W`Hi?jz&)oj{o+j1mvkK@6n1wD8ewVJkDi$nKTFa0NeU1>Rv65}heihm)3 zzQA1O$52O;2|8y|MY@(KxA?O{Izi?EvNJHh3}AWw$a$xVyeW4q9hplN`n{A;s=A;? z4;Ks^jBgX1TS{7M8I&1>NN9QF(jj zi@F7=3K`7qva6wHek{iEa5XB*k;ouRHn=}P7|(1SMO9EK9bvxE@9=lnQl6X^9H0Z2 z{d&+^iE&n z!B5$=RR-c1m=?4Nq4sdD_KKW0mV92YbaWHS{x#~ka12*_`Ad;M&S24&9+~HMd;Ee* z{Y)zFO>%hF(NJ|XRTG;{35x=G?BIcwjkfy^?GzSYrYv0bX)F!jt}J#SFVFh9bWw(F z<2wZmw+!~>;_ZzTA1ktmLOh6&@Qv+%GHbGPxe|>}%57>W^H`HkN@v))f;!o%xH--$e^@!da3y`Imwk+Cb0e)m9Wr4dqa z#&xVCPf8k`@P;?68uPB;AW{gnG*>FXu{PRz{Sv=zTF=IdhklV=fl6ZDqS>)@ul?@G zx9ZaMFMjwZSgt__%xFaBM0x`|LO(!{9vSgX8p!Px=-M+y0QDwc}@Wf7$jhn(_&MK~nB~Xzu?u@`g4xwOen8SI-^&=pe6H7r_CxYAEZmJgXSS`RH%swr(IjH zm==hoVHCTe?@&&N%y)sq&mW)Lv3jae!Y;dk_-`18=i>SzoKqnQ{A26?4lC(v`Y@NZ z;0NJLOPeuT2OBull5l9^0jSov}w$y?k>RqR9Kz(V`Y1js<`(bM1OK24_xG@KXC4 zO(CD4=%tP8-N{`|8km_!u%VMoCym{AT-=+!+-bO* z2)M<&x}iUGGPetMW5k#1aa7yC)LWV9aaBK31BhvIa)hXJpKziv)574DqLaC>D_`AF z!7L3Ms>CT*_N=SStgB4=45B3J2z?x3^(lsH>p^=(NCkkR=mMe9hn6WqmhnoK$@MT1 zMEJ!x#N6naMTACLL1DH-#S1ZIy5VVCQEhw?NM3e3Gz=WJK2W4o@(78FCBGhnzKElg} z8wvP}#_$2Hn}ue*+wJuWG@^P(O^R5{f(9>+X9NZh2_Evab4Fv=T`Fy*&53-Fm1$Rw z?k)JjbD20PCnR2}bBw?Fvt>Qxo)COyolTKK2nSWcy`Wm~*IXc25fEN-na!3^G3q@q z*nRO%`Glj9Om>XK4^z3wPnh^FOU&BARcGsWhjoGOdzMfV7|J;0H79X8_o|E-9YGVj z=^?`6#`wZflQhEbVgF|G*V81%_|HbYq{3TUo&ELAa1PJL-d9T<4dBT&Thbo+opa5R z<+`Ui`p49Ae~!+$P5DWoD{EX>um37`5V1nInIXX#scL}*(O|M9yYEkJj|wuJg&)H{ zqFDkB7?m6eu2`e($nS1^y&WHSOUmnLOB zL803Yi;%P9vAGL;xln5k5yWBxIKUZkJ<}EPxqJGGNUdFGjiQJbclS?Xq?`?oor8_I z*P_!ARbGs-oLVD1`8oq`xh)v~tRxrz@)898naA2rQ`n?0b56E$QAPbkgYr^&Lc_Y_ zGOkEY`;AdZoTOM!MQzIbn~svwW^};E9RiwQIf4N^qv2ZX0Kp zRd3DX{k2fQp@03u5lJH-j$QiFW^A>=V}Ob)6`a8!XLc+0!5Q<5Ew?hS&anJp;#3h> zDp$SHyRcM9B4WcM|Adx-_uC%Q8S_I?EL3yXIDfS1c?x# zQlA6?l{tc(#WSPD5ky#?(Vt86KbPG=+4j&hc4(YXBBpEq*`3j-I)$<`qk>E3E)oiT z@|qq7fluL)Jw&Zv1{2C%)RVWg#_Ku_0EbCGPl=uW&U?b0#FsmKz(uPG(=p=+E!Br4x5i4zn=7 z<4t0suvJ+6Wg;tVJ5hsT8@-(yuKd7R-39=r83C_d5azqE;K?0-11NX`+lQ70xzb_0 zF-+KckY@SiN!xwu!LqQk`=*Y7LjTTRb$&9LQ$4aTQ(lR-yN6YWUbSy)PSR)$lj{+xgw0DE7j^XHT1-@Jr zYq`@Zkq)hNB7hVI^ePkTHhZ5xw` z&53O%GqEvoa`W3~*S_bRx^=6%s;jH<*W0VU@3YotJ-^?8?EV&I^{}21!UgQ1+gFe> z2zU^fE2&Mp`w)@;g*fD=@r+$^{P9~|%a=`8f_b9Xn)@3FH&DFlBhj0yY-(iiW#sx2 zx)X8EV+`ec=~5~|dYaBLjcd$i$Ye=K?Xj9Y{LO_Z_utcDa(IY9(dV|)2crRfwnj-6 z$NA*!7N2RsU~{vYREDMt*%@%3dELXkRlrGwlLlAyz7rGIMur`(l#qOXOj&4e&bv)I zN%O9tHrDyqJ+0OsFrW|0cWnMI>qK!K=3ZTOjDQ3yvp?-&?T|+FH7Vaq9Ex8oGZ0tS z$@Hz}IoZj@J${PRZ46H`hvhp;*~Ix>$ym#u3}d`t4MH*r#lA2202XRbzzY?O8^Fd& zMu~90CwP??k<=bkswy4F<`*Ao*iV`d!L{juS0@wc^{EarRESS5z`BE%*=LYL7mPH;CtH3BLaHU1j-Sq zWzwE6;+)&2$x5tZ5GibO#2IC@& z3I|IQsX#FbQhC134eZ#rX%ZffK0F>1_ZK~b#;UpyN*Pj$R{d1*%tI_wO(hA(4kn4# zHEp8Z_YDUsE;2mi6GyUv^*DXhu+v#m0CA3byC5@GT7-Agj+BS zb>KBIk)(R!@SUEdm#M+S`#4l4G9_=@;vS*RghU^9dl36LRZ|7t?mZJ48FbeUxO{ZC#Y1!i_8wcVD%(-$b=X*yj=xBXc+zkR z?BY#{GkB~UyMN6Yt$R?1U&Tkl%mNH)UKk#7$}MtnT-RUysGkdfHzwDgvpm9_dF~*Y z%`_(eQV`)*nHv#uEU8S@CI=B_QWN4H+>|?kL$9nW>c!XRe@-Wy#T?nL&mMOU#T#>9 zA@%!T=iegelp~f&o4~le|DuFM>1|OuA{<)fN!!NEgM)s~1U}_TS`}%vKmb({u(hl! zBBc>h%h=KgML!%kcUz|%VI}@C`vw%fFwF~+z2hMG%XS~ff#0*Z34a|3Y>(T;yLtLDHCL)M%WIzZApNFwG~v3{c6Ok>ETZ@d?sJ^@KRJF2inQ&kzPf`+q^qobL#sFjPWvz76u z5INYZIRmyJ2m4Q%_!OM~p2e%!eHxTV{>_ZKI&qleQ6wZK`ON|RgN(yCs6m<1<2`at7uM+s)}O3Cg8qJQkcRLI&cBVe zM3}?CF`_k_9Ji0Ya~EIFgeQhHhLDFA0Efy_Z$ZRbG|Sk^xWXz-(M!cBIynQO;aj(% z3c0@YSFHwz32g4u8FMddyQticB3CJm%<0$Jk8=8WgoO8}WfPJk~ zKJgbh_~wsWl8pM*H=;bxBmvv!{*87mQkT1?r!!5@9 z$TUE}R)sBBIhO0q5454^>8#*==_v|-kM^C=_0j?(vHNjMJIuHxW#|iH(tL7q^S9+uP*_!Y{eT zg1s#EHGA#>ysf7u>m&Sxa)BupYnBhX`AgP$P@Z94mEg6*Yvr8t*Fviv&hgCi;kTmZ zlyfI6xs?2zb0L7x;~171BC8f!BvHBSUVB=BBto;|+oO^xRR;{SIk=+kpKEYF=MTvl*0lBi7?Y)=@ib^YNTI>s ze63N{NFbW0P@NSUSMC#}8as(jHQSVOpIZryzjqM(R>J_cQ`#ry&en+ujhn$!-&tzn zx{wgB6!ZOdhapaYd$XVB6P3#zBYrDBv zz5;aku#Rb`HMdIv6nyWL3~_lj5n;DRt`Yj8w3cbS+eF=}(_b%BXjc2owszr!I>cor z%cn;rM3<$W2k2GQ>i%S)(}RCqvg%#GN45q{@F85`(4!t_H~16tDoz1r~@h*8V?y#WYE{& zY;rPIee$|`-p+qMj0%3dy<_!Kzmky#6h|kuQWHvYMR9#)dRtYo6Fq$mE`KWGcaam9D5Ct2sTX zluuL~o2Yzlw6@yoAi3i`#Q~neOJr&De(PAvA4d43YSTH>I`y&PuNTCLsj<$*T61q? z8bht@r5G`_C$<;amqY8Z-$XQ-Sc&_OC0Uy9C6?Y&W5!wkrS4Cl7=~-abe^I^N(H;m z!d~M$53)vnuD0Uxop+j-&#;b7Vmdo#YE5cwNUl_hn1m2HkHkV)9t7OQNSbCCoh>#e znC}*_G=1d`wJ3Lwf8S{GJLwG3c;&>{mr0oa?hbAp+tO2wLTB}IXC04M}ydT7LiU1A^4?A;mt_^K)os2Xs&KKu=IN!QTYvV|m+>P0H5-grYAsy$NZ)Ni=4 zL5Z4>^~AfmL2|a#k63v~9j?tIT}5pALp&FOXg{bP(eh@w(GP*ZayzPuplK(AeoUC| zK@F5{^(%PDDo2`El~d$5lDig|?g21}?ftLpi?II|c76mAUXc!5!P@8BuYt5wNjTr?^SkEb$E+O8rvljS!d`q_>L2}GPh`)I8}CoPZiJ3lNxj?FLWyX zUSPY6K^_NfNn1c8zJ9sGlVx?o=|AnLkBT>UkcrmA!q8r*W({73OCn zW~1S6863EnQ}(a3QB{yefdx!3wlopTIOhxu}J z3rCKt@z2)wlTB=E;b?v*wIQ5RGQDleV**S-fQk9p62GtxoFAJXjC9?wXHEuIzx3B4 zdMLAO)gCrcBo;rmIFqz`Q^q~05XeW{79LM&=$Y+;HK6$O@DV69jHz&$?}j^<*8ycN zxsZAtlL8Q@&C0`+M913UrQcod7_Jx$7t{;7wnopG65&DN6Q52+GrF?r4L6J~Inv(p z#m;#wPu72My0Svm`(vI#nQF(O4x(Cu7~hPKM$kwkm8YmXMFkllEiDoHiDyU(xDj2+ ziLWt6(z8sV_Xj0my=eB(y>Aopq-1BNi3GhOcL6qi@=ZI}T{wNxME$y%{o^g7O|3-m zzIU-a(L1?zENn06$gI--r)jd=+1m+*{)`00X^z-3@o}zeq~N6cQ)XoWh4tan;JXYYI^{SYjIv*C(vY1-`M}K*1_mmb;U;dv%s2ljL`@i? z;bposYgIWpxB6q$?S6!dS4gSjG$%Sd-)q|sxK?)d&m_s!uE zNQ;3RhId<;hbQZW1wD&hsJ_9Eo$&?xW9fb%(sQ z_e`o^dKTRU@?oW-Rw}qq$;0q2N2nZUTD2sL5I_H$^624qk?iGum%f|IM~_4L0@;;# zsU@F+U&MBCZNW3;prHVjY0_lkj7SQRB-8yRM0zkUc|CNSPWBkl+^ zy=^fA?;aVFn;N5bWRBT|Oej?YAdpRIv^AlWN(+KRpb_tq-m&`YJMB?X(neDNA%vMs z@1KDWs3La|=8!tMZvp@A7!}_`a|zDiE`&?2S6xIcS&Y=KSX3@O-y}59HD|z zNVM)jr0U3`nrP5Vu>=?+P%_5ZZpN8zQtnoBGL~}gtgX?>rkue_jgWt=Wpi=Me!-9< zpXS?ncjF`*a8ezbczYXKBGNMhn_KD1NhdD4B<6j^&!o@bhsEuPIhG^h`UUI(i>}Hg zblpPh(a*djHk&5|g+O=mj!JsyY`oJ~qr_PmsdEtH=?EEaFItBrN@%f0XekH6wSvNPzXi2oh(g}tAilz28OxjYIn@I3_GR4x0o|MMuW=F@p zDx87MBiolneuUR~StW=OmS;EACEaU6GCQCM3?j4sTT0dx^8XYUw*L_qnq{m{VB*CARRZb#pRMyhGr4G7NfjK)DA?wt6@(H*6#YKxUvX?4+}%!QAb2gU1L0|F!9Hpz1F%_1aSI0~woH3CmP@tD(y|*NE#}=O z)H&L{Ph zDOS2(Ru)z8JE|W%)WFFn_PgpPAl?wWlCM$toIr+)}=Gn zpB$aLl&Q!hb)VvZ>!2auB*6qa@3?iSA$l77d5yJ4`{!BW9hZ8&beNfk%3*5_+@+&$ zU)%+dTjm+cKBEQWlq*8_k(?a#X6Ymh=zq3Kf2FWsihP7(2j z4!%QpnAMrwb8?H4gb`Lri{yEdo101~owYR$B@iCBCBDPA!hy6rBZ0fZm7n&zA;MK9#?(Bx#z=lZQnQafV}nV1 z-$RC}L!8%m{`kM{ndiWWW_dol<=E(w@{uWlNo{Cf)x||Y%8Uu0j80oHQOK_n5O7*4 zG%`WRC_&I)3$<8c!puw1wiKJ;~D-| zQ^^N(G1LDP(HRr_jIC0kf?Zr|Q}txrYG+%QK(K971NR$5Q85H-!-w8Sw7$8+jn08n<9}U3CaROoQ`qF@*laoh?R{AOh2KBj>=UM=inWSvwV!Mk+vEfeeaZuu ztu|_Jy>l2-mBPYu59F;lejnqqU(B_xgKXMHKsKI9VY%q`(=aU-UO(B=Bu1b6}&RTWN8J0c6rs`%_lj-pRoJ+Kt z?F_GVm32+Wur=Stvf;~<< zCHA{mekmN%y7}jbZ!bRH6Ld$`Ej{6I@5AF5R9)k``6o>+A9orYp1O4l+uob+K4au; zSKh9>`gcrmp1dODILti-*mi0G`yST5ut~Gn2s*RP@z_yX%%!YLS_9@JXa<<8s0d;c z1(UPCB^M%x+JhQeAw(z`OaEQyWQE6R?|M4UL`yJfZEgQ-u$W)U#n)N$0n5qq7Fu!( zXvqwflILmzNSYDfn5zSr2+&Sb*Ttm+sS$@Uce+?ep9TbO>SPv^f>;Ptq|CRNe1m`0rS)h{Mt zty_t`Oym&D=;C3sfpjJ;6^EyaX$5e8l){>`V3^v!Y)dau7v^vPSkRZDPGIwNe)4Xq z%&f4JGG$)*P)xBG0~Q@`+>~j?37L>N7JR3Vm9J$3cVE8tOHesS|8(Fp%Rlfvw0QBJ zpQ5eq^Sr&ozIL-BvPZb+7jVlQzMOm9#OVpEcv(ObFjLgyFA9Fok>o;;Rp}(@e%k>Q z15}z4!@VYfIe8iY>f-Igfr|Xl7yQ)G5xm0Q8bS%XrCvLH%tYO@e1Ij)yJnf98tYrd z+*gi7T@%2eEGN+st$AX)+I4V$|E)`}oYCk93!d&Nt4d6fuT~-gyFVj~$g_|sxZiJ}fyVj>En=Re8ZnfPyvG~? zKH{&^RA{~_)7eTsT^brYnVYo*m%Z3PDO75>*6c6RR29(#XLpLwuo5A3TZf_9-9gPd za^vJdQYY30vk-~BA}vZSPzCkY7oV~dT^%xFy7Yqss$7#9R#ut7-#ZMn7pmEK1C=nU zDe9&wBm%iWI2d#)cj(_BL#`3(-HF2C7Hi+E;TD@$ftX84UNC=cE_5)Jw`L*>l6pow z&IfZDHHhGr%!ZvE)dl*=)2idKsAaz3W9Ctmrh7~kB&Z2^R z#mUjavE~>O-2|~Cbtd7%rfU3?(3KL5oeEy$G%APShSE4`$jcR+;jX&6ThCo2q29i*dijcgaTgm2Hfn0;gjzC7@OA5Sk^UVF;y0)X3Apy83znl`*O`2YBPBy? zw5L`h-J8zV`JI=iBuNey+;Q1~Emo)8_ZcMfyt&7(!Ew%W`35tL@VPrCkc5Zdk@*-6 z;1yYT)|P8oAHfIy^^|@D&5H(kL$HChAuYYI3EEys`48?$41Leroi3eHy*d>O672?L z!VvaMXgG9G`{E$U^1t#PQ2I8RSAwG#*y!^kU&Bn)1!LFxf5B%n5N&F(+9Q+I0t{|-O`D*F!DuXgXTecOK#S)Y_IZZ4Tk-t!ke!7M&| zcy`NI{@|WzL8iyBS5k_(#}P4a7!b{%x6SgTSa zJ9&|;0LA3A*g;vzLp0lTVW9RjF`qdVX8nuz5a^Y|UVN8;JM~?PaW^HO2(Z1neT6N3 z(^>xa*~PDWb{Q8Dj_>D}^;S9d=rSHH7$gz74L88YY=eYJ1e7L1C8=8dGfDa|Mu&eV z9@JoKWhG{Vf1e~CS7m}83Hp*Qm|%`&DKv)co?v+;T~^*^M-2B&-(`8l_@n{(k@@ur zX0}~;P6AX#qXqd9Y9K^q3cw%-xk^uQKDNAmUUO$%QFFXwXCe!j4Z*#;NqVtt?>T)v zhl0KSZ+@qz8aS^K?k)+B=|Mv)_lzlED z`>3Tz*c86M4C9cB1RcY#K0(*B*smDTPyflKreYDs1x&^hy1c{#r*F8;t^*hPye{lq z8RPO+YHdkbIWUwBZx+EH{b$M5p_}qwS+f&V(#OtsHOO&Q?uHtM zhnRu;J<-)SQr!Avy&n0B$yD3sviHEwS@-2zd*4Yc-Mb|$ z?SHtJgvy^t*=0HdT0h8dw}%>Ujk%)uV0rwCW`7gBwDD73qEle{oUDUUg){xe@V0kz z@0#{HI6aXG4k+28TvbiCo?=cZoDH@DQ~MiV21lt7r^LEsavoEaHp78dU61oeKX9&v zm(z69^6S1gAHF-!K{luGZtF(BhPuKwj~~V56Yj?}L5i~rz<`HLOE*d?uYZ6!=?j}> z?_rZOR3-6=W75!iAe~TRQWHFN>yk z-fOD#;=<*o3%Pebi`ea|nekR{i55`Ph&V?$y-N$MwZ4B|%1#UhXC>idanOQjl^2qx z!wz-4FS`o>oGy4KRgP{S-Duu?CD{g?CnruyO?0fPjhCYPUEFD;cxi7#-Q&)2V8l%_ z98ek!_PQr@r)1QY#*$el3Yw_Ld+8|uW~UC(zfjxsobN#Y5aPSva2H$r*;(%GQI3HL@eHJQ3$`xSOALl^pAIV&iAJ^+${&_?>bK5c9>_l4OY^^5@@VEtM^MT#j<0 z6;!c{Z@xrsW#1An&2GO1phXfPqQi%hFniheK?e3I$2w2BPSA5@jq!t#OZW;LaX;+wsyK50@tYXXtacb9GUzr>}*@$0Ek!6?u zX8~v16<|3ehbN7o&ECi85!orh3O7>8FqO;YUoSf!6);zDkT?z_AM;Q!iGJuTX?{sk8nJFtO#a3td~A1;$jk$6gz6Q6XYP*V;{ z-;yS{nU!<>@|G1*9`a80M4 z=P}Qp5A+m%d>QtnE;5L1^En1tA{sU2Z2U=F&D5@~5)_9RDR&IgeW;Qn6hG~woPAOi z$DEOvscINKF1lmB*BN&vhpftlQqK1#kuETH%^R@%!Irq~qHfNdxu2O|SW&I63{j(8 z4NSFg7Hg@M{?~)2x|s60&2h}=nQN&x8Mc9B&t5?IA`p76-8!+Du*|shqJ965QMwa1 z54mhy{H%%&kS(2&s2VEIJ-_eCPe3w2VEB(q4Q*}-loYp2(3inL?vj$|#D45bOkawz zCW)zpSfh0F(&xuaU!XAaCfz@ICj~sC3Aml)e@}LZtwe>vt0XHw`-Ny|_sz!ck9R~T z4*vYnBN;t;nmFPbX$%~V;-+8HN^*yyCF9QacD*^+&X1d6P_xmIw&#FdM_29E;SIW4 zuFCFXA=5bK>CQj*5}7Eu+~xD2mLRq-F!NvP14*dplrwP<-Zp3Iej}gGOIHJ7_zk(e zofIF7`Q|~L?7t+e)aBlkGWGUd@JqPay91Aww(bX(Ae!jq~DW)uU zu{ds_ljuo$^!h>I7S!8sUjS%n-+pO$xZ7vz`9f8tS_ENzhn13-9|FeCCv1U73W(RR zkc%)*mI+jr(o6eh?J7&WLPLxNJ&~us!TBvg2aYpQ1`*Wqi(60}S6>9Bwv*+&LD5?~ zKk04_NogyqoPvmQgO%82+t{S)IYn>Cp<$&elS;eIgvtGO87g^&;Q=tpa^zXp+J{au z`T?W5o7}jmATqrjy;%7~b=jG*q%cdjBpdS+3RhckOwX+I9FozKqz4cLVvGu0Mz4Ag zL@P1Qm+Tg!zsi|nX?;a$q(v9`Jl^n$Nm6o6s0o}<+lWS&RPKnR>#;--5c626etAXH z160u3Uu^_yU%j|u0)T-#h-Z@4Q=z}8cjQ>JU=IG+0t~8NCpBVT}j6{dr75I*}n*%|OU?H)%THm%$F}Vi|n@dc1CUVZ9F?bIO-R0&OS< zy3%E^9~#7Wb*1L*kXE-G*e#?UU>Gx?)~0_RUF5 zVr=N3E!bkoy=RW8`Ce|}?Sjj1CQ9IA50384WYGI}!C!ufbsT-a1JMMk7TuBFNf(S@ z5)Z@$HUO9v$bHwz#S;2SB4pkOB(pz}wR-9AP@k#MMIhb(VK}kAMf)Sbrd+e2i`t{} zC@7DTX{K1KR?Kq5~}&bU_wQwt^8R|hR~8Hb(H>7 zatg(!3F7PPD_Nz8n83F~M9CRhkPDk)N}20KVW#=3E>|;arp&bq zwm-wjG{S4AdC&x@ULrwP@UO%h)%=%)Y4-!N*EpjC0UlVSr*IbyE?8|r@gC*7dm5e9 zifuVt>lHns9xKP286z&?8yy*VPq_O9()G>DU)IDbiJ=apAc#SzZ-rC5nUTf$g9>lp zdPcwqLL#UXieB~pCTZuMI{o3RWMc7r@20|t(}x$+Y0yfdyb1j=+mcAnS0R{sA95nU z-qCWVCBX{t+?<@|LmH$v3@p`uf8t#<+K|oHQ;HQmay;myj2w!u=Gk(Km;Wtz6|uy& zF%eMR4TGiIIxn&=p-Qc7s*+*i(NRFc*mMCtiA|W`9fSpb67{!kjkou0ynYN*5_TG_ zmul`2LE$|1u4%nbT~IGJS61ugkg3FvV&Cr$zrDhj6I6XklgZa-3^GLf*9y7oLjO(j z%#E6k2@|cSXnX$$Bv00RKrSq+%W>QtrKckrNAqE=*ysoA8$_2rS!PcmB~}}=-6<}R zqF3U5Ue+_aOZ%EYl z5<h6X^v8 zc3+iRlI0R~rGd8!qa>M_I)%8Xg~!mlm2*FrklKKtkk!Di1$n4gUpBsh*&8Ss3f;DW zfqB~*=J)G`iB}=w6}8|=8GJjleCBTQ!FjXTiL*c!n=WwWi_;lnY_u*wY zY90yX_s^$N>Vf}k!hl`HPAWD*O$y=Y`roX~-69Vw&}SN?8urTEi?&pBQXeW0^@d}0j`aXc+`@0YbE)^?D6nK%TJw#NRB*hV68cKK`JxUz zJ+uaHJp;8|&7~|QNlJwGV2Z2+($$SDSAwf>o|uaIRTGqqs4Y87v+PQ97AB*_-Dj9e zg5W_K_cq=O^+nNyYW1;R%Au$5Sg}EJViU|L+|%_nP9wS~jm4Pwgi#4I;^u(N+7dcx zj*IJo%8Y<1@3H0DtV(J06puFtZO)Nt{lB!vMBf@tyH>kR7CbH)$XsZ(fq<9Vb*R}l}mVc0>Wkz%1i zx~Sxg_ETvQkGee%9mEhU5;-7wZ`ko=Yz&Ij@H8(~s|x-ecMrVh0gKO>Y!T2ouq`{hNMn=nu}!drG99D zh@Odf1$!d*NJ1*+IVI)FSi{Yge7%Ab?;)AljtX-#gLzSLUSneEIS!!it?51QEw%3iLoc0*!jR)kQA$<`jVp)`?_S@LD7F9UgnC z@{2|baDC%WSVq{+psa6oES@n|b^GvvoY$$n>z)!r9p5f@{Q?oM3L@jc1%@fV<*__` zW`>6_zZvY&qPKu|n;!!XS2evJtrdnZjkG4*^ck%5pw9Zij-#9 ztQC1JswZePj&{;O=3LVF7M`)g()%kNKi6Li8!vx%RYQV$3;Ow`ibXYz9+DCK;M{b_ zw$Xnnb-$>Fj=jCy4LSueXx;sp=LYbs4sl5CFRdN#CH~MQ&4?Hf)hNz{W)6$z&V8wQ zfuWtW21=aH>)6JQgDW%r^}-WXInSqxV16|=%;Vf4e>C5d3R~P{al`I@WCPsr*s|j+}p`yfi>UxhM zZO!_PXZRzKMG3p1b_a`IY>m;-B`Rf!%zLxaR$Uf?sI^Suo)Ej46lgM;)cwx8!a4+r zF>_OvCpgs)&4z?mj3+2(5L3qd18a{f7#2(X8>!?zUYCW_Mj;#!=kyv5{rW@dRT?j< z^^XN(5Yp&*FEZZ!t!GR82$O#=b7g_Z+-Au9zUa1P^ae`Sl*< z9@_H%c7+;D%jUg5v%Z+0`TzeF!TXQs!U>@RpK&2Ytl_+$ZnU)cJFmlx$_Zad4&c^0|6Sjxx$RBx za#q^rWvdCZTQB`#RN~q>AY5rd$eW7_@EfI{1>RXz%9|J2h0!1=_c`{rLuJ!T*s>JM z%sXJ;{0d+1IPFYfGjm*&a_Uw#N~h1kX3(mLOF=Lc{-zH3<&Gc*G*bv(g8;|lAB12u zp284?sHS|o9!PIGJ9V9z1cjRBxH2tdOz-NyBAS`MwkA?QmbG}0RF;strE8qw$hi`YFW5uV}){MZ~@tnyRA&BWKHo3pQT2C+;K zG+z&dO$3~)Ly-T;6H^*v4?Dpt0<6#$))ZNCvvIk;$_LmnH~QVL=xYu~Ym}D9e(muW zH#lxylaxDIchf}dugNj+yBKOQUh4hh@#ho%3ezzR@{ld$VS^q_ULvyQ-h`Tf6SBuk z_`C(`Ht*VX>?5yoS;Vb0pIg)Frm=e_*VbWTj6)kxx zqV?%!q10$HO6H$tX#F%H$~cx<_*SqX#q{pw86^iL}xjNr# zpNCDSi;NHMhseXNr#TbRCRN^XnIT=uIBzdD&x#z*Bj5Jm$G-q&=byb8uOs{95elzt z;y4OM{^?15``t->@8p)>`?5JYU2GZarnBlfEu-1zJeOC>$d_nq=Qk^VOB}B4ttxW1 zi#|)31tbn#+z`C27#yw~!#a8Y&i*x0+1k|49N=$kULGL!%A<6hPLt3i@Z*tijrFdG zeCbjh#r#c55!VWQI)aFvUWk|XR|1TPHz5Swzh%ZBjaQ#hav1Ng%tZcl5%}k&Sy#W0 z-yUQ7iV3_W)+LXq5%~AG8l3Oim|plJ8e~l`U*F$21@qb8U48GoBkYzsMD(r@d-RNP zNX^wLMo(J`>-41sR%DR7Teh2>$|cQinMN-7;GqK2HSQ%L9aI z2?|hPdC3uZH&?=pK&BumE}(w+(z!5z`)A)@>z+H~F(8a^;VFJ9jQ`aO5fB#dIVutG zmm~n`=S~gq5GFhf=;Q1#9`o&$_!$RC{CO+qYj^XX7>~O}z44rrNxK>%cyA2LySdSL ztnzwg69h$t*RW>6#{7pD~3 zO{oA=$`yDZ{Iyp+Sbrq9$II_<2r-Is(=4hnl$B3(S$3&*Cik!a>g+sI+>N+09C z+Ip=nPK>ilPLoABYa~;Cz1gk=N4AwAHp=C}VQ(K@%_Bq#Z<{{AKthvhdis~4%mE%< zCSY`N3Wqod@|l1ysMlIwwHn@^?2}ZyR?mqN8BoFu$o7$=LXoaEmz5^sw-m zb*HeD^dq!0DG^4Na43wMmrr_x zJpaYz2^LI$Yy5N$jyOoUQ87E8Q=_k?~_LsQ$3`GXnI`-}>zU=BfvJUL9DA3Hku1QvY@D;P9E|K!H|!4{9`2R8PRT>U(^u3V z6I{fs<=IZJ`bqT9g}R>$nD6e(*v>;;+@&<-6>4+^XEyDICu-H%N&3wcN72@f#++00 zg6@RC$CR2aGPCBzsh66|po*%T02hi~D?RfS+4RV%B}*WwZR7{z&>*Jth>DYIgba2> zbwm>D*&;ZHu$#3z9O6I9{S`s;i_A0rrKO`+)*Jxgy1l4D-X&P`#Bz^ZPZ2AtINRHX zX~~3w&Q3u--S186u(2J6xx|GC?#FMY$JYkqgGN$Pgbn;LP1&`J`x((XpbhbjSV*OX zr1rk=-drbY-~3RBE*Y!Z9(nP-Nd{LbKe5X}(IQX!eKm5nlT^8Y5-vYJNKr>o|?a z=t}-pw8yZ>8-^@bM>4A?K+l6)OF)w@_GI4TfJ6;ZHC$CW35? z+74ObsuQ0WnG_umcoY-)W)y{e3Olrqab&%Rdf{0}%M&lj9ai`YAjUa`r9gqf&Nd>G zmc6+A5@cp+Awx$)&3BA)HR@klc#UeU+*js}OG<=`dldH0vTGP**4=JtV8HY(jDv|9 z=jW#8p+-TNqOSy1P$Q%)uQcY@pPRFuGKv#97Df@$y!$g?sP~TnG@OQMQ~LF|th=9P z?nsulgH+o|lBykzj#Nta^V&cwkz!}u-ca~{bB6a3i@c!x&cZaiv% z^ou26IwJC0%b%XHfNzhx;C%FW^~w1lx)j8DrF{R{2kZ(K$@7Ftr9!p!;Jk9a^LkFA z4ebC|f?tUN2?N`!9?wwWy16>IXW~D5z^x!W4g|h;NOxR`1miTEcc8xPl;Zn550cc6 z=ZOWlAJa;W*o_t}O6hv<6MXxay8m!r3H{{=>PV~K3R(qG?k}N3L3;j<1*NLkuc7tN zpA)Ss9g-4#bd8Lyot7v3V2J|Wm<6;LVR8@bP!VE4#YmkpH9UfFfeqvm5Ojcsiut#E zDZc)+5Nwy>D($LDd43x=`r%n==Fx4^%+g-&yR^n}=E%&=qg*d$bGQWQ*Pa3|;mpIR z)F|f#n{w;9Vst)Zscxu~JIcbD_^3@ttZYL|R3j0)L=Nm9ClDzG7DsHMKd@sygAH`K z@Rl{e3F0tHsCqA};b!qav&vfZez0F8pe&Lfk!H==VYFfyYpQnIbFs~dEJ$NBr8WYf ztb)(2DOzi`dRZoxF6>M^3R#G^R+QLl-&QX-=2ITbbi9qEd<%MLt%p;>xkAW;3c>}k zuw|JMCu(mvS1JsOFT^=+vR>jp27=$ot%$3D{F){&4v*|Gdl2ocJV#TAc0~dG+yQIX zVY%#z&q#yV!uCUtlcA-Vc3Z6)mUaoGJ4aW?AWC>&I+EPz#dHHqa@DUP$hTB~3rm@% zl8LVMk_8wynuS}54wsr69m--a@`OZ5-g>&j?Cu?+SGTz1OQy+iLFBX3wBJ{k@Z{b= zl{5*Au8H5fr~^}A*s($SEnD-?gUEo_e8rXZHrxe-ohCg@4@A$u+CqEeob&mv}w6?406L4~K zkf1USrawt9TC~@C&!l_T%jxn{LNkt4qpdgV?XSfF=@jKyTiOhT_;FW)dI_$9xC`ZJDZ)U=ET2UWR2{IB{g*5S&; zMzU5tMzqTr9jiIopsb3sTEmG@pvbt|+DbXXJ=cWAsj>5MVS|U&yT?5BJU68?>Z71u z3wrFXDt@5yMCs*LXL?#YBG0wqDGAXT#aIR1JHw0~6KsAM;45cNppS1Oc0f~!QVzJ5@ zGdg@0he}Kw|20olslVjP;Y~`jZASZ5nZ2J^14n zDQar>U6m!Ci5}idgnA-fJJSm>aS(;urs&;{`Qa;9HuC+Ldu%dqTg^*wQMT>e%_Kel z(yXFaTidjV?vXso^b(bdfTuKM+E@hG zh7COq5gr-LQFq!Ms&QivQNEuw0?=bRL|4(0U0TxHneGenS-QC^Y-Q6{4 zu;A`GNN{Ixcb7nL3+}GL-2wy#NRZe!n_qS}?E5|co@eOkTj$)auBmEzy87NDQv6Ds z@=Lakfj4u-iWDfK_s3A-W@ybteb5hlIj?)r8%33;%x=wu@rvW6C6Fl`|3MK_5jEVB znCfQgnY&fX=Xo2b511FuvLu`7eF`#5dl4-p*K$EG;nF>WduvA1FmiLfhGKP3y$osi}qMq^#) zkLwvbv#-F8a)lU9jOUsi$qh5`jh7z)CT|)ph^7_9_m6F+9N=>T=V)3d@T6PC-Zj)N zxs^@Jv)9@c)^X$_S%3<0&@kg7EC~sknsU3Y0?zdyOxL+ajJ0&F8L7{C?`(pO*OB;n zZAo#ogfPwyOS(>-%sb&s3AbXe60HL=_P=7?jW69-RH{2I&9SB`@qF%0{G@jUn4O3A z!87|5<^exD_~6IZF&2Fv+GOUI9-maxGiNM5iwgXK?mIC-R@~hb6FFw6`-px-rYjUc zI!kak;*O(RU&!Er=%cUVPA^WUff5KwWreHqL@6R&YA}FRlkQShm41CBeua)wB3HR1 zdfGC*v+q-SO+^Kye96s7YoL za07ee(qr=n2me^TH%*vjo6sV~QQV|`H5%kDsU^droRcD}E1~C67h5roO2bp<8n&SuZnO*T zv_X4)RmOfV>E zhk%8obQY%JxE-SKF_1lU;DGQ5loO-QGkf~4<<4J&+zl(P~ z&7^92l}nmeAOc>fR8b~2%jVf_52ch2uDm*pyrUv&e-FtS>XtJRj8ws+C#>9}%#wzN z#R!6K#*7z)?J0H`t!~>oUTSXMuR;+*O%Qe0zXV3ycU^ZAdG*322e3JcuiHvjDA z`G73K<98`&rf6xPQmDH3>F%^#zH!|VR^=CL?5j{;Is&41Oi%A7`BE*x7r+kCy$%(n zsL{k<8mKxLLtUMn3tCV0jK@e$%}r ziEc5JyPwQHJ&C+jB93wkoADk5(gVtLtqG~!BzN{3J|w*P({eM9@dI4Ri&A~%TQ1AU zA3$R&t$;kfPueze9#UqD7-r>9P=g?d+Qy6r$o1c zMGpU{8Dah>Lm#Je2~H?h+XtgWsnS+lLk!46LcPYCn@0bt&R|)lSmQ}n5lKT9i1p*{ zoSVRz@z_Y4uc!rDoyS-03&U`7rb+RNs39E+uK?VIh34^ohIZ=-)o%*n`LNj$iVTCN zL`Wn=h|GE*5b47a(HCwqA&SG58s9D_D!y0HJGFU>&Ns52pb8>tT^Yq;{i*g zBmon-nQ>)Y=eZoOi}+9&vtq;H{1;oO2%QY!LV1ar{#_--m++T@l3i$Khs;ZFz0FQV zEFy`~7T2+AtW8ErsqQ2GXkZfzRd=cxxm)zF>4-GS6Q8Xo>AUS=uB=*_|0o? z_hGJ;QTWf~4}OM>L#2szsf=$w7+-V(GL9c}hd-5#eSJa?M@`Z=TO=#L;FO9+!p+%!OS)@}FhD)M;6SzYOz&tNUoH;NN%4t#W%7j%UDeaNCSBFEeJ*5R<~@Bq0Be zx#@h48J;|em85vG^q_|&O${i<1+edCGltWDdB9%EAgkelBB`|92EGKb_%yH=O5TgQ zCn6jY<3ovaYiTe7gS{(x+5!KHJ$&Y<%0pDGWb%WYUSmQ1UX};TY;n$9Z@Behop9u* z-3|}5*%GyzfG18i_125XWp8yH`uDY=Z{N_}Q0up3ytc^b+5=2hrXjrrVgca&Ve!n^ z@Qh3+C-$*ODnu_~2JxNIN?qa(6!6{y$=*SEFRx=b{7Krq}}^+fQKQt5bEEO8(g~w?O-RR5yRVjd=>XxD7jo@_aYW9^wx`3Q(tR$Vnx^ko81KCRYLp!8{j52lf8x*R#Wpw~@wM#-F#Likp zGq*lp&dH0%f8M>am;ioElJfWtf9Wj8+o5ZheLmz)R(?)XmATL zqf;S)(CP7k99_nI|FzFgcPbAg$rGtd(R=nS@Wbw?r&ej4XS@ZX%4EqO_+64{cXugR zh=oxTwj)TKGbAb12z!MA+U=?jzHRt;fbSpkBEzuJau zB1cya*cZgleV}=+&zh6@=2@MJotz}39Y&&S!(p$tM-5LYon+oL&x6@v_nzH6o_+L1 zyrKvidy+gFlQin(L`Ktlz&$oWP0dUt-{hOyb1lX9`I8sa-XeeuCb8KPrgo?im4m#N zripq4I|YCtJK+7yvhyN?;1>LQQgBFh5qa236zWcr`CVYr3xO2!^vxDH=DoNK4-VQc97 z*&>(#Cs_kF1qFZ+c(MoaWlOpgSIWvs^~87xr9WXqaI8TJVQG(y(;*IVxWM$CC0fIw zj+X<^tF&BI4^J<*QfKW=yI98I(4FjoiVw`EQD{nMf^elx5aWa<7Uz4+UAi}+mSwp- z&4U6}2BE%M+C2=_Ch9Fth}|wc=jDBq_RA^~j2afRo&h}BEV6wgq-{&qx&C5EcAHh- zH@^fCZtA;j_;qS!4TeA)anzp4V7C15$432zfAk&i*YhavLiB2&(EgoTI>UUGnE(_r zPy@`b_`GL&P_My9-@%r^mY`>(5AAi_DBB_gcB(ATYO22=183k=%-zCmWQ=0ta({h1 zmAe+`5AcO~oAAi2i9g%d|ArUHT5deW-mbHz$Z82Rd%LvDC!FN^mQAX0jpb5dIB7d2 zS-F+q7^z34$L2Ave=WWyltM2hncu-QEgT?tbdf*&o_;S?D1>e%a0{`b5VT?o4PpjkU_I4Jkz&H{k4&z?W7AX##0=%KTSyyI2a{KmqP(1 zZc^Hquw8|wu6qr(`lV{h^RoumEwC{GEK%JkvQJHxUlH=OB2`570$`cyh5H%nMf-!; zwP)vun>?FRY*3K*F`-jmp3cFeLDDW9WJTXe#+s82Zt+0+8Y|(DnQZ}3)p8D72u?i- zJD~|=gJ?E(#=YMsvBVJyMF{%_R)>)@ETla`JdZ!ts~YXZ0>>VUqyDAvP-KA%6gI*I zm=dkxh=iqMnCnwo2)%l1bwNmhfZgS~fj^3ZIW#7*+f?>J;aZ+>=)*!BXKZ{|g=d?G z%6h3v4)0dZr_y*Dx@OS*4;9Ct9`Dyl!BMo2H^;qv-U9dCUqAW(47$JchRE&z&aP@v zN8+05qmL#v{Fz;W&xih29is@;Gy|-T0$2~8_7Q?pW@l08e`^_p-=k&Q**B9Kx@7kQ zWwDFK&W3}0141s};}2vE_@J7i9uW3|)rB!kkFHh+@P}4?A0nchV|+y4IEQn*agMwu z(fz@Swqqf;V|@mL!4`21jSIjZP@?E29!S*xIZA1QaorbZk~9gdwk5FJZq+u%0+3tr zsBmyvt#RXM_3g#pVgb3dYLt+)Zfh3ZJF1q$haWF4WFV8X&Tmu%bkbWi?Lvrc%3LAy z2#mQ{UcO5|YN~@j?GzUCwq<+94^Ed`?*PeGkU!!~s2jGps>`R=)4I)>Cmx#yTm)9F*3^AJ zu{_mzrlk;P&&O*{$fS2#jV)K3m$FW-JiSO(r%(xV@yx)s=hLZa)b G^I3GVOfiq z>O7#jBHBCj{}Ot}d~ruvSeBCx3G?QrscLFs%C%D7$+&TF&a-?aFZx^9>wJKROdVoo zY>&5vm~=i%jAV2CO|wHiP@1@Np$b>SfY4hPdofjMqSQcBS*fqE#*z_cL%nXJYIA0% zlx%FLwcTZ-z8nTV^`M``q=FYwaruDGMv#IYoGTB{>F}^x4|^*@bKaRzizvM~3-vN+ z+DwVu>kYH(sZQwRUQ$MMxjvw(?D0Yro4rR#wnO7;WBssO(TaSZ4r<_#PbKHrVQlWl z3!d4Sg8NKlJdX`}`fmB~-kREx50V4?L5zD?KGFjM!j$_u2)5sp2XusK_7tWRGe@vI zzIbbzXFB9h(^Yyot*IDy zMOMq6z(=rQ3<+nj6dL^F_+xk7OFNl0kUM$F#*w-9V%@1=nv?c&bt{f%taV)AD!n)6 z$9B3smTnfa*#6$(z2YlChEPja4~p)97>KPJzrkIz$W0|TR&xuSoyg9fkNbPN)Vz@8 zmb7TbNqvXCZGVl6X`JD~HJtF!Ati59n;eI5O)JLtT? zhM{)g%O@{dIs+4kE@GB0xM;tu*!i4x{DkJ+S1G5==bVsOD!wX!mz>&=a)x9dX~`C5 z1U{oH73hyyzT4nW{8m7F#G6#>u7(T0d-nb8L)&C{yH0!j3>nd$E?#qu%o?S4$cJTa zAUd<(d}w2Bmm7P!V}~(Fm*jm%Q@hh?TRV^7rq|qLa35Y;dxSx*wBlR$fZ!mF7f3SrrPA3ZtqNGz$SVrjiq1#qeq{DcQ1BYN{9U(t-F0Tnda*S zUA}n-wKHJ43MmX*xFd`B&a}p?l;AtM74ig!_@hFq8QKwc5pj0c@{agiVg(3!7=D*r zH_trf)P)1LAgqjJ0Dytv8oxJZI23j(++nsqLr3|7{t;0U#5doX6&1((x>seJry-Zp zLR(f0w?l#i2$s(;Rd8SYAuSRkKVH?@aCHrM=ijmQ z^AlTJ#M2Xqk1eX_{=>`a43FHB^LNRF-aqxvXWZY|Ttm?zBj&7OxbhVb7EWR zTNkFHjJ5#c!?Nx5X~SCg8^361sch+Zw<0bg@5h5+rsoMf9t3ozYb$BuvT#JN;*Uu= zYyp^4lwIyH;6a5XuHqXU=;!eb5Cwz~~aSAa%@Snqoz@ zJ{3S{jCWL@?@&RdsQS9$Bu4S;=;Z3P_o9*0VBCVL4Shs)Pb|Vn?g*UNJ{}t74=E@r zqRlq|R|o!sH|`>oR!Db@BJ}GhU67R{LURY-sAMKSX=Le-SFc4rHA%R?ry=~rpH~Xy zU6|M(yel~;G$oV}6r(pf(%9fIeG;qmRj912?)&oeXBrs6A|$gH3!!K21~_I0Y+k1& zF4*#t8Bkl63#FGhHn%GsFI$?MpxO%MLQLB00OC-B*z(Dgw*`E7zHDq0$Nh~#rvv0a zAom~8qQ$XvhIFucLQjApYB0S**JpiHu_qXCfl&B)MC(BTg8hLJLDcso`t=90B&9}j zN+g!fB%qafBTB4>!RcIWxT6|9I|xUzF`F*&fe{V|!ckcU2Tvj*lp>O$%6+`Zu6F2l z0BMB3gawYsaJKtS;pfSnVwUaKfUx$*h6hngC=l~&J`FFYX4JY2c@Af9c%DI%@YDhv z?LwS95}p~#B~SEdxN&$1H+Dv-WS=CBrMU3mx$8<$Cc5;ogf_((G)L4_n6T_L5IxBf zf|K=y?SVu-qJ%bwJP{gae0COkk~YK*Kph@)PvZCudEyW`2B{?m&m(%$CkRVPc+4XS zU9feST!YjSg=ZK&$phl%1uYCYpO`y&j${%8F#*~_tSJ|orsT92Jp6ZwN)VS1D};tm zQk!HF9)BQY)IeCb)bv+$^rvu*0|K?%oBv2QW;n4!Um`%jLPX<2K+pplZAgIQ_UHhF z0BmcVpK49x4iO6EL@6owAJbvwc_}0&P|8#!lUO>YoI(-oaxYXuG zA`j@nJd#yWdQt6*iF%6k12xj!29gMX1bK89JS`Kd{g$9^)uD45;t?Y1)V+92+})@s zJ_Y?KDl2MVKEU==K}k1=^hbBN_YTuuoe$Au&sL)M^@Hm1*62I$N01Zg&S1g)lWW}Q zJ;&GY!e4{Q$PPh4KLW-Q(QY3weh}XuyhtRoT1y07K#Hl}@DHXk&%Txk*i3{2tZixq z1%w6)PESQXxEl-+Amm&t(26meVHWI*6r^9ni&E`r z_P}Q^8Si_P3&Qva|IR1a5?0+yb$@RkfB$Ct<~c)1&51d!YBM`K1M&Dv*O4Vm$L|7y zzQ!DMEmBHJ8#t|{x==S!7weaJakZseL#e9m*imyT-OIrVc;68XK7Ej_J^=n8A?m~ z(lHfwfPN}KYqS`ZvR~S6a_vyCm9pcRQSObO&v^osbu~p0zt-WG1MKwS_O#*4rU`Z?NU(M`9bO zYe&>+JGkoyT5R@N24L-&JMNU{dt~v@QH55K0vzm-T?uyjy=4N_M!++{ zakmeUwsBpA;*lx3R^O6n(DrEw#LQcKF~7$MFdU3BgRoxfc4Z|igtKOhnJD+`KB=}jG(rGwvt!3!@EN5Y$W7xQwq{yUxocJb4N zHXYWZI&wYSUWG@2{=ksX`P0Wz^XL?PN$b^f)*pbvLiHi}ZQe!2hsi*`=}CizPgkEI zD7qGeOROtS-0kyAikD5FMmov|@>_HT67 z#9eWFwde_Ein)jYxc32K{c>v-z` zEV0X6J}VqcpA9s+MiLCT>;G9Fg zN4UPJSWlL)+I_vgv>DP@OSV@>-Sr08r;xg4Qptv6E(qa4xfP?pN zQT9Qf1UkpK>zra^hL32=&IMmv!g*RpkJ@%XhT@o=@7_K7{%HsyDCS%IE}zyl>Mb~#~b)Q z@%07F!lj8h)%?p*?#r~X3utV1QvfT3eUzHB#%M^LG*c7Q9P>kE3}WC1YunmJD>uUL zKFP~__-C|mwr~_U8}ckB@}1}CCsd$|VQ!`-c4sek?_}=DjL7VBYgZASE9UhpHVD7b5TaaJIoDbx5Hd$VvZ#xQIh(3EH5wz>P8)h#4ZFMBXU_#1Plpt zPeB*FO)+Y{sBG_4!zU#rK|uH@ej`m;&9;-7_XUWF-phu8PX5u0ClP^`faP$dVscjR zPPbxFYo#8G*x(Gq8}Dy;>aa?XP}tDee`$LFO_wOZ@sS}*65zjoZGTuI{{0DYndmdtY>0sDv`$!arm|EF5gv)PGl5ZHo%Z0~xsM$pu8;h6Qu# z!G@oxU;_d0Vv7-Mz}u#RdW!|zOC<*CZ^)M+rX9QT(I zbq5oSq}ZW?x*!G{sDQRRD1RK%P&9>w68P8bdjtpwp}#8*UYCZflKg_d-y#14zQ&6r zSPTwvq6Obc{;L)KUP?p!DSpFYfM~HOIKPkTA8i!E&g5_3foi)rP)^jpfZyYZnEwkp zE)`c)0(-v#C*hU-+ckJy8Zu1(i*&oo^haf^@2HEA!4>hrfPfHr2KQhB!^MDVhp>OZ z9d6IMD!|_Fz~NcK&)^%Jzr3^M5@G+hO8s6Ki9pDGT&PW+Ul{QUSRi)+?tff=am>NW z0k@(8JOl*aGuM0k|Iq68aZ&&6OTD@o?}77R$MeGfAQZ|l{^JS8#J;eJ1 z{!C%|85~va7aY()`ky0trZD}CBCiOhPy!K;kpJrAM^sP*#=z?#dbqy_hCSFsYXwX? z;s%!wgEtgyfE07Wzq|VO{GS7k)DHN0Ug&obc+fNaCGhiq3p&K51jzo`@cSkA^Y?DR z=wEU_|Dq`z{ulkPhR^>E+kZOvf5m_P-fd}!!T;0EpHe_}&$NL4+ZF#SCGzhcUc3B1 zD*FE`EaCu!+{XFi3;iVm0ST5V0e9lR&TxM(r6JJnK+rM+uxAr_e!>4QNdM24eil>ujAByt z59MNw;E#iT7UB1dLRI^lf(5Q+h#mpZaUBuLc;uHcVIA{-rg9tBai9>!e-#TGp#V?U z|7_c56N=Avb2;&wg7r@u8E#NPNiX~|w^@+zU_L(p3)n6plO*r6;4c7k< lf8PcAznehMh%YvN6Y;QNz$bhN2!8M@7YlrTKKg6x{{#N5%QpZ3 delta 40255 zcmZ6yV{qV2^zRwlwrv{|+qP{xzlm+zww;M>+s4G4OlF_`->uzyx2j)sSD$wW-%r;$ zefa=BJO>V`EC&t&mja4_nS_T93YWy>0{TBEWC#!t5GPkFW^j=I&tenve_f_PfD&TE zfq=lk{AVNrl18~)-USK*f(s4;!knU#iIp<;@gh6OxJ_@w?YlCiNH`zc2M)v1`#LBlR*>wxjtqEW{AUv-^>%_Gy*^7-3w3s(%HY-OxkD8e)TeT2S z@O3PN4+8GfSf_}rnrSeG$6Xx%sO(R1s4Y^{OOacYVEg=r8$VFDUG`Ywv*;*rr};q@ zg~uCIr|C~BJSBa;D3@0?M=@1;DP>^QcImZsN5j6VX?$r!lZL}vtNty82GjkqK~*gd zXRl9nQfc0FjhmBbYLBps zZ4%8pB4)qoZ40a}R3w}fNz{BVcSTEl-Rb( zuUBnA8ES|jK|m-{NIkfKZ8dZ)oPUIFn~e;StaMSqO`%C|KtDgBmWq z#G;DI^Hu zd91CjSsA#&74B+YitO)blk^DRu^I;m+ZwwkEon<+9p`NlAv7kdQ+8vRvumS%aTi|c z9?ePWj6Io5Te^e5!DUZ-d-KrkGw-zP6jI-eb$6Br$M)eXk60l?Jpy>t^%di7d^#6L zOXeJ3yCc@PV6B=%oSBhb#8ost@mw2TC+HgG7K9fu*))($?20ch1Ts!3FYz9KU*Ah_zg%>xq zqeEGKuXN3(+Hi$Te~fF|FTs+!PE#~@SFWb)bNYD4EDP9J(kq(Y!Qww&`)mVw~&!ZFlJziS5}PF0l@2J^%Hjy40SL0iM{4_3n5 z84j3YYV(@9E>|bCn*ygrD?VWNSFEGc4OZP&)qn(y4&)$>4(+Z=eV5q7HO`9r;ra)S z3H9snIAYWhKu`1__YZ@D?;d`Z-(W`AA4CQd-;)n7(9^Lz3pD^XkL}usr#CivlDZUf z=>|*I%}P}Hd8=a&FISpQi)T@LtCCu^K|jqHXB3k5#hYEME5>rJ`7~103zF2s9@3{) z_{jm)6GhLun|swKUugXJsIf(0@s2t4G; zw%iQ^BjDmCX-3D*^^XiB5u?obH$ z&HRJeF8QYOE&jfbryDX0vL@+GDJADM^44mP-ZdMvPV~W&x(JwGt^CLQTrU>?35cbN z{Cw>xRJ$m3V;0$sKzc4J2;_++k4KPbQ2pX|L7|N96J6XVM?~Ez#s0y_~`M*hI8912? z|9_IY0sWs~{wI+{DZYL*z^)p;2FAZ#doK8CC{<~i)b^k4oDj0rnysaE4nfw|G-=8x zb$l5oT=qRTN0#7!@jnmLj6RE%6pj2ZV_{aaUKOl9vEN^c+4)M2Lx_*ZW7*@+4Tq#E zelD|S<@&wl`pw;W3B8^T3KQ>x-y`g?p^n49SP#O|LX}NqQYfw+0;y5U-c6vexk=eA zRC6Ykpu;$L86b0{vot~&1sgg*1k71Kh@ykvbR zPhpUU6;D%{CYAKCQmH;9IPs2N&Kr8Jgb5i;pN5;*X|j9u5JMXEe%Ss^)_$u~W4MRd zVfZYK1cwE!2K+p;fU{5+e9(CCO_nJPvJd6aR%(ZVOA((i{g;f;bz(X19cCB%Xn>y3 zdg`I^Ts@0BQVf0X6$HP8Wuq%oofuMsIs|X-R@{2gzeve4nN-_$(SZDc(GTm(b9Nf3lM&NRJoUH z4BHl$nnKH~53`p6&M;jq*w+=YrcL`Lpjlvx{jwLz$?tOKed4898^(T~63an-({#0n z)@MXvw9Jzm!f+tZBfCi<`kJogKx2~HPA+}%h37BY!cd@o>q2xN*4Bcf2{9i7frN0= z759B~7%T<@Krn_HvzKFqD6iWYN(;Wc^hlTHfxm_DCv~l8se-!N(Re-vu|zzV^*%dn z-DPtKztjFeA$;cF1s`Q!6t|F{21XTMUjpkMg08A(Wx#kxm|=C>Z#IG&#AMNuhe!CM z+iK?+vgMXhXU)9ykR+c-L(+SP4*8IdiM(o@U!r+Rz*#$AJt0ZOyXRn}nX9!_ZhPGd z)w#cu46eCtTuwMEQ-o;F`T8lssjF*vt543>T9e%Df<%W2!3Z{9_UXvN%Q{0u_*!Bv zzV5L3egZfJ^3pQHC8zFj6=tLQ9h+!XzlAle1MVUJR85LGy?b&&${lv)c!u?eR_HV5 zVNl={K)lOSTEE>nWMNC4B-UE7S$o)*022^2SpS)GXR351W?e8S@6i^nRhZK21FxbQ zo=r|Xn3;a2gqkA9jC)ti1U4zFR*N)5@_}gZx{tQzmAd;D`V9VgPp)`CJ<24J3+oWF zOOh|D+JrBTtRrT-UNiTyXc&Q&(3Y6J*MN5lKyyxQW@cU87>WeUxSv5ihX%q+Me6Vr z{fYojb`v!UlW8@JxGN?Ny;K*ipxcvNF8qcqX21P}!@Jv8IRF=5s4jbexRU;sm-rio z_e39m$ld%;hB{CR3NVHMs?_7ryClg9%EdjJGu)cCVf%af}^xSZ$o zf3E)USwvKswhL}f-h0rNx$a-|8ICEr+~Tj>KAIQF_kl(O0r zIVZTf@}DIRHP$InO6BDni!j2SAp_m?6`<1U8Z5(s$q&gfR@Wg!ck)qZqQb6mq9um{tEdfcjs^@n%3_>4 zi^arbE7}gniM%9h@bYJQ`r4`a+ayE@f&%Smtm=C?;7B3oUtQ1Y?h}xt^{B^NNo#rU zj$+|#>AgqJ%{&w>Gp$R9!;PpRhdLobqNa3V6K)ItD^nx#7rWzB)Ow5SShdCghgiki z3>lP^543|GIKu5Y2<}K{K0BJM_Gy4SQ5RTlK`0c5taqdo7?E7&AUdoPDk=-T3DOfn z+^L2w&cHh;i{E=EYB`TS*cFDp;wb zia0w`7S@*Ejt+mcrE2?(Yt^S{C)NEO;{a03;FOEZM9nNI4Rhk5DJFtGAN3vy-N(w!5RUCP#D3L`r-jq{U9sIA zA$|IQzdrg~VSW+s`g=_mu0jsa-rz>0NBleQpu~a2#LzIu*hlXU56|csEV-TGiqWoS zXa=RML!XNZ*>UWQ>Mpz0k$**YAg{*c;zUKrDICHa8<%?)ondHB4zn{94@?5#_hU4Z zXGaFa5bDv6iICiQFZQd54x`F}|1+m3Kqdo^kwHMTNkBkI|L>dvn9S@=+}!GPVZHIk zJpvOTn&g~)M9?TNLM;d}kQb6YlGE*ziYcUf#S>F$b&|CPl0zX)4@X5Y@_6EJC!%g? zJngAna?2fa{#!grxiF~`+p-B0b-P@bsBhBS&(aC43QFsJ$&LRIutL0^aX)1TrG@UZU%F~?7G*7x>p!i-v(Qu~i5qOqhQro;W3Db~1a227|+9+`ji)df$P+z-0kzG`; z(r3))6jiMoGR&Nf5pU7vkP}y<&Mqs~p~5Q|n#MFNdXz=JJ=e7l)vD^<5~KEsn+i;G zQuV1T+yf9Q9{G?FAAQrfy)UkNRZe}wxM5X8rsC+hX`gY!as&wuu+p4R*|_L?B@Xp8 z_NpJb(mHB-#ZL2v#tcOLYNj0M_RAj~)7~omd#1c9d$kzswK~NP1LSpCh`4LxGxO!~ zWXd`J#G(pfw!CGbKV()(eKNSMuq98{TQ6}9OaLd4mpdnWse+axx7OMn3Me(uen@Z6 zM7O-0E1Se{udhGru8IEE?x8IomoSoUM~_KuXVUS{crUFTza|pN;nI1rX|y8$-rwH@ z=r9DrQK99cuA-`{8-Bh00IX=-tB*;{Gom90yW{ur^XKA0t$8?6Zhqeo67Z}N-dw?j z^8u_a%%P+BcA5Tv^Zed0EsR~qXBJhO5-<(QIk(tsFOxDC*-S2@LQUG-CuOv&jdw~C z@a2h~!x89lIgjNzqkO)tnW)Yse}|aAIV^gw>(oX2LFnMyQ}O zwsVv0$XtglpGK;OTyVLDKIga+S%MX%QjmnteUm=;U06bC+kTTUhEOH4NRDcPr&^PU zNsGgp?8))_qMA-W2I4{hn+wepEyk{yFT`cL@yHheUR7pzi{F+pyJ1%l#Du={EkAFHQR{9PN_~}eUEsfo9^U^4M*!38m7{i zSoB=Jd6|eSWVQjm=rSz7$$LDg70s$<;26?J%b(PY3MEE7?kFDPMI1Yq6<+(!xX$O>xl^)-raJjjR%T-g+_T z5a4F#!bJS?r;ft74|Ox6NQl&B5i$h>Q@WNh`?EIZt-ZDs{z=BGi!f^|iOAnFam97R zicV^nKW>Ff&T4HpITK{WPT`iWHHlCsT6-fHfQ%K?BfHT4qMO%^83R{O=>zD05GBX* zKjQ4N)hy^_cZibtXXO5v=+3kSMLtxQ?}!`BrC!5I&^&A}J3m6hUxf%&%*66MW<;T$ z4zh6xP=O^9!Dl-{b#YfWhe8@yn^Qcsc4W^AI&x*tQrfW#Q{l)@%xWGAr_uZ&juiza z8ZVi!0J$hovkoIK|B$a2rF z*LsWQ8!H`X1J3_Q$_U6#2vcPr+ggxM%9(kj*+(p$_60@pksE!8R&L-o9>^aV-Kh zgTh7Be|_M=hi*cL-fZn%RLycwHC5kh$Ix>Z-g6^ovb{hhRwj17?3E;X_T9v3`9>0W00{cmPirBX-p9fVL5l1M zc6uR*eWstmKht!`|G3coFxfjP{=0OT{X#BUB*zSD~w^}!7g*&^qx|Z~f z+r2);2Rj}h3K9fyF`xro&uMis;Ot?^BP6FXV@~462Y4^glU$=UYSk*W*D8HpuTyWI z>?`;f#0gIpfaPL}WFPeJI5@3}l62#~73nooUi=_ZEH?Ebvj6q&K}sBZ~uT(Sm~N)Xn#K?}ATq_$@(5 zr1oB0A@EaasuIK21AZj7#;!Ty`v!AMFpvtZE%}iQK(MgLSps z_4DGu%@yQ*V*UsKi*QY6pc4%bgw@p6xG|0G0Dlx5URW&l)*j9MA7KqUy>R>MdW|T zPxca`dbruCXj9rc`lDyi zL>N5}Lx0VWB`cDI*>dOd8+93P{gzh~bMp%^r69|LOI0t91) z8%GxYe#FC{$FaNd_wU{ZXqLc2;~UHdvkSjb{49T=8-WMaunOqjgoTL3K!_3%I)EHI z{}eH9XGK85Unbf|oh`l4fi%srXnetLf@SIWS>+?IL!Zuc6TMp2T#1H0jgEO1@c7yZPqp~ zwVb3Exa)OA=uP7_EEIDvI(jHACm-5Wu zeWr5MJ$Bi04=r%cE#JA7U6!vkZ~6L4IB1Mo-+C&2#7938ruDNGWS8eebYx@*D2-w2 zW|Y4alv6SFr~A6EG# zr^%K#mGls=>}ftPt(>WqU$ooRt&WD#h(o?9Tam9M0)a5J-Z=WZ(i=h)mcpDWFgE-@IdH`}B3S$|R`_jjI00_L z3YJ|7a(6Hf0Ikg*&c>H}i8a<*^1^4vKTOgld+Y*{4;&xunXo&fUk)n(nZ7>(A~0v{ zk}!HW8=|4a&j(!xARx)

$|chPVR@j{Ne$@@WnWOc#pdglpYbnqRa^G=aT%hc%Yu zeaQ7WQv&S z-Bq<`n10M5tTIoGCSRX*XE}4X-yKG@*&4QX9KS>QdOcc?HyX#d?b+Z|_!H3wjaPATz^QW< zXl!5w`X~SaObxeUZBT*fLl4?DUC)zRKmhCkn4pu!i8AUm!+V1NwN#1|2$6y|u52x5h~<_a*4PTB zwZbROhRfpidY0V55XOH=QZt*L?wXbvb}pSCneNmv;npvM38FTjLG&fWlf3`s2_+t2 zKQ4g+yu+0h>84C@U-5smdKRU|7b<_M;F!_GK`Ub+7qf)^`W+0N9%Pnn7!(Qucc<~J zU&v6het}2E14V3QjeK5XAc$d3d=;ndIDGong1O7+?_HxZ$c3abZz2~p>E#B72eu(E86|crO)*r{Ah21 z(zfHUdORg-wmUIpGP^qQ2|xwyh1fO{oeh9=_Tgn#<2tY1XK2C2X43w$dkicBO%4>y zpv4>!E~T=$lacQiapLm~#FrH}&A*Qy8e+Q3Y~`Y>ec20XUp*BhC$iYf^zQ6C=B!2l zSRVH=@jMSzu<#_aL&JB4o-qpeIcmAW!|iqytW(bxFr$rf-IRQAJq^RcmOHKcg5`E= zDudUZrS((%_%m52HgoWyhnyxRtYJo+ruuwbaG}#iv3P1 zp7+Gi#wUe)DwfkAFQ?y%y7IW4zO~N#aEW}r4(UNOqafk(i%i+`t3*dzPVVh_cj^v! z>F6lBz~(jX0RhPQw`0h_US+ho8gEp?n{l}>@2X%w^%dDMUH!xuX0->`UeQ5%jT!gJ z2Gs}K9eR_ylwrG*dtJ=8V-GmPyK($4?-IBmZd&h_=rHe?Xh`px;EpP72GHN*;BZ9G z$G3Dt-VxDWM+T4AyRO~|1bf%x62eSXl_P&nzW&k)0Y8zeCycd6VTe>8SR^t1r3WoA zuU#ZY4LYyJBTmB;-XByTiBk%QGhzyqA7uQi;R?pAFa*eWh3QFUz6pewBbY1S$@)u= zrr)E38>%hhN_Bg^d3xNT!H6qfRJ@dT<`Y<7HPvam z8ix$50GjMs%`c^WMhO*&LCTY_?XP?3_0oQNNEJ-e%~nQQeopax4L^08t4z%pa9g-83$>rZi^^|%#3g6NL7ql&Rc+~6FalP)DK7jz`tEUQX1x+mEgZN-oNrz%T| z0Ja@*+ARlqYYUkp5`whFxvvE25reCdLi$qRT4cFH%2!P9J2Hl=Oh-pS99}&yT>sp` z#oxc9jwqe9`Z$S0S+R9jvaV@{$|HNq1an)pq91JKVR9Q^E|z60j2Wmh!;V`W9Wi#n zu4mXNesh!#f9>ap9z!3|95OcX*43)Gfa7;A_PiUX4uUi6zYCWp9OG#37znNA{&YkCc9oK$M=^%M<v3Et~jFb@I2<1=rHpGJtC`s#4w7Y4Np)7 z-FsX3{y_(ro50Lf@+l9|`JpHFobqYfQqeE^=L4L7j=MzmGG(z4En~_4zcPl2A+7{7 zJDN4i>=jFYWjfc303!tutzQDgfXweX%;QtVp>Lf*BaSajVENt)cLzAg4hN3#rib%p z;O&xrXbh$Uhx@MkW^msnhb~`QMI@vn7!s*AL)254Dn+mo?^#ORJR;94-ikL0)VJD0 z6O3p^>b9b3y6^F7J__ov3dU|V`SRJGmHUNBu;DBiY3GiS-*AN7b;@f1HR;;Ng3Gjg zXtBM__;V_1wNY-hkxF93?zke3iXOU}L>q=yNu*77CFXz6VjEMwrCJVdp@ZzqAiL(E_PK2Ojap$H%gcM8Dvq220xmznGc4jW41^Al2d-gwOQ{Sffi;Tw#nfQ!8Ky6 zFnp@zRJs|43%>a^AMi-vw|-SlWCSf+Wrc2Sko%DI7J60saN6HTZ+j94R$lCkl}=SN zb7mSZzDM)A2m36a?cAdQQ96qYjX5zB$jt?14(!a|l#+Y= zOP(>cI6=;=5CM(ON5AFpy-AQTyhJ-tYH4kXQf$w|ps-&umyErE{bk!2ixkiI@Bu?e zk6L=4daP6>sh_4inhVcjhBn8vLv@?^c7~MeNp3Oc8s!_1aYTuu4%I2R7#UhEeC1~& zUgb+8uBy5n-UPduT4!hS-A&I-y_EFkn`P7d>6W-+E(UwpwHP1k5!9Fl%rl>p4rN-l zV^xZE9tstUT+&u$TWJ>iq4ae7yFfmc~TVJAM#{A_aUhJdSDmCKmN zAwt!d(uc4Pf=rRD>da&AFnULfIzvv&Dfh%5$2Lq=k`AVRgkk_JS{4X12%+PnTqJh0J4+ z%8IL1VV8h5)7u(kKpd{TQ$5aLtR-b-qAqK6mU$MCHh6;&EK)yX^9ucUT8c$W@r+Z8 z34id*lCzR4-c-b>(G?@u?4bOIH4b-zsfp2oaI9W?A=2^! zl)4$Mr3vnt8Sk1gBwthVUT<2w_U!qrE>0(+RTGht82j%r$y}>gCS&;e!c~{u#A_mg zp*%(4M)E^|Pu@$DEQI_kTNE}U(jCVl^@+rtfP9^Z0#!oTATU)QDxRGHDo^OA2u-R7 zbVGau?)cNn5riVzE!ay8`JgieAukx!uaDOWNnY7n+9ftVSB%5{u^+=Mcv6k2LNm$f zXGvp(stTh&9V*43(--`0R^+kau+n}$d91JkvT4lywF7ONt<|Pq>0SSruqfB#drzue zzraK{cq7vp_8FuO5z?QWBnoL8*+TRpnyPW?`H>wpk>VQ`8FotC^HzGe3oRS@LO5}2 zXAjy5k&SK5F|PllBOSliU@Q`BBo2=KVbMba&+*S_>T0NMvVzbHcNy2yo7}_Nc>eh#g0{O-4XX!=z*)2Et{SB?BSwEe%vwK$G`Qbz9<&(MQ&LuI2SU`y zKOy6Ssu9|EV=f&}crPak)v5)9nJ&i!ntPSs)M|rxXWCr6n4Db~Fm<6=BTV0mXQOor zFx3R3Z^avmDot)^;^!s>IFZAE&lY_w>55!`XQW7Mg4n>BRu$h9OcVYcNgLn)XKg4SU!o z|JjXVIN!WSavbN4-q71c@OH!~|E`(eUq_(Q+eg6K8_A_( zkjHA95%U#rsF9~u-Zt5MklxWW3&+B3S~XW~ArCOz2eOr9zYa|~1;wta+pc|=V1s0p zvWl`Fq>)iGT})y4#C&Z>WrI%3T3d5yr8p7Fw@Y)nTOfKG1Tiz-|2qLDCkfse+*L?B~o}XwTQ$3d{9>TL_Z8-XD(^G1# z%f=XR^t8ALob2v@$((%a0K!DJ!s|K4_=^g&q9UiAD=V-w1s^y0ckXpf$0xv zly=VvX*A9Yxj(>7DNuZ%=dC{2!Ag6`57!@a2Mdv%TzyOPE)@7f@)YDpca6>=GUb=_ zU_#b4^?Oxl0qr|)V9|jxrkH87j4*5BIYjKU)0~i0NPW)_ z`%CK{`b%Xn_?TH-A1pJpQj^|cq*`IRN-?M7deT<5(0067kpnigo0HQbi;?1` z!T;db;T>H5Q0c&u&7DVuf|QcAn&_sMduZOx$!QBEy$$nN>_A#eu;js~ocy9bu+UN# zGv#T*r@WYDXzj&8r=Onplx(MxpOJ2;Pg}%gYgc`IRzDD)oYrn0m#b3XywKF(>C zF;(&U_@me-BYPpb#rc!Vc#|qEX)GJf!fQ+w>udzamBC5oU@KeI;#X&2#&uOY!GgY9 zl_TU!s@1t@v)i@t6x&jKyPQWjFu`ieQC)UXtSh6X;XkLPe8_sHoYi8RqvJ4aZwt@+ z!NI$yF{8(qUgi^HmKAZ6Z$>LsQnORB>G=)W6r*^y@WH{EWc6aZ*6TBu4Nuxs8HyyT znrsDi=;K0Ls{AvAm5Byp#)5K1XK>x z|6tM}?DI|jM>OTPG#k1O__kZTQEntByvx!0@IvBi503r&gL@lY4DON4z^MqUDP&N3 zb|ukI-b-I0hkr<^zMP>5KOqD`Pxnp>q5O+-dpTs{_EO>G^_jud&zF0VyEq|`|K9(| zv0@QqibMr4F!+ljZZM29b%i&6Py_#G{Gb6IdJLr!9(o+57C+({08vRlw6qNwL9QKP zT+v*_llcMN4dOMDeIYWa1hz#k*sq6bENJnl6Z&~gB(4MXG$;C-SgMO#jV;rt>t{9s zR{U~LhGqb+K3DY13$A*6aTXQ?voC%Om9vl4Fa%ZtnYh7f)v~teUrgN4s6d+n>efdg z>2LJ=KU~W@!a)`Wz_b*rKn?74g}n7c#9tj1Q!p({8TtmY;4y@Hs$zudzF9kM{|x|Y z{(7YIRN74mM)H8!QaF|BlSH;Zlz@(fx-X6_J z7FJUMGZd6dDD)^L2pNie9&TP`#~4>b)fj%%)IOh=%NOJESD@RJfLmTPGK7pY`I+_3 zi`9d>-sN9}O2}&H9cO4o+eH!bp8yVgir#V9ee%%9P*j;Ma{R-IK1hjr)@)<#y z%0RqZQ&>kV;Myf-BOIxT(BO!~GX~-{x!lpDL~18N@QA>7lzfAFuEa310+nIm4XD^JKvg{)=65vsWo z3uX8gX@=prNe6NG;crUg;uOiW)^^Z6BksD_AK%3P=j_S`LNbLv*nj^rpg_Pt82?`! z(SJn;(ozkS&_yu9_iZ{1x_3nx14)Yg<@D(E;IdIhab#ktB$!zg?j5zmn;ZX5IM#fV zJ9RFI7cY*;F@LFyvA4+S$s%$n%+GA*z46{{X6*_Cz!#YE5IMNZiG{YJGR?&Ok8*mx zXjgsC#2+%_cp)k;@BQ?KT(-d`t^OnXZqqh^HZy^iKsh}0j>~rb23G%kO)D9Ct+P*` z?QN?-g<+Y7Z)fzNzs8&1jz|FU8#9LL=TnFcwvbe{$V5(DVOC+O zVTO3Ci|u%S)Xi&eRz|Nq9hAJCKJshyIqiRIcAifN^j5CV$zKOBS@HL}k zVx)c+o#qlkSUo?JA?y)AFNE=|3OQl72=Ls$At>j!R0BNNES5HGS_Sncns>q5$w;Xj zkJ6)5^w~|wEQWq8jbQw~(zep>E+$6@&^sB2#lqd!w{!Z)O*(L>{w1j7s1G9aslfU^ zkWENKb4*L~b5PMxdljO~Zt`(tgN`YUc09>~+LRWGsohDpjy;;j?dTx(O8|tV6ZUkXK@JT> zZ_SCAq}vS{qxoaOTpUZvh!MBUUnErQf06AQy+LEZM;2?M?z}vE>A&MAERIsqm_4|9 zv}Tylq5tG+utv0Q1$>&LhH_mI{Qn~L#1qW91Oo(wi4g>Z)FNb3D^n@EK~S*-k&u|;REyj=RNGtUeDW(+x(;OdA{Fy#J{dP z98|``U(hzp=W=Q!vjFard{VhHL3Y&=#^iY`Nt&zl@g>nwfdEb^$$Vl{*3t~zqrH$? zwsYe7{SFD?K}%^?g^NpK`MrOUQK5^>Pq`3x>`xm@PmKD|m0>`U=-v)ZL)Y#Xds zaDczm%qr3L!(gcu;?ifY?7=Z^pRoZO;?h4*DUs_j49^Iobap6!93Rv%ErH8M({_ib z^w!>X2lYhpH;_z)R+_iu=91{?Ml;}df}3V(k!VJM>`XSX>p#iU&O=ML392~xq>5T8 zb-YL75v9@7=_JrM=U3*_Fm?y88kL$MG~rzkqc5g5eNxDl9RYg)l)W_XwiF zQtzOa^%rVfgZUEvk<50aBT};WXS(;t8jmthmMTALnsTLba;{G00!11$mv8+8=z4bJq6`i1k=0YXmv|iF$ zs=rf5u{=8AtIKlzR(~5PMOYWbtif3FDSfsYYx!4YWj~XZ@^Q_=E>Cxk&8AG9fYS^^ zZSCaLHJPSnrAeMg+k3rqhyQT;K-4DVax$I~Vux`fBW9S78$`YyTe4i0-ZRU{DU@*y zz`43e+BmaqFnw~#=C?>34p$Cvpg=TT2qEB-myKdT`(usF^oN~Ve!2LFF@xw zfmNYzrIm~@pbKj!TN*^?JYmVVcB$SQkU4fYbaV`ck?1nkwxZgumF_q;bMhMrZcicn z#!1lRluX49M!H6f!a?BnFdumKunMLUuszC7GHo!Zdl-*cm5*pZqouiRU@4R(~ZV0xwMs+!D!D zFOqAQ@-E?W-=v0(V&{df>(se{*nBy*K~Pl#GA#C^NMS;8Sb9PaJR|rN$z*Voj{T^IS%3WQiSJ0w#`Knt;)g$_aHAoKz^Z_BW4!!()kl%QJ@t71x z-y{nkvg%#ZuR#lNJL>vt(Nlw1+u(F+4J9e+2EjK8NC%Tmnt3aX*h(6KXqe_`*UZ&% zHCFbVEkRiZryklrG40$bbTMP~zkehP7d=peuC|MN87Y>V>S`Zl5AImF6+*T6U}OrY zu$n9=m*;g@FOrojuGcZOFn+~i@`benv%!`59ax^ADb zuGf_a4VcvD9!vHqhi$5Ww?;lvgTZjheEQ^_K-gqOj?I&A22w+_tfo%Dmh=Q-#e{tw0l1g<+S$E;?Hh7(edMt zsmUvEp3|XTk!XE*v(0V>33~j(VL=MzVw6)PsdJzIr(j9d^q!ENK>w-MRJ+KeVd}hJM@6@_dofMi8l4 zPTI{Ph!hfD1_mdUth|kOJ$QP{Mrp5&!k7mg#MGwm>)SajJ7P?{ElW9yuE^T1i~)a+ z)oHR~wR#8~nY#$2C=aU|OeHSoy;$gVE7ocng625K(Y=l#TznDsqrS|t^tYEEc~V$f zUZcQvM<`<=SncCYvwc!PUVj<*s+`|F4D$g-dqhFtmyl6W#>@n$CX;Od~%)rFFU z{BCsjZ62d&G(H0K8O-Y+5s{qEKI-S=IEQ~iK>~qlKZ|h;*UjEM);wTD39h7~^y2}h ztU0Y@2etcIpbP%DN|- zAhj!UP(Ba;HxZNjFd=LWAH&BvHlA?B)6)?SW0F3O)M&*6Jm0SgW}C0(xrX~1zJJL; z*dahvA+++b{)L|hO#c#-xza_we75@Tn*&g!zLWl?Hr;17E1a)Wy!_SK5pZio=SrwN zFF!3m+#zlHXEZ_xtX>j7E9LzgGXjHC%Kgg1$~7enZRTZX7>rGJnY<((V;9n@pYlzy z8Pg;9>E@EGr+DVPwPr!-n|r)JlC+9o`wXx?unwv4wlOVZbf~K5ft21b*;pr5wuM(lo95(A4bRL&~AJ zZ(gU-?|Bw+E!kGo=K4WiaxYQ0;;px&4?%ir{X~W4?x{u^g6)*lf95#_!yrJ0Oaq`E zxU4%jPCpBuDc1Q73u_JT+j`p79b;8@Z^Ieeu=xlkKDLUZD15(eFC*{MQ>Q#szb6=~ z>V?O*qY#HXeuPmX*5f=L3#{6B(b`XEoAUF*&C^uj%N6wTRP!`>I-Y>?Cnbr+P+Xhs zaw*n*BejuNrYz%F_KfRpXnfhv_5<3suWtIId@oOV+_;5N2~6sLwINzo-Vja+yaS+{}o>;#lL0qLdlsU;Ii2H3xRV6RXoT_~B_ zQ)3X$zlSCjIqN3HIV^I}?n=r}#$qZe!Q8-a>NB=J0t zM?WzJR@|W#+y`-jHk*|sOWUaFu&C(pQf=LlS&x2ki{Xl-#r3(lfsWj3QFc6UmXlofPpfP|R<3@|+11l}Q~QL; z+0X4&sxmidl`e;q$~SQhaT3VlbhXi6UqA`6ygQ3WH|`eM6{R9X=rWuRlXdOmd=#}; z%}ClwZJhb6#0}9yfj>UBY{>g2xGk^;TQp`mhg&4xKGt`Q2v6cX10HMWwANAA{iuT* z8=$viWZbNo)6kL>DdhCp>8NP>`)e|8UduR61 zML^KwJ5GV0ZEFyMX+evgDV2bb6c9!oACHSyQ*#XdFinxL*fVVIADNS*6j=YUkCsro zV3?#!G?ru8-=As$qLaD#PEjAENFFIz>b+3Q?-sL04~4E>UHH93GYiqk;Aff-KiMo% zGsk32pJzoo57fOyw*6?zp2qg0tpwgEgFk}Uii_zE5MOD=X(7w%@=AV5in+%oHlp#Q z1~`M8R2N}4Atf>@IoUa=O^p9dwfiG4L_%0y@cCfr06otFXh(i}G_b?=4Ydn3WBqe% ze(L-uQ=0V@qx1DtZSu+J$TmG_zpW5)C#D-n{0UQr_jkT*5L;KVkG~n4r<%t-37V@1ZO#VStkVsF(Md=!(RPED*^ys&sm_Ux^C4P~^ z1khCZlc(AX0QQskx_-k_@fUnZXUJDEA=hu`%I5fGd2>(u!dv2<1F=swd-G9B-67uE zoBO_eN|V2@?!u!|E*v?qz%#`-j}KIhmw$wt@D(ai(U1j?joLgAbEFit1evi|Vm&dc z^U2IKRpO2zek-Cr&dQw?tDP0v0X4;K!wPm2)}4n$02tLNuKlH8fszKZ)R~=NPo)^!v)%>;TK`@28baZ2d6&`h~T$YqdopE|4a61@|Yo|MrH?tWUFC zC|{s8(h@kpTKr<3tW=8TbaA$(aJEDqD5msk=Ms7WRD?S?A+KChD`i)*nN0mDpKS4= zM@SxT0MRcNkJ%L!PeytJ9zkW8-<{9OmQkezuT&}c#do~SN&%D3w4pQ-h@Mx)A)a92 zFqv^mOV2`07HA1@blu8hMBVA~`?G#vUi#26&&2;~AdqVFm$3K|F}C2mb%K%F)lMtP zCfBP(`jVG66jwPAbr=e~Pk*gm@M-uV73#fV0ES&nHL*Jgjg2~_4!GqEV`60mGko=_tdba<+QR)ffC7QeWEy zS&Zyo>K4*kL%D;WT|>m1-kX{86iDqz7$!X_>76BRm&!Mz&NT;RZSEayrZM?^L6~pN z2jn3x(w_2qBt0mnHH+Z$7bz8WO0^x8w_aD&{i;f&`i6ybX8$1I&vy06jogh1YJyQz zr?<3x1l9@~$)vF8YEsJfv@7W5L6>_}TaND|NvSF8=n2B~c9_2ivt@qwTJdkpk?!K=~V;S)UO_VfY0<8o3M0M-(a1mJ2z zoPJ=u+Ts0?1zl8$>FmaC*#^OVdq2&gUkV5-rz%3XaWx`Gv$!ff${CF_+Ow5~v@98L zgVd{6#w&JzRE~1FKtT+tSGNdi!o}Osbr2Hhk}wFD5YSzf$HWii2!X1rwCM2K_9xrx zb-?T>xc{Veo*$EDuSID-;5>w zd*br{0DFodG}QNi>HTCj`x5nR!gbh+*gAoZmbyU?`l7B{7HbrA#a`C=t$k{#;9bA{ z`k?%V?c)q@k(ZxWXfMF`4#!{F`=x*ZidbGJE(8nrDICy+ROZD1`{V@!1_-UQBic9q zSh7^9oV&-dU5r;a;hGZ91M16?7XA6G$#^M)`<}qPm~};6cBPH1yaF7PwXO?V{H*Nh z7@6M7Nw1?0?g{Sj#)sVkP@b{Fzns&bHG4m~O{2>Z!kTb+WQ)>NCL>3Ig}rhqP!7hf zX-`$-`jHZ^)lw^&w8JHi0TeUqn&_(t$H~-!YLi+Zq6qQoEz4P>$J{OEP13HqrUVphfZ_p+TWLz)-`$MFKuWU>X&u z8#ATZ9%Pwha%FrR*y4GqU2y+GkPGzQs1-Idhu|1+gCc!M=X?sxE98k%M0suyTVF&? zZv0bkU%vcULDxLCf_*;FU40ru@3g%TPn69gTtB6f%+&xx6Qgx6g@4QmBi1LbY{|D! zjUWE-D`fPuJWtpcAZ=Ud8>AEvw1Pyg(FTumVw+2Fd z-iY$AbG9VPe60+bdoBU<8OCX?0<5QQ5zPWD)oE+18Fwo>L?Ug`@6xlH0h-~vSZQ0A z8AqA}!+c6ez`yE!%lva@X}ao^6k~ftIQ3<}=0P}e;Z@>*Abe!DH~DpJ96Wkc2{-c` zJcGc69H1H!HI-juGgnovVZDYiW1bg|85aW0V|s!U89F&~8h)yie`nlK5(O$#cIIGw zK5n{T39s`P4p9F&TC&;)xRTLB7?@=n^M&bhbC*^KDyAv}WoI`~0P*sg%K8V4oSw4mFm7+V`3j zz}zD_vxLDZ`Tnk#zQMyQTMLBF!u#ox=_?;)&uzXvYd0=R)c!#ZSZJ%RD1iOwCfCk9 zCJquq1a;sq+HKb`qWaJ$fM%u31J%EJV7w#A_EM6 z$Jb5sVo1ATAweW()rD24RRPjN}~VD_`<{Ai=?!*21RcZQzR z2dkO735OA1Zs?I2VY!%$4^ou08UZ%S6WlFkCm;vWHI+vyQuTC8C=M_E{jU#`59@b( z5B=*ye=i=^_vVGoo&xI2%^o32Z)X|jpn|rY9R@jaBS&Y+%lFeyc2UIvXR9M+-SI>{fDp@QuO-=-DYAsuq zl~pdgZZ)Es`@J@^#x`iR=9tl!`FY=J)Z%(b|KT-$*r5T_8*1U8Ax%@K@>Dty4S)we z4$3VsjlwTzM|?n5`NYD+zydOSg?o2(Iiw#8 zw&y5r;AudS1<;6)ugJ)!WJgE8fUR`GfsWG=7;s`U)IF0T0rHwL_t4m=9+Jb@+32^V z*p?p}!$}^$hiQ&X`6B7IF1JQm`~uZY4ix`rZ%-P{&;15pO1@QIe#Q2a6OtNx0k5UF zk;d*ZI#ul?`M3Da=mi*lX%62ReWCZG+zovJY{4Y0Jf$)=_bE$*&#dSDxn)_neL}BAx~N zXrK(5?P6WaxZLnBD`gEpGE?GGQBnWw^7*N>Z)S$e`wP$dY>M7rt+PY)a&rHKkq_ay ziLa+)VP}ivwP8;csV6qGM0IXMvB?H_+wA zTmPm&=M`pnjMFzPH!k=PMVrCJ9a#qk&C9ZIeRS&r;Y5>+LFbbBpZdloI~>k7{dVN@ zB2M6hpD-wAb*u((_q(0}CnsLnX9c>2bp`;*hmm5QV=^FdDfn3Rd2LSG8`fu{VW|Og z&~xEW^qTfNl4d^VG!_50zZ=}YATD@d!U9#?y{5058rMX>MOG<<1%hS;oSC^ZzfADV zpj({a6`iHHS*kfWI8uL7k94v%<$h0@`AHzT~F)C5A+TBIx|=54q4+Cj_g7xNC*yzsH92XE_jR5WpaX*&kHTw&6%bjp05N zuJVBh#RCiC2PuYiW*EG(&vUnmR&|Ktcy8!E-7^6SUjK+hlz4OK7h2EQ#LOZe2n(UW zpe2Ukq=@H>uG0x&qtt*i(k`*R=UK>$4Xqa#{|$}<7LYxHg~i#H{lQ|4Y1>#^6L%pr(AHv z)`$bdsnkcV+D0X)PZj&EgRl8wl1|84y{UIelkbd8a$flbiJ|81zY8^p-gD3j#OUVM zjL8^{haSy3r~UBaIxYmnouGu}$arl(AZ|4Ei<5MGd?TO~JD&6N(~xCUP%cGOH`N`l zVVxt}a{0w0vWRIlT@rQ>JIK#-tF_Mu$X5WFk~nF%V48QAUy!;FeEX2$_RpR?W9dO? zrKoFUrAOP&115Z$QV5W_H6+V*e&Ku&p4empra#E@Cq2)JR6EEOB1mIk!Gtv2kIIgD z%%v+`x?`dkv>$+soM6oJuzGviDawS`=0bu}OX3K-`*LnkNk$^&zBJKF%HoE*&n{6! zlg-~#MMC(;$;tZsV7i&hwKU=d)#QgGxkW3sf**-c+xIIyA6!s4k04>#`h56CZK>z$AB0>b|W{U7P%#Pff-W>6bl=l8+>fBMM^{&K{+AH{;e&*1$Z!9w>7WK#4B z8X(E`N3Vc1VxIr7zW-Y~56lMy-4b!P2nL1(T2fU8T?8CuC!Rk0Q1WkLMwVtm<<;ZNj(!jDACL*2ALZ6RLy)6H13|GM31|MVwlw+6L}>4Y)G9cxgp39&A>hP&po z#(A@@3$b$!=GpH0ei`8zPb=+2AiXbLxPA8x*uEL7Xqx3Aa;5T|n^L?H3&b80KDp^Q|ow<{tXRRiT~p8`=Xb8vmr+pCdW0d@R=pXtcSm z*8=tA2iTNf`+0!r=>GVMGyJc^V-$Y!h*4Cw=&WF(T)(@&}+Xn0RXP z(LZo3wP4icLJ+3$VvBT-K=NbI@eL?s#6f)Of$3K9!Eg^CU{d2ms^p`f z?2<|lYl2f*1VrG#ET~py-~WU8{})h7e3T)g{}{mVesm60{|zX+U(f+5>dyewW9;u- z`qzVf4HgI+IOJjfcpEq{DB7ac^u1+~W}9&0YHn%scfn=qQq+HFnRD|lMYOh=@mDUh z8R-}{IGp*Y>n_(_@8$;!PoCSnMM+##pF-DOxzFzx$NXJ)*O>Ycb>QELx8czeA|5hA z=-V{=wlINQrGot%uLl4}>}#mqpV325%i{fEiKk!g&&6l7t;~S8d;Fl5T5=yH zNKcI^NE2NB<`GFRdA6>Hmz!&LiqOoK9u7eo>KSiE&gv4Io_9O9 ziJp|VTf6^5jy0>bxyn~^0?h?F#uNzuJyDk+*vZIf=bsRwqbD}Ar^C)@s_lkEqDU7? zD*mZlG#TVOWIKQcnLinZi`+bed#eGSpV6?q(5sJwh z=5lgy^_wc{FHlY{u$Tvchww75S(Ucu-F`YtbdhVD{H zQBmoYc@V%nUIU8@v9Z-@FeSaPcq)qK3PqG#{M^=>PM=$>`@~CVbec)0%oX8^ZLL=k zZcZ||o-p6rw@E}5EMokRL{!3_fkB|ij-f?nIBnT5ljF4X(2KoAy3u9}#SzA0nM+gq zm^3Jv2~QGQwiT7iaI6gRi+;Rc9UUfqz->00EDLa)@V;rFU|SWnU9|}z;H%ndRQkpy zzP9UpEtfF=maaCsd7{I64RspMs4_ZFNT-lrT22)!36*OiiLFjuOI0sBam9Y;X+*zP zNhXHD+uT-EK*G@g1wHlM;Wi3mU;jH??S^-Q!@Z+^@k#}5FNFvxlSSS0aaH7W-wmUuK0lX^Jd#B_NqMCGvXD zo9+^aJ&(7F0KInLTotd^S`|;U6(+`&Kd_LdX8)ax?2>v3fxfo#1z1lpVMGdDz(mRv z4|*zB;gNKBemM0FAyoX7llYzhYXf+_Pt zj(X zR}OAm3u&lmR-r7vblaP51$vpeCXe7GGNKEK+9aU6%gmT@NMHY4!oB{6qCR32I3pww3N+)PNqM8MZKIo-jws?#V@Em_{ zcQ{fZv`IU1)Ni!z7!`$JT0v7}WX`^Vr_WqN`SP0BmV#mkVE^86cocgoO3I>c7c_)h zFDVNeN+C4+uy7(zOi|oH1U-T(VWHSq^f)(9vXMdVq5owgy1se3(kILD;tCM&F;9IM z-{^10*oljT5vkAoBAzS+2sc~w>TODNtjyNHWLfmgH0q1LBh2`LU-I(5t2XUiuW>GP zPc-UBF|}H2h5a>-%JAZvx|ec8^onSVbIU2qN1tVawDdqw9jJGBqyuq=LYOHq!?7`@_Ig$?}vM?Q&L6H8tzm^1WINk^x~ zP^dMkA;^kE8qJkCdz7$rmYIOose~%~V8A0>{C+CzFIQsRs3F)33+*vyN*CL#C(eb@ z6Wz{b=}aI$tX*p$b%CO2rYI0pY=o^hya1OvQ(y=YGrb0LTqTuV?E;uq<2H9s2qR(D zxWwb&4YLL_j&g2U=GLa1Ue*^h&T|-m7=d?m6WO3MQfEy3LgouGM{>oV4G?3qBe7nd z{T`aq5dO}?`p0)Q1dH|^>|p5sB<%O z)hpcgROSr%b`Z8M4GB)>5SI(LN|FO4EIGk#gdfmzGIyx4qQg#)FnbJq{+x+=RkBd? zl@_UESDbSUf~BN`zEx#opnGs6V7oUZ*f!k=*mV9EKOH}3>d&k8%rJqiFSh%!baE_=<~y{ws~EUA1|Ze>Hc3?u%=X#CCtN` zg2e-s>S6^tA}PZ}Re5L9DcJ*^Wl|Cs?Nc+ZS}vyOCa^+DPZ5c+(T zVc?Mn;V3!3x^+OG+SYI)hl+vFZHnQ!`Qp|!vQfOWXviH|4Fj0a zWE9;!!hIY=>A0c}J<=0TkqZQlZjGfC(^3l<=xZ1{GfBXnj7hg;%z+b3U@G**G=?(_ z=pA$Dy+l}rEGJttMM*n2PdFNOfmXg^TJ(0)M)(QrXwK#j&PaCY1HX5_LH<+Nyl5H) zOZXE#kN@+K0ww)BB2SuvMMXZKp_!r`o0M%n1o_|4dddHjSg#L<{j>UWjNOKw(kZ?ofWMAjK>_JH96g`D2^_i3UpOTS4Ms@nW~W8>TzHLqL(B&}uV1}aH0Za{ zN9k=wwBxj0fRT0!7Rq<_#ALR8H#aY6m5cxUJThoHNEBp zg{rJ(YD}Qf;Fy=rl8SSpVav+ehdr!xHhq26b2W1ts+XFf1#)0k4C4tH zb!7r*fJjnJb!LNMNsFxN3Kt4o_0zhW*zcq|y$1@;gB2$-M(e+$6_#aM40;Tw&SrX{ zvUq1Eq?8ObaBc5(H0fC5qO-_8bh7gT-&c7!2sYTKjmYAZs zQ9NsGt$xToVnUwEa-X(H>%dhK@`l2o5SknOCA3d=iu4>o6|G`zA!{i(>d;+4MZK0$ z1Hatmc&HOgiB)7@BPRS|w=+ggCRhvdVMg{CRfwS8NrLIM3 zz2?a(-Psymrwsu<**OvZ+CEAR&~oG(0AUQPCW#aG5xp!X5_>c)Jr;|4yr z`0Lt&7f2s5p@ew!X|By3$nq0t`%xjirTa@nY#~=nZPo(Szy`V62KtgN1W3ES49u2N zLWRNsc1u*K%5Gs?3^)wA7r+0M*b;P=5sZt^FJMiZEQ_SNcUSGs|act?V7|^Q)odHAqA>j=OS~SZaAva>6H^@HHOSFpfHxiUP@X%&w!)RkiOeiM7%%p!wCdjV%WpyN@$W;H zc<5LCJndJiHUlQR^-@}F8GW=p6M(F(s{CLb1KW!aS?DC)^u&66s;ucm86FpZ6yInF zb8cAe_&Vg(oUeW_LSV_{Yuun-+4lCfAi+h)SmRee{)n-8;ICP?k|jZ1PM>6YxZ#Rc zdfF!uiN_(qteNBrrYN`utF~M*PB?r{tRv%7>%Hci?Fa;QPLI{ZNaoUgGXO>_(+rbm z6@*DT*Yq0eBtZ}R$$gA~YUo@GF8@V0jH4eMArJc-z#`p(@XNa0*75ZIaOo@vU;mE9 zz4cN=&z}Y6L8s&tzF0!=5lu>W_9sxkIIKyc$db)mrUi0}&QHiFO$EM-?TJK)H?J_N zdcXj8G{N@IX)K={NI+3tG{CQPmQeWELQPL=&p0ZD1a~zGO2nF(tsxr$D~Jn|gRZQ7-})a}y%lDG7b4tiCvwZlN0_u2(x5I~|Q>_A6)?-vbTn zNz%?}MecwpXLsiB#aiS0WhsB<=Y5{OA1G5;7>k_oEf~BsOK9C_LK3l|rZ`60KwDrX z9%1AZ%t(bo2ZhLwd?Xf^c=Mo*e4pc2BD241Y-cnT2Nw*UJN8?SeYBTPs3D#GT8hk& zT5F}3cqL8-d!?H4)McmPnY(I7%?9_p9*4}p-+l+@dHqjUc=gV$g0!r4llbK-+nn8G zBpWs>)2;5()Jn35BYN3tyNVX#C)s?me=Km-XNdILJ%+0Q*V0ugPFohLR$1lNl?tn_ znxypt#!(M-5j0B;UWH3xIdeKV&{Rzql?`e>H@Jy|mtezLZSU@rSz>MNq*sZvR;!YV z%oLfqdich~^JJMuATNCbs-hP3nPka z2d7Z|P|Ym>X9?d6Kb=^Tfoa?^+HWMYtxZ_I9OQv2tRt+wu1(|kD7ArQDsxd`1osme z*emqxq3}S%?A^AJ_+J>Mdw0IzSue@^tl;D}%!3~r#oMyc!9L z*wVqeZDp~uN5!#2|>p34D$ED)02JcXpBdsOPcakgDRE|h3X5b>kn_BccB{*|Z ze|aCsYkKPO2mJl+DU-$@p)p$I{YfVuB0*N{v_uybTy$dUlM2gvIk^tMrclJ%+X+ zwj;hL0hU`R@W|=`#E3lpn{@s<{c(`8Tfzm=iCSvIA@Cu^+#8EZO#XMzo(gq3!!HRF z%pk@mB>G~BB6Tf$erHe=g&oo~18FeUD8tQuUAW2{V z&8iX$bis5#CFr8jBdQwW7)z_)takAMJqi2qT*9TKL?Gr_`52Pw1sNTi^`KX8A%+~s zJaQg1@3Gv?z2-V2c=rt6M$P`PS1W%{*4u)gE%n60yA4wNVTt7K+sNJy=n@wZW}uW4 zkVNx3A?Co%9U%+yruU4g{TVI3loG%3{-;{$fBC;Ano2F%A8z~lrv^ei$q*es$^SP* z5-2qT!2P{mp;c)jERrN#)j|lvgSjNQOjagyF|H{1IUoP*pIh3bT?An0yElq4{l&oN zi4gmCfBFg{NX&XqvZdg$4^XfCZljJ1Ng`B|F|pDJjUKdyw>ww%3^;9%Wq12WB! zsAoP8SC{Ml*_O~W1qEDE@K%P557w?qg$rz18yuY0QzSo>D zB8d7I#Ui1i3b#mPO0G>PEuKCEr5Ex5Oul_t%#0=yBRZG-Rqmbj3J2`=i4Wjup4VhRGJhr$qC+g}&0JEAJxw3MGA{qNj!xlc`97sL zW~7(fAU&Xa@`wd=_vI5ZTho`zXinMTusW8q)Z9()VdLoxxE^K5Qt%w^%^P1C0!S~v z{jXW@qMB3WN2~9y!Cv=!!l@`Oe;Ys^DJ6#CRWAa!uLfj*IdE7b{0!u0Y`Vdh4UOo1 ze4U8n*3~N-_lzM~P{x=~u>V9+J{L;Uvp-b;6v#=tLX=5u=XiiAjZ=5jpUROgj;W#r zVCe)JF-OspM3;a-UNvj6swS~&3|a=bv3P_cR#&t6K-{a2@JLBT2N6e1KBcOEUYm&D zp~o+r9$aT#tVu<-AeOHOY0ul6?$3|pfRFpfRv@k0kZ7+>@{z9KmEPVmJ0LnVu{v?^VJNF{CkvaT;RE7z;7BXAbq-dJq8K-4S z;YJkYygoJ36FC$e4}7`2$SV3RUL8;bB?)styyQ5Zy0a_v3~F<&Fe4~fX4E+kaGomu zvXW&>LxXiAM^$r?F6q*|DHp?5$}^6XvhxB5vmW1}SMhhw{G^Grfje%awq<(g28F{P zzfe8et8&0zY(~Z{ye~*T0T3J80aidPRhSZwclo3=_qfgk{_JJ5P&t)| z9v5q#=V=n=B@r!ICy`-TFebR)`}eVqCXCVojEkOYNJkQnmKpVmY+5yUK!-s`^GjWoEfqVrzz$GK1%e z-DcH@RAbsLOl7NdU*#%&UBi~jV;`}*cB%~i9G>fFOK41Rt^%iK3ywg@i5YY)^=gnJ zxbBHc9i}x}XDmC)Hd0$rS!)OUNWRY9eF#7XL94Gb&|%q=(DAZsSl!G3OB^s-^jmm4_te6(0uw4zR~ie zUUUTM)%ai#cI$eJ%~w&uwMsRolERPB{Mo0<=%LuAi%P()N>?h%;EyY+7M5(Mnr#3$ zFGH|eKhcxbQ`dNl4wmrBRgmmwJ!zQfWak|v7-;ZmAfQHi`9J@|l-o00Ao(neYlK&*oU{BN3>@1X|*q8RcSw6qAT6Upp@zwB7@0rr3 zDj{B_pUP05jFpQYnnLlnj9O;!{p|qw??=s4bQ=0rBuF7*kF>>^Dp9=!KI^OcihRM= zQQ%g}IA=+S2kjP5)!d zVvX>wod#>901h8qhOFMTDW>PvU1j+?3;Nx|g>y0@gI(bAEfF zjHDv(!qA5fweWjCiAWvUg!1!+y0D9bCbodg3$FN60+}bU!Quj{e{PsGzCcz2DPo$^ z;MFir0=F8L7}$t$e2_pTa)nvGGXSR^5i|T#gJgSfDY&u!INI8Q{$GxU@@|gC3d;51 zda4)YGNejCH=6@6mA2LBv@dDOf99~RA9W%4X%`jY-n6z1-BEz>*I^cw?5==kJg z_J=i3+R(6~YM|?&#TD_M#+jy~$hN-+W+InhW>1`!Ba-c&h)ZM~A8dv1sV1yf9n4CS zUF9jB@EADksShX*s4b_*I;gZ{E?a1$1alsFT#_?Wq~?gi){Ne-<5?2`xmn}up0i4n zh{6zNuECHw8kFAUE=-F5g9~&~^Zc}Ag5Wyk+G;SiT%c1l2{36NB6yyj#lZ$rpIn{2 zgd(Sq>Q2Hjh6`B~EZ|U6T*pt`7kCzFVUsD9s+<&B^Mk{3&OEYQFl{1DLPpJ6=?4z}w?GinK>U z-BDHn^z!dXM2F|qNqWD4G(_FCWbNrh?jQUm7+0B| zK@C9Mr~|cjRE`ISMT*Tipj?@vRAksq?NM|_iFD`cK~b@2h1dnGi^@>15lI-w$li-c z5F^M#uhQm%*#1)EI5gSBK#Pg){$pWM1sf?oe5p5gQ%>j}AB|G={IVTEF#~Tn`0r1` zmHMooWB7N4!>rs+*JL+~u+$Y1{1@k7UnB9Wz<*9Zvcc|x;vcy6@G}AVet5$F>atAw zWa0VY6c!ZFM!wx~x0cbdX~N@VMAtwY;1h_;pr^yIC^HS1`qVL(Co``w?0E}rW9%Om zUW8FX1~L7B1d?wzTPA^}Atn;9vNxRlj_WV;dV2go(}xmc!JK#!M=7Ofs9d!qU^ti7 zq7x$>llRk2XS3;NoJ8?ju|oA*};!&P&54q1!f)U~GImAm(FIdZaV zxU)9(_UDznJh1M!wUVz!ohMxB=b+*z8j#hRXL+M)a#en}j|teN7fCU;NhmfnyZZpL zFl`xdhE(MfH-M>U_Gdol589E?ur6H~i_+kNKp|4-5;f8NypQh>jo}kziUadifXIKN!I5~Bj zpWySKmiB8UFv{b(9@;KF=+!0Ee4#Ro<|ZeXDMimX{8CmpWR~G&&~sxr7V{%Gts&UiyJ|oB zJS7@Y&ddKpiK&1||4O=IS0XBM+-oCC=Fk}@FQS&+l3o|2?sA|;7emh{0vDsP#~n#B z;GhQ#c5$JMmd`TLxUZ;qMVF5n>x9HYgD26T$n)6k z$x^vugVgD&1$$+Q$8aV59b7VA5GRd}#{3f?2RVa5!_s z$SSC#Myf5Om(IB><3v|k_N&Dzk-XCvZa|^?A+qNv1fumkq=AyIqnqt3n|M-8mtqsW zD3$9e)R+*7ESAi>2UFK!SYqL#G^YMB-Tob2X+lmK>nM{v#%1Nyvb>BqA~|#+ePI?5 zr;KA~q|w(Is;!|=S7r!30p}c$QPp`PQ*Q>nLfcy5mu^^>rd_dRmd-7Bsa+!IyalVh5uf;&Fi~wUZ(l6m z-DHwknVOoKr6=GY?n*}Oc+|hTcC-dGZWp^b)z~mGB<9Z)ixbWxK^*#kmM3R>+yx`& z6XO64U^n~@hFZv+r*!Lcc|s@lb;8`0|I(b*jBKP+;Rqy~FbwyxjGV*PngPAcS%gA9 z28Vl}j53i{QOSD=91RocrW)$I!{?h5$)#f0Lm9$mAl<*e_){B0bC!opQSl3)wZI(2}Zau4vj_+YRzq) zluM#g&XVlJlLMt7J(d>v^?Qz4ES#&FmCUJ7H){3&p}Nw^|4nxM9I+KYM=a<6IbzM7 z3{7m3Y|)Yb`*usnjRjEo?*rHGYI#nP2d@^U+aGQVCWu84DH4idj!v`JBy=#&l&!JI zT51Cs5GoMN=m$(1vD^4PT&5p$+yXDhLCv5$GvPb!e8qqK;P?6X3hOVHOm4zNnxEJ6 z#zbo*7YL-<5AvG?LyS&J(wR4gl0=QmM|Dsc*_vb-+lxa6u<^i&od|9kCq%^y2{BMz zVTsFIebl|%J@-t12d9?PZg+WFGj=&j{cocnUP62s_?=hXr6>cY+`jyh9aM`l$`;V>InWff;f39@tRFTG|-t?rsP&$%95E%NGlL>rc zaiR$sK$+EC(ua&ZfY|HVf$}}naQ+aS{GF%}pP8rpNQY2ro#804}PpqTucq|f{f88*j19PhW{j%g^34=`k zv&x5WlgLKgA=}}Nb!nHP7LJ*bu?G8qehPqj)jG%|HS0Ig{5l{>WKWDJ`&H%bD=yM| zD5so0OsXZn=jcCEh$IQ#DkY~l#X_aD$aVTKQ8K1H$hT&hIDz#I|DUMhz)U2)^rz~& z@TX>v>wifcM1Dz77+<_bEq)K+|DV01VE9?AGHLghAmCf>N4)s;A@Fnw<8z zpPIb-e7pao^#AdtiV4W%3^v8GMGDgwGZpUR(7`wIu%U%e!7``y+wSt#?$(5Q!$A`) zV>L`{06s`t`L0%~nz>v)*Fi+&XT!I8OQ#CXJ8pk=Y4=v`mXe0K0GOUZG#Ou$r^D?z)kJ@%5vL=0B6YDOKj$QkU8dw=9e;b^|HH8+&C8vTLlOufxa zGmTK!^k;?SZDv>k>XF>AGVp08s(^E0=!ifq;D+b$Z#tt3O%s6r=qXISllau4Z6-c4 z=%_vv5{_|3#ogV{bPe}#p$f^A_z26%Ji_>7zvWU?v4&4TdN<{RyJN22!Iyp&+V=P_ zZ79=bC=;nLoQ~kIAV!cd9~+ZD95Z7I9GyXe;Q?T?l($CRRTwm`&g37@FcucKeqVYh zU<9t%`POXoV?cjv)9vCV`E=B}z#H+j=2-0gk?P10ugiI#J~SU8iN3Rxb_N%Iq!wjM z4#BoWZEA7;)=rd3ZiZ1-UOnGUiP16*oxX&f+BWD<)bDi&OK2^~NfENiQ{OT(M?xF< zP=qlibb|-4^gz8-!OU_jigyoIIMOyaz-W%-z=0f@l7;+&MR7zC0$t|LAG0LLlh?p{ z!XFiM0*V#m8a6%TY>&~y$)D@RK87JmvQmP8A-1sri@g>Po#Gw{)4OVMLJEp2u_%AB zN(Y%tNG7+qN^25q%J@XtqUf>@aaxa*y9$uCYz6}1HD3JK9hOa-c05ke0ntigAsoB$ z&~ROZBuNvcwvciTGnG?2i4#&YR1_^Cy>SrnLm#xC5?q}?Io5oAibu@<-16o^jt$94 zn?k<99o=>ACST(C;LQNE$j3kMgNTDiYCHcUSEUT&GHg=WzQrkP0 zm8RDzSP(H+2}ok@UaO(PsJ@-`6gbLy?tXSP>+$jaM(!n1b9pcp4`aZD_x#zvDwAV} z389{UWtSK0{^SqF>$K|f{;0$5LUbXT_bvh2a3bs*&ABbHPjugZSDmR?b?$Nc*U-D^ z_qobLA>Df8*SHaEXR5=xFF9zp=jw07PF~@}mt5(4_QHwkpjy@LKT6gfhPsV2;72&1 zy~#Fx*Df+{KqqE&^~)#!uor}9P9Io@?TMzxI%JtaYFfvUe6b}D!*&J>3a-qH=LSe)H^&qNBskm1IX#DJtphcl8nW` z)Ry4sIO{~-2hX~ZQTdS?_KN}(O|Ss-J@;lBpEIy7#TpWHp$X@UM(Jmt^0VZQbgkF~ zqBEg(>n63V8h_kNgAD!k%3&BniY?+vlITdY(z}2F5(pzm)lwM;F!Kkv_&|0B!E{M? zgJA+9`FwS%d|?IM0VUlb6*iNfIMroq$|r?q*eIPj{7F~TC|2*Fi;$ zR1mOZKd*rHB}a`0>+HX=$c>K7iG{n=g&j?SA}cd$7PvOB%`jWXaJanbCjL#S?=v?D z`3>|)u`xk}K5m5L%)`iVL^vqkdsm9l zOKOxYa|EmrH(ICPY9{Gw_toTI1)|YE=Mum?Y-qm##`wZ5o27WEo+MQ#CXI`#017f? z)OC@I>I$ae$=!q-qk^${)!?XmPX0CbmH`X0QxPwj>!XTim_lYaBWM~aI=*jory$BQ zZWrsV6jyh=aVa6Sd@S!2s_-@}BN2A~u+|}5Y#qudT2=@}e)fyHOWvd#vNGYEsf1pt2Ty~*hRjLVP0M9qz&JC&m|uG^roRGmxkYE@cQ0v4V!dqpm}<@ zg-1ot_8AF8<9Lr6!drvE|JT-4fJM1AVOT){32By;Sfmk`kQTUr(jna3PRIkzN75w#pa!^;HBKjUt(o{nb z-wop8MI{9<^5m3Tvkea?Lrt4Y*k|NevjWSrS$CALr&sXhm=2P}t9g{idz8ER20Q5R zb&0nrRwwtMl5GnU__b^n`DZ9N@wkzH5{K*uweb))WdpHesf?}**v+nTR}{&ngGhc8 zdv0WjULymlH`}lxcnnAZ5)k3f3qMnJtc>+LqtE1$5(PYfYNFHSqQ*A!S2p5!s!NgT zVrXD_{J@zAvb^@QojnN~c8{WPXDf4N??3M#4&z03Zq`;mu)oXc2#EG6svZ2fLW2+B5bDIUi|nr&Pz z)~H~d3##E%&sDL6%a>Hto8na%N7<5+->c7;l3QJP(C_v72nK55c-TU2Rjw@y#q1}d zM&4g{!{{qC2bc7!wQ#6EU!gWwH+#*s(#O`qt3sR>%)4H$J8_H@ zsjAgPF#D;}g(Q@j%^Qo@bzv@Qx(fC2oH(I{`_k zO0m$cOdLKjD4f&HsBl{; zux*^DVs2KWi85F>_%a{f z*rI>Yk~ZBM-zqb8oNX`dskI!O+;JvP;3nhe&<#lj4FlgZhN zIx*(R_7O&;{U!VSWv*9HeRV~CVU2tQhDDqWrOi{TYK*WVK1F=UQVs5DwjkG|=MUJQ zRVDPkn`TJRdnuza{6#I4;HhxC+SG2L@nMvV5)}z-C1wH2SQKtcs~{S1Gbx-GsX~4L zVR~ni`M#IRQ9N^!;dI`m}>MO$OjBT!)8KlkZfVA2R2pl9u z|E2KV(Bw!uF-mYSNmGAhJ1|sQ3op^W@#Zsa*xgjtg~BD^6ftK}L^hh71bS~re&%W& zvk|YC*{kFTP`bzeX%JW7)D@Wq-EW$2%k7m;!r+^hY1|HnQ`ldZ8^z!ZgSVT9k)ql0 zY=P7aGn<9BoH6v8iV%_{A9ccZ#}Xg!v_eCY^VQmGiW-U(X@&wNs5q-M$DY})`wut5 z{H|eev8bo%Y}!TZQs<}|3BOiP%)h3mJK*N^Ate!t`Cc9_np8gng(BaL$9*=nqCsMp(P#)(Z1Y+uhfGMnM#v zM{nTBLkRhX!VST0znxn?8Wre#oh^8lrwR3t%0P0esBqSKzKs(J-;AlHZ^-VBl1JW= z;)-X-qJe}hzQ*rtE4U-oOs~b3`IOQzR$tMra$>w(x6`&ZNFyAoRrk6e+#&s{KCE}$ zMw){x0_+%}=5hMD5-UhgqYG=RUb7gwr03W~FTf%@%c4c$i13<;N=81BvTNOf&$88k z_h=w&-)66NmebetyXt7yz0D4dAip!@Vlcq#UhMxqSceQx=#vd=}z*E5f-H zT0Upv0(zk%s4zeMfiFPz2FDRsU7anyQ_q4Nh zcGa1tGJBGK7t_SBg4`%86s0i7o^A?oeN@nBW@VaeC}Qg2CF8(iNR8V)U<|WXc3|K6 z@O)bLb>(rH;}=Hw>0hrUx5|x~h!jb#>FI@KSv5-R$-IPe@+*oEhC@PK;Y2i@P&SK) z;A67l$)#Ml2-^#*J!mYxYHN;(97m)~n`kHJ$bANiP?eG5NaMie4oS{VP8yLiGPrii zZvJ6;eG#;v`Ht~c`{a^?)FF&rnmNwK(Ch1RasPT-jAv)gSf1lXT)CQ5TGXwzF?!Pw z$k9vs5V)7vFqK+Ih~a2^i0hGSweiFxEEV@!pfXA(9V)^>v;UaRPRv4l7L(Ly#r+O- z>9E&+e0su1$N|nZ-&T)I?G-VGETzXho0HwN0j}y$hwYG_0G)vAQ zw0N|&vvQa%t5+~1d;c#N?avq*uL?H08^n|A%DpMf`rZ*#WY8t&>NSw!PxzZDu^_)V zfR`b|lA`fK{<|_xT5TuAtsecvWj^7YtS;=j*Pmf{R_Djtb3}W^kjB==1W=88o-J$} z-%XQ_62T@KBXE3YWY-MqnyGm$m1=6(=&3gwGM@R;W0L4uAkGReF@JpmDqcj-pv5}e znO|M0y7}nY~tdBcPG$iNfeKviaVVplR;x*UwC3S|yr`Y4! ziN7YCNI>5#{S{Ug1&krd<20_eK&*UDp)?JwVpLTR=sHB)$0h&PnLarpcn#yzvx;uX zrRXbRcoIn5l28Fy{oGS;+fvKZS)Zowcx~MoG&F}=fqubGC)fn&J!?jk%=M7%dmQdF zZF9SkOP$e3k&nLZxQZ*&B0JV=N#Kg&&)vimMdi2cWYu)X({?39F!gvgRE2L^g5{f- z+j7BHJW#L46#`QVUksQ8n2-^2h@7)&i5^S7#f*gMBo9$oKE}?n|3uqrWm=0-^n0%K zFAi)%Wn{kOxAF_(v#1Yb;GdbTPi@b3>ue&PYIwI|9F#Ba5N6L)C2hHWwI*~FTyUI5 zck4Tuw-rPC1nqHeTWAa@8lp|OLa@A`6p5Qm>pE|DsI^=hYpC;8!mY^?F)L$0-{pf4AfCy>UyIBFtM`E3BC()C$1Wk3DR!jTz zM)qi3=;4;D-95|YID)>a5lC;A&)3_CQTry9#x;$_GC}?=Z3((h&EC$0l{FyCd}~Vc z$QPewy`o!8Cfx|^@^+-lz0!2oNhB72I*IphX28VkzlAS4fUwI{+HrS(6C z;fyO6!Va#THs#GmwE2o#acQ(FKB+Gl(L-p(baFkB!9_MZjYwzQ z%{FaQ_-sLpBZuo{adAa6!TaD*dBU}c=s}xVR~vIPZl#i`r_#?ub8o4(9*QU!6Ddd& zub1MpJBZC3U_H80y$ITW1=f1R_}-Y<)D}wHMFtazxV}3%6>7A|&?w(`REn3Lh1osA z#%SE)z&F9g{WmTbG{e> zP1=Ipr3tsNM(MO`iG9)^b*h>}A1kFr2Z#*}wZg5N!oPje*f)uMRW^E+KD@;FcAgA9 zOkJ9LXx8;KpxjS8txX;Deg4+6;zIu5W25%kyDwH6{Z^WzEpql#6$fu+yb~P!ay%)I zyU!x3u3Znl#>sI2B|brMa4Mx`h`t{NyTH}w1&37jtyafSDe#qPoVi`h92(V%Zv>_c ziTLxFGmyGrd*Qay(*ioD%mlo1~buh55B4xd*6NDhd6`29F8tGjG(reBt3cPN&7a& z_Y+>qi9K1+R{N44GPAY6`{?RvkOf_b;A{}v7<(Bv=uHGGuw}NB z#BeN^_Chs&_AM_qN{%h&{OGJy%_WVun%+0?_zb&(A6ZckjK)6FDQbKd%tzKx^|hBY zXvICP`@^z+)jKB3^-dv5-Vz3@;jg@}pIg>7+XvXj2m~}vFW#>NzxXt8xAAkxLtMkY z9<|k&Za3`P@8!Xeic&i3gmj5zi$K^~6$0!i;I!n^HAmky{S<8UclZhlJ*~StMR34a z5S|_uX>>#0CGRWkj-V*hsQ%;`2 zkMlcsE&5lLdyhRm)XgUGDBP*5l%6%cHYtuZZZXmIb87^he8$A%n>e-&Tg4(Hk|J1q z%&@GgP>FI@*me-=P42{@HXDSQLO7tVfkE9%2Hq4-Bp=q-iObc~yt_Vj`J)Fej8~ zM}>OY-G?7l94uAsB6542`U0kORF@JpHmdH;ZNw=1`PkTUHTFCZefnMkgTR<7><%V3 zXYawp=D{r!wx?AGncgp?-ov65or;28J0rg5S!s^%p$Ag3aZJg#2r+Bq-0Lu1L+0Oq zH0-I#7h~<-0+$v=(RVE{eq^SrQ2AR_^a$JfmGTH&e8I68xSyS;U(6yBCb9JOrMu@{ z7aY?OlQ}lS;>gmy`*Uo;YBhcIE1Gq&7WsRe?!lJbpKG`x8S~72mBe7-`9^O&Nu)J- zp-j1C$Gbbn1S{sn<|X(_b$5?O3Ts+ZDut)}ZB~XJpDCZlUw2YEY;Q~b+G5}uXRS+QofUJwn+3c zP8;=}C2yAOEukuf9q`sl%wRNYn#8PzyU6eV@KP#h4REo5G_uAW;F4G~oGU=SnX={k zANgiJC~$?ylR9*!-~WXAJ|&(>3ItS%f!`l_Zs$Q&Gfq<*D+Fqp6v%bMCPe<9TsKmD z$Yrp^3KjMhAQcWBL~;cOfsRXxP)E|E<3w|T5s^q1!1oW)0FwIWr!yqu&rbr&>=&wX z#6sTZ)B!;+Fc9?OMz}9CA%^xyc$s*(Ol?e@oPL`Bm*;GS&hds06AkUh^8nX5{QJuG zW4wYe9wh~oZvt+1_837CSm%Nl9yd7twDS52!vkS}DLn;L0+IOF1{zwnpFQ?ZC2WMJ zC*(hhBlSv~96(3k0zqlsONu!7|0-VdrTC8`6I!p&A^{qj_DwW2`b&z>34bbL;az%U zgz-KjsDS=gBjRZS8Nk~3XRup>F&8p7Q_S)s7ufb7sLGV6^)4_?j7=7uzKlcj!RaP zB>}6{e~d`SAtT63>%7BfheQ`*q5qV+qdOu6vFM&R)Ar*bw2x>nxVltv?UJkO`ae~O z{~dzX&MATvCX(M%tnmC?R&Fc!l(8=VaMAu*)7-$C=KeKjUac^KI$RJ@xKPCH zy&pNJe**$#H$VVJh_12$0?SoK5Slk)o`o8bze)oL`$xXtYKIAa|+3h_E#rkO&+QG9v2N@GcD8k91afV9~Sy^+|+(bsl)n_PZ5)4!^N} z^FsFPd48VQIvJ=x^k*w3qJK1B z3*G$9Xh%a6y#(!yIk#WC!EgcoCk61AMz$X+`5aCOr9y~pUcI35gJx9#P+B^G-Q%){ zoiqgcHY)u0B#Lz$l{ma_e##;JKIbb;J@Q2Kmx)gxJNkvXF%xf-~zLf*5Kk|8S6mI z?=T=r&YK!{7(w#`fPfdkDO-XO+$bCn<~xKiN)izGpcp~ZBM6}y^*>3m+I#>2 diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 3e7c5fc21..ac72c34e8 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,7 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-7.4-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-bin.zip +networkTimeout=10000 +validateDistributionUrl=true zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -org.gradle.jvmargs=-Xmx4096m \ No newline at end of file diff --git a/gradlew b/gradlew index 4f906e0c8..0adc8e1a5 100755 --- a/gradlew +++ b/gradlew @@ -1,7 +1,7 @@ -#!/usr/bin/env sh +#!/bin/sh # -# Copyright 2015 the original author or authors. +# Copyright © 2015-2021 the original authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -17,67 +17,99 @@ # ############################################################################## -## -## Gradle start up script for UN*X -## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# ############################################################################## # Attempt to set APP_HOME + # Resolve links: $0 may be a link -PRG="$0" -# Need this for relative symlinks. -while [ -h "$PRG" ] ; do - ls=`ls -ld "$PRG"` - link=`expr "$ls" : '.*-> \(.*\)$'` - if expr "$link" : '/.*' > /dev/null; then - PRG="$link" - else - PRG=`dirname "$PRG"`"/$link" - fi +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac done -SAVED="`pwd`" -cd "`dirname \"$PRG\"`/" >/dev/null -APP_HOME="`pwd -P`" -cd "$SAVED" >/dev/null -APP_NAME="Gradle" -APP_BASE_NAME=`basename "$0"` - -# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. -DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit # Use the maximum available, or set MAX_FD != -1 to use that value. -MAX_FD="maximum" +MAX_FD=maximum warn () { echo "$*" -} +} >&2 die () { echo echo "$*" echo exit 1 -} +} >&2 # OS specific support (must be 'true' or 'false'). cygwin=false msys=false darwin=false nonstop=false -case "`uname`" in - CYGWIN* ) - cygwin=true - ;; - Darwin* ) - darwin=true - ;; - MINGW* ) - msys=true - ;; - NONSTOP* ) - nonstop=true - ;; +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; esac CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar @@ -87,9 +119,9 @@ CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar if [ -n "$JAVA_HOME" ] ; then if [ -x "$JAVA_HOME/jre/sh/java" ] ; then # IBM's JDK on AIX uses strange locations for the executables - JAVACMD="$JAVA_HOME/jre/sh/java" + JAVACMD=$JAVA_HOME/jre/sh/java else - JAVACMD="$JAVA_HOME/bin/java" + JAVACMD=$JAVA_HOME/bin/java fi if [ ! -x "$JAVACMD" ] ; then die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME @@ -98,88 +130,120 @@ Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi else - JAVACMD="java" - which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. Please set the JAVA_HOME variable in your environment to match the location of your Java installation." + fi fi # Increase the maximum file descriptors if we can. -if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then - MAX_FD_LIMIT=`ulimit -H -n` - if [ $? -eq 0 ] ; then - if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then - MAX_FD="$MAX_FD_LIMIT" - fi - ulimit -n $MAX_FD - if [ $? -ne 0 ] ; then - warn "Could not set maximum file descriptor limit: $MAX_FD" - fi - else - warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" - fi -fi - -# For Darwin, add options to specify how the application appears in the dock -if $darwin; then - GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" -fi - -# For Cygwin or MSYS, switch paths to Windows format before running java -if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then - APP_HOME=`cygpath --path --mixed "$APP_HOME"` - CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` - - JAVACMD=`cygpath --unix "$JAVACMD"` - - # We build the pattern for arguments to be converted via cygpath - ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` - SEP="" - for dir in $ROOTDIRSRAW ; do - ROOTDIRS="$ROOTDIRS$SEP$dir" - SEP="|" - done - OURCYGPATTERN="(^($ROOTDIRS))" - # Add a user-defined pattern to the cygpath arguments - if [ "$GRADLE_CYGPATTERN" != "" ] ; then - OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" - fi - # Now convert the arguments - kludge to limit ourselves to /bin/sh - i=0 - for arg in "$@" ; do - CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` - CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option - - if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition - eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` - else - eval `echo args$i`="\"$arg\"" - fi - i=`expr $i + 1` - done - case $i in - 0) set -- ;; - 1) set -- "$args0" ;; - 2) set -- "$args0" "$args1" ;; - 3) set -- "$args0" "$args1" "$args2" ;; - 4) set -- "$args0" "$args1" "$args2" "$args3" ;; - 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; - 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; - 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; - 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; - 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" esac fi -# Escape application args -save () { - for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done - echo " " -} -APP_ARGS=`save "$@"` +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. -# Collect all arguments for the java command, following the shell quoting and substitution rules -eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command; +# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of +# shell script including quotes and variable substitutions, so put them in +# double quotes to make sure that they get re-expanded; and +# * put everything else in single quotes, so that it's not re-expanded. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + org.gradle.wrapper.GradleWrapperMain \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat index 107acd32c..93e3f59f1 100644 --- a/gradlew.bat +++ b/gradlew.bat @@ -14,7 +14,7 @@ @rem limitations under the License. @rem -@if "%DEBUG%" == "" @echo off +@if "%DEBUG%"=="" @echo off @rem ########################################################################## @rem @rem Gradle startup script for Windows @@ -25,7 +25,8 @@ if "%OS%"=="Windows_NT" setlocal set DIRNAME=%~dp0 -if "%DIRNAME%" == "" set DIRNAME=. +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused set APP_BASE_NAME=%~n0 set APP_HOME=%DIRNAME% @@ -40,7 +41,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome set JAVA_EXE=java.exe %JAVA_EXE% -version >NUL 2>&1 -if "%ERRORLEVEL%" == "0" goto execute +if %ERRORLEVEL% equ 0 goto execute echo. echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. @@ -75,13 +76,15 @@ set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar :end @rem End local scope for the variables with windows NT shell -if "%ERRORLEVEL%"=="0" goto mainEnd +if %ERRORLEVEL% equ 0 goto mainEnd :fail rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of rem the _cmd.exe /c_ return code! -if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 -exit /b 1 +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% :mainEnd if "%OS%"=="Windows_NT" endlocal diff --git a/platforms/bukkit/build.gradle.kts b/platforms/bukkit/build.gradle.kts index dbc2d4125..9238647fe 100644 --- a/platforms/bukkit/build.gradle.kts +++ b/platforms/bukkit/build.gradle.kts @@ -1,5 +1,5 @@ plugins { - id("xyz.jpenilla.run-paper") version "1.0.6" + id("xyz.jpenilla.run-paper") version Versions.Bukkit.runPaper } repositories { @@ -13,6 +13,7 @@ dependencies { shaded(project(":platforms:bukkit:nms:v1_19_R2", configuration = "reobf")) shaded(project(":platforms:bukkit:nms:v1_19_R3", configuration = "reobf")) shaded(project(":platforms:bukkit:nms:v1_20_R1", configuration = "reobf")) + shaded(project(":platforms:bukkit:nms:v1_20_R2", configuration = "reobf")) shaded("xyz.jpenilla", "reflection-remapper", Versions.Bukkit.reflectionRemapper) } diff --git a/platforms/bukkit/common/build.gradle.kts b/platforms/bukkit/common/build.gradle.kts index a806ce672..d8b1671ef 100644 --- a/platforms/bukkit/common/build.gradle.kts +++ b/platforms/bukkit/common/build.gradle.kts @@ -5,14 +5,10 @@ repositories { dependencies { shadedApi(project(":common:implementation:base")) - api("org.slf4j:slf4j-api:1.8.0-beta4") { - because("Minecraft 1.17+ includes slf4j 1.8.0-beta4, so we need to shade it for other versions.") - } - - compileOnly("io.papermc.paper:paper-api:${Versions.Bukkit.paper}") + compileOnly("io.papermc.paper", "paper-api", Versions.Bukkit.paper) shadedApi("io.papermc", "paperlib", Versions.Bukkit.paperLib) - shadedApi("com.google.guava:guava:30.0-jre") + shadedApi("com.google.guava", "guava", Versions.Libraries.Internal.guava) shadedApi("cloud.commandframework", "cloud-paper", Versions.Libraries.cloud) } diff --git a/platforms/bukkit/nms/v1_18_R2/build.gradle.kts b/platforms/bukkit/nms/v1_18_R2/build.gradle.kts index 2fa163cee..e3fc99195 100644 --- a/platforms/bukkit/nms/v1_18_R2/build.gradle.kts +++ b/platforms/bukkit/nms/v1_18_R2/build.gradle.kts @@ -7,7 +7,7 @@ repositories { dependencies { api(project(":platforms:bukkit:common")) paperDevBundle("1.18.2-R0.1-SNAPSHOT") - implementation("xyz.jpenilla", "reflection-remapper", "0.1.0-SNAPSHOT") + implementation("xyz.jpenilla", "reflection-remapper", Versions.Bukkit.reflectionRemapper) } tasks { diff --git a/platforms/bukkit/nms/v1_19_R1/build.gradle.kts b/platforms/bukkit/nms/v1_19_R1/build.gradle.kts index 27f3b157e..9b301aa70 100644 --- a/platforms/bukkit/nms/v1_19_R1/build.gradle.kts +++ b/platforms/bukkit/nms/v1_19_R1/build.gradle.kts @@ -7,7 +7,7 @@ repositories { dependencies { api(project(":platforms:bukkit:common")) paperDevBundle("1.19-R0.1-SNAPSHOT") - implementation("xyz.jpenilla", "reflection-remapper", "0.1.0-SNAPSHOT") + implementation("xyz.jpenilla", "reflection-remapper", Versions.Bukkit.reflectionRemapper) } tasks { diff --git a/platforms/bukkit/nms/v1_19_R2/build.gradle.kts b/platforms/bukkit/nms/v1_19_R2/build.gradle.kts index 687d651b6..c6f6d8205 100644 --- a/platforms/bukkit/nms/v1_19_R2/build.gradle.kts +++ b/platforms/bukkit/nms/v1_19_R2/build.gradle.kts @@ -7,7 +7,7 @@ repositories { dependencies { api(project(":platforms:bukkit:common")) paperDevBundle("1.19.3-R0.1-SNAPSHOT") - implementation("xyz.jpenilla", "reflection-remapper", "0.1.0-SNAPSHOT") + implementation("xyz.jpenilla", "reflection-remapper", Versions.Bukkit.reflectionRemapper) } tasks { diff --git a/platforms/bukkit/nms/v1_19_R3/build.gradle.kts b/platforms/bukkit/nms/v1_19_R3/build.gradle.kts index 5b92e7ab2..4b2ad7d63 100644 --- a/platforms/bukkit/nms/v1_19_R3/build.gradle.kts +++ b/platforms/bukkit/nms/v1_19_R3/build.gradle.kts @@ -7,7 +7,7 @@ repositories { dependencies { api(project(":platforms:bukkit:common")) paperDevBundle("1.19.4-R0.1-SNAPSHOT") - implementation("xyz.jpenilla", "reflection-remapper", "0.1.0-SNAPSHOT") + implementation("xyz.jpenilla", "reflection-remapper", Versions.Bukkit.reflectionRemapper) } tasks { diff --git a/platforms/bukkit/nms/v1_20_R1/build.gradle.kts b/platforms/bukkit/nms/v1_20_R1/build.gradle.kts index 96f9038d8..c3c0d9809 100644 --- a/platforms/bukkit/nms/v1_20_R1/build.gradle.kts +++ b/platforms/bukkit/nms/v1_20_R1/build.gradle.kts @@ -6,8 +6,8 @@ repositories { dependencies { api(project(":platforms:bukkit:common")) - paperDevBundle(Versions.Bukkit.paperDevBundle) - implementation("xyz.jpenilla", "reflection-remapper", "0.1.0-SNAPSHOT") + paperDevBundle("1.20.1-R0.1-SNAPSHOT") + implementation("xyz.jpenilla", "reflection-remapper", Versions.Bukkit.reflectionRemapper) } tasks { diff --git a/platforms/bukkit/nms/v1_20_R2/build.gradle.kts b/platforms/bukkit/nms/v1_20_R2/build.gradle.kts new file mode 100644 index 000000000..6881c96ca --- /dev/null +++ b/platforms/bukkit/nms/v1_20_R2/build.gradle.kts @@ -0,0 +1,17 @@ +apply(plugin = "io.papermc.paperweight.userdev") + +repositories { + maven("https://s01.oss.sonatype.org/content/repositories/snapshots/") +} + +dependencies { + api(project(":platforms:bukkit:common")) + paperDevBundle(Versions.Bukkit.paperDevBundle) + implementation("xyz.jpenilla", "reflection-remapper", Versions.Bukkit.reflectionRemapper) +} + +tasks { + assemble { + dependsOn("reobfJar") + } +} \ No newline at end of file diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/AwfulBukkitHacks.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/AwfulBukkitHacks.java new file mode 100644 index 000000000..c30882958 --- /dev/null +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/AwfulBukkitHacks.java @@ -0,0 +1,101 @@ +package com.dfsek.terra.bukkit.nms.v1_20_R1; + +import com.google.common.collect.ImmutableMap; +import com.mojang.serialization.Lifecycle; +import net.minecraft.core.Holder; +import net.minecraft.core.Holder.Reference; +import net.minecraft.core.MappedRegistry; +import net.minecraft.core.WritableRegistry; +import net.minecraft.core.registries.Registries; +import net.minecraft.resources.ResourceKey; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.tags.TagKey; +import net.minecraft.world.level.biome.Biome; +import org.bukkit.NamespacedKey; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +import com.dfsek.terra.bukkit.world.BukkitPlatformBiome; +import com.dfsek.terra.registry.master.ConfigRegistry; + + +public class AwfulBukkitHacks { + private static final Logger LOGGER = LoggerFactory.getLogger(AwfulBukkitHacks.class); + + private static final Map> terraBiomeMap = new HashMap<>(); + + public static void registerBiomes(ConfigRegistry configRegistry) { + try { + LOGGER.info("Hacking biome registry..."); + WritableRegistry biomeRegistry = (WritableRegistry) RegistryFetcher.biomeRegistry(); + + Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry) biomeRegistry, false); + + configRegistry.forEach(pack -> pack.getRegistry(com.dfsek.terra.api.world.biome.Biome.class).forEach((key, biome) -> { + try { + BukkitPlatformBiome platformBiome = (BukkitPlatformBiome) biome.getPlatformBiome(); + NamespacedKey vanillaBukkitKey = platformBiome.getHandle().getKey(); + ResourceLocation vanillaMinecraftKey = new ResourceLocation(vanillaBukkitKey.getNamespace(), vanillaBukkitKey.getKey()); + Biome platform = NMSBiomeInjector.createBiome(biome, Objects.requireNonNull(biomeRegistry.get(vanillaMinecraftKey))); + + ResourceKey delegateKey = ResourceKey.create( + Registries.BIOME, + new ResourceLocation("terra", NMSBiomeInjector.createBiomeID(pack, key)) + ); + + Reference holder = biomeRegistry.register(delegateKey, platform, Lifecycle.stable()); + Reflection.REFERENCE.invokeBindValue(holder, platform); // IMPORTANT: bind holder. + + platformBiome.getContext().put(new NMSBiomeInfo(delegateKey)); + + terraBiomeMap.computeIfAbsent(vanillaMinecraftKey, i -> new ArrayList<>()).add(delegateKey.location()); + + LOGGER.debug("Registered biome: " + delegateKey); + } catch(NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) { + throw new RuntimeException(e); + } + })); + + Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry) biomeRegistry, true); // freeze registry again :) + + LOGGER.info("Doing tag garbage...."); + Map, List>> collect = biomeRegistry + .getTags() // streamKeysAndEntries + .collect(HashMap::new, + (map, pair) -> + map.put(pair.getFirst(), new ArrayList<>(pair.getSecond().stream().toList())), + HashMap::putAll); + + terraBiomeMap + .forEach((vb, terraBiomes) -> + NMSBiomeInjector.getEntry(biomeRegistry, vb).ifPresentOrElse( + vanilla -> terraBiomes.forEach( + tb -> NMSBiomeInjector.getEntry(biomeRegistry, tb).ifPresentOrElse( + terra -> { + LOGGER.debug("{} (vanilla for {}): {}", + vanilla.unwrapKey().orElseThrow().location(), + terra.unwrapKey().orElseThrow().location(), + vanilla.tags().toList()); + vanilla.tags() + .forEach(tag -> collect + .computeIfAbsent(tag, t -> new ArrayList<>()) + .add(terra)); + }, + () -> LOGGER.error("No such biome: {}", tb))), + () -> LOGGER.error("No vanilla biome: {}", vb))); + + biomeRegistry.resetTags(); + biomeRegistry.bindTags(ImmutableMap.copyOf(collect)); + + } catch(SecurityException | IllegalArgumentException exception) { + throw new RuntimeException(exception); + } + } +} + diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInfo.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInfo.java new file mode 100644 index 000000000..7d8203ce3 --- /dev/null +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInfo.java @@ -0,0 +1,10 @@ +package com.dfsek.terra.bukkit.nms.v1_20_R1; + +import net.minecraft.resources.ResourceKey; +import net.minecraft.world.level.biome.Biome; + +import com.dfsek.terra.api.properties.Properties; + + +public record NMSBiomeInfo(ResourceKey biomeKey) implements Properties { +} diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java new file mode 100644 index 000000000..d0c32c7d5 --- /dev/null +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java @@ -0,0 +1,83 @@ +package com.dfsek.terra.bukkit.nms.v1_20_R1; + +import net.minecraft.core.Holder; +import java.util.stream.Stream; +import net.minecraft.core.Registry; +import net.minecraft.resources.ResourceKey; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.level.biome.Biome; +import net.minecraft.world.level.biome.BiomeSpecialEffects; + +import java.util.Locale; +import java.util.Objects; +import java.util.Optional; +import java.util.function.Function; + +import com.dfsek.terra.api.config.ConfigPack; +import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; + +import static net.minecraft.world.level.biome.Biome.ClimateSettings; +import static net.minecraft.world.level.biome.Biome.Precipitation; + +public class NMSBiomeInjector { + + public static Optional> getEntry(Registry registry, ResourceLocation identifier) { + return registry.getOptional(identifier) + .flatMap(registry::getResourceKey) + .flatMap(registry::getHolder); + } + + public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla) + throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { + Biome.BiomeBuilder builder = new Biome.BiomeBuilder(); + + builder + .downfall(vanilla.climateSettings.downfall()) + .temperature(vanilla.getBaseTemperature()) + .mobSpawnSettings(vanilla.getMobSettings()) + .generationSettings(vanilla.getGenerationSettings()); + + + BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder(); + + effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier()); + + VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); + + effects.fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor())) + + .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) + + .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) + + .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); + + if(vanillaBiomeProperties.getFoliageColor() == null) { + vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride); + } else { + effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor()); + } + + if(vanillaBiomeProperties.getGrassColor() == null) { + vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride); + } else { + // grass + effects.grassColorOverride(vanillaBiomeProperties.getGrassColor()); + } + + vanilla.getAmbientLoop().ifPresent(effects::ambientLoopSound); + vanilla.getAmbientAdditions().ifPresent(effects::ambientAdditionsSound); + vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound); + vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic); + vanilla.getAmbientParticle().ifPresent(effects::ambientParticle); + + builder.specialEffects(effects.build()); + + return builder.build(); + } + + public static String createBiomeID(ConfigPack pack, com.dfsek.terra.api.registry.key.RegistryKey biomeID) { + return pack.getID() + .toLowerCase() + "/" + biomeID.getNamespace().toLowerCase(Locale.ROOT) + "/" + biomeID.getID().toLowerCase(Locale.ROOT); + } +} diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java new file mode 100644 index 000000000..2f29ac3ef --- /dev/null +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java @@ -0,0 +1,47 @@ +package com.dfsek.terra.bukkit.nms.v1_20_R1; + +import com.mojang.serialization.Codec; +import net.minecraft.core.Holder; +import java.util.stream.Stream; +import net.minecraft.core.Registry; +import net.minecraft.world.level.biome.Biome; +import net.minecraft.world.level.biome.BiomeSource; +import net.minecraft.world.level.biome.Climate.Sampler; +import org.jetbrains.annotations.NotNull; + +import com.dfsek.terra.api.world.biome.generation.BiomeProvider; +import com.dfsek.terra.bukkit.world.BukkitPlatformBiome; + + +public class NMSBiomeProvider extends BiomeSource { + private final BiomeProvider delegate; + private final long seed; + private final Registry biomeRegistry = RegistryFetcher.biomeRegistry(); + + public NMSBiomeProvider(BiomeProvider delegate, long seed) { + super(); + this.delegate = delegate; + this.seed = seed; + } + @Override + protected Stream> collectPossibleBiomes() { + return delegate.stream() + .map(biome -> RegistryFetcher.biomeRegistry() + .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey())); + } + + @Override + protected @NotNull Codec codec() { + return BiomeSource.CODEC; + } + + @Override + public @NotNull Holder getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) { + return biomeRegistry.getHolderOrThrow(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed) + .getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey()); + } +} diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java new file mode 100644 index 000000000..120e9c533 --- /dev/null +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java @@ -0,0 +1,170 @@ +package com.dfsek.terra.bukkit.nms.v1_20_R1; + +import com.mojang.serialization.Codec; +import net.minecraft.core.BlockPos; +import net.minecraft.server.level.WorldGenRegion; +import net.minecraft.world.level.LevelAccessor; +import net.minecraft.world.level.LevelHeightAccessor; +import net.minecraft.world.level.NoiseColumn; +import net.minecraft.world.level.StructureManager; +import net.minecraft.world.level.WorldGenLevel; +import net.minecraft.world.level.biome.BiomeManager; +import net.minecraft.world.level.block.Blocks; +import net.minecraft.world.level.block.state.BlockState; +import net.minecraft.world.level.chunk.ChunkAccess; +import net.minecraft.world.level.chunk.ChunkGenerator; +import net.minecraft.world.level.levelgen.Beardifier; +import net.minecraft.world.level.levelgen.DensityFunction.SinglePointContext; +import net.minecraft.world.level.levelgen.GenerationStep.Carving; +import net.minecraft.world.level.levelgen.Heightmap.Types; +import net.minecraft.world.level.levelgen.RandomState; +import net.minecraft.world.level.levelgen.blending.Blender; +import org.bukkit.craftbukkit.v1_20_R2.block.data.CraftBlockData; +import org.jetbrains.annotations.NotNull; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.Executor; + +import com.dfsek.terra.api.config.ConfigPack; +import com.dfsek.terra.api.world.biome.generation.BiomeProvider; +import com.dfsek.terra.api.world.info.WorldProperties; +import com.dfsek.terra.bukkit.config.PreLoadCompatibilityOptions; +import com.dfsek.terra.bukkit.world.BukkitWorldProperties; +import com.dfsek.terra.bukkit.world.block.data.BukkitBlockState; + + +public class NMSChunkGeneratorDelegate extends ChunkGenerator { + private static final Logger LOGGER = LoggerFactory.getLogger(NMSChunkGeneratorDelegate.class); + private final com.dfsek.terra.api.world.chunk.generation.ChunkGenerator delegate; + + private final ChunkGenerator vanilla; + private final ConfigPack pack; + + private final long seed; + + public NMSChunkGeneratorDelegate(ChunkGenerator vanilla, ConfigPack pack, NMSBiomeProvider biomeProvider, long seed) { + super(biomeProvider); + this.delegate = pack.getGeneratorProvider().newInstance(pack); + this.vanilla = vanilla; + this.pack = pack; + this.seed = seed; + } + + @Override + protected @NotNull Codec codec() { + return ChunkGenerator.CODEC; + } + + @Override + public void applyCarvers(@NotNull WorldGenRegion chunkRegion, long seed, @NotNull RandomState noiseConfig, @NotNull BiomeManager world, + @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk, @NotNull Carving carverStep) { + // no-op + } + + @Override + public void buildSurface(@NotNull WorldGenRegion region, @NotNull StructureManager structures, @NotNull RandomState noiseConfig, + @NotNull ChunkAccess chunk) { + // no-op + } + + @Override + public void applyBiomeDecoration(@NotNull WorldGenLevel world, @NotNull ChunkAccess chunk, + @NotNull StructureManager structureAccessor) { + vanilla.applyBiomeDecoration(world, chunk, structureAccessor); + } + + @Override + public void spawnOriginalMobs(@NotNull WorldGenRegion region) { + vanilla.spawnOriginalMobs(region); + } + + @Override + public int getGenDepth() { + return vanilla.getGenDepth(); + } + + @Override + public @NotNull CompletableFuture fillFromNoise(@NotNull Executor executor, @NotNull Blender blender, + @NotNull RandomState noiseConfig, + @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) { + return vanilla.fillFromNoise(executor, blender, noiseConfig, structureAccessor, chunk) + .thenApply(c -> { + LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); + BiomeProvider biomeProvider = pack.getBiomeProvider(); + PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); + if(compatibilityOptions.isBeard()) { + beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), biomeProvider, compatibilityOptions); + } + return c; + }); + } + + private void beard(StructureManager structureAccessor, ChunkAccess chunk, WorldProperties world, BiomeProvider biomeProvider, + PreLoadCompatibilityOptions compatibilityOptions) { + Beardifier structureWeightSampler = Beardifier.forStructuresInChunk(structureAccessor, chunk.getPos()); + double threshold = compatibilityOptions.getBeardThreshold(); + double airThreshold = compatibilityOptions.getAirThreshold(); + int xi = chunk.getPos().x << 4; + int zi = chunk.getPos().z << 4; + for(int x = 0; x < 16; x++) { + for(int z = 0; z < 16; z++) { + int depth = 0; + for(int y = world.getMaxHeight(); y >= world.getMinHeight(); y--) { + double noise = structureWeightSampler.compute(new SinglePointContext(x + xi, y, z + zi)); + if(noise > threshold) { + chunk.setBlockState(new BlockPos(x, y, z), ((CraftBlockData) ((BukkitBlockState) delegate + .getPalette(x + xi, y, z + zi, world, biomeProvider) + .get(depth, x + xi, y, z + zi, world.getSeed())).getHandle()).getState(), false); + depth++; + } else if(noise < airThreshold) { + chunk.setBlockState(new BlockPos(x, y, z), Blocks.AIR.defaultBlockState(), false); + } else { + depth = 0; + } + } + } + } + } + + @Override + public int getSeaLevel() { + return vanilla.getSeaLevel(); + } + + @Override + public int getMinY() { + return vanilla.getMinY(); + } + + @Override + public int getBaseHeight(int x, int z, @NotNull Types heightmap, @NotNull LevelHeightAccessor world, @NotNull RandomState noiseConfig) { + WorldProperties properties = new NMSWorldProperties(seed, world); + int y = properties.getMaxHeight(); + BiomeProvider biomeProvider = pack.getBiomeProvider(); + while(y >= getMinY() && !heightmap.isOpaque().test( + ((CraftBlockData) delegate.getBlock(properties, x, y - 1, z, biomeProvider).getHandle()).getState())) { + y--; + } + return y; + } + + @Override + public @NotNull NoiseColumn getBaseColumn(int x, int z, @NotNull LevelHeightAccessor world, @NotNull RandomState noiseConfig) { + BlockState[] array = new BlockState[world.getHeight()]; + WorldProperties properties = new NMSWorldProperties(seed, world); + BiomeProvider biomeProvider = pack.getBiomeProvider(); + for(int y = properties.getMaxHeight() - 1; y >= properties.getMinHeight(); y--) { + array[y - properties.getMinHeight()] = ((CraftBlockData) delegate.getBlock(properties, x, y, z, biomeProvider) + .getHandle()).getState(); + } + return new NoiseColumn(getMinY(), array); + } + + @Override + public void addDebugScreenInfo(@NotNull List text, @NotNull RandomState noiseConfig, @NotNull BlockPos pos) { + + } +} diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInitializer.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInitializer.java new file mode 100644 index 000000000..6fb689ee7 --- /dev/null +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInitializer.java @@ -0,0 +1,15 @@ +package com.dfsek.terra.bukkit.nms.v1_20_R1; + +import org.bukkit.Bukkit; + +import com.dfsek.terra.bukkit.PlatformImpl; +import com.dfsek.terra.bukkit.nms.Initializer; + + +public class NMSInitializer implements Initializer { + @Override + public void initialize(PlatformImpl platform) { + AwfulBukkitHacks.registerBiomes(platform.getRawConfigRegistry()); + Bukkit.getPluginManager().registerEvents(new NMSInjectListener(), platform.getPlugin()); + } +} diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInjectListener.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInjectListener.java new file mode 100644 index 000000000..da8363c69 --- /dev/null +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInjectListener.java @@ -0,0 +1,48 @@ +package com.dfsek.terra.bukkit.nms.v1_20_R1; + +import net.minecraft.server.level.ServerLevel; +import net.minecraft.world.level.chunk.ChunkGenerator; +import org.bukkit.World; +import org.bukkit.craftbukkit.v1_20_R2.CraftWorld; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.world.WorldInitEvent; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.HashSet; +import java.util.Set; +import java.util.concurrent.locks.ReentrantLock; + +import com.dfsek.terra.api.config.ConfigPack; +import com.dfsek.terra.bukkit.generator.BukkitChunkGeneratorWrapper; + + +public class NMSInjectListener implements Listener { + private static final Logger LOGGER = LoggerFactory.getLogger(NMSInjectListener.class); + private static final Set INJECTED = new HashSet<>(); + private static final ReentrantLock INJECT_LOCK = new ReentrantLock(); + + @EventHandler + public void onWorldInit(WorldInitEvent event) { + if(!INJECTED.contains(event.getWorld()) && + event.getWorld().getGenerator() instanceof BukkitChunkGeneratorWrapper bukkitChunkGeneratorWrapper) { + INJECT_LOCK.lock(); + INJECTED.add(event.getWorld()); + LOGGER.info("Preparing to take over the world: {}", event.getWorld().getName()); + CraftWorld craftWorld = (CraftWorld) event.getWorld(); + ServerLevel serverWorld = craftWorld.getHandle(); + + ConfigPack pack = bukkitChunkGeneratorWrapper.getPack(); + + ChunkGenerator vanilla = serverWorld.getChunkSource().getGenerator(); + NMSBiomeProvider provider = new NMSBiomeProvider(pack.getBiomeProvider(), craftWorld.getSeed()); + + serverWorld.getChunkSource().chunkMap.generator = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed()); + + LOGGER.info("Successfully injected into world."); + + INJECT_LOCK.unlock(); + } + } +} diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSWorldProperties.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSWorldProperties.java new file mode 100644 index 000000000..9754c7627 --- /dev/null +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSWorldProperties.java @@ -0,0 +1,36 @@ +package com.dfsek.terra.bukkit.nms.v1_20_R1; + +import net.minecraft.world.level.LevelHeightAccessor; + +import com.dfsek.terra.api.world.info.WorldProperties; + + +public class NMSWorldProperties implements WorldProperties { + private final long seed; + private final LevelHeightAccessor height; + + public NMSWorldProperties(long seed, LevelHeightAccessor height) { + this.seed = seed; + this.height = height; + } + + @Override + public Object getHandle() { + return height; + } + + @Override + public long getSeed() { + return seed; + } + + @Override + public int getMaxHeight() { + return height.getMaxBuildHeight(); + } + + @Override + public int getMinHeight() { + return height.getMinBuildHeight(); + } +} diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/Reflection.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/Reflection.java new file mode 100644 index 000000000..6197e6e01 --- /dev/null +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/Reflection.java @@ -0,0 +1,50 @@ +package com.dfsek.terra.bukkit.nms.v1_20_R1; + +import net.minecraft.core.Holder; +import net.minecraft.core.Holder.Reference; +import net.minecraft.core.MappedRegistry; +import net.minecraft.world.level.LevelAccessor; +import net.minecraft.world.level.StructureManager; +import xyz.jpenilla.reflectionremapper.ReflectionRemapper; +import xyz.jpenilla.reflectionremapper.proxy.ReflectionProxyFactory; +import xyz.jpenilla.reflectionremapper.proxy.annotation.FieldGetter; +import xyz.jpenilla.reflectionremapper.proxy.annotation.FieldSetter; +import xyz.jpenilla.reflectionremapper.proxy.annotation.MethodName; +import xyz.jpenilla.reflectionremapper.proxy.annotation.Proxies; + + +public class Reflection { + public static final MappedRegistryProxy MAPPED_REGISTRY; + public static final StructureManagerProxy STRUCTURE_MANAGER; + + public static final ReferenceProxy REFERENCE; + + static { + ReflectionRemapper reflectionRemapper = ReflectionRemapper.forReobfMappingsInPaperJar(); + ReflectionProxyFactory reflectionProxyFactory = ReflectionProxyFactory.create(reflectionRemapper, + Reflection.class.getClassLoader()); + + MAPPED_REGISTRY = reflectionProxyFactory.reflectionProxy(MappedRegistryProxy.class); + STRUCTURE_MANAGER = reflectionProxyFactory.reflectionProxy(StructureManagerProxy.class); + REFERENCE = reflectionProxyFactory.reflectionProxy(ReferenceProxy.class); + } + + + @Proxies(MappedRegistry.class) + public interface MappedRegistryProxy { + @FieldSetter("frozen") + void setFrozen(MappedRegistry instance, boolean frozen); + } + + @Proxies(StructureManager.class) + public interface StructureManagerProxy { + @FieldGetter("level") + LevelAccessor getLevel(StructureManager instance); + } + + @Proxies(Holder.Reference.class) + public interface ReferenceProxy { + @MethodName("bindValue") + void invokeBindValue(Reference instance, T value); + } +} diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/RegistryFetcher.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/RegistryFetcher.java new file mode 100644 index 000000000..0fad80ec7 --- /dev/null +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/RegistryFetcher.java @@ -0,0 +1,24 @@ +package com.dfsek.terra.bukkit.nms.v1_20_R1; + +import net.minecraft.core.Registry; +import net.minecraft.core.registries.Registries; +import net.minecraft.resources.ResourceKey; +import net.minecraft.server.dedicated.DedicatedServer; +import net.minecraft.world.level.biome.Biome; +import org.bukkit.Bukkit; +import org.bukkit.craftbukkit.v1_20_R2.CraftServer; + + +public class RegistryFetcher { + private static Registry getRegistry(ResourceKey> key) { + CraftServer craftserver = (CraftServer) Bukkit.getServer(); + DedicatedServer dedicatedserver = craftserver.getServer(); + return dedicatedserver + .registryAccess() + .registryOrThrow(key); + } + + public static Registry biomeRegistry() { + return getRegistry(Registries.BIOME); + } +} diff --git a/platforms/cli/build.gradle.kts b/platforms/cli/build.gradle.kts index e273422af..945bfbc0e 100644 --- a/platforms/cli/build.gradle.kts +++ b/platforms/cli/build.gradle.kts @@ -7,10 +7,10 @@ val javaMainClass = "com.dfsek.terra.cli.TerraCLI" dependencies { shadedApi(project(":common:implementation:base")) - shadedApi("commons-io:commons-io:${Versions.CLI.commonsIO}") + shadedApi("commons-io:commons-io:${Versions.Libraries.Internal.apacheIO}") shadedApi("com.github.Querz:NBT:${Versions.CLI.nbt}") - shadedImplementation("com.google.guava:guava:${Versions.CLI.guava}") + shadedImplementation("com.google.guava:guava:${Versions.Libraries.Internal.guava}") shadedImplementation("ch.qos.logback:logback-classic:${Versions.CLI.logback}") diff --git a/platforms/fabric/build.gradle.kts b/platforms/fabric/build.gradle.kts index 72abe20f9..ef49ab714 100644 --- a/platforms/fabric/build.gradle.kts +++ b/platforms/fabric/build.gradle.kts @@ -1,7 +1,7 @@ plugins { id("dev.architectury.loom") version Versions.Mod.architecuryLoom id("architectury-plugin") version Versions.Mod.architecturyPlugin - id("io.github.juuxel.loom-quiltflower") version Versions.Mod.loomQuiltflower + id("io.github.juuxel.loom-vineflower") version Versions.Mod.loomVineflower } architectury { @@ -23,7 +23,7 @@ dependencies { minecraft("com.mojang:minecraft:${Versions.Mod.minecraft}") mappings("net.fabricmc:yarn:${Versions.Mod.yarn}:v2") - modImplementation("net.fabricmc:fabric-loader:${Versions.Fabric.fabricLoader}") + modImplementation("net.fabricmc:fabric-loader:${Versions.Mod.fabricLoader}") setOf( "fabric-lifecycle-events-v1", @@ -47,15 +47,7 @@ loom { mixin { defaultRefmapName.set("terra.fabric.refmap.json") } - - launches { - named("client") { - property("fabric.log.level", "info") - } - named("server") { - property("fabric.log.level", "info") - } - } + } diff --git a/platforms/forge/build.gradle.kts b/platforms/forge/build.gradle.kts index 328d9d481..947879bb1 100644 --- a/platforms/forge/build.gradle.kts +++ b/platforms/forge/build.gradle.kts @@ -1,7 +1,7 @@ plugins { id("dev.architectury.loom") version Versions.Mod.architecuryLoom id("architectury-plugin") version Versions.Mod.architecturyPlugin - id("io.github.juuxel.loom-quiltflower") version Versions.Mod.loomQuiltflower + id("io.github.juuxel.loom-vineflower") version Versions.Mod.loomVineflower } architectury { @@ -37,16 +37,16 @@ loom { defaultRefmapName.set("terra.forge.refmap.json") } - launches { - named("client") { - property("fabric.log.level", "info") - property("mixin.env.disableRefMap", "true") - } - named("server") { - property("fabric.log.level", "info") - property("mixin.env.disableRefMap", "true") - } - } +// launches { +// named("client") { +// property("fabric.log.level", "info") +// property("mixin.env.disableRefMap", "true") +// } +// named("server") { +// property("fabric.log.level", "info") +// property("mixin.env.disableRefMap", "true") +// } +// } forge { convertAccessWideners.set(true) diff --git a/platforms/mixin-common/build.gradle.kts b/platforms/mixin-common/build.gradle.kts index b293f3cfa..49c2f5188 100644 --- a/platforms/mixin-common/build.gradle.kts +++ b/platforms/mixin-common/build.gradle.kts @@ -1,7 +1,7 @@ plugins { id("dev.architectury.loom") version Versions.Mod.architecuryLoom id("architectury-plugin") version Versions.Mod.architecturyPlugin - id("io.github.juuxel.loom-quiltflower") version Versions.Mod.loomQuiltflower + id("io.github.juuxel.loom-vineflower") version Versions.Mod.loomVineflower } loom { diff --git a/platforms/mixin-lifecycle/build.gradle.kts b/platforms/mixin-lifecycle/build.gradle.kts index e8b852dc5..1108046f3 100644 --- a/platforms/mixin-lifecycle/build.gradle.kts +++ b/platforms/mixin-lifecycle/build.gradle.kts @@ -1,7 +1,7 @@ plugins { id("dev.architectury.loom") version Versions.Mod.architecuryLoom id("architectury-plugin") version Versions.Mod.architecturyPlugin - id("io.github.juuxel.loom-quiltflower") version Versions.Mod.loomQuiltflower + id("io.github.juuxel.loom-vineflower") version Versions.Mod.loomVineflower } dependencies { diff --git a/platforms/quilt/build.gradle.kts b/platforms/quilt/build.gradle.kts index b8933e76e..31b4589d2 100644 --- a/platforms/quilt/build.gradle.kts +++ b/platforms/quilt/build.gradle.kts @@ -1,7 +1,7 @@ plugins { id("dev.architectury.loom") version Versions.Mod.architecuryLoom id("architectury-plugin") version Versions.Mod.architecturyPlugin - id("io.github.juuxel.loom-quiltflower") version Versions.Mod.loomQuiltflower + id("io.github.juuxel.loom-vineflower") version Versions.Mod.loomVineflower } architectury { @@ -47,15 +47,6 @@ loom { mixin { defaultRefmapName.set("terra.quilt.refmap.json") } - - launches { - named("client") { - property("fabric.log.level", "info") - } - named("server") { - property("fabric.log.level", "info") - } - } } From eb3994005c9cb8fcf7f1ea0a9b86e94dba66a78b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Sun, 1 Oct 2023 22:46:41 -0600 Subject: [PATCH 22/83] fix me being fucking stupid --- .../nms/{v1_20_R1 => v1_20_R2}/AwfulBukkitHacks.java | 2 +- .../bukkit/nms/{v1_20_R1 => v1_20_R2}/NMSBiomeInfo.java | 2 +- .../nms/{v1_20_R1 => v1_20_R2}/NMSBiomeInjector.java | 7 +------ .../nms/{v1_20_R1 => v1_20_R2}/NMSBiomeProvider.java | 2 +- .../{v1_20_R1 => v1_20_R2}/NMSChunkGeneratorDelegate.java | 2 +- .../bukkit/nms/{v1_20_R1 => v1_20_R2}/NMSInitializer.java | 2 +- .../nms/{v1_20_R1 => v1_20_R2}/NMSInjectListener.java | 2 +- .../nms/{v1_20_R1 => v1_20_R2}/NMSWorldProperties.java | 2 +- .../bukkit/nms/{v1_20_R1 => v1_20_R2}/Reflection.java | 2 +- .../bukkit/nms/{v1_20_R1 => v1_20_R2}/RegistryFetcher.java | 2 +- 10 files changed, 10 insertions(+), 15 deletions(-) rename platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/{v1_20_R1 => v1_20_R2}/AwfulBukkitHacks.java (99%) rename platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/{v1_20_R1 => v1_20_R2}/NMSBiomeInfo.java (83%) rename platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/{v1_20_R1 => v1_20_R2}/NMSBiomeInjector.java (91%) rename platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/{v1_20_R1 => v1_20_R2}/NMSBiomeProvider.java (97%) rename platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/{v1_20_R1 => v1_20_R2}/NMSChunkGeneratorDelegate.java (99%) rename platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/{v1_20_R1 => v1_20_R2}/NMSInitializer.java (90%) rename platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/{v1_20_R1 => v1_20_R2}/NMSInjectListener.java (97%) rename platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/{v1_20_R1 => v1_20_R2}/NMSWorldProperties.java (94%) rename platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/{v1_20_R1 => v1_20_R2}/Reflection.java (97%) rename platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/{v1_20_R1 => v1_20_R2}/RegistryFetcher.java (94%) diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/AwfulBukkitHacks.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/AwfulBukkitHacks.java similarity index 99% rename from platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/AwfulBukkitHacks.java rename to platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/AwfulBukkitHacks.java index c30882958..98d031de2 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/AwfulBukkitHacks.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/AwfulBukkitHacks.java @@ -1,4 +1,4 @@ -package com.dfsek.terra.bukkit.nms.v1_20_R1; +package com.dfsek.terra.bukkit.nms.v1_20_R2; import com.google.common.collect.ImmutableMap; import com.mojang.serialization.Lifecycle; diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInfo.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeInfo.java similarity index 83% rename from platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInfo.java rename to platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeInfo.java index 7d8203ce3..fd415fb20 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInfo.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeInfo.java @@ -1,4 +1,4 @@ -package com.dfsek.terra.bukkit.nms.v1_20_R1; +package com.dfsek.terra.bukkit.nms.v1_20_R2; import net.minecraft.resources.ResourceKey; import net.minecraft.world.level.biome.Biome; diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeInjector.java similarity index 91% rename from platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java rename to platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeInjector.java index d0c32c7d5..3db3fcd25 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeInjector.java @@ -1,9 +1,7 @@ -package com.dfsek.terra.bukkit.nms.v1_20_R1; +package com.dfsek.terra.bukkit.nms.v1_20_R2; import net.minecraft.core.Holder; -import java.util.stream.Stream; import net.minecraft.core.Registry; -import net.minecraft.resources.ResourceKey; import net.minecraft.resources.ResourceLocation; import net.minecraft.world.level.biome.Biome; import net.minecraft.world.level.biome.BiomeSpecialEffects; @@ -11,13 +9,10 @@ import net.minecraft.world.level.biome.BiomeSpecialEffects; import java.util.Locale; import java.util.Objects; import java.util.Optional; -import java.util.function.Function; import com.dfsek.terra.api.config.ConfigPack; import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; -import static net.minecraft.world.level.biome.Biome.ClimateSettings; -import static net.minecraft.world.level.biome.Biome.Precipitation; public class NMSBiomeInjector { diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeProvider.java similarity index 97% rename from platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java rename to platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeProvider.java index 2f29ac3ef..a6025e03f 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeProvider.java @@ -1,4 +1,4 @@ -package com.dfsek.terra.bukkit.nms.v1_20_R1; +package com.dfsek.terra.bukkit.nms.v1_20_R2; import com.mojang.serialization.Codec; import net.minecraft.core.Holder; diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSChunkGeneratorDelegate.java similarity index 99% rename from platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java rename to platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSChunkGeneratorDelegate.java index 120e9c533..7b10e9418 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSChunkGeneratorDelegate.java @@ -1,4 +1,4 @@ -package com.dfsek.terra.bukkit.nms.v1_20_R1; +package com.dfsek.terra.bukkit.nms.v1_20_R2; import com.mojang.serialization.Codec; import net.minecraft.core.BlockPos; diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInitializer.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSInitializer.java similarity index 90% rename from platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInitializer.java rename to platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSInitializer.java index 6fb689ee7..89cf3b878 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInitializer.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSInitializer.java @@ -1,4 +1,4 @@ -package com.dfsek.terra.bukkit.nms.v1_20_R1; +package com.dfsek.terra.bukkit.nms.v1_20_R2; import org.bukkit.Bukkit; diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInjectListener.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSInjectListener.java similarity index 97% rename from platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInjectListener.java rename to platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSInjectListener.java index da8363c69..7fd566251 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInjectListener.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSInjectListener.java @@ -1,4 +1,4 @@ -package com.dfsek.terra.bukkit.nms.v1_20_R1; +package com.dfsek.terra.bukkit.nms.v1_20_R2; import net.minecraft.server.level.ServerLevel; import net.minecraft.world.level.chunk.ChunkGenerator; diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSWorldProperties.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSWorldProperties.java similarity index 94% rename from platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSWorldProperties.java rename to platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSWorldProperties.java index 9754c7627..117bda467 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSWorldProperties.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSWorldProperties.java @@ -1,4 +1,4 @@ -package com.dfsek.terra.bukkit.nms.v1_20_R1; +package com.dfsek.terra.bukkit.nms.v1_20_R2; import net.minecraft.world.level.LevelHeightAccessor; diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/Reflection.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/Reflection.java similarity index 97% rename from platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/Reflection.java rename to platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/Reflection.java index 6197e6e01..15511b989 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/Reflection.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/Reflection.java @@ -1,4 +1,4 @@ -package com.dfsek.terra.bukkit.nms.v1_20_R1; +package com.dfsek.terra.bukkit.nms.v1_20_R2; import net.minecraft.core.Holder; import net.minecraft.core.Holder.Reference; diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/RegistryFetcher.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/RegistryFetcher.java similarity index 94% rename from platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/RegistryFetcher.java rename to platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/RegistryFetcher.java index 0fad80ec7..fb18b3e17 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/RegistryFetcher.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/RegistryFetcher.java @@ -1,4 +1,4 @@ -package com.dfsek.terra.bukkit.nms.v1_20_R1; +package com.dfsek.terra.bukkit.nms.v1_20_R2; import net.minecraft.core.Registry; import net.minecraft.core.registries.Registries; From 2d2bba20b6827176ed3bcbc94b6f4f3db215cc72 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Sun, 1 Oct 2023 23:22:44 -0600 Subject: [PATCH 23/83] found an untrue in read me --- README.md | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/README.md b/README.md index 77e2e511e..c0f9414b7 100644 --- a/README.md +++ b/README.md @@ -47,14 +47,7 @@ JARs are produced in `platforms//build/libs`. To run Minecraft with Terra in the IDE (for testing) use the following tasks: * Bukkit - * `installPaper` - Install a [Paper](https://github.com/PaperMC/Paper) test - server. (Only needs to be run once). - * `installPurpur` - Install a [Purpur](https://github.com/pl3xgaming/Purpur) - test server. (Only needs to be run once). - * `runPaper` - Run the Paper test server with Terra (`installPaper` must - have been run previously). - * `runPurpur` - Run the Purpur test server with Terra (`installPurpur` must - have been run previously). + * `runServer` - Run the Paper test server with Terra installed. * Fabric * `runClient` - Run a Minecraft Fabric client with Terra installed. * `runServer` - Run a Minecraft Fabric server with Terra installed. From 27eebf6a476c35e20101093e019e0f75cdff7871 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Mon, 2 Oct 2023 00:21:09 -0600 Subject: [PATCH 24/83] Folia support Co-authored-by: Janet Blackquill --- buildSrc/src/main/kotlin/DependencyConfig.kt | 3 +++ buildSrc/src/main/kotlin/Versions.kt | 1 + platforms/bukkit/build.gradle.kts | 5 ++++- platforms/bukkit/common/build.gradle.kts | 1 + .../main/java/com/dfsek/terra/bukkit/BukkitEntity.java | 5 +++-- .../main/java/com/dfsek/terra/bukkit/BukkitPlayer.java | 5 +++-- .../main/java/com/dfsek/terra/bukkit/PlatformImpl.java | 4 +++- .../java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java | 9 ++++++++- .../main/java/com/dfsek/terra/bukkit/util/PaperUtil.java | 8 +++++--- platforms/bukkit/common/src/main/resources/plugin.yml | 1 + 10 files changed, 32 insertions(+), 10 deletions(-) diff --git a/buildSrc/src/main/kotlin/DependencyConfig.kt b/buildSrc/src/main/kotlin/DependencyConfig.kt index b0e7d32c4..fd87495a7 100644 --- a/buildSrc/src/main/kotlin/DependencyConfig.kt +++ b/buildSrc/src/main/kotlin/DependencyConfig.kt @@ -48,6 +48,9 @@ fun Project.configureDependencies() { maven("https://jitpack.io") { name = "JitPack" } + maven("https://nexuslite.gcnt.net/repos/other/") { + name = "devmart-other" + } } dependencies { diff --git a/buildSrc/src/main/kotlin/Versions.kt b/buildSrc/src/main/kotlin/Versions.kt index 529d15726..401f03ace 100644 --- a/buildSrc/src/main/kotlin/Versions.kt +++ b/buildSrc/src/main/kotlin/Versions.kt @@ -50,6 +50,7 @@ object Versions { object Bukkit { const val paper = "1.18.2-R0.1-SNAPSHOT" const val paperLib = "1.0.5" + const val foliaLib = "0.2.5" const val minecraft = "1.20.2" const val reflectionRemapper = "0.1.0-SNAPSHOT" const val paperDevBundle = "1.20.2-R0.1-SNAPSHOT" diff --git a/platforms/bukkit/build.gradle.kts b/platforms/bukkit/build.gradle.kts index 9238647fe..c72bae196 100644 --- a/platforms/bukkit/build.gradle.kts +++ b/platforms/bukkit/build.gradle.kts @@ -3,7 +3,9 @@ plugins { } repositories { - maven("https://s01.oss.sonatype.org/content/repositories/snapshots/") + maven("https://s01.oss.sonatype.org/content/repositories/snapshots/") { + name = "sonatype" + } } dependencies { @@ -20,6 +22,7 @@ dependencies { tasks { shadowJar { relocate("io.papermc.lib", "com.dfsek.terra.lib.paperlib") + relocate("com.tcoded.folialib", "com.dfsek.terra.lib.folialib") relocate("com.google.common", "com.dfsek.terra.lib.google.common") relocate("org.apache.logging.slf4j", "com.dfsek.terra.lib.slf4j-over-log4j") exclude("org/slf4j/**") diff --git a/platforms/bukkit/common/build.gradle.kts b/platforms/bukkit/common/build.gradle.kts index d8b1671ef..e85f59e3a 100644 --- a/platforms/bukkit/common/build.gradle.kts +++ b/platforms/bukkit/common/build.gradle.kts @@ -8,6 +8,7 @@ dependencies { compileOnly("io.papermc.paper", "paper-api", Versions.Bukkit.paper) shadedApi("io.papermc", "paperlib", Versions.Bukkit.paperLib) + shadedApi("com.tcoded", "FoliaLib" , Versions.Bukkit.foliaLib) shadedApi("com.google.guava", "guava", Versions.Libraries.Internal.guava) shadedApi("cloud.commandframework", "cloud-paper", Versions.Libraries.cloud) diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitEntity.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitEntity.java index f36436471..7ea9d2294 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitEntity.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitEntity.java @@ -17,6 +17,7 @@ package com.dfsek.terra.bukkit; +import io.papermc.lib.PaperLib; import org.bukkit.Location; import com.dfsek.terra.api.entity.Entity; @@ -44,14 +45,14 @@ public class BukkitEntity implements Entity { @Override public void position(Vector3 location) { - entity.teleport(BukkitAdapter.adapt(location).toLocation(entity.getWorld())); + PaperLib.teleportAsync(entity, BukkitAdapter.adapt(location).toLocation(entity.getWorld())); } @Override public void world(ServerWorld world) { Location newLoc = entity.getLocation().clone(); newLoc.setWorld(BukkitAdapter.adapt(world)); - entity.teleport(newLoc); + PaperLib.teleportAsync(entity, newLoc); } @Override diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitPlayer.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitPlayer.java index 7d8b0a5f0..c2958d44c 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitPlayer.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitPlayer.java @@ -17,6 +17,7 @@ package com.dfsek.terra.bukkit; +import io.papermc.lib.PaperLib; import org.bukkit.Location; import com.dfsek.terra.api.entity.Player; @@ -45,14 +46,14 @@ public class BukkitPlayer implements Player { @Override public void position(Vector3 location) { - delegate.teleport(BukkitAdapter.adapt(location).toLocation(delegate.getWorld())); + PaperLib.teleportAsync(delegate, BukkitAdapter.adapt(location).toLocation(delegate.getWorld())); } @Override public void world(ServerWorld world) { Location newLoc = delegate.getLocation().clone(); newLoc.setWorld(BukkitAdapter.adapt(world)); - delegate.teleport(newLoc); + PaperLib.teleportAsync(delegate, newLoc); } @Override diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/PlatformImpl.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/PlatformImpl.java index bba0e1bc1..189f1d12f 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/PlatformImpl.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/PlatformImpl.java @@ -20,6 +20,7 @@ package com.dfsek.terra.bukkit; import com.dfsek.tectonic.api.TypeRegistry; import com.dfsek.tectonic.api.depth.DepthTracker; import com.dfsek.tectonic.api.exception.LoadException; +import com.tcoded.folialib.wrapper.task.WrappedTask; import org.bukkit.Bukkit; import org.bukkit.entity.EntityType; import org.jetbrains.annotations.NotNull; @@ -29,6 +30,7 @@ import org.slf4j.LoggerFactory; import java.io.File; import java.util.List; import java.util.Locale; +import java.util.function.Consumer; import com.dfsek.terra.AbstractPlatform; import com.dfsek.terra.api.addon.BaseAddon; @@ -85,7 +87,7 @@ public class PlatformImpl extends AbstractPlatform { @Override public void runPossiblyUnsafeTask(@NotNull Runnable task) { - Bukkit.getScheduler().runTask(plugin, task); + plugin.getFoliaLib().getImpl().runAsync(task); } @Override diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java index 6390444f2..0bbf6e2e5 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java @@ -42,6 +42,7 @@ import com.dfsek.terra.bukkit.nms.Initializer; import com.dfsek.terra.bukkit.util.PaperUtil; import com.dfsek.terra.bukkit.util.VersionUtil; import com.dfsek.terra.bukkit.world.BukkitAdapter; +import com.tcoded.folialib.FoliaLib; public class TerraBukkitPlugin extends JavaPlugin { @@ -50,6 +51,8 @@ public class TerraBukkitPlugin extends JavaPlugin { private final PlatformImpl platform = new PlatformImpl(this); private final Map generatorMap = new HashMap<>(); + private final FoliaLib foliaLib = new FoliaLib(this); + @Override public void onEnable() { if(!doVersionCheck()) { @@ -150,7 +153,7 @@ public class TerraBukkitPlugin extends JavaPlugin { """.strip()); }; runnable.run(); - Bukkit.getScheduler().scheduleAsyncDelayedTask(this, runnable, 200L); + getFoliaLib().getImpl().runLaterAsync(runnable, 200L); // Bukkit.shutdown(); // we're not *that* evil Bukkit.getPluginManager().disablePlugin(this); return false; @@ -177,4 +180,8 @@ public class TerraBukkitPlugin extends JavaPlugin { return pack.getGeneratorProvider().newInstance(pack); }), platform.getRawConfigRegistry().getByID(id).orElseThrow(), platform.getWorldHandle().air()); } + + public FoliaLib getFoliaLib() { + return foliaLib; + } } diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/PaperUtil.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/PaperUtil.java index d7b06b93d..b5c029000 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/PaperUtil.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/PaperUtil.java @@ -17,6 +17,8 @@ package com.dfsek.terra.bukkit.util; +import com.dfsek.terra.bukkit.TerraBukkitPlugin; + import io.papermc.lib.PaperLib; import org.bukkit.Bukkit; import org.bukkit.plugin.java.JavaPlugin; @@ -25,10 +27,10 @@ import static io.papermc.lib.PaperLib.suggestPaper; public final class PaperUtil { - public static void checkPaper(JavaPlugin main) { - Bukkit.getScheduler().scheduleSyncDelayedTask(main, () -> { + public static void checkPaper(TerraBukkitPlugin plugin) { + plugin.getFoliaLib().getImpl().runLaterAsync(() -> { if(!PaperLib.isPaper()) { - suggestPaper(main); + suggestPaper(plugin); } }, 100L); } diff --git a/platforms/bukkit/common/src/main/resources/plugin.yml b/platforms/bukkit/common/src/main/resources/plugin.yml index 15f937a48..d4bfd5534 100644 --- a/platforms/bukkit/common/src/main/resources/plugin.yml +++ b/platforms/bukkit/common/src/main/resources/plugin.yml @@ -6,3 +6,4 @@ author: dfsek website: "@WIKI@" api-version: "1.13" description: "@DESCRIPTION@" +folia-supported: true From 86ba52850d59963fb37e7493494a85d847a53f88 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Mon, 2 Oct 2023 00:41:54 -0600 Subject: [PATCH 25/83] update strata --- buildSrc/src/main/kotlin/Versions.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/buildSrc/src/main/kotlin/Versions.kt b/buildSrc/src/main/kotlin/Versions.kt index 529d15726..85209d089 100644 --- a/buildSrc/src/main/kotlin/Versions.kt +++ b/buildSrc/src/main/kotlin/Versions.kt @@ -2,7 +2,7 @@ object Versions { object Libraries { const val tectonic = "4.2.0" const val paralithic = "0.7.0" - const val strata = "1.1.1" + const val strata = "1.3.2" const val cloud = "1.8.4" From 0ee5f4997258d8c8d1a35a232c005bc45d0de208 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Mon, 2 Oct 2023 01:37:47 -0600 Subject: [PATCH 26/83] quilt --- platforms/quilt/src/main/resources/quilt.mod.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/platforms/quilt/src/main/resources/quilt.mod.json b/platforms/quilt/src/main/resources/quilt.mod.json index 0f53988ec..3f1ad2232 100644 --- a/platforms/quilt/src/main/resources/quilt.mod.json +++ b/platforms/quilt/src/main/resources/quilt.mod.json @@ -39,7 +39,7 @@ }, { "id": "minecraft", - "version": "1.19.x" + "version": "1.20.x" }, { "id": "quilted_fabric_api", From 79b3b3466910b433e65d8b8c1504dadb606d71d1 Mon Sep 17 00:00:00 2001 From: Astrash Date: Tue, 3 Oct 2023 09:51:39 +1100 Subject: [PATCH 27/83] Add slant API for noise3d --- .../generation/NoiseChunkGenerator3D.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java index f0f6de8e3..e98dcc316 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java @@ -155,6 +155,16 @@ public class NoiseChunkGenerator3D implements ChunkGenerator { return biomeProvider.getBiome(x, y, z, world.getSeed()).getContext().get(paletteInfoPropertyKey).paletteHolder().getPalette(y); } + public double getSlant(int x, int y, int z, WorldProperties world, BiomeProvider biomeProvider) { + int fdX = FastMath.floorMod(x, 16); + int fdZ = FastMath.floorMod(z, 16); + return biomeProvider.getBiome(x, y, z, world.getSeed()) + .getContext() + .get(paletteInfoPropertyKey) + .slantHolder() + .calculateSlant(samplerCache.get(x, z, world, biomeProvider), fdX, y, fdZ); + } + public SamplerProvider samplerProvider() { return samplerCache; } From f896a9a27832ad92ee067746f153335befd3ffb1 Mon Sep 17 00:00:00 2001 From: Astrash Date: Tue, 3 Oct 2023 11:01:50 +1100 Subject: [PATCH 28/83] Bump noise3d addon minor version --- common/addons/chunk-generator-noise-3d/build.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common/addons/chunk-generator-noise-3d/build.gradle.kts b/common/addons/chunk-generator-noise-3d/build.gradle.kts index 685cc848c..193c9f00b 100644 --- a/common/addons/chunk-generator-noise-3d/build.gradle.kts +++ b/common/addons/chunk-generator-noise-3d/build.gradle.kts @@ -1,4 +1,4 @@ -version = version("1.1.0") +version = version("1.2.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) From f1ea8074de8af6c01bfcd361019890461eb7acc2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Tue, 3 Oct 2023 11:54:04 -0600 Subject: [PATCH 29/83] config-ore-v2 --- common/addons/config-ore-v2/LICENSE | 21 ++ common/addons/config-ore-v2/README.md | 3 + common/addons/config-ore-v2/build.gradle.kts | 11 + .../com/dfsek/terra/addons/ore/OreAddon.java | 33 +++ .../dfsek/terra/addons/ore/OreConfigType.java | 37 ++++ .../dfsek/terra/addons/ore/OreFactory.java | 24 +++ .../dfsek/terra/addons/ore/OreTemplate.java | 80 ++++++++ .../terra/addons/ore/ores/VanillaOre.java | 188 ++++++++++++++++++ .../src/main/resources/terra.addon.yml | 12 ++ 9 files changed, 409 insertions(+) create mode 100644 common/addons/config-ore-v2/LICENSE create mode 100644 common/addons/config-ore-v2/README.md create mode 100644 common/addons/config-ore-v2/build.gradle.kts create mode 100644 common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java create mode 100644 common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java create mode 100644 common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java create mode 100644 common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java create mode 100644 common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java create mode 100644 common/addons/config-ore-v2/src/main/resources/terra.addon.yml diff --git a/common/addons/config-ore-v2/LICENSE b/common/addons/config-ore-v2/LICENSE new file mode 100644 index 000000000..64c1cd516 --- /dev/null +++ b/common/addons/config-ore-v2/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2020-2021 Polyhedral Development + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/common/addons/config-ore-v2/README.md b/common/addons/config-ore-v2/README.md new file mode 100644 index 000000000..1b72835ea --- /dev/null +++ b/common/addons/config-ore-v2/README.md @@ -0,0 +1,3 @@ +# config-ore + +Registers the default configuration for Terra Ores, `ORE`. \ No newline at end of file diff --git a/common/addons/config-ore-v2/build.gradle.kts b/common/addons/config-ore-v2/build.gradle.kts new file mode 100644 index 000000000..3799c6be1 --- /dev/null +++ b/common/addons/config-ore-v2/build.gradle.kts @@ -0,0 +1,11 @@ +version = version("2.0.0") + +dependencies { + compileOnlyApi(project(":common:addons:manifest-addon-loader")) + implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) + testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) +} + +tasks.named("shadowJar") { + relocate("net.jafama", "com.dfsek.terra.addons.ore.lib.jafama") +} diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java new file mode 100644 index 000000000..4e6f1751b --- /dev/null +++ b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore; + +import com.dfsek.terra.addons.manifest.api.AddonInitializer; +import com.dfsek.terra.api.Platform; +import com.dfsek.terra.api.addon.BaseAddon; +import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent; +import com.dfsek.terra.api.event.functional.FunctionalEventHandler; +import com.dfsek.terra.api.inject.annotations.Inject; + + +public class OreAddon implements AddonInitializer { + @Inject + private Platform platform; + + @Inject + private BaseAddon addon; + + @Override + public void initialize() { + platform.getEventManager() + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> event.getPack().registerConfigType(new OreConfigType(), addon.key("ORE"), 1)) + .failThrough(); + } +} diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java new file mode 100644 index 000000000..2bdc87bdd --- /dev/null +++ b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore; + +import com.dfsek.terra.api.Platform; +import com.dfsek.terra.api.config.ConfigFactory; +import com.dfsek.terra.api.config.ConfigPack; +import com.dfsek.terra.api.config.ConfigType; +import com.dfsek.terra.api.structure.Structure; +import com.dfsek.terra.api.util.reflection.TypeKey; + + +public class OreConfigType implements ConfigType { + public static final TypeKey ORE_TYPE_TOKEN = new TypeKey<>() { + }; + private final OreFactory factory = new OreFactory(); + + @Override + public OreTemplate getTemplate(ConfigPack pack, Platform platform) { + return new OreTemplate(); + } + + @Override + public ConfigFactory getFactory() { + return factory; + } + + @Override + public TypeKey getTypeKey() { + return ORE_TYPE_TOKEN; + } +} diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java new file mode 100644 index 000000000..9d8b1055a --- /dev/null +++ b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore; + +import com.dfsek.terra.addons.ore.ores.VanillaOre; +import com.dfsek.terra.api.Platform; +import com.dfsek.terra.api.block.state.BlockState; +import com.dfsek.terra.api.config.ConfigFactory; +import com.dfsek.terra.api.structure.Structure; + + +public class OreFactory implements ConfigFactory { + @Override + public VanillaOre build(OreTemplate config, Platform platform) { + BlockState m = config.getMaterial(); + return new VanillaOre(m, config.getSize(), config.getReplaceable(), config.doPhysics(), config.isExposed(), + config.getMaterialOverrides()); + } +} diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java new file mode 100644 index 000000000..8bfbc82d3 --- /dev/null +++ b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore; + +import com.dfsek.tectonic.api.config.template.annotations.Default; +import com.dfsek.tectonic.api.config.template.annotations.Description; +import com.dfsek.tectonic.api.config.template.annotations.Final; +import com.dfsek.tectonic.api.config.template.annotations.Value; + +import java.util.HashMap; +import java.util.Map; + +import com.dfsek.terra.api.block.BlockType; +import com.dfsek.terra.api.block.state.BlockState; +import com.dfsek.terra.api.config.AbstractableTemplate; +import com.dfsek.terra.api.config.meta.Meta; +import com.dfsek.terra.api.util.collection.MaterialSet; + + +@SuppressWarnings({ "unused", "FieldMayBeFinal" }) +public class OreTemplate implements AbstractableTemplate { + @Value("id") + @Final + private String id; + + @Value("material") + private @Meta BlockState material; + + @Value("material-overrides") + @Default + private @Meta Map<@Meta BlockType, @Meta BlockState> materials = new HashMap<>(); + + @Value("replace") + private @Meta MaterialSet replaceable; + + @Value("physics") + @Default + private @Meta boolean physics = false; + + @Value("size") + private @Meta double size; + + @Value("exposed") + @Default + @Description("The chance that ore blocks bordering air will be exposed. 0 = 0%, 1 = 100%") + private @Meta double exposed = 1; + + public boolean doPhysics() { + return physics; + } + + public double getSize() { + return size; + } + + public BlockState getMaterial() { + return material; + } + + public MaterialSet getReplaceable() { + return replaceable; + } + + public String getID() { + return id; + } + + public Map getMaterialOverrides() { + return materials; + } + + public double isExposed() { + return exposed; + } +} diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java new file mode 100644 index 000000000..32f5c7c22 --- /dev/null +++ b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore.ores; + +import net.jafama.FastMath; + +import java.util.BitSet; +import java.util.Map; +import java.util.Random; + +import com.dfsek.terra.api.block.BlockType; +import com.dfsek.terra.api.block.state.BlockState; +import com.dfsek.terra.api.structure.Structure; +import com.dfsek.terra.api.util.Rotation; +import com.dfsek.terra.api.util.collection.MaterialSet; +import com.dfsek.terra.api.util.vector.Vector3Int; +import com.dfsek.terra.api.world.WritableWorld; + + +public class VanillaOre implements Structure { + + private final BlockState material; + + private final double size; + private final MaterialSet replaceable; + private final boolean applyGravity; + private final double exposed; + private final Map materials; + + public VanillaOre(BlockState material, double size, MaterialSet replaceable, boolean applyGravity, + double exposed, Map materials) { + this.material = material; + this.size = size; + this.replaceable = replaceable; + this.applyGravity = applyGravity; + this.exposed = exposed; + this.materials = materials; + } + + protected static boolean shouldNotDiscard(Random random, double chance) { + if(chance <= 0.0F) { + return true; + } else if(chance >= 1.0F) { + return false; + } else { + return random.nextFloat() >= chance; + } + } + + public static double lerp(double t, double v0, double v1) { + return v0 + t * (v1 - v0); + } + + @Override + public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation) { + float f = random.nextFloat() * (float) Math.PI; + double g = size / 8.0F; + int i = (int) FastMath.ceil((size / 16.0F * 2.0F + 1.0F) / 2.0F); + double startX = (double) location.getX() + FastMath.sin(f) * g; + double endX = (double) location.getX() - FastMath.sin(f) * g; + double startZ = (double) location.getZ() + FastMath.cos(f) * g; + double endZ = (double) location.getZ() - FastMath.cos(f) * g; + double startY = location.getY() + random.nextInt(3) - 2; + double endY = location.getY() + random.nextInt(3) - 2; + int x = (int) (location.getX() - FastMath.ceil(g) - i); + int y = location.getY() - 2 - i; + int z = (int) (location.getZ() - FastMath.ceil(g) - i); + int horizontalSize = (int) (2 * (FastMath.ceil(g) + i)); + int verticalSize = 2 * (2 + i); + + int i1 = 0; + BitSet bitSet = new BitSet(horizontalSize * verticalSize * horizontalSize); + + int j1 = (int) size; + double[] ds = new double[j1 * 4]; + + for(int k1 = 0; k1 < j1; ++k1) { + float f1 = (float) k1 / (float) j1; + double d1 = lerp(f1, startX, endX); + double e1 = lerp(f1, startY, endY); + double g1 = lerp(f1, startZ, endZ); + double h1 = random.nextDouble() * (double) j1 / 16.0; + double l1 = ((FastMath.sin((float) Math.PI * f1) + 1.0F) * h1 + 1.0) / 2.0; + ds[k1 * 4] = d1; + ds[k1 * 4 + 1] = e1; + ds[k1 * 4 + 2] = g1; + ds[k1 * 4 + 3] = l1; + } + + for(int k1 = 0; k1 < j1 - 1; ++k1) { + if(!(ds[k1 * 4 + 3] <= 0.0)) { + for(int m1 = k1 + 1; m1 < j1; ++m1) { + if(!(ds[m1 * 4 + 3] <= 0.0)) { + double d1 = ds[k1 * 4] - ds[m1 * 4]; + double e1 = ds[k1 * 4 + 1] - ds[m1 * 4 + 1]; + double g1 = ds[k1 * 4 + 2] - ds[m1 * 4 + 2]; + double h1 = ds[k1 * 4 + 3] - ds[m1 * 4 + 3]; + if(h1 * h1 > d1 * d1 + e1 * e1 + g1 * g1) { + if(h1 > 0.0) { + ds[m1 * 4 + 3] = -1.0; + } else { + ds[k1 * 4 + 3] = -1.0; + } + } + } + } + } + } + + for(int m1 = 0; m1 < j1; ++m1) { + double d1 = ds[m1 * 4 + 3]; + if(!(d1 < 0.0)) { + double e1 = ds[m1 * 4]; + double g1 = ds[m1 * 4 + 1]; + double h1 = ds[m1 * 4 + 2]; + int n1 = (int) FastMath.max(FastMath.floor(e1 - d1), x); + int o1 = (int) FastMath.max(FastMath.floor(g1 - d1), y); + int p1 = (int) FastMath.max(FastMath.floor(h1 - d1), z); + int q1 = (int) FastMath.max(FastMath.floor(e1 + d1), n1); + int r1 = (int) FastMath.max(FastMath.floor(g1 + d1), o1); + int s1 = (int) FastMath.max(FastMath.floor(h1 + d1), p1); + + for(int t1 = n1; t1 <= q1; ++t1) { + double u1 = ((double) t1 + 0.5 - e1) / d1; + if(u1 * u1 < 1.0) { + for(int v1 = o1; v1 <= r1; ++v1) { + double w1 = ((double) v1 + 0.5 - g1) / d1; + if(u1 * u1 + w1 * w1 < 1.0) { + for(int aa = p1; aa <= s1; ++aa) { + double ab = ((double) aa + 0.5 - h1) / d1; + if(u1 * u1 + w1 * w1 + ab * ab < 1.0 && !(v1 < world.getMinHeight() || v1 >= world.getMaxHeight())) { + int ac = t1 - x + (v1 - y) * horizontalSize + (aa - z) * horizontalSize * verticalSize; + if(!bitSet.get(ac)) { + bitSet.set(ac); + + BlockType block = world.getBlockState(x, y, z).getBlockType(); + + if(shouldPlace(block, random, world, t1, v1, aa)) { + world.setBlockState(t1, v1, aa, getMaterial(block), isApplyGravity()); + ++i1; + break; + } + } + } + } + } + } + } + } + } + } + + + return i1 > 0; + } + + public boolean shouldPlace(BlockType type, Random random, WritableWorld world, int x, int y, int z) { + if(!getReplaceable().contains(type)) { + return false; + } else if(shouldNotDiscard(random, exposed)) { + return true; + } else { + return !(world.getBlockState(x, y, z - 1).isAir() || + world.getBlockState(x, y, z + 1).isAir() || + world.getBlockState(x, y - 1, z).isAir() || + world.getBlockState(x, y + 1, z).isAir() || + world.getBlockState(x - 1, y, z).isAir() || + world.getBlockState(x + 1, y, z).isAir()); + } + } + + public BlockState getMaterial(BlockType replace) { + return materials.getOrDefault(replace, material); + } + + public MaterialSet getReplaceable() { + return replaceable; + } + + public boolean isApplyGravity() { + return applyGravity; + } +} diff --git a/common/addons/config-ore-v2/src/main/resources/terra.addon.yml b/common/addons/config-ore-v2/src/main/resources/terra.addon.yml new file mode 100644 index 000000000..7edad8d07 --- /dev/null +++ b/common/addons/config-ore-v2/src/main/resources/terra.addon.yml @@ -0,0 +1,12 @@ +schema-version: 1 +contributors: + - Terra contributors +id: config-ore-v2 +version: @VERSION@ +entrypoints: + - "com.dfsek.terra.addons.ore.OreAddon" +website: + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org +license: MIT License \ No newline at end of file From 200281f1401c9a324384182acd3e9ee05bf6aa6c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Tue, 3 Oct 2023 11:58:25 -0600 Subject: [PATCH 30/83] dep orev1 --- .../src/main/java/com/dfsek/terra/addons/ore/OreAddon.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java index 4e6f1751b..7ac64ef2b 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java @@ -14,8 +14,13 @@ import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent; import com.dfsek.terra.api.event.functional.FunctionalEventHandler; import com.dfsek.terra.api.inject.annotations.Inject; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + public class OreAddon implements AddonInitializer { + private static final Logger logger = LoggerFactory.getLogger(OreAddon.class); + @Inject private Platform platform; @@ -29,5 +34,7 @@ public class OreAddon implements AddonInitializer { .register(addon, ConfigPackPreLoadEvent.class) .then(event -> event.getPack().registerConfigType(new OreConfigType(), addon.key("ORE"), 1)) .failThrough(); + + logger.warn("The ore-config addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the ore-config-v2 addon for future pack development instead."); } } From 0c1a6efc72ba077a6e1f0b1691229260d7e81f83 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Tue, 3 Oct 2023 19:42:15 -0600 Subject: [PATCH 31/83] refractor classes --- .../main/java/com/dfsek/terra/addons/ore/{ => v2}/OreAddon.java | 0 .../java/com/dfsek/terra/addons/ore/{ => v2}/OreConfigType.java | 0 .../java/com/dfsek/terra/addons/ore/{ => v2}/OreFactory.java | 0 .../java/com/dfsek/terra/addons/ore/{ => v2}/OreTemplate.java | 0 .../com/dfsek/terra/addons/ore/{ => v2}/ores/VanillaOre.java | 0 common/addons/config-ore-v2/src/main/resources/terra.addon.yml | 2 +- 6 files changed, 1 insertion(+), 1 deletion(-) rename common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/{ => v2}/OreAddon.java (100%) rename common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/{ => v2}/OreConfigType.java (100%) rename common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/{ => v2}/OreFactory.java (100%) rename common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/{ => v2}/OreTemplate.java (100%) rename common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/{ => v2}/ores/VanillaOre.java (100%) diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreAddon.java similarity index 100% rename from common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java rename to common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreAddon.java diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreConfigType.java similarity index 100% rename from common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java rename to common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreConfigType.java diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreFactory.java similarity index 100% rename from common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java rename to common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreFactory.java diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java similarity index 100% rename from common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java rename to common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java similarity index 100% rename from common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java rename to common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java diff --git a/common/addons/config-ore-v2/src/main/resources/terra.addon.yml b/common/addons/config-ore-v2/src/main/resources/terra.addon.yml index 7edad8d07..72f4b24b9 100644 --- a/common/addons/config-ore-v2/src/main/resources/terra.addon.yml +++ b/common/addons/config-ore-v2/src/main/resources/terra.addon.yml @@ -4,7 +4,7 @@ contributors: id: config-ore-v2 version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.ore.OreAddon" + - "com.dfsek.terra.addons.ore.v2.OreAddon" website: issues: https://github.com/PolyhedralDev/Terra/issues source: https://github.com/PolyhedralDev/Terra From 84898a7a6beb6f545c9e3754e75b153fb3428037 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Tue, 3 Oct 2023 20:03:46 -0600 Subject: [PATCH 32/83] fixes --- common/addons/config-ore-v2/build.gradle.kts | 2 +- .../src/main/java/com/dfsek/terra/addons/ore/v2/OreAddon.java | 2 +- .../java/com/dfsek/terra/addons/ore/v2/OreConfigType.java | 2 +- .../main/java/com/dfsek/terra/addons/ore/v2/OreFactory.java | 4 ++-- .../main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java | 2 +- .../java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java | 2 +- 6 files changed, 7 insertions(+), 7 deletions(-) diff --git a/common/addons/config-ore-v2/build.gradle.kts b/common/addons/config-ore-v2/build.gradle.kts index 3799c6be1..d575f43d3 100644 --- a/common/addons/config-ore-v2/build.gradle.kts +++ b/common/addons/config-ore-v2/build.gradle.kts @@ -1,4 +1,4 @@ -version = version("2.0.0") +version = version("1.0.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreAddon.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreAddon.java index 4e6f1751b..9a3d3d05b 100644 --- a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreAddon.java +++ b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreAddon.java @@ -5,7 +5,7 @@ * reference the LICENSE file in this module's root directory. */ -package com.dfsek.terra.addons.ore; +package com.dfsek.terra.addons.ore.v2; import com.dfsek.terra.addons.manifest.api.AddonInitializer; import com.dfsek.terra.api.Platform; diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreConfigType.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreConfigType.java index 2bdc87bdd..dd9c74f12 100644 --- a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreConfigType.java +++ b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreConfigType.java @@ -5,7 +5,7 @@ * reference the LICENSE file in this module's root directory. */ -package com.dfsek.terra.addons.ore; +package com.dfsek.terra.addons.ore.v2; import com.dfsek.terra.api.Platform; import com.dfsek.terra.api.config.ConfigFactory; diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreFactory.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreFactory.java index 9d8b1055a..65b3f5d65 100644 --- a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreFactory.java +++ b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreFactory.java @@ -5,9 +5,9 @@ * reference the LICENSE file in this module's root directory. */ -package com.dfsek.terra.addons.ore; +package com.dfsek.terra.addons.ore.v2; -import com.dfsek.terra.addons.ore.ores.VanillaOre; +import com.dfsek.terra.addons.ore.v2.ores.VanillaOre; import com.dfsek.terra.api.Platform; import com.dfsek.terra.api.block.state.BlockState; import com.dfsek.terra.api.config.ConfigFactory; diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java index 8bfbc82d3..4fe711d62 100644 --- a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java +++ b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java @@ -5,7 +5,7 @@ * reference the LICENSE file in this module's root directory. */ -package com.dfsek.terra.addons.ore; +package com.dfsek.terra.addons.ore.v2; import com.dfsek.tectonic.api.config.template.annotations.Default; import com.dfsek.tectonic.api.config.template.annotations.Description; diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java index 32f5c7c22..0ea41d823 100644 --- a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java +++ b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java @@ -5,7 +5,7 @@ * reference the LICENSE file in this module's root directory. */ -package com.dfsek.terra.addons.ore.ores; +package com.dfsek.terra.addons.ore.v2.ores; import net.jafama.FastMath; From d71f7d4c36d494112e76bae5e51467a6138827ff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Tue, 3 Oct 2023 21:03:44 -0600 Subject: [PATCH 33/83] clarify value and change default --- .../main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java index 4fe711d62..fa8f49b9e 100644 --- a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java +++ b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java @@ -47,8 +47,8 @@ public class OreTemplate implements AbstractableTemplate { @Value("exposed") @Default - @Description("The chance that ore blocks bordering air will be exposed. 0 = 0%, 1 = 100%") - private @Meta double exposed = 1; + @Description("The chance that ore blocks bordering air will be discarded as candidates for ore. 0 = 0%, 1 = 100%") + private @Meta double exposed = 0.0f; public boolean doPhysics() { return physics; From b5e7c7c1127195a73e09494002e38ce9d14a2435 Mon Sep 17 00:00:00 2001 From: Astrash Date: Tue, 10 Oct 2023 09:44:53 +1100 Subject: [PATCH 34/83] Fix TOP locator --- .../dfsek/terra/addons/feature/locator/locators/TopLocator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/TopLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/TopLocator.java index f9e8e0ea6..7706f1ee1 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/TopLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/TopLocator.java @@ -22,7 +22,7 @@ public class TopLocator implements Locator { @Override public BinaryColumn getSuitableCoordinates(Column column) { - for(int y : search) { + for(int y = search.getMax(); y >= search.getMin(); y--) { if(column.getBlock(y).isAir() && !column.getBlock(y - 1).isAir()) { return new BinaryColumn(y, y + 1, yi -> true); } From abd83e82782f5cdefd0a3d3abb4dfaf2b6d19a07 Mon Sep 17 00:00:00 2001 From: Astrashh Date: Tue, 10 Oct 2023 11:35:26 +1100 Subject: [PATCH 35/83] Add number predicate addon (#412) --- .../config-number-predicate/build.gradle.kts | 13 ++++++ .../DoublePredicateLoader.java | 34 +++++++++++++++ .../numberpredicate/NumberPredicateAddon.java | 41 +++++++++++++++++++ .../src/main/resources/terra.addon.yml | 12 ++++++ 4 files changed, 100 insertions(+) create mode 100644 common/addons/config-number-predicate/build.gradle.kts create mode 100644 common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/DoublePredicateLoader.java create mode 100644 common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java create mode 100644 common/addons/config-number-predicate/src/main/resources/terra.addon.yml diff --git a/common/addons/config-number-predicate/build.gradle.kts b/common/addons/config-number-predicate/build.gradle.kts new file mode 100644 index 000000000..2ea535016 --- /dev/null +++ b/common/addons/config-number-predicate/build.gradle.kts @@ -0,0 +1,13 @@ +import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar + +version = version("1.0.0") + +dependencies { + compileOnlyApi(project(":common:addons:manifest-addon-loader")) + api("com.dfsek", "paralithic", Versions.Libraries.paralithic) +} + + +tasks.named("shadowJar") { + relocate("com.dfsek.paralithic", "com.dfsek.terra.addons.numberpredicate.lib.paralithic") +} diff --git a/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/DoublePredicateLoader.java b/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/DoublePredicateLoader.java new file mode 100644 index 000000000..4b9bf789e --- /dev/null +++ b/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/DoublePredicateLoader.java @@ -0,0 +1,34 @@ +package com.dfsek.terra.addons.numberpredicate; + +import com.dfsek.paralithic.Expression; +import com.dfsek.paralithic.eval.parser.Parser; +import com.dfsek.paralithic.eval.parser.Scope; +import com.dfsek.paralithic.eval.tokenizer.ParseException; +import com.dfsek.tectonic.api.depth.DepthTracker; +import com.dfsek.tectonic.api.exception.LoadException; +import com.dfsek.tectonic.api.loader.ConfigLoader; +import com.dfsek.tectonic.api.loader.type.TypeLoader; +import org.jetbrains.annotations.NotNull; + +import java.lang.reflect.AnnotatedType; +import java.util.function.DoublePredicate; + + +public class DoublePredicateLoader implements TypeLoader { + @Override + public DoublePredicate load(@NotNull AnnotatedType annotatedType, @NotNull Object o, @NotNull ConfigLoader configLoader, + DepthTracker depthTracker) throws LoadException { + if (o instanceof String expressionString) { + Scope scope = new Scope(); + scope.addInvocationVariable("value"); + try { + Expression expression = new Parser().parse(expressionString, scope); + return d -> expression.evaluate(d) != 0; // Paralithic expressions treat '!= 0' as true + } catch(ParseException e) { + throw new LoadException("Failed to parse double predicate expression", e, depthTracker); + } + } else { + throw new LoadException("Double predicates must be defined as a string. E.g. 'value > 3'", depthTracker); + } + } +} diff --git a/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java b/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java new file mode 100644 index 000000000..e81da028d --- /dev/null +++ b/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.numberpredicate; + +import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; + +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.function.DoublePredicate; +import java.util.function.Supplier; + +import com.dfsek.terra.addons.manifest.api.AddonInitializer; +import com.dfsek.terra.api.Platform; +import com.dfsek.terra.api.addon.BaseAddon; +import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent; +import com.dfsek.terra.api.event.functional.FunctionalEventHandler; +import com.dfsek.terra.api.inject.annotations.Inject; + +public class NumberPredicateAddon implements AddonInitializer { + + @Inject + private Platform plugin; + + @Inject + private BaseAddon addon; + + @Override + public void initialize() { + plugin.getEventManager() + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> event.getPack().applyLoader(DoublePredicate.class, new DoublePredicateLoader())) + .priority(50) + .failThrough(); + } +} diff --git a/common/addons/config-number-predicate/src/main/resources/terra.addon.yml b/common/addons/config-number-predicate/src/main/resources/terra.addon.yml new file mode 100644 index 000000000..e4014b3a3 --- /dev/null +++ b/common/addons/config-number-predicate/src/main/resources/terra.addon.yml @@ -0,0 +1,12 @@ +schema-version: 1 +contributors: + - Terra contributors +id: config-number-predicate +version: @VERSION@ +entrypoints: + - "com.dfsek.terra.addons.numberpredicate.NumberPredicateAddon" +website: + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org +license: MIT License \ No newline at end of file From 47f531089ebbeaa199b5a3dd336b3ef979b6766c Mon Sep 17 00:00:00 2001 From: Astrashh Date: Tue, 10 Oct 2023 11:35:47 +1100 Subject: [PATCH 36/83] Add slant locator (#413) * Add slant locator addon * Bump slant locator noise3d dependency version * Fix slant locator dependency version range * Actually fix slant locator dependency version range --- .../locator-slant-noise-3d/build.gradle.kts | 6 +++ .../feature/locator/slant/SlantLocator.java | 32 ++++++++++++++++ .../locator/slant/SlantLocatorAddon.java | 37 +++++++++++++++++++ .../locator/slant/SlantLocatorTemplate.java | 20 ++++++++++ .../src/main/resources/terra.addon.yml | 14 +++++++ 5 files changed, 109 insertions(+) create mode 100644 common/addons/locator-slant-noise-3d/build.gradle.kts create mode 100644 common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocator.java create mode 100644 common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorAddon.java create mode 100644 common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java create mode 100644 common/addons/locator-slant-noise-3d/src/main/resources/terra.addon.yml diff --git a/common/addons/locator-slant-noise-3d/build.gradle.kts b/common/addons/locator-slant-noise-3d/build.gradle.kts new file mode 100644 index 000000000..b4283bb75 --- /dev/null +++ b/common/addons/locator-slant-noise-3d/build.gradle.kts @@ -0,0 +1,6 @@ +version = version("1.0.0") + +dependencies { + compileOnlyApi(project(":common:addons:manifest-addon-loader")) + compileOnlyApi(project(":common:addons:chunk-generator-noise-3d")) +} diff --git a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocator.java b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocator.java new file mode 100644 index 000000000..732ec540c --- /dev/null +++ b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocator.java @@ -0,0 +1,32 @@ +package com.dfsek.terra.addon.feature.locator.slant; + +import com.dfsek.terra.addons.chunkgenerator.generation.NoiseChunkGenerator3D; +import com.dfsek.terra.api.structure.feature.BinaryColumn; +import com.dfsek.terra.api.structure.feature.Locator; +import com.dfsek.terra.api.world.World; +import com.dfsek.terra.api.world.biome.generation.BiomeProvider; +import com.dfsek.terra.api.world.chunk.generation.util.Column; + +import java.util.function.DoublePredicate; + + +public class SlantLocator implements Locator { + + private final DoublePredicate predicate; + + public SlantLocator(DoublePredicate predicate) { + this.predicate = predicate; + } + + @Override + public BinaryColumn getSuitableCoordinates(Column column) { + return column.newBinaryColumn(y -> { + int x = column.getX(); + int z = column.getZ(); + World world = column.getWorld(); + NoiseChunkGenerator3D generator = (NoiseChunkGenerator3D) world.getGenerator(); + BiomeProvider biomeProvider = world.getBiomeProvider(); + return predicate.test(generator.getSlant(x, y, z, world, biomeProvider)); + }); + } +} diff --git a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorAddon.java b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorAddon.java new file mode 100644 index 000000000..78df933d8 --- /dev/null +++ b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorAddon.java @@ -0,0 +1,37 @@ +package com.dfsek.terra.addon.feature.locator.slant; + +import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; + +import com.dfsek.terra.addons.manifest.api.AddonInitializer; +import com.dfsek.terra.api.Platform; +import com.dfsek.terra.api.addon.BaseAddon; +import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent; +import com.dfsek.terra.api.event.functional.FunctionalEventHandler; +import com.dfsek.terra.api.inject.annotations.Inject; +import com.dfsek.terra.api.structure.feature.Locator; +import com.dfsek.terra.api.util.reflection.TypeKey; + +import java.util.function.Supplier; + + +public class SlantLocatorAddon implements AddonInitializer { + + public static final TypeKey>> LOCATOR_TOKEN = new TypeKey<>() { + }; + + @Inject + private Platform platform; + + @Inject + private BaseAddon addon; + + @Override + public void initialize() { + platform.getEventManager() + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .priority(1) + .then(event -> event.getPack().getOrCreateRegistry(LOCATOR_TOKEN).register(addon.key("SLANT"), SlantLocatorTemplate::new)) + .failThrough(); + } +} diff --git a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java new file mode 100644 index 000000000..82beba1dc --- /dev/null +++ b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java @@ -0,0 +1,20 @@ +package com.dfsek.terra.addon.feature.locator.slant; + +import com.dfsek.tectonic.api.config.template.annotations.Value; +import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; + +import com.dfsek.terra.api.structure.feature.Locator; + +import java.util.function.DoublePredicate; + + +public class SlantLocatorTemplate implements ObjectTemplate { + + @Value("condition") + private DoublePredicate predicate; + + @Override + public Locator get() { + return new SlantLocator(predicate); + } +} diff --git a/common/addons/locator-slant-noise-3d/src/main/resources/terra.addon.yml b/common/addons/locator-slant-noise-3d/src/main/resources/terra.addon.yml new file mode 100644 index 000000000..8a7ef4ad9 --- /dev/null +++ b/common/addons/locator-slant-noise-3d/src/main/resources/terra.addon.yml @@ -0,0 +1,14 @@ +schema-version: 1 +contributors: + - Terra contributors +id: locator-slant-noise-3d +version: @VERSION@ +entrypoints: + - "com.dfsek.terra.addon.feature.locator.slant.SlantLocatorAddon" +website: + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org +license: MIT License +depends: + chunk-generator-noise-3d: "[1.2.0,2.0.0)" \ No newline at end of file From 94854f2bdb7cbd76ad895e2188e8e02e5e2e8b68 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Sat, 14 Oct 2023 15:55:43 -0600 Subject: [PATCH 37/83] update versions --- buildSrc/src/main/kotlin/Versions.kt | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/buildSrc/src/main/kotlin/Versions.kt b/buildSrc/src/main/kotlin/Versions.kt index 85209d089..8d2638cca 100644 --- a/buildSrc/src/main/kotlin/Versions.kt +++ b/buildSrc/src/main/kotlin/Versions.kt @@ -1,7 +1,7 @@ object Versions { object Libraries { - const val tectonic = "4.2.0" - const val paralithic = "0.7.0" + const val tectonic = "4.2.1" + const val paralithic = "0.7.1" const val strata = "1.3.2" const val cloud = "1.8.4" @@ -14,14 +14,14 @@ object Versions { const val apacheText = "1.10.0" const val jafama = "2.3.2" const val apacheIO = "2.14.0" - const val guava = "32.1.2-jre" + const val guava = "32.1.3-jre" const val asm = "9.5" const val snakeYml = "2.2" } } object Fabric { - const val fabricAPI = "0.89.3+${Mod.minecraft}" + const val fabricAPI = "0.90.0+${Mod.minecraft}" } object Quilt { @@ -33,8 +33,8 @@ object Versions { const val mixin = "0.12.5+mixin.0.8.5" const val minecraft = "1.20.2" - const val yarn = "$minecraft+build.2" - const val fabricLoader = "0.14.22" + const val yarn = "$minecraft+build.4" + const val fabricLoader = "0.14.23" const val architecuryLoom = "1.3.357" const val architecturyPlugin = "3.4.146" From 491716012357302d42512ce179b5d9c1852ece60 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB?= Date: Tue, 17 Oct 2023 18:32:00 -0600 Subject: [PATCH 38/83] Update README.md --- common/addons/config-ore-v2/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/common/addons/config-ore-v2/README.md b/common/addons/config-ore-v2/README.md index 1b72835ea..9171511a3 100644 --- a/common/addons/config-ore-v2/README.md +++ b/common/addons/config-ore-v2/README.md @@ -1,3 +1,3 @@ -# config-ore +# config-ore-v2 -Registers the default configuration for Terra Ores, `ORE`. \ No newline at end of file +Registers the default configuration for Terra Ores, `ORE`. From c8f2871aaa201093d0c8c7b093c091440fa74318 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB?= Date: Tue, 17 Oct 2023 20:59:27 -0600 Subject: [PATCH 39/83] Update build.gradle.kts --- platforms/bukkit/build.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/platforms/bukkit/build.gradle.kts b/platforms/bukkit/build.gradle.kts index c72bae196..455c963ec 100644 --- a/platforms/bukkit/build.gradle.kts +++ b/platforms/bukkit/build.gradle.kts @@ -4,7 +4,7 @@ plugins { repositories { maven("https://s01.oss.sonatype.org/content/repositories/snapshots/") { - name = "sonatype" + name = "Sonatype" } } From 9f4a8e06e18e500e3dc7a4d26360fc79dffad546 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB?= Date: Tue, 17 Oct 2023 21:00:28 -0600 Subject: [PATCH 40/83] Update DependencyConfig.kt --- buildSrc/src/main/kotlin/DependencyConfig.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/buildSrc/src/main/kotlin/DependencyConfig.kt b/buildSrc/src/main/kotlin/DependencyConfig.kt index fd87495a7..82b3b206b 100644 --- a/buildSrc/src/main/kotlin/DependencyConfig.kt +++ b/buildSrc/src/main/kotlin/DependencyConfig.kt @@ -49,7 +49,7 @@ fun Project.configureDependencies() { name = "JitPack" } maven("https://nexuslite.gcnt.net/repos/other/") { - name = "devmart-other" + name = "GCNT" } } @@ -61,4 +61,4 @@ fun Project.configureDependencies() { compileOnly("com.google.guava:guava:30.0-jre") testImplementation("com.google.guava:guava:30.0-jre") } -} \ No newline at end of file +} From d3a9b578722b50b5f931c5bbf2978f6df0e404a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Wed, 18 Oct 2023 19:53:59 -0600 Subject: [PATCH 41/83] disable quilt --- buildSrc/src/main/kotlin/Versions.kt | 24 +++++++++---------- .../dfsek/terra/fabric/FabricPlatform.java | 2 +- platforms/mixin-common/README.md | 2 +- platforms/mixin-common/build.gradle.kts | 3 ++- platforms/mixin-lifecycle/README.md | 2 +- platforms/mixin-lifecycle/build.gradle.kts | 3 ++- .../terra/lifecycle/LifecyclePlatform.java | 4 ++-- ...d.gradle.kts => build.gradle.kts.disabled} | 0 .../com/dfsek/terra/quilt/QuiltPlatform.java | 2 +- 9 files changed, 22 insertions(+), 20 deletions(-) rename platforms/quilt/{build.gradle.kts => build.gradle.kts.disabled} (100%) diff --git a/buildSrc/src/main/kotlin/Versions.kt b/buildSrc/src/main/kotlin/Versions.kt index 0982994a4..6a56ded4c 100644 --- a/buildSrc/src/main/kotlin/Versions.kt +++ b/buildSrc/src/main/kotlin/Versions.kt @@ -23,11 +23,11 @@ object Versions { object Fabric { const val fabricAPI = "0.90.0+${Mod.minecraft}" } - - object Quilt { - const val quiltLoader = "0.20.2" - const val fabricApi = "7.3.1+0.89.3-1.20.1" - } +// +// object Quilt { +// const val quiltLoader = "0.20.2" +// const val fabricApi = "7.3.1+0.89.3-1.20.1" +// } object Mod { const val mixin = "0.12.5+mixin.0.8.5" @@ -57,13 +57,13 @@ object Versions { const val runPaper = "2.2.0" const val paperWeight = "1.5.6" } - - object Sponge { - const val sponge = "9.0.0-SNAPSHOT" - const val mixin = "0.8.2" - const val minecraft = "1.17.1" - } - +// +// object Sponge { +// const val sponge = "9.0.0-SNAPSHOT" +// const val mixin = "0.8.2" +// const val minecraft = "1.17.1" +// } +// object CLI { const val nbt = "6.1" const val logback = "1.4.11" diff --git a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricPlatform.java b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricPlatform.java index 1501b736d..da44b168e 100644 --- a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricPlatform.java +++ b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricPlatform.java @@ -33,7 +33,7 @@ public class FabricPlatform extends LifecyclePlatform { @Override protected Collection getPlatformMods() { return FabricLoader.getInstance().getAllMods().stream().flatMap( - mod -> parseModData(mod.getMetadata().getId(), mod.getMetadata().getVersion().getFriendlyString())).collect( + mod -> parseModData(mod.getMetadata().getId(), mod.getMetadata().getVersion().getFriendlyString(), "fabric")).collect( Collectors.toList()); } diff --git a/platforms/mixin-common/README.md b/platforms/mixin-common/README.md index 0c411a1bf..f252941a2 100644 --- a/platforms/mixin-common/README.md +++ b/platforms/mixin-common/README.md @@ -1,4 +1,4 @@ # mixin-common -This project contains mixins shared between Forge, Fabric and Quilt, as +This project contains mixins shared between Forge, Fabric and formerly Quilt, as well as glue code. \ No newline at end of file diff --git a/platforms/mixin-common/build.gradle.kts b/platforms/mixin-common/build.gradle.kts index 49c2f5188..fb73717b1 100644 --- a/platforms/mixin-common/build.gradle.kts +++ b/platforms/mixin-common/build.gradle.kts @@ -24,7 +24,8 @@ dependencies { } architectury { - common("fabric", "forge", "quilt") +// common("fabric", "forge", "quilt") + common("fabric", "forge") minecraft = Versions.Mod.minecraft } diff --git a/platforms/mixin-lifecycle/README.md b/platforms/mixin-lifecycle/README.md index 6c2c62cba..95d7e8c1c 100644 --- a/platforms/mixin-lifecycle/README.md +++ b/platforms/mixin-lifecycle/README.md @@ -1,3 +1,3 @@ # mixin-lifecycle -This project contains lifecycle mixins shared between Fabric and Quilt. \ No newline at end of file +This project contains lifecycle mixins shared between Fabric and formerly Quilt. \ No newline at end of file diff --git a/platforms/mixin-lifecycle/build.gradle.kts b/platforms/mixin-lifecycle/build.gradle.kts index 1108046f3..142d6868b 100644 --- a/platforms/mixin-lifecycle/build.gradle.kts +++ b/platforms/mixin-lifecycle/build.gradle.kts @@ -41,6 +41,7 @@ tasks { } architectury { - common("fabric", "quilt") +// common("fabric", "quilt") + common("fabric") minecraft = Versions.Mod.minecraft } \ No newline at end of file diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java index bafd0a02e..9e0e081d3 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java @@ -111,11 +111,11 @@ public abstract class LifecyclePlatform extends ModPlatform { return addons; } - protected Stream parseModData(String id, String modVersion) { + protected Stream parseModData(String id, String modVersion, String platform) { if(id.equals("terra") || id.equals("minecraft") || id.equals("java")) return Stream.empty(); try { Version version = Versions.parseVersion(modVersion); - return Stream.of(new EphemeralAddon(version, "quilt:" + id)); + return Stream.of(new EphemeralAddon(version, platform + ":" + id)); } catch(ParseException e) { LOGGER.warn( "Mod {}, version {} does not follow semantic versioning specification, Terra addons will be unable to depend on " + diff --git a/platforms/quilt/build.gradle.kts b/platforms/quilt/build.gradle.kts.disabled similarity index 100% rename from platforms/quilt/build.gradle.kts rename to platforms/quilt/build.gradle.kts.disabled diff --git a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java index 0aa2e4323..32772b349 100644 --- a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java +++ b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java @@ -32,7 +32,7 @@ public class QuiltPlatform extends LifecyclePlatform { @Override protected Collection getPlatformMods() { - return QuiltLoader.getAllMods().stream().flatMap(mod -> parseModData(mod.metadata().id(), mod.metadata().version().raw())).collect( + return QuiltLoader.getAllMods().stream().flatMap(mod -> parseModData(mod.metadata().id(), mod.metadata().version().raw(), "quilt")).collect( Collectors.toList()); } From e80e998cec9d41f5509b60605b8ae5134af6bae6 Mon Sep 17 00:00:00 2001 From: Astrash Date: Fri, 20 Oct 2023 09:32:33 +1100 Subject: [PATCH 42/83] Only log warnings with debug logging --- .../addons/biome/image/ImageBiomeProviderAddon.java | 3 ++- .../addons/biome/pipeline/BiomePipelineAddon.java | 3 ++- .../java/com/dfsek/terra/addons/ore/OreAddon.java | 3 ++- .../java/com/dfsek/terra/api/config/PluginConfig.java | 2 ++ .../java/com/dfsek/terra/config/PluginConfigImpl.java | 11 +++++++++++ 5 files changed, 19 insertions(+), 3 deletions(-) diff --git a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java index ecef73f5d..142b7e034 100644 --- a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java +++ b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java @@ -50,6 +50,7 @@ public class ImageBiomeProviderAddon implements AddonInitializer { () -> new ImageProviderTemplate(event.getPack().getRegistry(Biome.class))); }) .failThrough(); - logger.warn("The biome-provider-image addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the biome-provider-image-v2 addon for future pack development instead."); + if(platform.getTerraConfig().isDebugLog()) + logger.warn("The biome-provider-image addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the biome-provider-image-v2 addon for future pack development instead."); } } diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java index 6765ab3c3..0200f17ad 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java @@ -90,6 +90,7 @@ public class BiomePipelineAddon implements AddonInitializer { event.getPack().applyLoader(BiomeDelegate.class, new BiomeDelegateLoader(biomeRegistry)); }); - logger.warn("The biome-provider-pipeline addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the biome-provider-pipeline-v2 addon for future pack development instead."); + if(platform.getTerraConfig().isDebugLog()) + logger.warn("The biome-provider-pipeline addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the biome-provider-pipeline-v2 addon for future pack development instead."); } } diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java index 7ac64ef2b..ff2ddf54c 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java @@ -35,6 +35,7 @@ public class OreAddon implements AddonInitializer { .then(event -> event.getPack().registerConfigType(new OreConfigType(), addon.key("ORE"), 1)) .failThrough(); - logger.warn("The ore-config addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the ore-config-v2 addon for future pack development instead."); + if(platform.getTerraConfig().isDebugLog()) + logger.warn("The ore-config addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the ore-config-v2 addon for future pack development instead."); } } diff --git a/common/api/src/main/java/com/dfsek/terra/api/config/PluginConfig.java b/common/api/src/main/java/com/dfsek/terra/api/config/PluginConfig.java index 2d540e483..f70b61ff0 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/config/PluginConfig.java +++ b/common/api/src/main/java/com/dfsek/terra/api/config/PluginConfig.java @@ -21,6 +21,8 @@ public interface PluginConfig { boolean isDebugScript(); + boolean isDebugLog(); + int getBiomeSearchResolution(); int getStructureCache(); diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/PluginConfigImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/PluginConfigImpl.java index ee40850d6..810206513 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/PluginConfigImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/PluginConfigImpl.java @@ -51,6 +51,10 @@ public class PluginConfigImpl implements ConfigTemplate, PluginConfig { @Default private boolean debugScript = false; + @Value("debug.log") + @Default + private boolean debugLog = false; + @Value("biome-search-resolution") @Default private int biomeSearch = 4; @@ -91,6 +95,8 @@ public class PluginConfigImpl implements ConfigTemplate, PluginConfig { logger.info("Debug profiler enabled."); if(debugScript) logger.info("Script debug blocks enabled."); + if(debugLog) + logger.info("Debug logging enabled."); } @Override @@ -113,6 +119,11 @@ public class PluginConfigImpl implements ConfigTemplate, PluginConfig { return debugScript; } + @Override + public boolean isDebugLog() { + return debugLog; + } + @Override public int getBiomeSearchResolution() { return biomeSearch; From 4e5b02ef4202e2ee009afaa512dad224002f8b65 Mon Sep 17 00:00:00 2001 From: Astrash Date: Fri, 20 Oct 2023 10:30:25 +1100 Subject: [PATCH 43/83] Pass correct coords for ore block checks --- .../java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java index 0ea41d823..68959678c 100644 --- a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java +++ b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java @@ -138,7 +138,7 @@ public class VanillaOre implements Structure { if(!bitSet.get(ac)) { bitSet.set(ac); - BlockType block = world.getBlockState(x, y, z).getBlockType(); + BlockType block = world.getBlockState(t1, v1, aa).getBlockType(); if(shouldPlace(block, random, world, t1, v1, aa)) { world.setBlockState(t1, v1, aa, getMaterial(block), isApplyGravity()); From 805f99f57a0984eb0c4f1c4f137b49618d554f7a Mon Sep 17 00:00:00 2001 From: Astrash Date: Fri, 20 Oct 2023 10:55:23 +1100 Subject: [PATCH 44/83] Make ore algorithm readable --- .../terra/addons/ore/v2/ores/VanillaOre.java | 161 ++++++++++-------- 1 file changed, 90 insertions(+), 71 deletions(-) diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java index 68959678c..dc77f31ed 100644 --- a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java +++ b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java @@ -58,53 +58,56 @@ public class VanillaOre implements Structure { @Override public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation) { - float f = random.nextFloat() * (float) Math.PI; - double g = size / 8.0F; - int i = (int) FastMath.ceil((size / 16.0F * 2.0F + 1.0F) / 2.0F); - double startX = (double) location.getX() + FastMath.sin(f) * g; - double endX = (double) location.getX() - FastMath.sin(f) * g; - double startZ = (double) location.getZ() + FastMath.cos(f) * g; - double endZ = (double) location.getZ() - FastMath.cos(f) * g; + float randomRadian = random.nextFloat() * (float) Math.PI; + double eigthSize = size / 8.0F; + + // Place points to form a line segment + double startX = (double) location.getX() + FastMath.sin(randomRadian) * eigthSize; + double endX = (double) location.getX() - FastMath.sin(randomRadian) * eigthSize; + + double startZ = (double) location.getZ() + FastMath.cos(randomRadian) * eigthSize; + double endZ = (double) location.getZ() - FastMath.cos(randomRadian) * eigthSize; + double startY = location.getY() + random.nextInt(3) - 2; double endY = location.getY() + random.nextInt(3) - 2; - int x = (int) (location.getX() - FastMath.ceil(g) - i); - int y = location.getY() - 2 - i; - int z = (int) (location.getZ() - FastMath.ceil(g) - i); - int horizontalSize = (int) (2 * (FastMath.ceil(g) + i)); - int verticalSize = 2 * (2 + i); - int i1 = 0; - BitSet bitSet = new BitSet(horizontalSize * verticalSize * horizontalSize); + int sizeInt = (int) size; + double[] points = new double[sizeInt * 4]; - int j1 = (int) size; - double[] ds = new double[j1 * 4]; - - for(int k1 = 0; k1 < j1; ++k1) { - float f1 = (float) k1 / (float) j1; - double d1 = lerp(f1, startX, endX); - double e1 = lerp(f1, startY, endY); - double g1 = lerp(f1, startZ, endZ); - double h1 = random.nextDouble() * (double) j1 / 16.0; - double l1 = ((FastMath.sin((float) Math.PI * f1) + 1.0F) * h1 + 1.0) / 2.0; - ds[k1 * 4] = d1; - ds[k1 * 4 + 1] = e1; - ds[k1 * 4 + 2] = g1; - ds[k1 * 4 + 3] = l1; + // Compute initial point positions and radius + for(int i = 0; i < sizeInt; ++i) { + float t = (float) i / (float) sizeInt; + double xt = lerp(t, startX, endX); + double yt = lerp(t, startY, endY); + double zt = lerp(t, startZ, endZ); + double roll = random.nextDouble() * size / 16.0; + // Taper radius closer to line ends + double radius = ((FastMath.sin((float) Math.PI * t) + 1.0F) * roll + 1.0) / 2.0; + points[i * 4] = xt; + points[i * 4 + 1] = yt; + points[i * 4 + 2] = zt; + points[i * 4 + 3] = radius; } - for(int k1 = 0; k1 < j1 - 1; ++k1) { - if(!(ds[k1 * 4 + 3] <= 0.0)) { - for(int m1 = k1 + 1; m1 < j1; ++m1) { - if(!(ds[m1 * 4 + 3] <= 0.0)) { - double d1 = ds[k1 * 4] - ds[m1 * 4]; - double e1 = ds[k1 * 4 + 1] - ds[m1 * 4 + 1]; - double g1 = ds[k1 * 4 + 2] - ds[m1 * 4 + 2]; - double h1 = ds[k1 * 4 + 3] - ds[m1 * 4 + 3]; - if(h1 * h1 > d1 * d1 + e1 * e1 + g1 * g1) { - if(h1 > 0.0) { - ds[m1 * 4 + 3] = -1.0; + // Compare every point to every other point + for(int a = 0; a < sizeInt - 1; ++a) { + double radiusA = points[a * 4 + 3]; + if(radiusA > 0.0) { + for(int b = a + 1; b < sizeInt; ++b) { + double radiusB = points[b * 4 + 3]; + if(radiusB > 0.0) { + double dxt = points[a * 4] - points[b * 4]; + double dyt = points[a * 4 + 1] - points[b * 4 + 1]; + double dzt = points[a * 4 + 2] - points[b * 4 + 2]; + double dRadius = radiusA - radiusB; + + // If the radius difference is greater than the distance between the two points + if(dRadius * dRadius > dxt * dxt + dyt * dyt + dzt * dzt) { + // Set smaller of two radii to -1 + if(dRadius > 0.0) { + points[b * 4 + 3] = -1.0; } else { - ds[k1 * 4 + 3] = -1.0; + points[a * 4 + 3] = -1.0; } } } @@ -112,37 +115,54 @@ public class VanillaOre implements Structure { } } - for(int m1 = 0; m1 < j1; ++m1) { - double d1 = ds[m1 * 4 + 3]; - if(!(d1 < 0.0)) { - double e1 = ds[m1 * 4]; - double g1 = ds[m1 * 4 + 1]; - double h1 = ds[m1 * 4 + 2]; - int n1 = (int) FastMath.max(FastMath.floor(e1 - d1), x); - int o1 = (int) FastMath.max(FastMath.floor(g1 - d1), y); - int p1 = (int) FastMath.max(FastMath.floor(h1 - d1), z); - int q1 = (int) FastMath.max(FastMath.floor(e1 + d1), n1); - int r1 = (int) FastMath.max(FastMath.floor(g1 + d1), o1); - int s1 = (int) FastMath.max(FastMath.floor(h1 + d1), p1); + int outset = (int) FastMath.ceil((size / 16.0F * 2.0F + 1.0F) / 2.0F); + int x = (int) (location.getX() - FastMath.ceil(eigthSize) - outset); + int y = location.getY() - 2 - outset; + int z = (int) (location.getZ() - FastMath.ceil(eigthSize) - outset); + + int horizontalSize = (int) (2 * (FastMath.ceil(eigthSize) + outset)); + int verticalSize = 2 * (2 + outset); + + int sphereCount = 0; + BitSet visited = new BitSet(horizontalSize * verticalSize * horizontalSize); + + // Generate a sphere at each point + for(int i = 0; i < sizeInt; ++i) { + double radius = points[i * 4 + 3]; + if(radius > 0.0) { + double xt = points[i * 4]; + double yt = points[i * 4 + 1]; + double zt = points[i * 4 + 2]; - for(int t1 = n1; t1 <= q1; ++t1) { - double u1 = ((double) t1 + 0.5 - e1) / d1; - if(u1 * u1 < 1.0) { - for(int v1 = o1; v1 <= r1; ++v1) { - double w1 = ((double) v1 + 0.5 - g1) / d1; - if(u1 * u1 + w1 * w1 < 1.0) { - for(int aa = p1; aa <= s1; ++aa) { - double ab = ((double) aa + 0.5 - h1) / d1; - if(u1 * u1 + w1 * w1 + ab * ab < 1.0 && !(v1 < world.getMinHeight() || v1 >= world.getMaxHeight())) { - int ac = t1 - x + (v1 - y) * horizontalSize + (aa - z) * horizontalSize * verticalSize; - if(!bitSet.get(ac)) { - bitSet.set(ac); + int xLowerBound = (int) FastMath.max(FastMath.floor(xt - radius), x); + int xUpperBound = (int) FastMath.max(FastMath.floor(xt + radius), xLowerBound); + + int yLowerBound = (int) FastMath.max(FastMath.floor(yt - radius), y); + int yUpperBound = (int) FastMath.max(FastMath.floor(yt + radius), yLowerBound); + + int zLowerBound = (int) FastMath.max(FastMath.floor(zt - radius), z); + int zUpperBound = (int) FastMath.max(FastMath.floor(zt + radius), zLowerBound); + + // Iterate over coordinates within bounds + for(int xi = xLowerBound; xi <= xUpperBound; ++xi) { + double dx = ((double) xi + 0.5 - xt) / radius; + if(dx * dx < 1.0) { + for(int yi = yLowerBound; yi <= yUpperBound; ++yi) { + double dy = ((double) yi + 0.5 - yt) / radius; + if(dx * dx + dy * dy < 1.0) { + for(int zi = zLowerBound; zi <= zUpperBound; ++zi) { + double dz = ((double) zi + 0.5 - zt) / radius; + + // If position is inside the sphere + if(dx * dx + dy * dy + dz * dz < 1.0 && !(yi < world.getMinHeight() || yi >= world.getMaxHeight())) { + int index = xi - x + (yi - y) * horizontalSize + (zi - z) * horizontalSize * verticalSize; + if(!visited.get(index)) { // Skip blocks that have already been visited - BlockType block = world.getBlockState(t1, v1, aa).getBlockType(); - - if(shouldPlace(block, random, world, t1, v1, aa)) { - world.setBlockState(t1, v1, aa, getMaterial(block), isApplyGravity()); - ++i1; + visited.set(index); + BlockType block = world.getBlockState(xi, yi, zi).getBlockType(); + if(shouldPlace(block, random, world, xi, yi, zi)) { + world.setBlockState(xi, yi, zi, getMaterial(block), isApplyGravity()); + ++sphereCount; break; } } @@ -155,8 +175,7 @@ public class VanillaOre implements Structure { } } - - return i1 > 0; + return sphereCount > 0; } public boolean shouldPlace(BlockType type, Random random, WritableWorld world, int x, int y, int z) { From e30bcbf1ba63f8291a2d441604f06cfc902e8e8c Mon Sep 17 00:00:00 2001 From: Astrash Date: Tue, 24 Oct 2023 13:26:35 +1100 Subject: [PATCH 45/83] Improve image caching options --- .../terra/addons/image/ImageLibraryAddon.java | 5 ++ .../ImageLibraryPackConfigTemplate.java | 41 ++++++++++++ .../addons/image/config/image/ImageCache.java | 62 ++++++++++++------- .../addons/image/image/SuppliedImage.java | 27 ++++++++ 4 files changed, 113 insertions(+), 22 deletions(-) create mode 100644 common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java create mode 100644 common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/SuppliedImage.java diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java index fdcbc701d..64d0149b8 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java @@ -6,6 +6,7 @@ import java.util.function.Supplier; import com.dfsek.terra.addons.image.config.ColorLoader; import com.dfsek.terra.addons.image.config.ColorLoader.ColorString; +import com.dfsek.terra.addons.image.config.ImageLibraryPackConfigTemplate; import com.dfsek.terra.addons.image.config.noisesampler.ChannelNoiseSamplerTemplate; import com.dfsek.terra.addons.image.config.noisesampler.DistanceTransformNoiseSamplerTemplate; import com.dfsek.terra.addons.image.config.image.ImageTemplate; @@ -52,6 +53,10 @@ public class ImageLibraryAddon implements AddonInitializer { .getHandler(FunctionalEventHandler.class) .register(addon, ConfigPackPreLoadEvent.class) .priority(10) + .then(event -> { + ImageLibraryPackConfigTemplate config = event.loadTemplate(new ImageLibraryPackConfigTemplate()); + event.getPack().getContext().put(config); + }) .then(event -> { ConfigPack pack = event.getPack(); CheckedRegistry>> imageRegistry = pack.getOrCreateRegistry(IMAGE_REGISTRY_KEY); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java new file mode 100644 index 000000000..929a073e6 --- /dev/null +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java @@ -0,0 +1,41 @@ +package com.dfsek.terra.addons.image.config; + +import com.dfsek.tectonic.api.config.template.ConfigTemplate; + +import com.dfsek.tectonic.api.config.template.annotations.Default; +import com.dfsek.tectonic.api.config.template.annotations.Description; +import com.dfsek.tectonic.api.config.template.annotations.Value; + +import com.dfsek.terra.api.properties.Properties; + +public class ImageLibraryPackConfigTemplate implements ConfigTemplate, Properties { + // TODO - These would be better as plugin wide config parameters in config.yml + + @Value("images.cache.load-on-use") + @Description("If set to true, images will load into memory upon use rather than on pack load.") + @Default + private boolean loadOnUse = false; + + @Value("images.cache.unload-on-timeout") + @Description("If set to true, images will be removed from memory if not used after a timeout, otherwise images will stay loaded in memory. " + + "Trades decreased memory consumption when not performing image reads for extra processing time required to perform cache lookups.") + @Default + private boolean unloadOnTimeout = false; + + @Value("images.cache.timeout") + @Description("How many seconds to keep images loaded in the image cache for if images.cache.unload-on-timeout is enabled.") + @Default + private int cacheTimeout = 300; + + public boolean loadOnUse() { + return loadOnUse; + } + + public boolean unloadOnTimeout() { + return unloadOnTimeout; + } + + public int getCacheTimeout() { + return cacheTimeout; + } +} diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java index 5f96ea390..565feca49 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java @@ -3,44 +3,62 @@ package com.dfsek.terra.addons.image.config.image; import javax.imageio.ImageIO; import java.io.FileNotFoundException; import java.io.IOException; -import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.TimeUnit; +import com.dfsek.terra.addons.image.config.ImageLibraryPackConfigTemplate; import com.dfsek.terra.addons.image.image.BufferedImageWrapper; import com.dfsek.terra.addons.image.image.Image; +import com.dfsek.terra.addons.image.image.SuppliedImage; import com.dfsek.terra.api.config.ConfigPack; import com.dfsek.terra.api.config.Loader; import com.dfsek.terra.api.properties.Properties; +import com.dfsek.terra.api.util.generic.Lazy; + +import com.github.benmanes.caffeine.cache.Caffeine; +import com.github.benmanes.caffeine.cache.LoadingCache; + /* * Cache prevents configs from loading the same image multiple times into memory */ -record ImageCache(ConcurrentHashMap map) implements Properties { +record ImageCache(LoadingCache cache) implements Properties { public static Image load(String path, ConfigPack pack, Loader files) throws IOException { - ImageCache cache; + ImageLibraryPackConfigTemplate config = pack.getContext().get(ImageLibraryPackConfigTemplate.class); + ImageCache images; if(!pack.getContext().has(ImageCache.class)) { - cache = new ImageCache(new ConcurrentHashMap<>()); - pack.getContext().put(cache); - } else { - cache = pack.getContext().get(ImageCache.class); + System.out.println("Initializing new image cache"); + var cacheBuilder = Caffeine.newBuilder(); + if (config.unloadOnTimeout()) cacheBuilder.expireAfterAccess(config.getCacheTimeout(), TimeUnit.SECONDS); + images = new ImageCache(cacheBuilder.build(s -> loadImage(path, files))); + pack.getContext().put(images); + } else images = pack.getContext().get(ImageCache.class); + + if (config.loadOnUse()) { + if(config.unloadOnTimeout()) { // Grab directly from cache if images are to unload on timeout + return new SuppliedImage(() -> images.cache.get(path)); + } else { + // If images do not time out, image can be lazily loaded once instead of performing cache lookups for each image operation + Lazy lazyImage = Lazy.lazy(() -> images.cache.get(path)); + return new SuppliedImage(lazyImage::value); + } } - if(cache.map.containsKey(path)) { - return cache.map.get(path); - } else { - try { - BufferedImageWrapper image = new BufferedImageWrapper(ImageIO.read(files.get(path))); - cache.map.put(path, image); - return image; - } catch(IllegalArgumentException e) { - throw new IllegalArgumentException("Unable to load image (image might be too large?)", e); - } catch(IOException e) { - if(e instanceof FileNotFoundException) { - // Rethrow using nicer message - throw new IOException("Unable to load image: No such file or directory: " + path, e); - } - throw new IOException("Unable to load image", e); + return images.cache.get(path); + } + + private static Image loadImage(String path, Loader files) throws IOException { + System.out.println("Loading image: " + path); + try { + return new BufferedImageWrapper(ImageIO.read(files.get(path))); + } catch(IllegalArgumentException e) { + throw new IllegalArgumentException("Unable to load image (image might be too large?)", e); + } catch(IOException e) { + if(e instanceof FileNotFoundException) { + // Rethrow using nicer message + throw new IOException("Unable to load image: No such file or directory: " + path, e); } + throw new IOException("Unable to load image", e); } } } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/SuppliedImage.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/SuppliedImage.java new file mode 100644 index 000000000..99fcbfcd3 --- /dev/null +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/SuppliedImage.java @@ -0,0 +1,27 @@ +package com.dfsek.terra.addons.image.image; + +import java.util.function.Supplier; + +public class SuppliedImage implements Image { + + private final Supplier imageSupplier; + + public SuppliedImage(Supplier imageSupplier) { + this.imageSupplier = imageSupplier; + } + + @Override + public int getRGB(int x, int y) { + return imageSupplier.get().getRGB(x, y); + } + + @Override + public int getWidth() { + return imageSupplier.get().getWidth(); + } + + @Override + public int getHeight() { + return imageSupplier.get().getHeight(); + } +} From cb6ecff113223b7bada797709089d4bc2c329cff Mon Sep 17 00:00:00 2001 From: Astrash Date: Tue, 24 Oct 2023 13:29:53 +1100 Subject: [PATCH 46/83] Remove sout --- .../com/dfsek/terra/addons/image/config/image/ImageCache.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java index 565feca49..c554b9c6a 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java @@ -27,7 +27,6 @@ record ImageCache(LoadingCache cache) implements Properties { ImageLibraryPackConfigTemplate config = pack.getContext().get(ImageLibraryPackConfigTemplate.class); ImageCache images; if(!pack.getContext().has(ImageCache.class)) { - System.out.println("Initializing new image cache"); var cacheBuilder = Caffeine.newBuilder(); if (config.unloadOnTimeout()) cacheBuilder.expireAfterAccess(config.getCacheTimeout(), TimeUnit.SECONDS); images = new ImageCache(cacheBuilder.build(s -> loadImage(path, files))); @@ -48,7 +47,6 @@ record ImageCache(LoadingCache cache) implements Properties { } private static Image loadImage(String path, Loader files) throws IOException { - System.out.println("Loading image: " + path); try { return new BufferedImageWrapper(ImageIO.read(files.get(path))); } catch(IllegalArgumentException e) { From 3f485b1825abd16b39a86b84ccf858ab4e1da702 Mon Sep 17 00:00:00 2001 From: Astrash Date: Tue, 24 Oct 2023 13:30:09 +1100 Subject: [PATCH 47/83] Add to unload on timeout description --- .../addons/image/config/ImageLibraryPackConfigTemplate.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java index 929a073e6..7d2cd5b58 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java @@ -18,7 +18,7 @@ public class ImageLibraryPackConfigTemplate implements ConfigTemplate, Propertie @Value("images.cache.unload-on-timeout") @Description("If set to true, images will be removed from memory if not used after a timeout, otherwise images will stay loaded in memory. " + - "Trades decreased memory consumption when not performing image reads for extra processing time required to perform cache lookups.") + "Trades decreased memory consumption when not performing any image reads for a period of time for extra processing time required to perform cache lookups.") @Default private boolean unloadOnTimeout = false; From 148b8dfe35039812994d5257e3ae9511c45af75c Mon Sep 17 00:00:00 2001 From: Astrash Date: Tue, 24 Oct 2023 13:34:10 +1100 Subject: [PATCH 48/83] Bump image lib patch version --- common/addons/library-image/build.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common/addons/library-image/build.gradle.kts b/common/addons/library-image/build.gradle.kts index 6f5d40074..fe8706428 100644 --- a/common/addons/library-image/build.gradle.kts +++ b/common/addons/library-image/build.gradle.kts @@ -1,4 +1,4 @@ -version = version("1.0.0") +version = version("1.0.1") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) From cd8605850f8708edbadb84ecb2bbcc258c74742c Mon Sep 17 00:00:00 2001 From: Astrash Date: Tue, 24 Oct 2023 13:47:25 +1100 Subject: [PATCH 49/83] Replace unload-on-timeout with timeout > 0 --- .../config/ImageLibraryPackConfigTemplate.java | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java index 7d2cd5b58..b3a78caed 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java @@ -16,23 +16,19 @@ public class ImageLibraryPackConfigTemplate implements ConfigTemplate, Propertie @Default private boolean loadOnUse = false; - @Value("images.cache.unload-on-timeout") - @Description("If set to true, images will be removed from memory if not used after a timeout, otherwise images will stay loaded in memory. " + - "Trades decreased memory consumption when not performing any image reads for a period of time for extra processing time required to perform cache lookups.") - @Default - private boolean unloadOnTimeout = false; - @Value("images.cache.timeout") - @Description("How many seconds to keep images loaded in the image cache for if images.cache.unload-on-timeout is enabled.") + @Description("How many seconds to keep images loaded in the image cache for. " + + "If set to a number greater than 0, images will be removed from memory if not used after the timeout, otherwise images will stay loaded in memory. " + + "Setting the timeout to greater than 0 will trade decreased memory consumption when not performing any image reads for a period of time for extra processing time required to perform cache lookups.") @Default - private int cacheTimeout = 300; + private int cacheTimeout = 0; public boolean loadOnUse() { return loadOnUse; } public boolean unloadOnTimeout() { - return unloadOnTimeout; + return cacheTimeout > 0; } public int getCacheTimeout() { From 0149a29b04f2871c723a598612b4b0bf60f35155 Mon Sep 17 00:00:00 2001 From: Astrash Date: Tue, 24 Oct 2023 14:08:56 +1100 Subject: [PATCH 50/83] Load correct path --- .../com/dfsek/terra/addons/image/config/image/ImageCache.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java index c554b9c6a..7558d4bfa 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java @@ -29,7 +29,7 @@ record ImageCache(LoadingCache cache) implements Properties { if(!pack.getContext().has(ImageCache.class)) { var cacheBuilder = Caffeine.newBuilder(); if (config.unloadOnTimeout()) cacheBuilder.expireAfterAccess(config.getCacheTimeout(), TimeUnit.SECONDS); - images = new ImageCache(cacheBuilder.build(s -> loadImage(path, files))); + images = new ImageCache(cacheBuilder.build(s -> loadImage(s, files))); pack.getContext().put(images); } else images = pack.getContext().get(ImageCache.class); From 9292d3de171464da7327c6d1d3e90ae2ff0375be Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Thu, 26 Oct 2023 10:25:39 -0600 Subject: [PATCH 51/83] Remove FastMath hotspot has intrinsics for almost everything we use it for --- buildSrc/src/main/kotlin/Versions.kt | 1 - .../biome-provider-image-v2/build.gradle.kts | 8 +- .../biome/image/v2/ImageBiomeProvider.java | 2 +- .../v2/config/ImageProviderTemplate.java | 2 +- .../biome-provider-image/build.gradle.kts | 8 +- .../biome/image/ImageBiomeProvider.java | 10 +- .../build.gradle.kts | 7 -- .../biome/pipeline/v2/BiomePipelineAddon.java | 6 +- .../pipeline/v2/PipelineBiomeProvider.java | 15 ++- .../biome/pipeline/v2/api/Expander.java | 2 +- .../addons/biome/pipeline/v2/api/Stage.java | 2 +- .../v2/config/BiomePipelineTemplate.java | 2 +- .../stage/expander/ExpanderStageTemplate.java | 2 +- .../mutator/BorderListStageTemplate.java | 2 +- .../stage/mutator/BorderStageTemplate.java | 2 +- .../mutator/ReplaceListStageTemplate.java | 2 +- .../stage/mutator/ReplaceStageTemplate.java | 2 +- .../stage/mutator/SmoothStageTemplate.java | 2 +- .../pipeline/v2/pipeline/BiomeChunkImpl.java | 7 +- .../pipeline/v2/source/SingleSource.java | 2 +- .../biome-provider-pipeline/build.gradle.kts | 7 -- .../biome/pipeline/BiomePipelineProvider.java | 5 +- .../chunk-generator-noise-3d/build.gradle.kts | 7 -- .../config/palette/BiomePaletteTemplate.java | 2 +- .../generation/NoiseChunkGenerator3D.java | 11 +-- .../generation/math/PaletteUtil.java | 2 +- .../math/interpolation/ChunkInterpolator.java | 6 +- .../LazilyEvaluatedInterpolator.java | 10 +- .../generation/math/samplers/Sampler3D.java | 6 +- .../math/samplers/SamplerProvider.java | 5 +- .../chunkgenerator/palette/PaletteHolder.java | 8 +- .../config-distributors/build.gradle.kts | 7 -- .../distributors/PaddedGridDistributor.java | 17 +--- common/addons/config-flora/build.gradle.kts | 6 -- .../addons/flora/flora/gen/TerraFlora.java | 8 +- .../addons/config-locators/build.gradle.kts | 9 +- .../locator/locators/PatternLocator.java | 6 +- .../locator/locators/SurfaceLocator.java | 6 +- .../locator/patterns/MatchPattern.java | 10 +- .../config-noise-function/build.gradle.kts | 8 -- .../CubicSplineNormalizerTemplate.java | 4 +- .../ExpressionNormalizerTemplate.java | 8 +- .../terra/addons/noise/math/CubicSpline.java | 8 +- .../noise/normalizer/ClampNormalizer.java | 4 +- .../normalizer/ExpressionNormalizer.java | 4 +- .../noise/normalizer/NormalNormalizer.java | 6 +- .../normalizer/PosterizationNormalizer.java | 4 +- .../addons/noise/paralithic/FunctionUtil.java | 6 +- .../addons/noise/samplers/ImageSampler.java | 6 +- .../noise/samplers/arithmetic/MaxSampler.java | 4 +- .../noise/samplers/arithmetic/MinSampler.java | 4 +- .../noise/samplers/noise/CellularSampler.java | 36 ++++--- .../noise/samplers/noise/DistanceSampler.java | 16 +-- .../samplers/noise/GaborNoiseSampler.java | 19 ++-- .../noise/samplers/noise/NoiseFunction.java | 87 +--------------- .../noise/fractal/BrownianMotionSampler.java | 5 +- .../noise/fractal/FractalNoiseFunction.java | 2 +- .../noise/fractal/PingPongSampler.java | 5 +- .../noise/fractal/RidgedFractalSampler.java | 9 +- .../random/PositiveWhiteNoiseSampler.java | 5 +- .../noise/random/WhiteNoiseSampler.java | 7 +- .../noise/simplex/OpenSimplex2SSampler.java | 10 +- .../noise/simplex/OpenSimplex2Sampler.java | 10 +- .../samplers/noise/simplex/PerlinSampler.java | 43 ++++---- .../noise/simplex/SimplexSampler.java | 10 +- .../noise/value/ValueCubicSampler.java | 67 +++++++------ .../samplers/noise/value/ValueSampler.java | 43 ++++---- common/addons/config-ore-v2/build.gradle.kts | 8 +- .../terra/addons/ore/v2/ores/VanillaOre.java | 33 +++---- common/addons/config-ore/build.gradle.kts | 5 - .../terra/addons/ore/ores/VanillaOre.java | 27 +++-- .../addons/config-structure/build.gradle.kts | 7 -- .../structure/structures/loot/Entry.java | 7 +- .../structure/structures/loot/Pool.java | 11 +-- .../loot/functions/EnchantFunction.java | 7 +- common/addons/library-image/build.gradle.kts | 4 +- .../terra/addons/image/ImageLibraryAddon.java | 10 +- .../image/SingleImageColorSampler.java | 2 +- .../image/TileImageColorSampler.java | 6 +- .../mutate/RotateColorSampler.java | 9 +- .../image/ImageColorSamplerTemplate.java | 2 +- .../image/operator/DistanceTransform.java | 16 ++- .../terra/addons/image/util/ColorUtil.java | 9 +- .../build.gradle.kts | 7 -- .../addons/terrascript/parser/lang/Scope.java | 8 +- .../statements/EqualsStatement.java | 4 +- .../statements/NotEqualsStatement.java | 4 +- .../terrascript/script/StructureScript.java | 34 +++---- .../script/functions/BiomeFunction.java | 6 +- .../script/functions/BlockFunction.java | 5 +- .../script/functions/CheckBlockFunction.java | 6 +- .../script/functions/GetMarkFunction.java | 6 +- .../script/functions/LootFunction.java | 5 +- .../script/functions/PullFunction.java | 6 +- .../script/functions/SetMarkFunction.java | 8 +- .../script/functions/StateFunction.java | 5 +- .../script/functions/StructureFunction.java | 9 +- .../build.gradle.kts | 9 +- .../terrascript/check/CheckFunction.java | 10 +- common/api/build.gradle.kts | 2 +- .../dfsek/terra/api/util/ConstantRange.java | 3 +- .../com/dfsek/terra/api/util/MathUtil.java | 98 +++++++++++++++++-- .../com/dfsek/terra/api/util/Rotation.java | 5 +- .../collection/ProbabilityCollection.java | 8 +- .../dfsek/terra/api/util/vector/Vector2.java | 12 +-- .../dfsek/terra/api/util/vector/Vector3.java | 41 ++++---- common/implementation/base/build.gradle.kts | 2 +- .../terra/config/loaders/RangeLoader.java | 5 +- .../BukkitChunkGeneratorWrapper.java | 3 - .../terra/bukkit/world/BukkitProtoWorld.java | 3 +- .../v1_18_R2/NMSChunkGeneratorDelegate.java | 5 +- .../v1_19_R1/NMSChunkGeneratorDelegate.java | 17 ++-- .../bukkit/nms/v1_19_R2/NMSBiomeInjector.java | 2 - .../terra/bukkit/nms/v1_19_R2/Reflection.java | 2 - .../bukkit/nms/v1_19_R2/RegistryFetcher.java | 1 - .../bukkit/nms/v1_19_R3/NMSBiomeInjector.java | 6 -- .../bukkit/nms/v1_19_R3/NMSBiomeProvider.java | 3 +- .../terra/bukkit/nms/v1_19_R3/Reflection.java | 2 - .../bukkit/nms/v1_19_R3/RegistryFetcher.java | 1 - .../bukkit/nms/v1_20_R1/NMSBiomeInjector.java | 6 -- .../bukkit/nms/v1_20_R1/NMSBiomeProvider.java | 3 +- platforms/cli/build.gradle.kts | 2 +- .../com/dfsek/terra/cli/world/CLIWorld.java | 13 ++- .../dfsek/terra/forge/ForgeEntryPoint.java | 1 - .../com/dfsek/terra/forge/ForgePlatform.java | 3 - .../mixin/lifecycle/NoiseConfigMixin.java | 9 +- .../java/com/dfsek/terra/mod/ModPlatform.java | 6 -- .../terra/mod/config/EntityTypeTemplate.java | 1 - .../terra/mod/config/ProtoPlatformBiome.java | 2 +- .../mod/config/VanillaBiomeProperties.java | 1 - .../mod/config/VillagerTypeTemplate.java | 1 - .../java/com/dfsek/terra/mod/data/Codecs.java | 2 - .../MinecraftChunkGeneratorWrapper.java | 6 +- .../mod/generation/TerraBiomeSource.java | 1 - .../terra/mod/handle/MinecraftItemHandle.java | 2 +- .../mod/handle/MinecraftWorldHandle.java | 1 - .../entity/MobSpawnerBlockEntityMixin.java | 1 - .../block/entity/SignBlockEntityMixin.java | 1 - .../terra/block/state/BlockStateMixin.java | 1 - .../terra/chunk/WorldChunkMixin.java | 1 - .../inventory/meta/EnchantmentMixin.java | 2 - .../inventory/meta/ItemStackMetaMixin.java | 1 - .../lifecycle/DataPackContentsMixin.java | 1 - .../dfsek/terra/mod/util/MinecraftUtil.java | 3 +- .../com/dfsek/terra/mod/util/TagUtil.java | 2 +- .../terra/lifecycle/LifecycleEntryPoint.java | 10 +- .../terra/lifecycle/LifecyclePlatform.java | 7 +- .../lifecycle/mixin/NoiseConfigMixin.java | 1 - .../terra/lifecycle/mixin/RegistryMixin.java | 1 - .../lifecycle/mixin/SimpleRegistryMixin.java | 5 +- .../mixin/lifecycle/SaveLoadingMixin.java | 6 +- .../dfsek/terra/lifecycle/util/BiomeUtil.java | 3 +- .../terra/lifecycle/util/RegistryUtil.java | 2 +- 153 files changed, 517 insertions(+), 771 deletions(-) diff --git a/buildSrc/src/main/kotlin/Versions.kt b/buildSrc/src/main/kotlin/Versions.kt index 6a56ded4c..3e45cc7d7 100644 --- a/buildSrc/src/main/kotlin/Versions.kt +++ b/buildSrc/src/main/kotlin/Versions.kt @@ -12,7 +12,6 @@ object Versions { object Internal { const val shadow = "8.1.1" const val apacheText = "1.10.0" - const val jafama = "2.3.2" const val apacheIO = "2.14.0" const val guava = "32.1.3-jre" const val asm = "9.5" diff --git a/common/addons/biome-provider-image-v2/build.gradle.kts b/common/addons/biome-provider-image-v2/build.gradle.kts index 3819ba485..38f4801d2 100644 --- a/common/addons/biome-provider-image-v2/build.gradle.kts +++ b/common/addons/biome-provider-image-v2/build.gradle.kts @@ -3,10 +3,6 @@ version = version("1.0.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) compileOnlyApi(project(":common:addons:library-image")) - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) - testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) -} -tasks.named("shadowJar") { - relocate("net.jafama", "com.dfsek.terra.addons.biome.image.lib.jafama") -} \ No newline at end of file + +} diff --git a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java index 7a37664a1..8b5ec2e5b 100644 --- a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java +++ b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java @@ -9,8 +9,8 @@ package com.dfsek.terra.addons.biome.image.v2; import java.util.Optional; -import com.dfsek.terra.addons.image.converter.ColorConverter; import com.dfsek.terra.addons.image.colorsampler.ColorSampler; +import com.dfsek.terra.addons.image.converter.ColorConverter; import com.dfsek.terra.api.world.biome.Biome; import com.dfsek.terra.api.world.biome.generation.BiomeProvider; diff --git a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/ImageProviderTemplate.java b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/ImageProviderTemplate.java index 8d9955ad4..80f7f87e1 100644 --- a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/ImageProviderTemplate.java +++ b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/ImageProviderTemplate.java @@ -13,8 +13,8 @@ import com.dfsek.tectonic.api.config.template.annotations.Value; import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; import com.dfsek.terra.addons.biome.image.v2.ImageBiomeProvider; -import com.dfsek.terra.addons.image.converter.ColorConverter; import com.dfsek.terra.addons.image.colorsampler.ColorSampler; +import com.dfsek.terra.addons.image.converter.ColorConverter; import com.dfsek.terra.api.world.biome.Biome; import com.dfsek.terra.api.world.biome.generation.BiomeProvider; diff --git a/common/addons/biome-provider-image/build.gradle.kts b/common/addons/biome-provider-image/build.gradle.kts index 15145b578..f1755a0f0 100644 --- a/common/addons/biome-provider-image/build.gradle.kts +++ b/common/addons/biome-provider-image/build.gradle.kts @@ -2,10 +2,6 @@ version = version("1.0.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) - testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) -} -tasks.named("shadowJar") { - relocate("net.jafama", "com.dfsek.terra.addons.biome.image.lib.jafama") -} \ No newline at end of file + +} diff --git a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProvider.java b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProvider.java index aa2f647bb..3af73c043 100644 --- a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProvider.java +++ b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProvider.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.biome.image; -import net.jafama.FastMath; - import java.awt.Color; import java.awt.image.BufferedImage; import java.util.HashMap; @@ -34,7 +32,7 @@ public class ImageBiomeProvider implements BiomeProvider { } private static int distance(Color a, Color b) { - return FastMath.abs(a.getRed() - b.getRed()) + FastMath.abs(a.getGreen() - b.getGreen()) + FastMath.abs(a.getBlue() - b.getBlue()); + return Math.abs(a.getRed() - b.getRed()) + Math.abs(a.getGreen() - b.getGreen()) + Math.abs(a.getBlue() - b.getBlue()); } @Override @@ -70,14 +68,14 @@ public class ImageBiomeProvider implements BiomeProvider { CENTER { @Override public Color getColor(BufferedImage image, int x, int z) { - return new Color(image.getRGB(FastMath.floorMod(x - image.getWidth() / 2, image.getWidth()), - FastMath.floorMod(z - image.getHeight() / 2, image.getHeight()))); + return new Color(image.getRGB(Math.floorMod(x - image.getWidth() / 2, image.getWidth()), + Math.floorMod(z - image.getHeight() / 2, image.getHeight()))); } }, NONE { @Override public Color getColor(BufferedImage image, int x, int z) { - return new Color(image.getRGB(FastMath.floorMod(x, image.getWidth()), FastMath.floorMod(z, image.getHeight()))); + return new Color(image.getRGB(Math.floorMod(x, image.getWidth()), Math.floorMod(z, image.getHeight()))); } }; diff --git a/common/addons/biome-provider-pipeline-v2/build.gradle.kts b/common/addons/biome-provider-pipeline-v2/build.gradle.kts index 8ca2e3b81..d3eaff9fe 100644 --- a/common/addons/biome-provider-pipeline-v2/build.gradle.kts +++ b/common/addons/biome-provider-pipeline-v2/build.gradle.kts @@ -2,11 +2,4 @@ version = version("1.0.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) - - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) - testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) -} - -tasks.named("shadowJar") { - relocate("net.jafama", "com.dfsek.terra.addons.biome.pipeline.lib.jafama") } \ No newline at end of file diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineAddon.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineAddon.java index 66c1a7908..3add75092 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineAddon.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineAddon.java @@ -11,6 +11,9 @@ import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; import java.util.function.Supplier; +import com.dfsek.terra.addons.biome.pipeline.v2.api.Source; +import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage; +import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; import com.dfsek.terra.addons.biome.pipeline.v2.config.BiomePipelineTemplate; import com.dfsek.terra.addons.biome.pipeline.v2.config.PipelineBiomeLoader; import com.dfsek.terra.addons.biome.pipeline.v2.config.source.SamplerSourceTemplate; @@ -20,9 +23,6 @@ import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.mutator.BorderStage import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.mutator.ReplaceListStageTemplate; import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.mutator.ReplaceStageTemplate; import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.mutator.SmoothStageTemplate; -import com.dfsek.terra.addons.biome.pipeline.v2.api.Source; -import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage; -import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; import com.dfsek.terra.addons.manifest.api.AddonInitializer; import com.dfsek.terra.api.Platform; import com.dfsek.terra.api.addon.BaseAddon; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/PipelineBiomeProvider.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/PipelineBiomeProvider.java index 1a34d06e0..08d321abd 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/PipelineBiomeProvider.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/PipelineBiomeProvider.java @@ -1,13 +1,7 @@ package com.dfsek.terra.addons.biome.pipeline.v2; -import com.dfsek.terra.addons.biome.pipeline.v2.api.BiomeChunk; -import com.dfsek.terra.addons.biome.pipeline.v2.api.Pipeline; -import com.dfsek.terra.addons.biome.pipeline.v2.api.SeededVector; -import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage; -import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; -import net.jafama.FastMath; import java.util.Comparator; import java.util.HashSet; @@ -15,6 +9,11 @@ import java.util.Optional; import java.util.Set; import java.util.stream.StreamSupport; +import com.dfsek.terra.addons.biome.pipeline.v2.api.BiomeChunk; +import com.dfsek.terra.addons.biome.pipeline.v2.api.Pipeline; +import com.dfsek.terra.addons.biome.pipeline.v2.api.SeededVector; +import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage; +import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; import com.dfsek.terra.api.noise.NoiseSampler; import com.dfsek.terra.api.registry.key.StringIdentifiable; import com.dfsek.terra.api.util.Column; @@ -81,8 +80,8 @@ public class PipelineBiomeProvider implements BiomeProvider { x /= resolution; z /= resolution; - int chunkX = FastMath.floorDiv(x, chunkSize); - int chunkZ = FastMath.floorDiv(z, chunkSize); + int chunkX = Math.floorDiv(x, chunkSize); + int chunkZ = Math.floorDiv(z, chunkSize); int chunkWorldX = chunkX * chunkSize; int chunkWorldZ = chunkZ * chunkSize; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Expander.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Expander.java index 177e74694..d3fab5263 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Expander.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Expander.java @@ -1,7 +1,7 @@ package com.dfsek.terra.addons.biome.pipeline.v2.api; -import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl.ViewPoint; import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; +import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl.ViewPoint; /** diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Stage.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Stage.java index ee2c75e89..b0d33667b 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Stage.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Stage.java @@ -1,7 +1,7 @@ package com.dfsek.terra.addons.biome.pipeline.v2.api; -import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl.ViewPoint; import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; +import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl.ViewPoint; public interface Stage { diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java index 776d5cd04..007add35d 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java @@ -15,9 +15,9 @@ import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; import java.util.List; import com.dfsek.terra.addons.biome.pipeline.v2.PipelineBiomeProvider; -import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.PipelineImpl; import com.dfsek.terra.addons.biome.pipeline.v2.api.Source; import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage; +import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.PipelineImpl; import com.dfsek.terra.api.config.meta.Meta; import com.dfsek.terra.api.noise.NoiseSampler; import com.dfsek.terra.api.world.biome.generation.BiomeProvider; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/expander/ExpanderStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/expander/ExpanderStageTemplate.java index 312880d3b..4478c987e 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/expander/ExpanderStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/expander/ExpanderStageTemplate.java @@ -7,8 +7,8 @@ package com.dfsek.terra.addons.biome.pipeline.v2.config.stage.expander; -import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate; import com.dfsek.terra.addons.biome.pipeline.v2.api.Expander; +import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate; import com.dfsek.terra.addons.biome.pipeline.v2.stage.expander.FractalExpander; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderListStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderListStageTemplate.java index 57d5c7deb..0d0aa4c2d 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderListStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderListStageTemplate.java @@ -11,9 +11,9 @@ import com.dfsek.tectonic.api.config.template.annotations.Value; import java.util.Map; -import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate; import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage; import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; +import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate; import com.dfsek.terra.addons.biome.pipeline.v2.stage.mutators.BorderListStage; import com.dfsek.terra.api.config.meta.Meta; import com.dfsek.terra.api.util.collection.ProbabilityCollection; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderStageTemplate.java index 605eeb9f4..e2ffa7872 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderStageTemplate.java @@ -9,9 +9,9 @@ package com.dfsek.terra.addons.biome.pipeline.v2.config.stage.mutator; import com.dfsek.tectonic.api.config.template.annotations.Value; -import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate; import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage; import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; +import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate; import com.dfsek.terra.addons.biome.pipeline.v2.stage.mutators.BorderStage; import com.dfsek.terra.api.config.meta.Meta; import com.dfsek.terra.api.util.collection.ProbabilityCollection; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceListStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceListStageTemplate.java index be9ade61c..179707d21 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceListStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceListStageTemplate.java @@ -11,9 +11,9 @@ import com.dfsek.tectonic.api.config.template.annotations.Value; import java.util.Map; -import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate; import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage; import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; +import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate; import com.dfsek.terra.addons.biome.pipeline.v2.stage.mutators.ReplaceListStage; import com.dfsek.terra.api.config.meta.Meta; import com.dfsek.terra.api.util.collection.ProbabilityCollection; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceStageTemplate.java index 6f273a294..397b2c78b 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceStageTemplate.java @@ -9,9 +9,9 @@ package com.dfsek.terra.addons.biome.pipeline.v2.config.stage.mutator; import com.dfsek.tectonic.api.config.template.annotations.Value; -import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate; import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage; import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; +import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate; import com.dfsek.terra.addons.biome.pipeline.v2.stage.mutators.ReplaceStage; import com.dfsek.terra.api.config.meta.Meta; import com.dfsek.terra.api.util.collection.ProbabilityCollection; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/SmoothStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/SmoothStageTemplate.java index a13e441af..c7a5b4feb 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/SmoothStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/SmoothStageTemplate.java @@ -7,8 +7,8 @@ package com.dfsek.terra.addons.biome.pipeline.v2.config.stage.mutator; -import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate; import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage; +import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate; import com.dfsek.terra.addons.biome.pipeline.v2.stage.mutators.SmoothStage; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/BiomeChunkImpl.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/BiomeChunkImpl.java index cf739fa77..df843ec4b 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/BiomeChunkImpl.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/BiomeChunkImpl.java @@ -1,13 +1,12 @@ package com.dfsek.terra.addons.biome.pipeline.v2.pipeline; +import java.util.List; + import com.dfsek.terra.addons.biome.pipeline.v2.api.BiomeChunk; import com.dfsek.terra.addons.biome.pipeline.v2.api.Expander; import com.dfsek.terra.addons.biome.pipeline.v2.api.SeededVector; import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage; import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; -import net.jafama.FastMath; - -import java.util.List; public class BiomeChunkImpl implements BiomeChunk { @@ -111,7 +110,7 @@ public class BiomeChunkImpl implements BiomeChunk { // chunk samples points on the same overall grid. // Without this, shared chunk borders (required because of adjacent cell reads) will not be identical // because points would be sampled on grids at different offsets, resulting in artifacts at borders. - return FastMath.ceilToInt((double) finalGridOrigin / initialGridInterval) * initialGridInterval; + return (int) Math.ceil((double) finalGridOrigin / initialGridInterval) * initialGridInterval; } private static int calculateFinalGridOrigin(int totalExpanderCount, List stages) { diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/source/SingleSource.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/source/SingleSource.java index b2c0ee8db..b8beebd10 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/source/SingleSource.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/source/SingleSource.java @@ -3,8 +3,8 @@ package com.dfsek.terra.addons.biome.pipeline.v2.source; import java.util.Collections; import java.util.Set; -import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; import com.dfsek.terra.addons.biome.pipeline.v2.api.Source; +import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; public class SingleSource implements Source { diff --git a/common/addons/biome-provider-pipeline/build.gradle.kts b/common/addons/biome-provider-pipeline/build.gradle.kts index 2629ac476..35e4d7076 100644 --- a/common/addons/biome-provider-pipeline/build.gradle.kts +++ b/common/addons/biome-provider-pipeline/build.gradle.kts @@ -2,11 +2,4 @@ version = version("1.0.1") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) - - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) - testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) } - -tasks.named("shadowJar") { - relocate("net.jafama", "com.dfsek.terra.addons.biome.pipeline.lib.jafama") -} \ No newline at end of file diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java index f3f4c3aa9..9222f2128 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java @@ -9,7 +9,6 @@ package com.dfsek.terra.addons.biome.pipeline; import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; -import net.jafama.FastMath; import java.util.Comparator; import java.util.HashSet; @@ -86,8 +85,8 @@ public class BiomePipelineProvider implements BiomeProvider { x /= resolution; z /= resolution; - int fdX = FastMath.floorDiv(x, pipeline.getSize()); - int fdZ = FastMath.floorDiv(z, pipeline.getSize()); + int fdX = Math.floorDiv(x, pipeline.getSize()); + int fdZ = Math.floorDiv(z, pipeline.getSize()); return holderCache.get(new SeededVector(fdX, fdZ, seed)).getBiome(x - fdX * pipeline.getSize(), z - fdZ * pipeline.getSize()).getBiome(); } diff --git a/common/addons/chunk-generator-noise-3d/build.gradle.kts b/common/addons/chunk-generator-noise-3d/build.gradle.kts index 193c9f00b..b4888dea4 100644 --- a/common/addons/chunk-generator-noise-3d/build.gradle.kts +++ b/common/addons/chunk-generator-noise-3d/build.gradle.kts @@ -2,11 +2,4 @@ version = version("1.2.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) - - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) - testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) -} - -tasks.named("shadowJar") { - relocate("net.jafama", "com.dfsek.terra.addons.chunkgenerator.lib.jafama") } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java index f872794c9..533f06928 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java @@ -16,8 +16,8 @@ import java.util.Collections; import java.util.List; import java.util.Map; -import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolder; import com.dfsek.terra.addons.chunkgenerator.palette.BiomePaletteInfo; +import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolder; import com.dfsek.terra.addons.chunkgenerator.palette.slant.SlantHolder; import com.dfsek.terra.api.Platform; import com.dfsek.terra.api.block.state.BlockState; diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java index e98dcc316..106aef8fa 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java @@ -8,15 +8,14 @@ package com.dfsek.terra.addons.chunkgenerator.generation; -import net.jafama.FastMath; import org.jetbrains.annotations.NotNull; import com.dfsek.terra.addons.chunkgenerator.config.noise.BiomeNoiseProperties; -import com.dfsek.terra.addons.chunkgenerator.palette.BiomePaletteInfo; import com.dfsek.terra.addons.chunkgenerator.generation.math.PaletteUtil; import com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation.LazilyEvaluatedInterpolator; import com.dfsek.terra.addons.chunkgenerator.generation.math.samplers.Sampler3D; import com.dfsek.terra.addons.chunkgenerator.generation.math.samplers.SamplerProvider; +import com.dfsek.terra.addons.chunkgenerator.palette.BiomePaletteInfo; import com.dfsek.terra.api.Platform; import com.dfsek.terra.api.block.state.BlockState; import com.dfsek.terra.api.config.ConfigPack; @@ -133,8 +132,8 @@ public class NoiseChunkGenerator3D implements ChunkGenerator { BiomePaletteInfo paletteInfo = biome.getContext().get(paletteInfoPropertyKey); - int fdX = FastMath.floorMod(x, 16); - int fdZ = FastMath.floorMod(z, 16); + int fdX = Math.floorMod(x, 16); + int fdZ = Math.floorMod(z, 16); Palette palette = PaletteUtil.getPalette(fdX, y, fdZ, sampler, paletteInfo, 0); double noise = sampler.sample(fdX, y, fdZ); @@ -156,8 +155,8 @@ public class NoiseChunkGenerator3D implements ChunkGenerator { } public double getSlant(int x, int y, int z, WorldProperties world, BiomeProvider biomeProvider) { - int fdX = FastMath.floorMod(x, 16); - int fdZ = FastMath.floorMod(z, 16); + int fdX = Math.floorMod(x, 16); + int fdZ = Math.floorMod(z, 16); return biomeProvider.getBiome(x, y, z, world.getSeed()) .getContext() .get(paletteInfoPropertyKey) diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/PaletteUtil.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/PaletteUtil.java index ebeabaf23..ca6798c73 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/PaletteUtil.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/PaletteUtil.java @@ -7,8 +7,8 @@ package com.dfsek.terra.addons.chunkgenerator.generation.math; -import com.dfsek.terra.addons.chunkgenerator.palette.BiomePaletteInfo; import com.dfsek.terra.addons.chunkgenerator.generation.math.samplers.Sampler3D; +import com.dfsek.terra.addons.chunkgenerator.palette.BiomePaletteInfo; import com.dfsek.terra.addons.chunkgenerator.palette.slant.SlantHolder; import com.dfsek.terra.api.world.chunk.generation.util.Palette; diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java index d712bfc60..dc4d6dcc7 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation; -import net.jafama.FastMath; - import com.dfsek.terra.addons.chunkgenerator.config.noise.BiomeNoiseProperties; import com.dfsek.terra.api.properties.PropertyKey; import com.dfsek.terra.api.util.Column; @@ -134,7 +132,7 @@ public class ChunkInterpolator { } private static int reRange(int value, int high) { - return FastMath.max(FastMath.min(value, high), 0); + return Math.max(Math.min(value, high), 0); } /** @@ -146,7 +144,7 @@ public class ChunkInterpolator { * @return double - The interpolated noise at the coordinates. */ public double getNoise(double x, double y, double z) { - return interpGrid[reRange(((int) x) / 4, 3)][(FastMath.max(FastMath.min(((int) y), max), min) - min) / 4][reRange(((int) z) / 4, + return interpGrid[reRange(((int) x) / 4, 3)][(Math.max(Math.min(((int) y), max), min) - min) / 4][reRange(((int) z) / 4, 3)].trilerp( (x % 4) / 4, (y % 4) / 4, (z % 4) / 4); } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/LazilyEvaluatedInterpolator.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/LazilyEvaluatedInterpolator.java index f2a48c50a..d2aa6d13d 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/LazilyEvaluatedInterpolator.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/LazilyEvaluatedInterpolator.java @@ -1,7 +1,5 @@ package com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation; -import net.jafama.FastMath; - import com.dfsek.terra.addons.chunkgenerator.config.noise.BiomeNoiseProperties; import com.dfsek.terra.api.properties.PropertyKey; import com.dfsek.terra.api.world.biome.generation.BiomeProvider; @@ -30,8 +28,8 @@ public class LazilyEvaluatedInterpolator { PropertyKey noisePropertiesKey, int min, int horizontalRes, int verticalRes, long seed) { this.noisePropertiesKey = noisePropertiesKey; - int hSamples = FastMath.ceilToInt(16.0 / horizontalRes); - int vSamples = FastMath.ceilToInt((double) (max - min) / verticalRes); + int hSamples = (int) Math.ceil(16.0 / horizontalRes); + int vSamples = (int) Math.ceil((double) (max - min) / verticalRes); this.zMul = (hSamples + 1); this.yMul = zMul * zMul; samples = new Double[yMul * (vSamples + 1)]; @@ -52,7 +50,7 @@ public class LazilyEvaluatedInterpolator { int xi = ox + chunkX; int zi = oz + chunkZ; - int y = FastMath.min(max, oy); + int y = Math.min(max, oy); sample = biomeProvider .getBiome(xi, y, zi, seed) @@ -93,7 +91,7 @@ public class LazilyEvaluatedInterpolator { return lerp_bottom; } - double yFrac = (double) FastMath.floorMod(y, verticalRes) / verticalRes; + double yFrac = (double) Math.floorMod(y, verticalRes) / verticalRes; double sample_0_1_0 = sample(xIndex, yIndex + 1, zIndex, x, y + verticalRes, z); diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/Sampler3D.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/Sampler3D.java index 15a480969..a4d6545d6 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/Sampler3D.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/Sampler3D.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.chunkgenerator.generation.math.samplers; -import net.jafama.FastMath; - import com.dfsek.terra.addons.chunkgenerator.config.noise.BiomeNoiseProperties; import com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation.ChunkInterpolator; import com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation.ElevationInterpolator; @@ -28,10 +26,10 @@ public class Sampler3D { } public double sample(double x, double y, double z) { - return interpolator.getNoise(x, y, z) + elevationInterpolator.getElevation(FastMath.roundToInt(x), FastMath.roundToInt(z)); + return interpolator.getNoise(x, y, z) + elevationInterpolator.getElevation((int) Math.round(x), (int) Math.round(z)); } public double sample(int x, int y, int z) { - return interpolator.getNoise(x, y, z) + elevationInterpolator.getElevation(FastMath.roundToInt(x), FastMath.roundToInt(z)); + return interpolator.getNoise(x, y, z) + elevationInterpolator.getElevation(x, z); } } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/SamplerProvider.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/SamplerProvider.java index ab20614b5..73a29ef52 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/SamplerProvider.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/SamplerProvider.java @@ -19,7 +19,6 @@ package com.dfsek.terra.addons.chunkgenerator.generation.math.samplers; import com.github.benmanes.caffeine.cache.Cache; import com.github.benmanes.caffeine.cache.Caffeine; -import net.jafama.FastMath; import com.dfsek.terra.addons.chunkgenerator.config.noise.BiomeNoiseProperties; import com.dfsek.terra.api.Platform; @@ -45,8 +44,8 @@ public class SamplerProvider { } public Sampler3D get(int x, int z, WorldProperties world, BiomeProvider provider) { - int cx = FastMath.floorDiv(x, 16); - int cz = FastMath.floorDiv(z, 16); + int cx = Math.floorDiv(x, 16); + int cz = Math.floorDiv(z, 16); return getChunk(cx, cz, world, provider); } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java index fcd48f4a8..3a3c2089b 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.chunkgenerator.palette; -import net.jafama.FastMath; - import java.util.List; import java.util.Map; import java.util.Map.Entry; @@ -55,11 +53,11 @@ public class PaletteHolder { public PaletteHolder build() { - int min = FastMath.min(paletteMap.keySet().stream().min(Integer::compareTo).orElse(0), 0); - int max = FastMath.max(paletteMap.keySet().stream().max(Integer::compareTo).orElse(255), 255); + int min = Math.min(paletteMap.keySet().stream().min(Integer::compareTo).orElse(0), 0); + int max = Math.max(paletteMap.keySet().stream().max(Integer::compareTo).orElse(255), 255); Palette[] palettes = new Palette[paletteMap.lastKey() + 1 - min]; - for(int y = min; y <= FastMath.max(paletteMap.lastKey(), max); y++) { + for(int y = min; y <= Math.max(paletteMap.lastKey(), max); y++) { Palette d = null; for(Entry e : paletteMap.entrySet()) { if(e.getKey() >= y) { diff --git a/common/addons/config-distributors/build.gradle.kts b/common/addons/config-distributors/build.gradle.kts index e38fb40ee..9d0aac37f 100644 --- a/common/addons/config-distributors/build.gradle.kts +++ b/common/addons/config-distributors/build.gradle.kts @@ -2,11 +2,4 @@ version = version("1.0.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) - - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) - testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) } - -tasks.named("shadowJar") { - relocate("net.jafama", "com.dfsek.terra.addons.feature.distributor.lib.jafama") -} \ No newline at end of file diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PaddedGridDistributor.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PaddedGridDistributor.java index bb380e034..bba9a1a42 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PaddedGridDistributor.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PaddedGridDistributor.java @@ -1,7 +1,5 @@ package com.dfsek.terra.addons.feature.distributor.distributors; -import net.jafama.FastMath; - import java.util.Random; import com.dfsek.terra.api.structure.feature.Distributor; @@ -21,21 +19,12 @@ public class PaddedGridDistributor implements Distributor { this.cellWidth = width + padding; } - private static long murmur64(long h) { - h ^= h >>> 33; - h *= 0xff51afd7ed558ccdL; - h ^= h >>> 33; - h *= 0xc4ceb9fe1a85ec53L; - h ^= h >>> 33; - return h; - } - @Override public boolean matches(int x, int z, long seed) { - int cellX = FastMath.floorDiv(x, cellWidth); - int cellZ = FastMath.floorDiv(z, cellWidth); + int cellX = Math.floorDiv(x, cellWidth); + int cellZ = Math.floorDiv(z, cellWidth); - Random random = new Random((murmur64(MathUtil.squash(cellX, cellZ)) ^ seed) + salt); + Random random = new Random((MathUtil.murmur64(MathUtil.squash(cellX, cellZ)) ^ seed) + salt); int pointX = random.nextInt(width) + cellX * cellWidth; int pointZ = random.nextInt(width) + cellZ * cellWidth; diff --git a/common/addons/config-flora/build.gradle.kts b/common/addons/config-flora/build.gradle.kts index 9e1e78d1f..9d0aac37f 100644 --- a/common/addons/config-flora/build.gradle.kts +++ b/common/addons/config-flora/build.gradle.kts @@ -2,10 +2,4 @@ version = version("1.0.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) - testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) -} - -tasks.named("shadowJar") { - relocate("net.jafama", "com.dfsek.terra.addons.flora.lib.jafama") } diff --git a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/TerraFlora.java b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/TerraFlora.java index 31fbf1558..b9c345677 100644 --- a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/TerraFlora.java +++ b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/TerraFlora.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.flora.flora.gen; -import net.jafama.FastMath; - import java.util.ArrayList; import java.util.EnumSet; import java.util.List; @@ -60,7 +58,7 @@ public class TerraFlora implements Structure { } private ProbabilityCollection getStateCollection(int layer) { - return layers.get(FastMath.max(FastMath.min(layer, layers.size() - 1), 0)); + return layers.get(Math.max(Math.min(layer, layers.size() - 1), 0)); } private EnumSet getFaces(Vector3Int b, WritableWorld world) { @@ -82,8 +80,8 @@ public class TerraFlora implements Structure { Direction.class); if(doRotation && faces.size() == 0) return false; // Don't plant if no faces are valid. - for(int i = 0; FastMath.abs(i) < size; i += c) { // Down if ceiling, up if floor - int lvl = (FastMath.abs(i)); + for(int i = 0; Math.abs(i) < size; i += c) { // Down if ceiling, up if floor + int lvl = (Math.abs(i)); BlockState data = getStateCollection((ceiling ? lvl : size - lvl - 1)).get(distribution, location.getX(), location.getY(), location.getZ(), world.getSeed()); if(doRotation) { diff --git a/common/addons/config-locators/build.gradle.kts b/common/addons/config-locators/build.gradle.kts index 50fc70400..47ace7fcc 100644 --- a/common/addons/config-locators/build.gradle.kts +++ b/common/addons/config-locators/build.gradle.kts @@ -2,11 +2,4 @@ version = version("1.1.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) - - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) - testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) -} - -tasks.named("shadowJar") { - relocate("net.jafama", "com.dfsek.terra.addons.feature.locator.lib.jafama") -} +} \ No newline at end of file diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/PatternLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/PatternLocator.java index b4ea6b1d8..0d748aea3 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/PatternLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/PatternLocator.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.feature.locator.locators; -import net.jafama.FastMath; - import com.dfsek.terra.addons.feature.locator.patterns.Pattern; import com.dfsek.terra.api.structure.feature.BinaryColumn; import com.dfsek.terra.api.structure.feature.Locator; @@ -27,8 +25,8 @@ public class PatternLocator implements Locator { @Override public BinaryColumn getSuitableCoordinates(Column column) { - int min = FastMath.max(column.getMinY(), search.getMin()); - int max = FastMath.min(column.getMaxY(), search.getMax()); + int min = Math.max(column.getMinY(), search.getMin()); + int max = Math.min(column.getMaxY(), search.getMax()); if(min >= max) return BinaryColumn.getNull(); return new BinaryColumn(min, max, y -> pattern.matches(y, column)); } diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SurfaceLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SurfaceLocator.java index 9e9b7ef2e..03cccd404 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SurfaceLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SurfaceLocator.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.feature.locator.locators; -import net.jafama.FastMath; - import com.dfsek.terra.api.structure.feature.BinaryColumn; import com.dfsek.terra.api.structure.feature.Locator; import com.dfsek.terra.api.util.Range; @@ -26,8 +24,8 @@ public class SurfaceLocator implements Locator { @Override public BinaryColumn getSuitableCoordinates(Column column) { BinaryColumnBuilder builder = column.newBinaryColumn(); - int max = FastMath.min(search.getMax(), column.getMaxY()); - int min = FastMath.max(search.getMin(), column.getMinY()); + int max = Math.min(search.getMax(), column.getMaxY()); + int min = Math.max(search.getMin(), column.getMinY()); if(min >= max) return builder.build(); for(int y = min; y < max; y++) { if(column.getBlock(y).isAir() && !column.getBlock(y - 1).isAir()) { diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/MatchPattern.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/MatchPattern.java index e2ca64f69..2f83ab30f 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/MatchPattern.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/MatchPattern.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.feature.locator.patterns; -import net.jafama.FastMath; - import java.util.function.Predicate; import com.dfsek.terra.api.block.state.BlockState; @@ -28,8 +26,8 @@ public class MatchPattern implements Pattern { @Override public boolean matches(int y, Column column) { - int min = FastMath.max(column.getMinY(), range.getMin() + y); - int max = FastMath.min(column.getMaxY(), range.getMax() + y); + int min = Math.max(column.getMinY(), range.getMin() + y); + int max = Math.min(column.getMaxY(), range.getMax() + y); if(max <= min) return false; for(int i = min; i < max; i++) { if(!matches.test(column.getBlock(i))) return false; @@ -39,8 +37,8 @@ public class MatchPattern implements Pattern { @Override public boolean matches(WritableWorld world, int x, int y, int z) { - int min = FastMath.max(world.getMinHeight(), range.getMin() + y); - int max = FastMath.min(world.getMaxHeight(), range.getMax() + y); + int min = Math.max(world.getMinHeight(), range.getMin() + y); + int max = Math.min(world.getMaxHeight(), range.getMax() + y); if(max <= min) return false; for(int i = min; i < max; i++) { if(!matches.test(world.getBlockState(x, i, z))) return false; diff --git a/common/addons/config-noise-function/build.gradle.kts b/common/addons/config-noise-function/build.gradle.kts index 02054f08b..887d158b7 100644 --- a/common/addons/config-noise-function/build.gradle.kts +++ b/common/addons/config-noise-function/build.gradle.kts @@ -5,12 +5,4 @@ version = version("1.1.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) api("com.dfsek", "paralithic", Versions.Libraries.paralithic) - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) - testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) } - - -tasks.named("shadowJar") { - relocate("com.dfsek.paralithic", "com.dfsek.terra.addons.noise.lib.paralithic") - relocate("net.jafama", "com.dfsek.terra.addons.noise.lib.jafama") -} \ No newline at end of file diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/CubicSplineNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/CubicSplineNormalizerTemplate.java index 7e70dcc3c..67e537fad 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/CubicSplineNormalizerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/CubicSplineNormalizerTemplate.java @@ -2,14 +2,14 @@ package com.dfsek.terra.addons.noise.config.templates.normalizer; import com.dfsek.tectonic.api.config.template.annotations.Value; +import java.util.List; + import com.dfsek.terra.addons.noise.math.CubicSpline; import com.dfsek.terra.addons.noise.math.CubicSpline.Point; import com.dfsek.terra.addons.noise.normalizer.CubicSplineNoiseSampler; import com.dfsek.terra.api.config.meta.Meta; import com.dfsek.terra.api.noise.NoiseSampler; -import java.util.List; - public class CubicSplineNormalizerTemplate extends NormalizerTemplate { diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java index 97318d388..217147efc 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java @@ -11,16 +11,16 @@ import com.dfsek.paralithic.eval.tokenizer.ParseException; import com.dfsek.tectonic.api.config.template.annotations.Default; import com.dfsek.tectonic.api.config.template.annotations.Value; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.Map; + import com.dfsek.terra.addons.noise.config.DimensionApplicableNoiseSampler; import com.dfsek.terra.addons.noise.config.templates.FunctionTemplate; import com.dfsek.terra.addons.noise.normalizer.ExpressionNormalizer; import com.dfsek.terra.api.config.meta.Meta; import com.dfsek.terra.api.noise.NoiseSampler; -import java.util.HashMap; -import java.util.LinkedHashMap; -import java.util.Map; - import static com.dfsek.terra.addons.noise.paralithic.FunctionUtil.convertFunctionsAndSamplers; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java index ff86bfa10..a1ab99d28 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java @@ -5,6 +5,8 @@ import org.jetbrains.annotations.NotNull; import java.util.Collections; import java.util.List; +import static com.dfsek.terra.api.util.MathUtil.lerp; + public class CubicSpline { @@ -74,11 +76,7 @@ public class CubicSpline { } return left; } - - private static double lerp(double t, double a, double b) { - return a + t * (b - a); - } - + public record Point(double from, double to, double gradient) implements Comparable { @Override diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ClampNormalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ClampNormalizer.java index 62836d966..531a11749 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ClampNormalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ClampNormalizer.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.noise.normalizer; -import net.jafama.FastMath; - import com.dfsek.terra.api.noise.NoiseSampler; @@ -24,6 +22,6 @@ public class ClampNormalizer extends Normalizer { @Override public double normalize(double in) { - return FastMath.max(FastMath.min(in, max), min); + return Math.max(Math.min(in, max), min); } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ExpressionNormalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ExpressionNormalizer.java index 95c607f76..816bba788 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ExpressionNormalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ExpressionNormalizer.java @@ -6,10 +6,10 @@ import com.dfsek.paralithic.eval.parser.Scope; import com.dfsek.paralithic.eval.tokenizer.ParseException; import com.dfsek.paralithic.functions.Function; -import com.dfsek.terra.api.noise.NoiseSampler; - import java.util.Map; +import com.dfsek.terra.api.noise.NoiseSampler; + public class ExpressionNormalizer extends Normalizer { diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/NormalNormalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/NormalNormalizer.java index 132efd3c2..165157119 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/NormalNormalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/NormalNormalizer.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.noise.normalizer; -import net.jafama.FastMath; - import com.dfsek.terra.api.noise.NoiseSampler; import com.dfsek.terra.api.util.MathUtil; @@ -41,8 +39,8 @@ public class NormalNormalizer extends Normalizer { end = mid; } } - double left = FastMath.abs(lookup[start] - in); - double right = FastMath.abs(lookup[end] - in); + double left = Math.abs(lookup[start] - in); + double right = Math.abs(lookup[end] - in); double fin; if(left <= right) { diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/PosterizationNormalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/PosterizationNormalizer.java index bdf1c90d9..03d3902d6 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/PosterizationNormalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/PosterizationNormalizer.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.noise.normalizer; -import net.jafama.FastMath; - import com.dfsek.terra.api.noise.NoiseSampler; @@ -22,6 +20,6 @@ public class PosterizationNormalizer extends Normalizer { @Override public double normalize(double in) { - return FastMath.roundToInt((in + 1) / stepSize) * stepSize - 1; + return (int) Math.round((in + 1) / stepSize) * stepSize - 1; } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java index f968f5bad..9bee3e2c0 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java @@ -3,15 +3,15 @@ package com.dfsek.terra.addons.noise.paralithic; import com.dfsek.paralithic.eval.tokenizer.ParseException; import com.dfsek.paralithic.functions.Function; +import java.util.HashMap; +import java.util.Map; + import com.dfsek.terra.addons.noise.config.DimensionApplicableNoiseSampler; import com.dfsek.terra.addons.noise.config.templates.FunctionTemplate; import com.dfsek.terra.addons.noise.paralithic.defined.UserDefinedFunction; import com.dfsek.terra.addons.noise.paralithic.noise.NoiseFunction2; import com.dfsek.terra.addons.noise.paralithic.noise.NoiseFunction3; -import java.util.HashMap; -import java.util.Map; - public class FunctionUtil { private FunctionUtil() {} diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/ImageSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/ImageSampler.java index 5016d7954..bd60744ad 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/ImageSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/ImageSampler.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.noise.samplers; -import net.jafama.FastMath; - import java.awt.image.BufferedImage; import com.dfsek.terra.api.noise.NoiseSampler; @@ -28,8 +26,8 @@ public class ImageSampler implements NoiseSampler { @Override public double noise(long seed, double x, double y) { - return ((channel.getChannel(image.getRGB(FastMath.floorMod(FastMath.floorToInt(x * frequency), image.getWidth()), - FastMath.floorMod(FastMath.floorToInt(y * frequency), image.getHeight()))) / 255D) - 0.5) * + return ((channel.getChannel(image.getRGB(Math.floorMod((int) Math.floor(x * frequency), image.getWidth()), + Math.floorMod((int) Math.floor(y * frequency), image.getHeight()))) / 255D) - 0.5) * 2; } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MaxSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MaxSampler.java index 4a6521dd3..0418d2069 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MaxSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MaxSampler.java @@ -1,7 +1,5 @@ package com.dfsek.terra.addons.noise.samplers.arithmetic; -import net.jafama.FastMath; - import com.dfsek.terra.api.noise.NoiseSampler; @@ -12,6 +10,6 @@ public class MaxSampler extends BinaryArithmeticSampler { @Override public double operate(double left, double right) { - return FastMath.max(left, right); + return Math.max(left, right); } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MinSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MinSampler.java index 7e7ee7087..a4ada7e26 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MinSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MinSampler.java @@ -1,7 +1,5 @@ package com.dfsek.terra.addons.noise.samplers.arithmetic; -import net.jafama.FastMath; - import com.dfsek.terra.api.noise.NoiseSampler; @@ -12,6 +10,6 @@ public class MinSampler extends BinaryArithmeticSampler { @Override public double operate(double left, double right) { - return FastMath.min(left, right); + return Math.min(left, right); } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java index cdd40990d..89efaf376 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.noise.samplers.noise; -import net.jafama.FastMath; - import com.dfsek.terra.addons.noise.samplers.noise.simplex.OpenSimplex2Sampler; import com.dfsek.terra.api.noise.NoiseSampler; @@ -223,8 +221,8 @@ public class CellularSampler extends NoiseFunction { @Override public double getNoiseRaw(long sl, double x, double y) { int seed = (int) sl; - int xr = fastRound(x); - int yr = fastRound(y); + int xr = (int) Math.round(x); + int yr = (int) Math.round(y); double distance0 = Double.MAX_VALUE; double distance1 = Double.MAX_VALUE; @@ -251,12 +249,12 @@ public class CellularSampler extends NoiseFunction { double vecY = (yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter; double newDistance = switch(distanceFunction) { - case Manhattan -> fastAbs(vecX) + fastAbs(vecY); - case Hybrid -> (fastAbs(vecX) + fastAbs(vecY)) + (vecX * vecX + vecY * vecY); + case Manhattan -> Math.abs(vecX) + Math.abs(vecY); + case Hybrid -> (Math.abs(vecX) + Math.abs(vecY)) + (vecX * vecX + vecY * vecY); default -> vecX * vecX + vecY * vecY; }; - distance1 = fastMax(fastMin(distance1, newDistance), distance0); + distance1 = Math.max(Math.min(distance1, newDistance), distance0); if(newDistance < distance0) { distance0 = newDistance; closestHash = hash; @@ -274,9 +272,9 @@ public class CellularSampler extends NoiseFunction { } if(distanceFunction == DistanceFunction.Euclidean && returnType != ReturnType.CellValue) { - distance0 = fastSqrt(distance0); + distance0 = Math.sqrt(distance0); if(returnType != ReturnType.CellValue) { - distance1 = fastSqrt(distance1); + distance1 = Math.sqrt(distance1); } } @@ -295,16 +293,16 @@ public class CellularSampler extends NoiseFunction { case Distance3Sub -> distance2 - distance0 - 1; case Distance3Mul -> distance2 * distance0 - 1; case Distance3Div -> distance0 / distance2 - 1; - case Angle -> FastMath.atan2(y / frequency - centerY, x / frequency - centerX); + case Angle -> Math.atan2(y / frequency - centerY, x / frequency - centerX); }; } @Override public double getNoiseRaw(long sl, double x, double y, double z) { int seed = (int) sl; - int xr = fastRound(x); - int yr = fastRound(y); - int zr = fastRound(z); + int xr = (int) Math.round(x); + int yr = (int) Math.round(y); + int zr = (int) Math.round(z); double distance0 = Double.MAX_VALUE; double distance1 = Double.MAX_VALUE; @@ -338,10 +336,10 @@ public class CellularSampler extends NoiseFunction { double newDistance = 0; switch(distanceFunction) { case Euclidean, EuclideanSq -> newDistance = vecX * vecX + vecY * vecY + vecZ * vecZ; - case Manhattan -> newDistance = fastAbs(vecX) + fastAbs(vecY) + fastAbs(vecZ); + case Manhattan -> newDistance = Math.abs(vecX) + Math.abs(vecY) + Math.abs(vecZ); case Hybrid -> { - newDistance = (fastAbs(vecX) + fastAbs(vecY) + fastAbs(vecZ)) + (vecX * vecX + vecY * vecY + vecZ * vecZ); - distance1 = fastMax(fastMin(distance1, newDistance), distance0); + newDistance = (Math.abs(vecX) + Math.abs(vecY) + Math.abs(vecZ)) + (vecX * vecX + vecY * vecY + vecZ * vecZ); + distance1 = Math.max(Math.min(distance1, newDistance), distance0); } } @@ -365,9 +363,9 @@ public class CellularSampler extends NoiseFunction { } if(distanceFunction == DistanceFunction.Euclidean && returnType != ReturnType.CellValue) { - distance0 = fastSqrt(distance0); + distance0 = Math.sqrt(distance0); if(returnType != ReturnType.CellValue) { - distance1 = fastSqrt(distance1); + distance1 = Math.sqrt(distance1); } } @@ -386,7 +384,7 @@ public class CellularSampler extends NoiseFunction { case Distance3Sub -> distance2 - distance0 - 1; case Distance3Mul -> distance2 * distance0 - 1; case Distance3Div -> distance0 / distance2 - 1; - case Angle -> FastMath.atan2(y / frequency - centerY, x / frequency - centerX); + case Angle -> Math.atan2(y / frequency - centerY, x / frequency - centerX); }; } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java index 1e083fb86..246c7bab1 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java @@ -25,9 +25,9 @@ public class DistanceSampler extends NoiseFunction { public double getNoiseRaw(long seed, double x, double y) { double dx = x - ox; double dy = y - oz; - if (normalize && (fastAbs(dx) > radius || fastAbs(dy) > radius)) return 1; + if (normalize && (Math.abs(dx) > radius || Math.abs(dy) > radius)) return 1; double dist = distance2d(distanceFunction, dx, dy); - if (normalize) return fastMin(((2*dist)/distanceAtRadius)-1, 1); + if (normalize) return Math.min(((2*dist)/distanceAtRadius)-1, 1); return dist; } @@ -36,25 +36,25 @@ public class DistanceSampler extends NoiseFunction { double dx = x - ox; double dy = y - oy; double dz = z - oz; - if(normalize && (fastAbs(dx) > radius || fastAbs(dy) > radius || fastAbs(dz) > radius)) return 1; + if(normalize && (Math.abs(dx) > radius || Math.abs(dy) > radius || Math.abs(dz) > radius)) return 1; double dist = distance3d(distanceFunction, dx, dy, dz); - if (normalize) return fastMin(((2*dist)/distanceAtRadius)-1, 1); + if (normalize) return Math.min(((2*dist)/distanceAtRadius)-1, 1); return dist; } private static double distance2d(DistanceFunction distanceFunction, double x, double z) { return switch(distanceFunction) { - case Euclidean -> fastSqrt(x*x + z*z); + case Euclidean -> Math.sqrt(x*x + z*z); case EuclideanSq -> x*x + z*z; - case Manhattan -> fastAbs(x) + fastAbs(z); + case Manhattan -> Math.abs(x) + Math.abs(z); }; } private static double distance3d(DistanceFunction distanceFunction, double x, double y, double z) { return switch(distanceFunction) { - case Euclidean -> fastSqrt(x*x + y*y + z*z); + case Euclidean -> Math.sqrt(x*x + y*y + z*z); case EuclideanSq -> x*x + y*y + z*z; - case Manhattan -> fastAbs(x) + fastAbs(y) + fastAbs(z); + case Manhattan -> Math.abs(x) + Math.abs(y) + Math.abs(z); }; } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java index 816b6f35e..458d5fbfe 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java @@ -7,9 +7,8 @@ package com.dfsek.terra.addons.noise.samplers.noise; -import net.jafama.FastMath; - import com.dfsek.terra.addons.noise.samplers.noise.random.WhiteNoiseSampler; +import com.dfsek.terra.api.util.MathUtil; public class GaborNoiseSampler extends NoiseFunction { @@ -17,11 +16,11 @@ public class GaborNoiseSampler extends NoiseFunction { private double k = 1.0; private double a = 0.1; private double f0 = 0.625; - private double kernelRadius = (FastMath.sqrt(-FastMath.log(0.05) / Math.PI) / a); + private double kernelRadius = (Math.sqrt(-Math.log(0.05) / Math.PI) / a); private double impulsesPerKernel = 64d; private double impulseDensity = (impulsesPerKernel / (Math.PI * kernelRadius * kernelRadius)); private double impulsesPerCell = impulseDensity * kernelRadius * kernelRadius; - private double g = FastMath.exp(-impulsesPerCell); + private double g = Math.exp(-impulsesPerCell); private double omega0 = Math.PI * 0.25; private boolean isotropic = true; @@ -32,17 +31,17 @@ public class GaborNoiseSampler extends NoiseFunction { } private void recalculateRadiusAndDensity() { - kernelRadius = (FastMath.sqrt(-FastMath.log(0.05) / Math.PI) / this.a); + kernelRadius = (Math.sqrt(-Math.log(0.05) / Math.PI) / this.a); impulseDensity = (impulsesPerKernel / (Math.PI * kernelRadius * kernelRadius)); impulsesPerCell = impulseDensity * kernelRadius * kernelRadius; - g = FastMath.exp(-impulsesPerCell); + g = Math.exp(-impulsesPerCell); } private double gaborNoise(long seed, double x, double y) { x /= kernelRadius; y /= kernelRadius; - int xi = fastFloor(x); - int yi = fastFloor(y); + int xi = (int) Math.floor(x); + int yi = (int) Math.floor(y); double xf = x - xi; double yf = y - yi; double noise = 0; @@ -55,7 +54,7 @@ public class GaborNoiseSampler extends NoiseFunction { } private double calculateCell(long seed, int xi, int yi, double x, double y) { - long mashedSeed = murmur64(31L * xi + yi) + seed; + long mashedSeed = MathUtil.murmur64(31L * xi + yi) + seed; double gaussianSource = (rand.getNoiseRaw(mashedSeed++) + 1) / 2; int impulses = 0; @@ -73,7 +72,7 @@ public class GaborNoiseSampler extends NoiseFunction { } private double gabor(double omega_0, double x, double y) { - return k * (FastMath.exp(-Math.PI * (a * a) * (x * x + y * y)) * fastCos(2 * Math.PI * f0 * (x * fastCos(omega_0) + y * fastSin( + return k * (Math.exp(-Math.PI * (a * a) * (x * x + y * y)) * MathUtil.cos(2 * Math.PI * f0 * (x * MathUtil.cos(omega_0) + y * MathUtil.sin( omega_0)))); } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java index a1a788ebb..545b59385 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java @@ -7,25 +7,15 @@ package com.dfsek.terra.addons.noise.samplers.noise; -import net.jafama.FastMath; - import com.dfsek.terra.api.noise.NoiseSampler; -@SuppressWarnings("ManualMinMaxCalculation") public abstract class NoiseFunction implements NoiseSampler { // Hashing protected static final int PRIME_X = 501125321; protected static final int PRIME_Y = 1136930381; protected static final int PRIME_Z = 1720413743; - static final int precision = 100; - static final int modulus = 360 * precision; - static final double[] sin = new double[360 * 100]; // lookup table - static { - for(int i = 0; i < sin.length; i++) { - sin[i] = (float) Math.sin((double) (i) / (precision)); - } - } + protected double frequency = 0.02d; protected long salt; @@ -33,10 +23,6 @@ public abstract class NoiseFunction implements NoiseSampler { this.salt = 0; } - protected static int fastFloor(double f) { - return f >= 0 ? (int) f : (int) f - 1; - } - protected static int hash(int seed, int xPrimed, int yPrimed, int zPrimed) { int hash = seed ^ xPrimed ^ yPrimed ^ zPrimed; @@ -51,77 +37,6 @@ public abstract class NoiseFunction implements NoiseSampler { return hash; } - protected static int fastRound(double f) { - return f >= 0 ? (int) (f + 0.5f) : (int) (f - 0.5); - } - - protected static double lerp(double a, double b, double t) { - return a + t * (b - a); - } - - protected static double interpHermite(double t) { - return t * t * (3 - 2 * t); - } - - protected static double interpQuintic(double t) { - return t * t * t * (t * (t * 6 - 15) + 10); - } - - protected static double cubicLerp(double a, double b, double c, double d, double t) { - double p = (d - c) - (a - b); - return t * t * t * p + t * t * ((a - b) - p) + t * (c - a) + b; - } - - protected static double fastMin(double a, double b) { - return a < b ? a : b; - } - - protected static double fastMax(double a, double b) { - return a > b ? a : b; - } - - protected static double fastAbs(double f) { - return f < 0 ? -f : f; - } - - protected static double fastSqrt(double f) { - return FastMath.sqrt(f); - } - - protected static int fastCeil(double f) { - int i = (int) f; - if(i < f) i++; - return i; - } - - /** - * Murmur64 hashing function - * - * @param h Input value - * - * @return Hashed value - */ - protected static long murmur64(long h) { - h ^= h >>> 33; - h *= 0xff51afd7ed558ccdL; - h ^= h >>> 33; - h *= 0xc4ceb9fe1a85ec53L; - h ^= h >>> 33; - return h; - } - - protected static double fastSin(double a) { - return sinLookup((int) (a * precision + 0.5f)); - } - - protected static double fastCos(double a) { - return sinLookup((int) ((a + Math.PI / 2) * precision + 0.5f)); - } - - private static double sinLookup(int a) { - return a >= 0 ? sin[a % (modulus)] : -sin[-a % (modulus)]; - } - public void setSalt(long salt) { this.salt = salt; } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/BrownianMotionSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/BrownianMotionSampler.java index 91a7fb3fc..a51c574c3 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/BrownianMotionSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/BrownianMotionSampler.java @@ -8,6 +8,7 @@ package com.dfsek.terra.addons.noise.samplers.noise.fractal; import com.dfsek.terra.api.noise.NoiseSampler; +import com.dfsek.terra.api.util.MathUtil; public class BrownianMotionSampler extends FractalNoiseFunction { @@ -23,7 +24,7 @@ public class BrownianMotionSampler extends FractalNoiseFunction { for(int i = 0; i < octaves; i++) { double noise = input.noise(seed++, x, y); sum += noise * amp; - amp *= lerp(1.0, fastMin(noise + 1, 2) * 0.5, weightedStrength); + amp *= MathUtil.lerp(1.0, Math.min(noise + 1, 2) * 0.5, weightedStrength); x *= lacunarity; y *= lacunarity; @@ -41,7 +42,7 @@ public class BrownianMotionSampler extends FractalNoiseFunction { for(int i = 0; i < octaves; i++) { double noise = input.noise(seed++, x, y, z); sum += noise * amp; - amp *= lerp(1.0, (noise + 1) * 0.5, weightedStrength); + amp *= MathUtil.lerp(1.0, (noise + 1) * 0.5, weightedStrength); x *= lacunarity; y *= lacunarity; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/FractalNoiseFunction.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/FractalNoiseFunction.java index f24e59f39..e52e6eff4 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/FractalNoiseFunction.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/FractalNoiseFunction.java @@ -25,7 +25,7 @@ public abstract class FractalNoiseFunction extends NoiseFunction { } protected void calculateFractalBounding() { - double gain = fastAbs(this.gain); + double gain = Math.abs(this.gain); double amp = gain; double ampFractal = 1.0; for(int i = 1; i < octaves; i++) { diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/PingPongSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/PingPongSampler.java index b5f9fdd50..e8fd2a114 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/PingPongSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/PingPongSampler.java @@ -8,6 +8,7 @@ package com.dfsek.terra.addons.noise.samplers.noise.fractal; import com.dfsek.terra.api.noise.NoiseSampler; +import com.dfsek.terra.api.util.MathUtil; public class PingPongSampler extends FractalNoiseFunction { @@ -35,7 +36,7 @@ public class PingPongSampler extends FractalNoiseFunction { for(int i = 0; i < octaves; i++) { double noise = pingPong((input.noise(seed++, x, y) + 1) * pingPongStrength); sum += (noise - 0.5) * 2 * amp; - amp *= lerp(1.0, noise, weightedStrength); + amp *= MathUtil.lerp(1.0, noise, weightedStrength); x *= lacunarity; y *= lacunarity; @@ -53,7 +54,7 @@ public class PingPongSampler extends FractalNoiseFunction { for(int i = 0; i < octaves; i++) { double noise = pingPong((input.noise(seed++, x, y, z) + 1) * pingPongStrength); sum += (noise - 0.5) * 2 * amp; - amp *= lerp(1.0, noise, weightedStrength); + amp *= MathUtil.lerp(1.0, noise, weightedStrength); x *= lacunarity; y *= lacunarity; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/RidgedFractalSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/RidgedFractalSampler.java index 9569a8971..19800bed8 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/RidgedFractalSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/RidgedFractalSampler.java @@ -8,6 +8,7 @@ package com.dfsek.terra.addons.noise.samplers.noise.fractal; import com.dfsek.terra.api.noise.NoiseSampler; +import com.dfsek.terra.api.util.MathUtil; public class RidgedFractalSampler extends FractalNoiseFunction { @@ -22,9 +23,9 @@ public class RidgedFractalSampler extends FractalNoiseFunction { double amp = fractalBounding; for(int i = 0; i < octaves; i++) { - double noise = fastAbs(input.noise(seed++, x, y)); + double noise = Math.abs(input.noise(seed++, x, y)); sum += (noise * -2 + 1) * amp; - amp *= lerp(1.0, 1 - noise, weightedStrength); + amp *= MathUtil.lerp(1.0, 1 - noise, weightedStrength); x *= lacunarity; y *= lacunarity; @@ -40,9 +41,9 @@ public class RidgedFractalSampler extends FractalNoiseFunction { double amp = fractalBounding; for(int i = 0; i < octaves; i++) { - double noise = fastAbs(input.noise(seed++, x, y, z)); + double noise = Math.abs(input.noise(seed++, x, y, z)); sum += (noise * -2 + 1) * amp; - amp *= lerp(1.0, 1 - noise, weightedStrength); + amp *= MathUtil.lerp(1.0, 1 - noise, weightedStrength); x *= lacunarity; y *= lacunarity; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/PositiveWhiteNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/PositiveWhiteNoiseSampler.java index 4046cdef4..d4b4ddd94 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/PositiveWhiteNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/PositiveWhiteNoiseSampler.java @@ -7,6 +7,9 @@ package com.dfsek.terra.addons.noise.samplers.noise.random; +import com.dfsek.terra.api.util.MathUtil; + + /** * NoiseSampler implementation to produce random, uniformly distributed (white) noise. */ @@ -15,7 +18,7 @@ public class PositiveWhiteNoiseSampler extends WhiteNoiseSampler { // Bits that when applied to the exponent/sign section of a double, produce a positive number with a power of 1. public double getNoiseRaw(long seed) { - return (Double.longBitsToDouble((murmur64(seed) & 0x000fffffffffffffL) | POSITIVE_POW1) - 1.5) * 2; + return (Double.longBitsToDouble((MathUtil.murmur64(seed) & 0x000fffffffffffffL) | POSITIVE_POW1) - 1.5) * 2; } @Override diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/WhiteNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/WhiteNoiseSampler.java index d8399f1af..4c98e04e1 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/WhiteNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/WhiteNoiseSampler.java @@ -8,6 +8,7 @@ package com.dfsek.terra.addons.noise.samplers.noise.random; import com.dfsek.terra.addons.noise.samplers.noise.NoiseFunction; +import com.dfsek.terra.api.util.MathUtil; /** @@ -24,18 +25,18 @@ public class WhiteNoiseSampler extends NoiseFunction { long hashX = Double.doubleToRawLongBits(x) ^ seed; long hashZ = Double.doubleToRawLongBits(y) ^ seed; long hash = (((hashX ^ (hashX >>> 32)) + ((hashZ ^ (hashZ >>> 32)) << 32)) ^ seed) + Double.doubleToRawLongBits(z); - return murmur64(hash); + return MathUtil.murmur64(hash); } public long randomBits(long seed, double x, double y) { long hashX = Double.doubleToRawLongBits(x) ^ seed; long hashZ = Double.doubleToRawLongBits(y) ^ seed; long hash = ((hashX ^ (hashX >>> 32)) + ((hashZ ^ (hashZ >>> 32)) << 32)) ^ seed; - return murmur64(hash); + return MathUtil.murmur64(hash); } public double getNoiseRaw(long seed) { - return (Double.longBitsToDouble((murmur64(seed) & 0x000fffffffffffffL) | POSITIVE_POW1) - 1.5) * 2; + return (Double.longBitsToDouble((MathUtil.murmur64(seed) & 0x000fffffffffffffL) | POSITIVE_POW1) - 1.5) * 2; } @Override diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2SSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2SSampler.java index 90f6a713f..be20803a8 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2SSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2SSampler.java @@ -26,8 +26,8 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler { y += s; - int i = fastFloor(x); - int j = fastFloor(y); + int i = (int) Math.floor(x); + int j = (int) Math.floor(y); double xi = x - i; double yi = y - j; @@ -131,9 +131,9 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler { z = r - z; - int i = fastFloor(x); - int j = fastFloor(y); - int k = fastFloor(z); + int i = (int) Math.floor(x); + int j = (int) Math.floor(y); + int k = (int) Math.floor(z); double xi = x - i; double yi = y - j; double zi = z - k; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2Sampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2Sampler.java index f4fc0018e..5c5256478 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2Sampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2Sampler.java @@ -25,8 +25,8 @@ public class OpenSimplex2Sampler extends SimplexStyleSampler { y += s; - int i = fastFloor(x); - int j = fastFloor(y); + int i = (int) Math.floor(x); + int j = (int) Math.floor(y); double xi = x - i; double yi = y - j; @@ -85,9 +85,9 @@ public class OpenSimplex2Sampler extends SimplexStyleSampler { z = r - z; - int i = fastRound(x); - int j = fastRound(y); - int k = fastRound(z); + int i = (int) Math.round(x); + int j = (int) Math.round(y); + int k = (int) Math.round(z); double x0 = x - i; double y0 = y - j; double z0 = z - k; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/PerlinSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/PerlinSampler.java index 999b73265..7b8866c44 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/PerlinSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/PerlinSampler.java @@ -7,6 +7,9 @@ package com.dfsek.terra.addons.noise.samplers.noise.simplex; +import com.dfsek.terra.api.util.MathUtil; + + /** * NoiseSampler implementation to provide Perlin Noise. */ @@ -14,34 +17,34 @@ public class PerlinSampler extends SimplexStyleSampler { @Override public double getNoiseRaw(long sl, double x, double y) { int seed = (int) sl; - int x0 = fastFloor(x); - int y0 = fastFloor(y); + int x0 = (int) Math.floor(x); + int y0 = (int) Math.floor(y); double xd0 = x - x0; double yd0 = y - y0; double xd1 = xd0 - 1; double yd1 = yd0 - 1; - double xs = interpQuintic(xd0); - double ys = interpQuintic(yd0); + double xs = MathUtil.interpQuintic(xd0); + double ys = MathUtil.interpQuintic(yd0); x0 *= PRIME_X; y0 *= PRIME_Y; int x1 = x0 + PRIME_X; int y1 = y0 + PRIME_Y; - double xf0 = lerp(gradCoord(seed, x0, y0, xd0, yd0), gradCoord(seed, x1, y0, xd1, yd0), xs); - double xf1 = lerp(gradCoord(seed, x0, y1, xd0, yd1), gradCoord(seed, x1, y1, xd1, yd1), xs); + double xf0 = MathUtil.lerp(gradCoord(seed, x0, y0, xd0, yd0), gradCoord(seed, x1, y0, xd1, yd0), xs); + double xf1 = MathUtil.lerp(gradCoord(seed, x0, y1, xd0, yd1), gradCoord(seed, x1, y1, xd1, yd1), xs); - return lerp(xf0, xf1, ys) * 1.4247691104677813; + return MathUtil.lerp(xf0, xf1, ys) * 1.4247691104677813; } @Override public double getNoiseRaw(long sl, double x, double y, double z) { int seed = (int) sl; - int x0 = fastFloor(x); - int y0 = fastFloor(y); - int z0 = fastFloor(z); + int x0 = (int) Math.floor(x); + int y0 = (int) Math.floor(y); + int z0 = (int) Math.floor(z); double xd0 = x - x0; double yd0 = y - y0; @@ -50,9 +53,9 @@ public class PerlinSampler extends SimplexStyleSampler { double yd1 = yd0 - 1; double zd1 = zd0 - 1; - double xs = interpQuintic(xd0); - double ys = interpQuintic(yd0); - double zs = interpQuintic(zd0); + double xs = MathUtil.interpQuintic(xd0); + double ys = MathUtil.interpQuintic(yd0); + double zs = MathUtil.interpQuintic(zd0); x0 *= PRIME_X; y0 *= PRIME_Y; @@ -61,14 +64,14 @@ public class PerlinSampler extends SimplexStyleSampler { int y1 = y0 + PRIME_Y; int z1 = z0 + PRIME_Z; - double xf00 = lerp(gradCoord(seed, x0, y0, z0, xd0, yd0, zd0), gradCoord(seed, x1, y0, z0, xd1, yd0, zd0), xs); - double xf10 = lerp(gradCoord(seed, x0, y1, z0, xd0, yd1, zd0), gradCoord(seed, x1, y1, z0, xd1, yd1, zd0), xs); - double xf01 = lerp(gradCoord(seed, x0, y0, z1, xd0, yd0, zd1), gradCoord(seed, x1, y0, z1, xd1, yd0, zd1), xs); - double xf11 = lerp(gradCoord(seed, x0, y1, z1, xd0, yd1, zd1), gradCoord(seed, x1, y1, z1, xd1, yd1, zd1), xs); + double xf00 = MathUtil.lerp(gradCoord(seed, x0, y0, z0, xd0, yd0, zd0), gradCoord(seed, x1, y0, z0, xd1, yd0, zd0), xs); + double xf10 = MathUtil.lerp(gradCoord(seed, x0, y1, z0, xd0, yd1, zd0), gradCoord(seed, x1, y1, z0, xd1, yd1, zd0), xs); + double xf01 = MathUtil.lerp(gradCoord(seed, x0, y0, z1, xd0, yd0, zd1), gradCoord(seed, x1, y0, z1, xd1, yd0, zd1), xs); + double xf11 = MathUtil.lerp(gradCoord(seed, x0, y1, z1, xd0, yd1, zd1), gradCoord(seed, x1, y1, z1, xd1, yd1, zd1), xs); - double yf0 = lerp(xf00, xf10, ys); - double yf1 = lerp(xf01, xf11, ys); + double yf0 = MathUtil.lerp(xf00, xf10, ys); + double yf1 = MathUtil.lerp(xf01, xf11, ys); - return lerp(yf0, yf1, zs) * 0.964921414852142333984375; + return MathUtil.lerp(yf0, yf1, zs) * 0.964921414852142333984375; } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexSampler.java index 4cacc6fef..5066f1488 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexSampler.java @@ -61,8 +61,8 @@ public class SimplexSampler extends SimplexStyleSampler { public double getNoiseRaw(long sl, double x, double y) { int seed = (int) sl; double t = (x + y) * F2; - int i = fastFloor(x + t); - int j = fastFloor(y + t); + int i = (int) Math.floor(x + t); + int j = (int) Math.floor(y + t); t = (i + j) * G2; double X0 = i - t; @@ -118,9 +118,9 @@ public class SimplexSampler extends SimplexStyleSampler { public double getNoiseRaw(long sl, double x, double y, double z) { int seed = (int) sl; double t = (x + y + z) * F3; - int i = fastFloor(x + t); - int j = fastFloor(y + t); - int k = fastFloor(z + t); + int i = (int) Math.floor(x + t); + int j = (int) Math.floor(y + t); + int k = (int) Math.floor(z + t); t = (i + j + k) * G3; double x0 = x - (i - t); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java index 9995046e1..ab4074a5c 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java @@ -7,12 +7,15 @@ package com.dfsek.terra.addons.noise.samplers.noise.value; +import com.dfsek.terra.api.util.MathUtil; + + public class ValueCubicSampler extends ValueStyleNoise { @Override public double getNoiseRaw(long sl, double x, double y) { int seed = (int) sl; - int x1 = fastFloor(x); - int y1 = fastFloor(y); + int x1 = (int) Math.floor(x); + int y1 = (int) Math.floor(y); double xs = x - x1; double ys = y - y1; @@ -26,14 +29,14 @@ public class ValueCubicSampler extends ValueStyleNoise { int x3 = x1 + (PRIME_X << 1); int y3 = y1 + (PRIME_Y << 1); - return cubicLerp( - cubicLerp(valCoord(seed, x0, y0), valCoord(seed, x1, y0), valCoord(seed, x2, y0), valCoord(seed, x3, y0), + return MathUtil.cubicLerp( + MathUtil.cubicLerp(valCoord(seed, x0, y0), valCoord(seed, x1, y0), valCoord(seed, x2, y0), valCoord(seed, x3, y0), + xs), + MathUtil.cubicLerp(valCoord(seed, x0, y1), valCoord(seed, x1, y1), valCoord(seed, x2, y1), valCoord(seed, x3, y1), xs), - cubicLerp(valCoord(seed, x0, y1), valCoord(seed, x1, y1), valCoord(seed, x2, y1), valCoord(seed, x3, y1), + MathUtil.cubicLerp(valCoord(seed, x0, y2), valCoord(seed, x1, y2), valCoord(seed, x2, y2), valCoord(seed, x3, y2), xs), - cubicLerp(valCoord(seed, x0, y2), valCoord(seed, x1, y2), valCoord(seed, x2, y2), valCoord(seed, x3, y2), - xs), - cubicLerp(valCoord(seed, x0, y3), valCoord(seed, x1, y3), valCoord(seed, x2, y3), valCoord(seed, x3, y3), + MathUtil.cubicLerp(valCoord(seed, x0, y3), valCoord(seed, x1, y3), valCoord(seed, x2, y3), valCoord(seed, x3, y3), xs), ys) * (1 / (1.5 * 1.5)); } @@ -41,9 +44,9 @@ public class ValueCubicSampler extends ValueStyleNoise { @Override public double getNoiseRaw(long sl, double x, double y, double z) { int seed = (int) sl; - int x1 = fastFloor(x); - int y1 = fastFloor(y); - int z1 = fastFloor(z); + int x1 = (int) Math.floor(x); + int y1 = (int) Math.floor(y); + int z1 = (int) Math.floor(z); double xs = x - x1; double ys = y - y1; @@ -63,45 +66,45 @@ public class ValueCubicSampler extends ValueStyleNoise { int y3 = y1 + (PRIME_Y << 1); int z3 = z1 + (PRIME_Z << 1); - return cubicLerp( - cubicLerp( - cubicLerp(valCoord(seed, x0, y0, z0), valCoord(seed, x1, y0, z0), valCoord(seed, x2, y0, z0), + return MathUtil.cubicLerp( + MathUtil.cubicLerp( + MathUtil.cubicLerp(valCoord(seed, x0, y0, z0), valCoord(seed, x1, y0, z0), valCoord(seed, x2, y0, z0), valCoord(seed, x3, y0, z0), xs), - cubicLerp(valCoord(seed, x0, y1, z0), valCoord(seed, x1, y1, z0), valCoord(seed, x2, y1, z0), + MathUtil.cubicLerp(valCoord(seed, x0, y1, z0), valCoord(seed, x1, y1, z0), valCoord(seed, x2, y1, z0), valCoord(seed, x3, y1, z0), xs), - cubicLerp(valCoord(seed, x0, y2, z0), valCoord(seed, x1, y2, z0), valCoord(seed, x2, y2, z0), + MathUtil.cubicLerp(valCoord(seed, x0, y2, z0), valCoord(seed, x1, y2, z0), valCoord(seed, x2, y2, z0), valCoord(seed, x3, y2, z0), xs), - cubicLerp(valCoord(seed, x0, y3, z0), valCoord(seed, x1, y3, z0), valCoord(seed, x2, y3, z0), + MathUtil.cubicLerp(valCoord(seed, x0, y3, z0), valCoord(seed, x1, y3, z0), valCoord(seed, x2, y3, z0), valCoord(seed, x3, y3, z0), xs), ys), - cubicLerp( - cubicLerp(valCoord(seed, x0, y0, z1), valCoord(seed, x1, y0, z1), valCoord(seed, x2, y0, z1), + MathUtil.cubicLerp( + MathUtil.cubicLerp(valCoord(seed, x0, y0, z1), valCoord(seed, x1, y0, z1), valCoord(seed, x2, y0, z1), valCoord(seed, x3, y0, z1), xs), - cubicLerp(valCoord(seed, x0, y1, z1), valCoord(seed, x1, y1, z1), valCoord(seed, x2, y1, z1), + MathUtil.cubicLerp(valCoord(seed, x0, y1, z1), valCoord(seed, x1, y1, z1), valCoord(seed, x2, y1, z1), valCoord(seed, x3, y1, z1), xs), - cubicLerp(valCoord(seed, x0, y2, z1), valCoord(seed, x1, y2, z1), valCoord(seed, x2, y2, z1), + MathUtil.cubicLerp(valCoord(seed, x0, y2, z1), valCoord(seed, x1, y2, z1), valCoord(seed, x2, y2, z1), valCoord(seed, x3, y2, z1), xs), - cubicLerp(valCoord(seed, x0, y3, z1), valCoord(seed, x1, y3, z1), valCoord(seed, x2, y3, z1), + MathUtil.cubicLerp(valCoord(seed, x0, y3, z1), valCoord(seed, x1, y3, z1), valCoord(seed, x2, y3, z1), valCoord(seed, x3, y3, z1), xs), ys), - cubicLerp( - cubicLerp(valCoord(seed, x0, y0, z2), valCoord(seed, x1, y0, z2), valCoord(seed, x2, y0, z2), + MathUtil.cubicLerp( + MathUtil.cubicLerp(valCoord(seed, x0, y0, z2), valCoord(seed, x1, y0, z2), valCoord(seed, x2, y0, z2), valCoord(seed, x3, y0, z2), xs), - cubicLerp(valCoord(seed, x0, y1, z2), valCoord(seed, x1, y1, z2), valCoord(seed, x2, y1, z2), + MathUtil.cubicLerp(valCoord(seed, x0, y1, z2), valCoord(seed, x1, y1, z2), valCoord(seed, x2, y1, z2), valCoord(seed, x3, y1, z2), xs), - cubicLerp(valCoord(seed, x0, y2, z2), valCoord(seed, x1, y2, z2), valCoord(seed, x2, y2, z2), + MathUtil.cubicLerp(valCoord(seed, x0, y2, z2), valCoord(seed, x1, y2, z2), valCoord(seed, x2, y2, z2), valCoord(seed, x3, y2, z2), xs), - cubicLerp(valCoord(seed, x0, y3, z2), valCoord(seed, x1, y3, z2), valCoord(seed, x2, y3, z2), + MathUtil.cubicLerp(valCoord(seed, x0, y3, z2), valCoord(seed, x1, y3, z2), valCoord(seed, x2, y3, z2), valCoord(seed, x3, y3, z2), xs), ys), - cubicLerp( - cubicLerp(valCoord(seed, x0, y0, z3), valCoord(seed, x1, y0, z3), valCoord(seed, x2, y0, z3), + MathUtil.cubicLerp( + MathUtil.cubicLerp(valCoord(seed, x0, y0, z3), valCoord(seed, x1, y0, z3), valCoord(seed, x2, y0, z3), valCoord(seed, x3, y0, z3), xs), - cubicLerp(valCoord(seed, x0, y1, z3), valCoord(seed, x1, y1, z3), valCoord(seed, x2, y1, z3), + MathUtil.cubicLerp(valCoord(seed, x0, y1, z3), valCoord(seed, x1, y1, z3), valCoord(seed, x2, y1, z3), valCoord(seed, x3, y1, z3), xs), - cubicLerp(valCoord(seed, x0, y2, z3), valCoord(seed, x1, y2, z3), valCoord(seed, x2, y2, z3), + MathUtil.cubicLerp(valCoord(seed, x0, y2, z3), valCoord(seed, x1, y2, z3), valCoord(seed, x2, y2, z3), valCoord(seed, x3, y2, z3), xs), - cubicLerp(valCoord(seed, x0, y3, z3), valCoord(seed, x1, y3, z3), valCoord(seed, x2, y3, z3), + MathUtil.cubicLerp(valCoord(seed, x0, y3, z3), valCoord(seed, x1, y3, z3), valCoord(seed, x2, y3, z3), valCoord(seed, x3, y3, z3), xs), ys), zs) * (1 / (1.5 * 1.5 * 1.5)); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueSampler.java index fbab36d35..c4912d90f 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueSampler.java @@ -7,37 +7,40 @@ package com.dfsek.terra.addons.noise.samplers.noise.value; +import com.dfsek.terra.api.util.MathUtil; + + public class ValueSampler extends ValueStyleNoise { @Override public double getNoiseRaw(long sl, double x, double y) { int seed = (int) sl; - int x0 = fastFloor(x); - int y0 = fastFloor(y); + int x0 = (int) Math.floor(x); + int y0 = (int) Math.floor(y); - double xs = interpHermite(x - x0); - double ys = interpHermite(y - y0); + double xs = MathUtil.interpHermite(x - x0); + double ys = MathUtil.interpHermite(y - y0); x0 *= PRIME_X; y0 *= PRIME_Y; int x1 = x0 + PRIME_X; int y1 = y0 + PRIME_Y; - double xf0 = lerp(valCoord(seed, x0, y0), valCoord(seed, x1, y0), xs); - double xf1 = lerp(valCoord(seed, x0, y1), valCoord(seed, x1, y1), xs); + double xf0 = MathUtil.lerp(valCoord(seed, x0, y0), valCoord(seed, x1, y0), xs); + double xf1 = MathUtil.lerp(valCoord(seed, x0, y1), valCoord(seed, x1, y1), xs); - return lerp(xf0, xf1, ys); + return MathUtil.lerp(xf0, xf1, ys); } @Override public double getNoiseRaw(long sl, double x, double y, double z) { int seed = (int) sl; - int x0 = fastFloor(x); - int y0 = fastFloor(y); - int z0 = fastFloor(z); + int x0 = (int) Math.floor(x); + int y0 = (int) Math.floor(y); + int z0 = (int) Math.floor(z); - double xs = interpHermite(x - x0); - double ys = interpHermite(y - y0); - double zs = interpHermite(z - z0); + double xs = MathUtil.interpHermite(x - x0); + double ys = MathUtil.interpHermite(y - y0); + double zs = MathUtil.interpHermite(z - z0); x0 *= PRIME_X; y0 *= PRIME_Y; @@ -46,14 +49,14 @@ public class ValueSampler extends ValueStyleNoise { int y1 = y0 + PRIME_Y; int z1 = z0 + PRIME_Z; - double xf00 = lerp(valCoord(seed, x0, y0, z0), valCoord(seed, x1, y0, z0), xs); - double xf10 = lerp(valCoord(seed, x0, y1, z0), valCoord(seed, x1, y1, z0), xs); - double xf01 = lerp(valCoord(seed, x0, y0, z1), valCoord(seed, x1, y0, z1), xs); - double xf11 = lerp(valCoord(seed, x0, y1, z1), valCoord(seed, x1, y1, z1), xs); + double xf00 = MathUtil.lerp(valCoord(seed, x0, y0, z0), valCoord(seed, x1, y0, z0), xs); + double xf10 = MathUtil.lerp(valCoord(seed, x0, y1, z0), valCoord(seed, x1, y1, z0), xs); + double xf01 = MathUtil.lerp(valCoord(seed, x0, y0, z1), valCoord(seed, x1, y0, z1), xs); + double xf11 = MathUtil.lerp(valCoord(seed, x0, y1, z1), valCoord(seed, x1, y1, z1), xs); - double yf0 = lerp(xf00, xf10, ys); - double yf1 = lerp(xf01, xf11, ys); + double yf0 = MathUtil.lerp(xf00, xf10, ys); + double yf1 = MathUtil.lerp(xf01, xf11, ys); - return lerp(yf0, yf1, zs); + return MathUtil.lerp(yf0, yf1, zs); } } diff --git a/common/addons/config-ore-v2/build.gradle.kts b/common/addons/config-ore-v2/build.gradle.kts index d575f43d3..d3eaff9fe 100644 --- a/common/addons/config-ore-v2/build.gradle.kts +++ b/common/addons/config-ore-v2/build.gradle.kts @@ -2,10 +2,4 @@ version = version("1.0.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) - testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) -} - -tasks.named("shadowJar") { - relocate("net.jafama", "com.dfsek.terra.addons.ore.lib.jafama") -} +} \ No newline at end of file diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java index dc77f31ed..9f219f17f 100644 --- a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java +++ b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.ore.v2.ores; -import net.jafama.FastMath; - import java.util.BitSet; import java.util.Map; import java.util.Random; @@ -16,6 +14,7 @@ import java.util.Random; import com.dfsek.terra.api.block.BlockType; import com.dfsek.terra.api.block.state.BlockState; import com.dfsek.terra.api.structure.Structure; +import com.dfsek.terra.api.util.MathUtil; import com.dfsek.terra.api.util.Rotation; import com.dfsek.terra.api.util.collection.MaterialSet; import com.dfsek.terra.api.util.vector.Vector3Int; @@ -62,11 +61,11 @@ public class VanillaOre implements Structure { double eigthSize = size / 8.0F; // Place points to form a line segment - double startX = (double) location.getX() + FastMath.sin(randomRadian) * eigthSize; - double endX = (double) location.getX() - FastMath.sin(randomRadian) * eigthSize; + double startX = (double) location.getX() + MathUtil.sin(randomRadian) * eigthSize; + double endX = (double) location.getX() - MathUtil.sin(randomRadian) * eigthSize; - double startZ = (double) location.getZ() + FastMath.cos(randomRadian) * eigthSize; - double endZ = (double) location.getZ() - FastMath.cos(randomRadian) * eigthSize; + double startZ = (double) location.getZ() + MathUtil.cos(randomRadian) * eigthSize; + double endZ = (double) location.getZ() - MathUtil.cos(randomRadian) * eigthSize; double startY = location.getY() + random.nextInt(3) - 2; double endY = location.getY() + random.nextInt(3) - 2; @@ -82,7 +81,7 @@ public class VanillaOre implements Structure { double zt = lerp(t, startZ, endZ); double roll = random.nextDouble() * size / 16.0; // Taper radius closer to line ends - double radius = ((FastMath.sin((float) Math.PI * t) + 1.0F) * roll + 1.0) / 2.0; + double radius = ((MathUtil.sin((float) Math.PI * t) + 1.0F) * roll + 1.0) / 2.0; points[i * 4] = xt; points[i * 4 + 1] = yt; points[i * 4 + 2] = zt; @@ -115,12 +114,12 @@ public class VanillaOre implements Structure { } } - int outset = (int) FastMath.ceil((size / 16.0F * 2.0F + 1.0F) / 2.0F); - int x = (int) (location.getX() - FastMath.ceil(eigthSize) - outset); + int outset = (int) Math.ceil((size / 16.0F * 2.0F + 1.0F) / 2.0F); + int x = (int) (location.getX() - Math.ceil(eigthSize) - outset); int y = location.getY() - 2 - outset; - int z = (int) (location.getZ() - FastMath.ceil(eigthSize) - outset); + int z = (int) (location.getZ() - Math.ceil(eigthSize) - outset); - int horizontalSize = (int) (2 * (FastMath.ceil(eigthSize) + outset)); + int horizontalSize = (int) (2 * (Math.ceil(eigthSize) + outset)); int verticalSize = 2 * (2 + outset); int sphereCount = 0; @@ -134,14 +133,14 @@ public class VanillaOre implements Structure { double yt = points[i * 4 + 1]; double zt = points[i * 4 + 2]; - int xLowerBound = (int) FastMath.max(FastMath.floor(xt - radius), x); - int xUpperBound = (int) FastMath.max(FastMath.floor(xt + radius), xLowerBound); + int xLowerBound = (int) Math.max(Math.floor(xt - radius), x); + int xUpperBound = (int) Math.max(Math.floor(xt + radius), xLowerBound); - int yLowerBound = (int) FastMath.max(FastMath.floor(yt - radius), y); - int yUpperBound = (int) FastMath.max(FastMath.floor(yt + radius), yLowerBound); + int yLowerBound = (int) Math.max(Math.floor(yt - radius), y); + int yUpperBound = (int) Math.max(Math.floor(yt + radius), yLowerBound); - int zLowerBound = (int) FastMath.max(FastMath.floor(zt - radius), z); - int zUpperBound = (int) FastMath.max(FastMath.floor(zt + radius), zLowerBound); + int zLowerBound = (int) Math.max(Math.floor(zt - radius), z); + int zUpperBound = (int) Math.max(Math.floor(zt + radius), zLowerBound); // Iterate over coordinates within bounds for(int xi = xLowerBound; xi <= xUpperBound; ++xi) { diff --git a/common/addons/config-ore/build.gradle.kts b/common/addons/config-ore/build.gradle.kts index d575f43d3..8cbbf63e6 100644 --- a/common/addons/config-ore/build.gradle.kts +++ b/common/addons/config-ore/build.gradle.kts @@ -2,10 +2,5 @@ version = version("1.0.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) - testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) } -tasks.named("shadowJar") { - relocate("net.jafama", "com.dfsek.terra.addons.ore.lib.jafama") -} diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java index a1046aea9..224d0b502 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java @@ -7,14 +7,13 @@ package com.dfsek.terra.addons.ore.ores; -import net.jafama.FastMath; - import java.util.Map; import java.util.Random; import com.dfsek.terra.api.block.BlockType; import com.dfsek.terra.api.block.state.BlockState; import com.dfsek.terra.api.structure.Structure; +import com.dfsek.terra.api.util.MathUtil; import com.dfsek.terra.api.util.Rotation; import com.dfsek.terra.api.util.collection.MaterialSet; import com.dfsek.terra.api.util.vector.Vector3Int; @@ -50,10 +49,10 @@ public class VanillaOre implements Structure { float f = random.nextFloat() * (float) Math.PI; - double d1 = centerX + 8 + FastMath.sin(f) * size / 8.0F; - double d2 = centerX + 8 - FastMath.sin(f) * size / 8.0F; - double d3 = centerZ + 8 + FastMath.cos(f) * size / 8.0F; - double d4 = centerZ + 8 - FastMath.cos(f) * size / 8.0F; + double d1 = centerX + 8 + MathUtil.sin(f) * size / 8.0F; + double d2 = centerX + 8 - MathUtil.sin(f) * size / 8.0F; + double d3 = centerZ + 8 + MathUtil.cos(f) * size / 8.0F; + double d4 = centerZ + 8 - MathUtil.cos(f) * size / 8.0F; double d5 = centerY + random.nextInt(3) - 2D; double d6 = centerY + random.nextInt(3) - 2D; @@ -62,16 +61,16 @@ public class VanillaOre implements Structure { float iFactor = (float) i / (float) size; double d10 = random.nextDouble() * size / 16.0D; - double d11 = (FastMath.sin(Math.PI * iFactor) + 1.0) * d10 + 1.0; - double d12 = (FastMath.sin(Math.PI * iFactor) + 1.0) * d10 + 1.0; + double d11 = (MathUtil.sin(Math.PI * iFactor) + 1.0) * d10 + 1.0; + double d12 = (MathUtil.sin(Math.PI * iFactor) + 1.0) * d10 + 1.0; - int xStart = FastMath.roundToInt(FastMath.floor(d1 + (d2 - d1) * iFactor - d11 / 2.0D)); - int yStart = FastMath.roundToInt(FastMath.floor(d5 + (d6 - d5) * iFactor - d12 / 2.0D)); - int zStart = FastMath.roundToInt(FastMath.floor(d3 + (d4 - d3) * iFactor - d11 / 2.0D)); + int xStart = (int) Math.round(Math.floor(d1 + (d2 - d1) * iFactor - d11 / 2.0D)); + int yStart = (int) Math.round(Math.floor(d5 + (d6 - d5) * iFactor - d12 / 2.0D)); + int zStart = (int) Math.round(Math.floor(d3 + (d4 - d3) * iFactor - d11 / 2.0D)); - int xEnd = FastMath.roundToInt(FastMath.floor(d1 + (d2 - d1) * iFactor + d11 / 2.0D)); - int yEnd = FastMath.roundToInt(FastMath.floor(d5 + (d6 - d5) * iFactor + d12 / 2.0D)); - int zEnd = FastMath.roundToInt(FastMath.floor(d3 + (d4 - d3) * iFactor + d11 / 2.0D)); + int xEnd = (int) Math.round(Math.floor(d1 + (d2 - d1) * iFactor + d11 / 2.0D)); + int yEnd = (int) Math.round(Math.floor(d5 + (d6 - d5) * iFactor + d12 / 2.0D)); + int zEnd = (int) Math.round(Math.floor(d3 + (d4 - d3) * iFactor + d11 / 2.0D)); for(int x = xStart; x <= xEnd; x++) { double d13 = (x + 0.5D - (d1 + (d2 - d1) * iFactor)) / (d11 / 2.0D); diff --git a/common/addons/config-structure/build.gradle.kts b/common/addons/config-structure/build.gradle.kts index dad8fff7d..aab2399ea 100644 --- a/common/addons/config-structure/build.gradle.kts +++ b/common/addons/config-structure/build.gradle.kts @@ -3,11 +3,4 @@ version = version("1.0.0") dependencies { api("com.googlecode.json-simple:json-simple:1.1.1") compileOnlyApi(project(":common:addons:manifest-addon-loader")) - - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) - testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) -} - -tasks.named("shadowJar") { - relocate("net.jafama", "com.dfsek.terra.addons.structure.lib.jafama") } diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Entry.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Entry.java index ab8be10e2..01344af73 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Entry.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Entry.java @@ -7,7 +7,6 @@ package com.dfsek.terra.addons.structure.structures.loot; -import net.jafama.FastMath; import org.json.simple.JSONArray; import org.json.simple.JSONObject; @@ -62,12 +61,12 @@ public class Entry { max = (long) ((JSONObject) loot).get("max"); min = (long) ((JSONObject) loot).get("min"); } - functions.add(new AmountFunction(FastMath.toIntExact(min), FastMath.toIntExact(max))); + functions.add(new AmountFunction(Math.toIntExact(min), Math.toIntExact(max))); } 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))); + functions.add(new DamageFunction(Math.toIntExact(minDamage), Math.toIntExact(maxDamage))); } case "minecraft:enchant_with_levels", "enchant_with_levels" -> { long maxEnchant = (long) ((JSONObject) ((JSONObject) function).get("levels")).get("max"); @@ -76,7 +75,7 @@ public class Entry { if(((JSONObject) function).containsKey("disabled_enchants")) disabled = (JSONArray) ((JSONObject) function).get("disabled_enchants"); functions.add( - new EnchantFunction(FastMath.toIntExact(minEnchant), FastMath.toIntExact(maxEnchant), disabled, platform)); + new EnchantFunction(Math.toIntExact(minEnchant), Math.toIntExact(maxEnchant), disabled, platform)); } } } diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Pool.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Pool.java index a807cb4a1..64200dd05 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Pool.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Pool.java @@ -7,7 +7,6 @@ package com.dfsek.terra.addons.structure.structures.loot; -import net.jafama.FastMath; import org.json.simple.JSONArray; import org.json.simple.JSONObject; @@ -37,16 +36,16 @@ public class Pool { entries = new ProbabilityCollection<>(); Object amount = pool.get("rolls"); if(amount instanceof Long) { - max = FastMath.toIntExact((Long) amount); - min = FastMath.toIntExact((Long) amount); + max = Math.toIntExact((Long) amount); + min = Math.toIntExact((Long) amount); } else { - max = FastMath.toIntExact((Long) ((JSONObject) amount).get("max")); - min = FastMath.toIntExact((Long) ((JSONObject) amount).get("min")); + max = Math.toIntExact((Long) ((JSONObject) amount).get("max")); + min = Math.toIntExact((Long) ((JSONObject) amount).get("min")); } for(Object entryJSON : (JSONArray) pool.get("entries")) { Entry entry = new Entry((JSONObject) entryJSON, platform); - entries.add(entry, FastMath.toIntExact(entry.getWeight())); + entries.add(entry, Math.toIntExact(entry.getWeight())); } } diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/EnchantFunction.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/EnchantFunction.java index 6f5b4d62d..2e3f4b515 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/EnchantFunction.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/EnchantFunction.java @@ -7,7 +7,6 @@ package com.dfsek.terra.addons.structure.structures.loot.functions; -import net.jafama.FastMath; import org.json.simple.JSONArray; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -57,7 +56,7 @@ public class EnchantFunction implements LootFunction { possible.add(ench); } } - int numEnchant = (r.nextInt((int) FastMath.abs(enchant)) / 10 + 1); + int numEnchant = (r.nextInt((int) Math.abs(enchant)) / 10 + 1); Collections.shuffle(possible); ItemMeta meta = original.getItemMeta(); iter: @@ -68,12 +67,12 @@ public class EnchantFunction implements LootFunction { } int lvl = r.nextInt(1 + (int) (((enchant / 40 > 1) ? 1 : enchant / 40) * (chosen.getMaxLevel()))); try { - meta.addEnchantment(chosen, FastMath.max(lvl, 1)); + meta.addEnchantment(chosen, Math.max(lvl, 1)); } catch(IllegalArgumentException e) { LOGGER.warn( "Attempted to enchant {} with {} at level {}, but an unexpected exception occurred! Usually this is caused by a " + "misbehaving enchantment plugin.", - original.getType(), chosen, FastMath.max(lvl, 1)); + original.getType(), chosen, Math.max(lvl, 1)); } } original.setItemMeta(meta); diff --git a/common/addons/library-image/build.gradle.kts b/common/addons/library-image/build.gradle.kts index 6f5d40074..e39ddc12a 100644 --- a/common/addons/library-image/build.gradle.kts +++ b/common/addons/library-image/build.gradle.kts @@ -3,6 +3,6 @@ version = version("1.0.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) - testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) + + } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java index fdcbc701d..9ef07e187 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java @@ -4,20 +4,20 @@ import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; import java.util.function.Supplier; +import com.dfsek.terra.addons.image.colorsampler.ColorSampler; import com.dfsek.terra.addons.image.config.ColorLoader; import com.dfsek.terra.addons.image.config.ColorLoader.ColorString; -import com.dfsek.terra.addons.image.config.noisesampler.ChannelNoiseSamplerTemplate; -import com.dfsek.terra.addons.image.config.noisesampler.DistanceTransformNoiseSamplerTemplate; -import com.dfsek.terra.addons.image.config.image.ImageTemplate; -import com.dfsek.terra.addons.image.config.image.StitchedImageTemplate; import com.dfsek.terra.addons.image.config.colorsampler.ConstantColorSamplerTemplate; import com.dfsek.terra.addons.image.config.colorsampler.image.SingleImageColorSamplerTemplate; import com.dfsek.terra.addons.image.config.colorsampler.image.TileImageColorSamplerTemplate; import com.dfsek.terra.addons.image.config.colorsampler.mutate.RotateColorSamplerTemplate; import com.dfsek.terra.addons.image.config.colorsampler.mutate.TranslateColorSamplerTemplate; +import com.dfsek.terra.addons.image.config.image.ImageTemplate; +import com.dfsek.terra.addons.image.config.image.StitchedImageTemplate; +import com.dfsek.terra.addons.image.config.noisesampler.ChannelNoiseSamplerTemplate; +import com.dfsek.terra.addons.image.config.noisesampler.DistanceTransformNoiseSamplerTemplate; import com.dfsek.terra.addons.image.image.Image; import com.dfsek.terra.addons.image.operator.DistanceTransform; -import com.dfsek.terra.addons.image.colorsampler.ColorSampler; import com.dfsek.terra.addons.manifest.api.AddonInitializer; import com.dfsek.terra.api.Platform; import com.dfsek.terra.api.addon.BaseAddon; diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/SingleImageColorSampler.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/SingleImageColorSampler.java index 420b0f62f..a66dee104 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/SingleImageColorSampler.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/SingleImageColorSampler.java @@ -1,8 +1,8 @@ package com.dfsek.terra.addons.image.colorsampler.image; -import com.dfsek.terra.addons.image.image.Image; import com.dfsek.terra.addons.image.colorsampler.ColorSampler; import com.dfsek.terra.addons.image.colorsampler.image.transform.ImageTransformation; +import com.dfsek.terra.addons.image.image.Image; public class SingleImageColorSampler implements ColorSampler { diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/TileImageColorSampler.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/TileImageColorSampler.java index ec03c4941..d9106d6ff 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/TileImageColorSampler.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/TileImageColorSampler.java @@ -1,10 +1,8 @@ package com.dfsek.terra.addons.image.colorsampler.image; -import net.jafama.FastMath; - -import com.dfsek.terra.addons.image.image.Image; import com.dfsek.terra.addons.image.colorsampler.ColorSampler; import com.dfsek.terra.addons.image.colorsampler.image.transform.ImageTransformation; +import com.dfsek.terra.addons.image.image.Image; public class TileImageColorSampler implements ColorSampler { @@ -22,6 +20,6 @@ public class TileImageColorSampler implements ColorSampler { public int apply(int x, int z) { x = transformation.transformX(image, x); z = transformation.transformZ(image, z); - return image.getRGB(FastMath.floorMod(x, image.getWidth()), FastMath.floorMod(z, image.getHeight())); + return image.getRGB(Math.floorMod(x, image.getWidth()), Math.floorMod(z, image.getHeight())); } } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/RotateColorSampler.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/RotateColorSampler.java index 46a449773..8ace7a3ef 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/RotateColorSampler.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/RotateColorSampler.java @@ -1,8 +1,7 @@ package com.dfsek.terra.addons.image.colorsampler.mutate; -import net.jafama.FastMath; - import com.dfsek.terra.addons.image.colorsampler.ColorSampler; +import com.dfsek.terra.api.util.MathUtil; public class RotateColorSampler implements ColorSampler { @@ -29,7 +28,7 @@ public class RotateColorSampler implements ColorSampler { else rotationMethod = RotationMethod.RAD_ANY; - this.radians = FastMath.toRadians(degrees); + this.radians = Math.toRadians(degrees); } @Override @@ -39,14 +38,14 @@ public class RotateColorSampler implements ColorSampler { case DEG_90 -> -z; case DEG_180 -> -x; case DEG_270 -> z; - case RAD_ANY -> (int) (x * FastMath.cos(radians) - z * FastMath.sin(radians)); + case RAD_ANY -> (int) (x * MathUtil.cos(radians) - z * MathUtil.sin(radians)); }; int rz = switch(rotationMethod) { case DEG_0 -> z; case DEG_90 -> x; case DEG_180 -> -z; case DEG_270 -> -x; - case RAD_ANY -> (int) (z * FastMath.cos(radians) + x * FastMath.sin(radians)); + case RAD_ANY -> (int) (z * MathUtil.cos(radians) + x * MathUtil.sin(radians)); }; return sampler.apply(rx, rz); } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/ImageColorSamplerTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/ImageColorSamplerTemplate.java index 3b9e6fe37..2053b53fe 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/ImageColorSamplerTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/ImageColorSamplerTemplate.java @@ -4,9 +4,9 @@ import com.dfsek.tectonic.api.config.template.annotations.Default; import com.dfsek.tectonic.api.config.template.annotations.Value; import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; -import com.dfsek.terra.addons.image.image.Image; import com.dfsek.terra.addons.image.colorsampler.ColorSampler; import com.dfsek.terra.addons.image.colorsampler.image.transform.Alignment; +import com.dfsek.terra.addons.image.image.Image; public abstract class ImageColorSamplerTemplate implements ObjectTemplate { diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java index 626380720..a7fbe1194 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java @@ -1,7 +1,5 @@ package com.dfsek.terra.addons.image.operator; -import net.jafama.FastMath; - import com.dfsek.terra.addons.image.image.Image; import com.dfsek.terra.addons.image.util.ColorUtil; import com.dfsek.terra.addons.image.util.ColorUtil.Channel; @@ -115,7 +113,7 @@ public class DistanceTransform { row[x] = d[x][y]; row = calculateDistance1D(row); for(int x = 0; x < f[0].length; x++) { - d[x][y] = FastMath.sqrt(row[x]); + d[x][y] = Math.sqrt(row[x]); } } return d; @@ -130,10 +128,10 @@ public class DistanceTransform { z[0] = Integer.MIN_VALUE; z[1] = Integer.MAX_VALUE; for(int q = 1; q <= f.length-1; q++) { - double s = ((f[q]+FastMath.pow2(q))-(f[v[k]]+FastMath.pow2(v[k])))/(2*q-2*v[k]); + double s = ((f[q]+Math.pow(q, 2))-(f[v[k]]+Math.pow(v[k], 2)))/(2*q-2*v[k]); while (s <= z[k]) { k--; - s = ((f[q]+FastMath.pow2(q))-(f[v[k]]+FastMath.pow2(v[k])))/(2*q-2*v[k]); + s = ((f[q]+Math.pow(q, 2))-(f[v[k]]+Math.pow(v[k], 2)))/(2*q-2*v[k]); } k++; v[k] = q; @@ -145,7 +143,7 @@ public class DistanceTransform { for(int q = 0; q <= f.length-1; q++) { while(z[k+1] < q) k++; - d[q] = FastMath.pow2(q-v[k]) + f[v[k]]; + d[q] = Math.pow(q-v[k], 2) + f[v[k]]; } return d; } @@ -166,9 +164,9 @@ public class DistanceTransform { yield lerp(distances[x][y], minDistance, -1, maxDistance, 1); } else { if(d > 0) { - yield FastMath.pow2(d/maxDistance); + yield Math.pow(d/maxDistance, 2); } else if(d < 0) { - yield -FastMath.pow2(d/minDistance); + yield -Math.pow(d/minDistance, 2); } else { yield 0; } @@ -231,7 +229,7 @@ public class DistanceTransform { @Override public double noise(long seed, double x, double y) { if(x<0 || y<0 || x>=transform.width || y>=transform.height) return transform.minDistance; - return transform.distances[FastMath.floorToInt(x)][FastMath.floorToInt(y)]; + return transform.distances[(int) Math.floor(x)][(int) Math.floor(y)]; } @Override diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/ColorUtil.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/ColorUtil.java index 0c52ea5a6..6e76cd72e 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/ColorUtil.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/ColorUtil.java @@ -1,8 +1,5 @@ package com.dfsek.terra.addons.image.util; -import net.jafama.FastMath; - - /** * Utility class for manipulating 8 bit ARGB colors */ @@ -11,9 +8,9 @@ public class ColorUtil { private ColorUtil() {} public static int distance(int a, int b) { - return FastMath.abs(getRed(a) - getRed(b)) + - FastMath.abs(getGreen(a) - getGreen(b)) + - FastMath.abs(getBlue(a) - getBlue(b)); + return Math.abs(getRed(a) - getRed(b)) + + Math.abs(getGreen(a) - getGreen(b)) + + Math.abs(getBlue(a) - getBlue(b)); } /** diff --git a/common/addons/structure-terrascript-loader/build.gradle.kts b/common/addons/structure-terrascript-loader/build.gradle.kts index 18d4019b9..7a6884eda 100644 --- a/common/addons/structure-terrascript-loader/build.gradle.kts +++ b/common/addons/structure-terrascript-loader/build.gradle.kts @@ -5,11 +5,4 @@ version = version("1.1.0") dependencies { api("commons-io:commons-io:2.7") compileOnlyApi(project(":common:addons:manifest-addon-loader")) - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) - testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) } - -tasks.named("shadowJar") { - relocate("org.apache.commons", "com.dfsek.terra.addons.terrascript.lib.commons") - relocate("net.jafama", "com.dfsek.terra.addons.terrascript.lib.jafama") -} \ No newline at end of file diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Scope.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Scope.java index 511c486bd..951bb261c 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Scope.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Scope.java @@ -1,8 +1,6 @@ package com.dfsek.terra.addons.terrascript.parser.lang; -import net.jafama.FastMath; - import java.util.HashMap; import java.util.Map; @@ -102,21 +100,21 @@ public class Scope { } private void updateBoolSize(int size) { - this.boolSize = FastMath.max(boolSize, size); + this.boolSize = Math.max(boolSize, size); if(parent != null) { parent.updateBoolSize(size); } } private void updateNumSize(int size) { - this.numSize = FastMath.max(numSize, size); + this.numSize = Math.max(numSize, size); if(parent != null) { parent.updateNumSize(size); } } private void updateStrSize(int size) { - this.strSize = FastMath.max(strSize, size); + this.strSize = Math.max(strSize, size); if(parent != null) { parent.updateStrSize(size); } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java index f402e4862..1e96a9b0f 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.terrascript.parser.lang.operations.statements; -import net.jafama.FastMath; - import com.dfsek.terra.addons.terrascript.parser.lang.ImplementationArguments; import com.dfsek.terra.addons.terrascript.parser.lang.Returnable; import com.dfsek.terra.addons.terrascript.parser.lang.Scope; @@ -40,7 +38,7 @@ public class EqualsStatement extends BinaryOperation { Object leftValue = left.apply(implementationArguments, scope); Object rightValue = right.apply(implementationArguments, scope); if(leftValue instanceof Number l && rightValue instanceof Number r) { - return FastMath.abs(l.doubleValue() - r.doubleValue()) <= EPSILON; + return Math.abs(l.doubleValue() - r.doubleValue()) <= EPSILON; } return leftValue.equals(rightValue); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/NotEqualsStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/NotEqualsStatement.java index 3241c8657..44eae0ef2 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/NotEqualsStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/NotEqualsStatement.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.terrascript.parser.lang.operations.statements; -import net.jafama.FastMath; - import com.dfsek.terra.addons.terrascript.parser.lang.ImplementationArguments; import com.dfsek.terra.addons.terrascript.parser.lang.Returnable; import com.dfsek.terra.addons.terrascript.parser.lang.Scope; @@ -33,7 +31,7 @@ public class NotEqualsStatement extends BinaryOperation { Object leftValue = left.apply(implementationArguments, scope); Object rightValue = right.apply(implementationArguments, scope); if(leftValue instanceof Number l && rightValue instanceof Number r) { - return FastMath.abs(l.doubleValue() - r.doubleValue()) > EPSILON; + return Math.abs(l.doubleValue() - r.doubleValue()) > EPSILON; } return !leftValue.equals(rightValue); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java index e865d0d6d..1a70cf4b8 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java @@ -7,7 +7,6 @@ package com.dfsek.terra.addons.terrascript.script; -import net.jafama.FastMath; import org.apache.commons.io.IOUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -44,6 +43,7 @@ import com.dfsek.terra.api.registry.key.Keyed; import com.dfsek.terra.api.registry.key.RegistryKey; import com.dfsek.terra.api.structure.LootTable; import com.dfsek.terra.api.structure.Structure; +import com.dfsek.terra.api.util.MathUtil; import com.dfsek.terra.api.util.Rotation; import com.dfsek.terra.api.util.vector.Vector3Int; import com.dfsek.terra.api.world.WritableWorld; @@ -100,25 +100,25 @@ public class StructureScript implements Structure, Keyed { Returnable.ReturnType.NUMBER)) .registerFunction("print", new UnaryStringFunctionBuilder(string -> LOGGER.info("[TerraScript:{}] {}", id, string))) - .registerFunction("abs", new UnaryNumberFunctionBuilder(number -> FastMath.abs(number.doubleValue()))) - .registerFunction("pow2", new UnaryNumberFunctionBuilder(number -> FastMath.pow2(number.doubleValue()))) + .registerFunction("abs", new UnaryNumberFunctionBuilder(number -> Math.abs(number.doubleValue()))) + .registerFunction("pow2", new UnaryNumberFunctionBuilder(number -> Math.pow(number.doubleValue(), 2))) .registerFunction("pow", new BinaryNumberFunctionBuilder( - (number, number2) -> FastMath.pow(number.doubleValue(), number2.doubleValue()))) - .registerFunction("sqrt", new UnaryNumberFunctionBuilder(number -> FastMath.sqrt(number.doubleValue()))) - .registerFunction("floor", new UnaryNumberFunctionBuilder(number -> FastMath.floor(number.doubleValue()))) - .registerFunction("ceil", new UnaryNumberFunctionBuilder(number -> FastMath.ceil(number.doubleValue()))) - .registerFunction("log", new UnaryNumberFunctionBuilder(number -> FastMath.log(number.doubleValue()))) - .registerFunction("round", new UnaryNumberFunctionBuilder(number -> FastMath.round(number.doubleValue()))) - .registerFunction("sin", new UnaryNumberFunctionBuilder(number -> FastMath.sin(number.doubleValue()))) - .registerFunction("cos", new UnaryNumberFunctionBuilder(number -> FastMath.cos(number.doubleValue()))) - .registerFunction("tan", new UnaryNumberFunctionBuilder(number -> FastMath.tan(number.doubleValue()))) - .registerFunction("asin", new UnaryNumberFunctionBuilder(number -> FastMath.asin(number.doubleValue()))) - .registerFunction("acos", new UnaryNumberFunctionBuilder(number -> FastMath.acos(number.doubleValue()))) - .registerFunction("atan", new UnaryNumberFunctionBuilder(number -> FastMath.atan(number.doubleValue()))) + (number, number2) -> Math.pow(number.doubleValue(), number2.doubleValue()))) + .registerFunction("sqrt", new UnaryNumberFunctionBuilder(number -> Math.sqrt(number.doubleValue()))) + .registerFunction("floor", new UnaryNumberFunctionBuilder(number -> Math.floor(number.doubleValue()))) + .registerFunction("ceil", new UnaryNumberFunctionBuilder(number -> Math.ceil(number.doubleValue()))) + .registerFunction("log", new UnaryNumberFunctionBuilder(number -> Math.log(number.doubleValue()))) + .registerFunction("round", new UnaryNumberFunctionBuilder(number -> Math.round(number.doubleValue()))) + .registerFunction("sin", new UnaryNumberFunctionBuilder(number -> MathUtil.sin(number.doubleValue()))) + .registerFunction("cos", new UnaryNumberFunctionBuilder(number -> MathUtil.cos(number.doubleValue()))) + .registerFunction("tan", new UnaryNumberFunctionBuilder(number -> Math.tan(number.doubleValue()))) + .registerFunction("asin", new UnaryNumberFunctionBuilder(number -> Math.asin(number.doubleValue()))) + .registerFunction("acos", new UnaryNumberFunctionBuilder(number -> Math.acos(number.doubleValue()))) + .registerFunction("atan", new UnaryNumberFunctionBuilder(number -> Math.atan(number.doubleValue()))) .registerFunction("max", new BinaryNumberFunctionBuilder( - (number, number2) -> FastMath.max(number.doubleValue(), number2.doubleValue()))) + (number, number2) -> Math.max(number.doubleValue(), number2.doubleValue()))) .registerFunction("min", new BinaryNumberFunctionBuilder( - (number, number2) -> FastMath.min(number.doubleValue(), number2.doubleValue()))); + (number, number2) -> Math.min(number.doubleValue(), number2.doubleValue()))); if(!platform.getTerraConfig().isDebugScript()) { parser.ignoreFunction("debugBlock"); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BiomeFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BiomeFunction.java index 452b9f43b..865cad586 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BiomeFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BiomeFunction.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.terrascript.script.functions; -import net.jafama.FastMath; - import com.dfsek.terra.addons.terrascript.parser.lang.ImplementationArguments; import com.dfsek.terra.addons.terrascript.parser.lang.Returnable; import com.dfsek.terra.addons.terrascript.parser.lang.Scope; @@ -48,9 +46,9 @@ public class BiomeFunction implements Function { return grid.getBiome(arguments.getOrigin() .toVector3() .mutable() - .add(Vector3.of(FastMath.roundToInt(xz.getX()), + .add(Vector3.of((int) Math.round(xz.getX()), y.apply(implementationArguments, scope).intValue(), - FastMath.roundToInt(xz.getZ()))).immutable(), arguments.getWorld().getSeed()).getID(); + (int) Math.round(xz.getZ()))).immutable(), arguments.getWorld().getSeed()).getID(); } @Override diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java index 7997a15aa..85be45515 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java @@ -7,7 +7,6 @@ package com.dfsek.terra.addons.terrascript.script.functions; -import net.jafama.FastMath; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -73,9 +72,9 @@ public class BlockFunction implements Function { Vector2 xz = RotationUtil.rotateVector(Vector2.of(x.apply(implementationArguments, scope).doubleValue(), z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); try { - Vector3.Mutable set = Vector3.of(FastMath.roundToInt(xz.getX()), + Vector3.Mutable set = Vector3.of((int) Math.round(xz.getX()), y.apply(implementationArguments, scope).doubleValue(), - FastMath.roundToInt(xz.getZ())).mutable().add(arguments.getOrigin()); + (int) Math.round(xz.getZ())).mutable().add(arguments.getOrigin()); BlockState current = arguments.getWorld().getBlockState(set); if(overwrite.apply(implementationArguments, scope) || current.isAir()) { arguments.getWorld().setBlockState(set, rot, physics.apply(implementationArguments, scope)); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/CheckBlockFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/CheckBlockFunction.java index d2fddf169..ef3518462 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/CheckBlockFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/CheckBlockFunction.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.terrascript.script.functions; -import net.jafama.FastMath; - import com.dfsek.terra.addons.terrascript.parser.lang.ImplementationArguments; import com.dfsek.terra.addons.terrascript.parser.lang.Returnable; import com.dfsek.terra.addons.terrascript.parser.lang.Scope; @@ -45,9 +43,9 @@ public class CheckBlockFunction implements Function { .getBlockState(arguments.getOrigin() .toVector3() .mutable() - .add(Vector3.of(FastMath.roundToInt(xz.getX()), + .add(Vector3.of((int) Math.round(xz.getX()), y.apply(implementationArguments, scope) - .doubleValue(), FastMath.roundToInt(xz.getZ())))) + .doubleValue(), (int) Math.round(xz.getZ())))) .getAsString(); if(data.contains("[")) return data.substring(0, data.indexOf('[')); // Strip properties else return data; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/GetMarkFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/GetMarkFunction.java index 09e735665..d29b900bf 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/GetMarkFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/GetMarkFunction.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.terrascript.script.functions; -import net.jafama.FastMath; - import com.dfsek.terra.addons.terrascript.parser.lang.ImplementationArguments; import com.dfsek.terra.addons.terrascript.parser.lang.Returnable; import com.dfsek.terra.addons.terrascript.parser.lang.Scope; @@ -37,9 +35,9 @@ public class GetMarkFunction implements Function { Vector2 xz = RotationUtil.rotateVector(Vector2.of(x.apply(implementationArguments, scope).doubleValue(), z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); - String mark = arguments.getMark(Vector3.of(FastMath.floorToInt(xz.getX()), FastMath.floorToInt( + String mark = arguments.getMark(Vector3.of((int) Math.floor(xz.getX()), (int) Math.floor( y.apply(implementationArguments, scope).doubleValue()), - FastMath.floorToInt(xz.getZ())) + (int) Math.floor(xz.getZ())) .mutable() .add(arguments.getOrigin()) .immutable()); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java index ebadb9288..17808f8a0 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java @@ -7,7 +7,6 @@ package com.dfsek.terra.addons.terrascript.script.functions; -import net.jafama.FastMath; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -66,10 +65,10 @@ public class LootFunction implements Function { registry.get(RegistryKey.parse(id)) .ifPresentOrElse(table -> { - Vector3 apply = Vector3.of(FastMath.roundToInt(xz.getX()), + Vector3 apply = Vector3.of((int) Math.round(xz.getX()), y.apply(implementationArguments, scope) .intValue(), - FastMath.roundToInt(xz.getZ())).mutable().add(arguments.getOrigin()).immutable(); + (int) Math.round(xz.getZ())).mutable().add(arguments.getOrigin()).immutable(); try { BlockEntity data = arguments.getWorld().getBlockEntity(apply); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/PullFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/PullFunction.java index 70fbbafc5..26511fd85 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/PullFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/PullFunction.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.terrascript.script.functions; -import net.jafama.FastMath; - import com.dfsek.terra.addons.terrascript.parser.exceptions.ParseException; import com.dfsek.terra.addons.terrascript.parser.lang.ImplementationArguments; import com.dfsek.terra.addons.terrascript.parser.lang.Returnable; @@ -46,8 +44,8 @@ public class PullFunction implements Function { Vector2 xz = RotationUtil.rotateVector(Vector2.of(x.apply(implementationArguments, scope).doubleValue(), z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); - Vector3.Mutable mutable = Vector3.of(FastMath.roundToInt(xz.getX()), y.apply(implementationArguments, scope).intValue(), - FastMath.roundToInt(xz.getZ())).mutable().add(arguments.getOrigin()); + Vector3.Mutable mutable = Vector3.of((int) Math.round(xz.getX()), y.apply(implementationArguments, scope).intValue(), + (int) Math.round(xz.getZ())).mutable().add(arguments.getOrigin()); while(mutable.getY() > arguments.getWorld().getMinHeight()) { if(!arguments.getWorld().getBlockState(mutable).isAir()) { arguments.getWorld().setBlockState(mutable, data); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/SetMarkFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/SetMarkFunction.java index 43a7436b9..1ab0782ee 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/SetMarkFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/SetMarkFunction.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.terrascript.script.functions; -import net.jafama.FastMath; - import com.dfsek.terra.addons.terrascript.parser.lang.ImplementationArguments; import com.dfsek.terra.addons.terrascript.parser.lang.Returnable; import com.dfsek.terra.addons.terrascript.parser.lang.Scope; @@ -40,10 +38,10 @@ public class SetMarkFunction implements Function { z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); - arguments.setMark(Vector3.of(FastMath.floorToInt(xz.getX()), - FastMath.floorToInt( + arguments.setMark(Vector3.of((int) Math.floor(xz.getX()), + (int) Math.floor( y.apply(implementationArguments, scope).doubleValue()), - FastMath.floorToInt(xz.getZ())).mutable().add(arguments.getOrigin()).immutable(), + (int) Math.floor(xz.getZ())).mutable().add(arguments.getOrigin()).immutable(), mark.apply(implementationArguments, scope)); return null; } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java index 6ccbe1a80..1d0e899bf 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java @@ -7,7 +7,6 @@ package com.dfsek.terra.addons.terrascript.script.functions; -import net.jafama.FastMath; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -45,8 +44,8 @@ public class StateFunction implements Function { z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); - Vector3 origin = Vector3.of(FastMath.roundToInt(xz.getX()), y.apply(implementationArguments, scope).intValue(), - FastMath.roundToInt(xz.getZ())).mutable().add(arguments.getOrigin()).immutable(); + Vector3 origin = Vector3.of((int) Math.round(xz.getX()), y.apply(implementationArguments, scope).intValue(), + (int) Math.round(xz.getZ())).mutable().add(arguments.getOrigin()).immutable(); try { BlockEntity state = arguments.getWorld().getBlockEntity(origin); state.applyState(data.apply(implementationArguments, scope)); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StructureFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StructureFunction.java index 51fb47054..1ec4886f5 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StructureFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StructureFunction.java @@ -7,7 +7,6 @@ package com.dfsek.terra.addons.terrascript.script.functions; -import net.jafama.FastMath; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -79,17 +78,17 @@ public class StructureFunction implements Function { if(script instanceof StructureScript structureScript) { return structureScript.generate(arguments.getOrigin(), arguments.getWorld() - .buffer(FastMath.roundToInt(xz.getX()), + .buffer((int) Math.round(xz.getX()), y.apply(implementationArguments, scope).intValue(), - FastMath.roundToInt(xz.getZ())), + (int) Math.round(xz.getZ())), arguments.getRandom(), arguments.getRotation().rotate(rotation1), arguments.getRecursions() + 1); } return script.generate(arguments.getOrigin(), arguments.getWorld() - .buffer(FastMath.roundToInt(xz.getX()), + .buffer((int) Math.round(xz.getX()), y.apply(implementationArguments, scope).intValue(), - FastMath.roundToInt(xz.getZ())), + (int) Math.round(xz.getZ())), arguments.getRandom(), arguments.getRotation().rotate(rotation1)); }).orElseGet(() -> { diff --git a/common/addons/terrascript-function-check-noise-3d/build.gradle.kts b/common/addons/terrascript-function-check-noise-3d/build.gradle.kts index 51bb33cf6..bb694d2c6 100644 --- a/common/addons/terrascript-function-check-noise-3d/build.gradle.kts +++ b/common/addons/terrascript-function-check-noise-3d/build.gradle.kts @@ -4,11 +4,4 @@ dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) compileOnlyApi(project(":common:addons:chunk-generator-noise-3d")) compileOnlyApi(project(":common:addons:structure-terrascript-loader")) - - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) - testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) -} - -tasks.named("shadowJar") { - relocate("net.jafama", "com.dfsek.terra.addon.terrascript.check.lib.jafama") -} +} \ No newline at end of file diff --git a/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunction.java b/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunction.java index 1dfb1d293..b1a5e6024 100644 --- a/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunction.java +++ b/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunction.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addon.terrascript.check; -import net.jafama.FastMath; - import com.dfsek.terra.addons.chunkgenerator.generation.NoiseChunkGenerator3D; import com.dfsek.terra.addons.chunkgenerator.generation.math.samplers.SamplerProvider; import com.dfsek.terra.addons.terrascript.parser.lang.ImplementationArguments; @@ -49,8 +47,8 @@ public class CheckFunction implements Function { RotationUtil.rotateVector(xz, arguments.getRotation()); Vector3 location = arguments.getOrigin().toVector3Mutable().add( - Vector3.of(FastMath.roundToInt(xz.getX()), y.apply(implementationArguments, scope).doubleValue(), - FastMath.roundToInt(xz.getZ()))).immutable(); + Vector3.of((int) Math.round(xz.getX()), y.apply(implementationArguments, scope).doubleValue(), + (int) Math.round(xz.getZ()))).immutable(); return apply(location, arguments.getWorld()); } @@ -82,8 +80,8 @@ public class CheckFunction implements Function { } private double sample(double x, double y, double z, SamplerProvider cache, World world) { - int cx = FastMath.floorDiv((int) x, 16); - int cz = FastMath.floorDiv((int) z, 16); + int cx = Math.floorDiv((int) x, 16); + int cz = Math.floorDiv((int) z, 16); return cache.getChunk(cx, cz, world, world.getBiomeProvider()).sample(x - (cx << 4), y, z - (cz << 4)); } } diff --git a/common/api/build.gradle.kts b/common/api/build.gradle.kts index 2fce99b17..bdcdd3901 100644 --- a/common/api/build.gradle.kts +++ b/common/api/build.gradle.kts @@ -7,5 +7,5 @@ dependencies { api("com.dfsek.tectonic", "common", Versions.Libraries.tectonic) api("com.github.ben-manes.caffeine:caffeine:3.1.0") - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) + } \ No newline at end of file diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/ConstantRange.java b/common/api/src/main/java/com/dfsek/terra/api/util/ConstantRange.java index 5849d09a6..405fdab28 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/ConstantRange.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/ConstantRange.java @@ -7,7 +7,6 @@ package com.dfsek.terra.api.util; -import net.jafama.FastMath; import org.jetbrains.annotations.NotNull; import java.util.Iterator; @@ -44,7 +43,7 @@ public class ConstantRange implements Range { @Override public Range intersects(Range other) { try { - return new ConstantRange(FastMath.max(this.getMin(), other.getMin()), FastMath.min(this.getMax(), other.getMax())); + return new ConstantRange(Math.max(this.getMin(), other.getMin()), Math.min(this.getMax(), other.getMax())); } catch(IllegalArgumentException e) { return null; } diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java index 3c95df139..f4122e694 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java @@ -7,8 +7,6 @@ package com.dfsek.terra.api.util; -import net.jafama.FastMath; - import java.util.List; @@ -16,11 +14,58 @@ import java.util.List; * Utility class for mathematical functions. */ public final class MathUtil { + private static final int SIN_BITS, SIN_MASK, SIN_COUNT; + private static final double radFull, radToIndex; + private static final double degFull, degToIndex; + private static final double[] sin, cos; + + static { + SIN_BITS = 12; + SIN_MASK = ~(-1 << SIN_BITS); + SIN_COUNT = SIN_MASK + 1; + + radFull = Math.PI * 2.0; + degFull = 360.0; + radToIndex = SIN_COUNT / radFull; + degToIndex = SIN_COUNT / degFull; + + sin = new double[SIN_COUNT]; + cos = new double[SIN_COUNT]; + + for (int i = 0; i < SIN_COUNT; i++) { + sin[i] = Math.sin((i + 0.5f) / SIN_COUNT * radFull); + cos[i] = Math.cos((i + 0.5f) / SIN_COUNT * radFull); + } + + // Four cardinal directions (credits: Nate) + for (int i = 0; i < 360; i += 90) { + sin[(int) (i * degToIndex) & SIN_MASK] = Math.sin(i * Math.PI / 180.0); + cos[(int) (i * degToIndex) & SIN_MASK] = Math.cos(i * Math.PI / 180.0); + } + } + /** * Epsilon for fuzzy floating point comparisons. */ public static final double EPSILON = 1.0E-5; + public static double sin(double rad) { + return sin[(int) (rad * radToIndex) & SIN_MASK]; + } + + public static double cos(double rad) { + return cos[(int) (rad * radToIndex) & SIN_MASK]; + } + + public static double invSqrt(double x) { + double xhalf = 0.5d * x; + long i = Double.doubleToLongBits(x); + i = 0x5fe6ec85e7de30daL - (i >> 1); + x = Double.longBitsToDouble(i); + x *= (1.5d - xhalf * x * x); + return x; + } + /** * Gets the standard deviation of an array of doubles. * @@ -39,10 +84,10 @@ public final class MathUtil { double mean = sum / length; for(Number num : numArray) { - standardDeviation += FastMath.pow2(num.doubleValue() - mean); + standardDeviation += Math.pow(num.doubleValue() - mean, 2); } - return FastMath.sqrt(standardDeviation / length); + return Math.sqrt(standardDeviation / length); } public static long hashToLong(String s) { @@ -65,11 +110,11 @@ public final class MathUtil { * @return Whether these values are equal */ public static boolean equals(double a, double b) { - return a == b || FastMath.abs(a - b) < EPSILON; + return a == b || Math.abs(a - b) < EPSILON; } public static int normalizeIndex(double val, int size) { - return FastMath.max(FastMath.min(FastMath.floorToInt(((val + 1D) / 2D) * size), size - 1), 0); + return Math.max(Math.min((int)Math.floor(((val + 1D) / 2D) * size), size - 1), 0); } public static long squash(int first, int last) { @@ -84,11 +129,11 @@ public final class MathUtil { * @return Clamped value */ public static double clamp(double in) { - return FastMath.min(FastMath.max(in, -1), 1); + return Math.min(Math.max(in, -1), 1); } public static int clamp(int min, int i, int max) { - return FastMath.max(FastMath.min(i, max), min); + return Math.max(Math.min(i, max), min); } /** @@ -115,7 +160,7 @@ public final class MathUtil { q = p - 0.5; - if(FastMath.abs(q) <= .425) { + if(Math.abs(q) <= .425) { r = .180625 - q * q; val = q * (((((((r * 2509.0809287301226727 + @@ -134,7 +179,7 @@ public final class MathUtil { r = p; } - r = FastMath.sqrt(-FastMath.log(r)); + r = Math.sqrt(-Math.log(r)); if(r <= 5) { r -= 1.6; @@ -173,4 +218,37 @@ public final class MathUtil { return mu + sigma * val; } + + /** + * Murmur64 hashing function + * + * @param h Input value + * + * @return Hashed value + */ + public static long murmur64(long h) { + h ^= h >>> 33; + h *= 0xff51afd7ed558ccdL; + h ^= h >>> 33; + h *= 0xc4ceb9fe1a85ec53L; + h ^= h >>> 33; + return h; + } + + public static double lerp(double a, double b, double t) { + return a + t * (b - a); + } + + public static double cubicLerp(double a, double b, double c, double d, double t) { + double p = (d - c) - (a - b); + return t * t * t * p + t * t * ((a - b) - p) + t * (c - a) + b; + } + + public static double interpHermite(double t) { + return t * t * (3 - 2 * t); + } + + public static double interpQuintic(double t) { + return t * t * t * (t * (t * 6 - 15) + 10); + } } diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/Rotation.java b/common/api/src/main/java/com/dfsek/terra/api/util/Rotation.java index 4d43b1732..20b37881b 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/Rotation.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/Rotation.java @@ -7,9 +7,6 @@ package com.dfsek.terra.api.util; -import net.jafama.FastMath; - - public enum Rotation { CW_90(90), @@ -23,7 +20,7 @@ public enum Rotation { } public static Rotation fromDegrees(int deg) { - return switch(FastMath.floorMod(deg, 360)) { + return switch(Math.floorMod(deg, 360)) { case 0 -> Rotation.NONE; case 90 -> Rotation.CW_90; case 180 -> Rotation.CW_180; diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java b/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java index f5d5863c6..f85344849 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java @@ -51,25 +51,25 @@ public class ProbabilityCollection implements Collection { @SuppressWarnings("unchecked") public E get(NoiseSampler n, double x, double y, double z, long seed) { if(array.length == 0) return null; - return (E) array[MathUtil.normalizeIndex(n.noise(seed, x, y, z), array.length)]; + return (E) array[(int) MathUtil.normalizeIndex(n.noise(seed, x, y, z), array.length)]; } @SuppressWarnings("unchecked") public E get(NoiseSampler n, Vector3Int vector3Int, long seed) { if(array.length == 0) return null; - return (E) array[MathUtil.normalizeIndex(n.noise(seed, vector3Int.getX(), vector3Int.getY(), vector3Int.getZ()), array.length)]; + return (E) array[(int) MathUtil.normalizeIndex(n.noise(seed, vector3Int.getX(), vector3Int.getY(), vector3Int.getZ()), array.length)]; } @SuppressWarnings("unchecked") public E get(NoiseSampler n, Vector3 vector3Int, long seed) { if(array.length == 0) return null; - return (E) array[MathUtil.normalizeIndex(n.noise(seed, vector3Int.getX(), vector3Int.getY(), vector3Int.getZ()), array.length)]; + return (E) array[(int) MathUtil.normalizeIndex(n.noise(seed, vector3Int.getX(), vector3Int.getY(), vector3Int.getZ()), array.length)]; } @SuppressWarnings("unchecked") public E get(NoiseSampler n, double x, double z, long seed) { if(array.length == 0) return null; - return (E) array[MathUtil.normalizeIndex(n.noise(seed, x, z), array.length)]; + return (E) array[(int) MathUtil.normalizeIndex(n.noise(seed, x, z), array.length)]; } @SuppressWarnings("unchecked") diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java index 5dc1e8f1c..057ab22aa 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java @@ -7,8 +7,6 @@ package com.dfsek.terra.api.util.vector; -import net.jafama.FastMath; - import com.dfsek.terra.api.util.MathUtil; @@ -41,7 +39,7 @@ public class Vector2 { * @return length */ public double length() { - return FastMath.sqrt(lengthSquared()); + return Math.sqrt(lengthSquared()); } /** @@ -61,7 +59,7 @@ public class Vector2 { * @return Distance between vectors */ public double distance(Vector2 other) { - return FastMath.sqrt(distanceSquared(other)); + return Math.sqrt(distanceSquared(other)); } /** @@ -102,11 +100,11 @@ public class Vector2 { public int getBlockX() { - return FastMath.floorToInt(x); + return (int) Math.floor(x); } public int getBlockZ() { - return FastMath.floorToInt(z); + return (int) Math.floor(z); } @Override @@ -166,7 +164,7 @@ public class Vector2 { * @return length */ public double length() { - return FastMath.sqrt(lengthSquared()); + return Math.sqrt(lengthSquared()); } /** diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java index b5c45ca61..1c024eaf1 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java @@ -7,7 +7,6 @@ package com.dfsek.terra.api.util.vector; -import net.jafama.FastMath; import org.jetbrains.annotations.NotNull; import com.dfsek.terra.api.util.MathUtil; @@ -33,11 +32,11 @@ public class Vector3 { } public double length() { - return FastMath.sqrt(lengthSquared()); + return Math.sqrt(lengthSquared()); } public double inverseLength() { - return FastMath.invSqrtQuick(lengthSquared()); + return MathUtil.invSqrt(lengthSquared()); } /** @@ -52,7 +51,7 @@ public class Vector3 { * @return the distance */ public double distance(@NotNull Vector3 o) { - return FastMath.sqrt(FastMath.pow2(x - o.getX()) + FastMath.pow2(y - o.getY()) + FastMath.pow2(z - o.getZ())); + return Math.sqrt(Math.pow(x - o.getX(), 2) + Math.pow(y - o.getY(), 2) + Math.pow(z - o.getZ(), 2)); } /** @@ -63,7 +62,7 @@ public class Vector3 { * @return the distance */ public double distanceSquared(@NotNull Vector3 o) { - return FastMath.pow2(x - o.getX()) + FastMath.pow2(y - o.getY()) + FastMath.pow2(z - o.getZ()); + return Math.pow(x - o.getX(), 2) + Math.pow(y - o.getY(), 2) + Math.pow(z - o.getZ(), 2); } /** @@ -94,15 +93,15 @@ public class Vector3 { public int getBlockX() { - return FastMath.floorToInt(x); + return (int) Math.floor(x); } public int getBlockY() { - return FastMath.floorToInt(y); + return (int) Math.floor(y); } public int getBlockZ() { - return FastMath.floorToInt(z); + return (int) Math.floor(z); } /** @@ -201,11 +200,11 @@ public class Vector3 { } public double length() { - return FastMath.sqrt(lengthSquared()); + return Math.sqrt(lengthSquared()); } public double inverseLength() { - return FastMath.invSqrtQuick(lengthSquared()); + return MathUtil.invSqrt(lengthSquared()); } public Mutable normalize() { @@ -323,8 +322,8 @@ public class Vector3 { double x = getX(), y = getY(), z = getZ(); double x2 = axis.getX(), y2 = axis.getY(), z2 = axis.getZ(); - double cosTheta = Math.cos(angle); - double sinTheta = Math.sin(angle); + double cosTheta = MathUtil.cos(angle); + double sinTheta = MathUtil.sin(angle); double dotProduct = this.dot(axis); double xPrime = x2 * dotProduct * (1d - cosTheta) @@ -355,8 +354,8 @@ public class Vector3 { */ @NotNull public Mutable rotateAroundX(double angle) { - double angleCos = Math.cos(angle); - double angleSin = Math.sin(angle); + double angleCos = MathUtil.cos(angle); + double angleSin = MathUtil.sin(angle); double y = angleCos * getY() - angleSin * getZ(); double z = angleSin * getY() + angleCos * getZ(); @@ -378,8 +377,8 @@ public class Vector3 { */ @NotNull public Mutable rotateAroundY(double angle) { - double angleCos = Math.cos(angle); - double angleSin = Math.sin(angle); + double angleCos = MathUtil.cos(angle); + double angleSin = MathUtil.sin(angle); double x = angleCos * getX() + angleSin * getZ(); double z = -angleSin * getX() + angleCos * getZ(); @@ -401,8 +400,8 @@ public class Vector3 { */ @NotNull public Mutable rotateAroundZ(double angle) { - double angleCos = Math.cos(angle); - double angleSin = Math.sin(angle); + double angleCos = MathUtil.cos(angle); + double angleSin = MathUtil.sin(angle); double x = angleCos * getX() - angleSin * getY(); double y = angleSin * getX() + angleCos * getY(); @@ -420,15 +419,15 @@ public class Vector3 { } public int getBlockX() { - return FastMath.floorToInt(x); + return (int) Math.floor(x); } public int getBlockY() { - return FastMath.floorToInt(y); + return (int) Math.floor(y); } public int getBlockZ() { - return FastMath.floorToInt(z); + return (int) Math.floor(z); } } } diff --git a/common/implementation/base/build.gradle.kts b/common/implementation/base/build.gradle.kts index 1910484f0..75ebf671e 100644 --- a/common/implementation/base/build.gradle.kts +++ b/common/implementation/base/build.gradle.kts @@ -9,7 +9,7 @@ dependencies { implementation("org.apache.commons", "commons-text", Versions.Libraries.Internal.apacheText) implementation("com.dfsek.tectonic", "yaml", Versions.Libraries.tectonic) - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) + implementation("com.dfsek", "paralithic", Versions.Libraries.paralithic) } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java index ca40d6b90..5093a0263 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java @@ -23,16 +23,13 @@ import com.dfsek.tectonic.api.depth.DepthTracker; import com.dfsek.tectonic.api.exception.LoadException; import com.dfsek.tectonic.api.loader.ConfigLoader; import com.dfsek.tectonic.api.loader.type.TypeLoader; - import com.dfsek.tectonic.impl.MapConfiguration; - -import com.dfsek.terra.api.config.meta.Meta; - import org.jetbrains.annotations.NotNull; import java.lang.reflect.AnnotatedType; import java.util.Map; +import com.dfsek.terra.api.config.meta.Meta; import com.dfsek.terra.api.util.ConstantRange; import com.dfsek.terra.api.util.Range; diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGeneratorWrapper.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGeneratorWrapper.java index 8a6b17bdd..f3235d65a 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGeneratorWrapper.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGeneratorWrapper.java @@ -20,7 +20,6 @@ package com.dfsek.terra.bukkit.generator; import org.bukkit.World; import org.bukkit.generator.BiomeProvider; import org.bukkit.generator.BlockPopulator; -import org.bukkit.generator.LimitedRegion; import org.bukkit.generator.WorldInfo; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -29,14 +28,12 @@ import org.slf4j.LoggerFactory; import java.util.List; import java.util.Random; -import java.util.stream.Collectors; import com.dfsek.terra.api.block.state.BlockState; import com.dfsek.terra.api.config.ConfigPack; import com.dfsek.terra.api.world.chunk.generation.ChunkGenerator; import com.dfsek.terra.api.world.chunk.generation.util.GeneratorWrapper; import com.dfsek.terra.api.world.info.WorldProperties; -import com.dfsek.terra.bukkit.world.BukkitProtoWorld; import com.dfsek.terra.bukkit.world.BukkitWorldProperties; diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java index d6316325d..d634eedba 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java @@ -1,7 +1,5 @@ package com.dfsek.terra.bukkit.world; -import com.dfsek.terra.bukkit.util.BukkitUtils; - import org.bukkit.Location; import org.bukkit.block.data.BlockData; import org.bukkit.generator.LimitedRegion; @@ -23,6 +21,7 @@ import com.dfsek.terra.api.world.chunk.generation.ChunkGenerator; import com.dfsek.terra.api.world.chunk.generation.ProtoWorld; import com.dfsek.terra.bukkit.BukkitEntity; import com.dfsek.terra.bukkit.generator.BukkitChunkGeneratorWrapper; +import com.dfsek.terra.bukkit.util.BukkitUtils; import com.dfsek.terra.bukkit.world.block.data.BukkitBlockState; import com.dfsek.terra.bukkit.world.block.state.BukkitBlockEntity; import com.dfsek.terra.bukkit.world.entity.BukkitEntityType; diff --git a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSChunkGeneratorDelegate.java index 395ea949c..284eff2b1 100644 --- a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSChunkGeneratorDelegate.java +++ b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSChunkGeneratorDelegate.java @@ -42,6 +42,7 @@ import java.util.concurrent.Executor; import java.util.stream.Collectors; import com.dfsek.terra.api.config.ConfigPack; +import com.dfsek.terra.api.util.MathUtil; import com.dfsek.terra.api.util.generic.Lazy; import com.dfsek.terra.api.world.biome.generation.BiomeProvider; import com.dfsek.terra.api.world.info.WorldProperties; @@ -215,8 +216,8 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { for(int j1 = 0; j1 < j; ++j1) { double d1 = (double) (4 * i + i * i1 * 6) + (random.nextDouble() - 0.5D) * (double) i * 2.5D; - int k1 = (int) Math.round(Math.cos(d0) * d1); - int l1 = (int) Math.round(Math.sin(d0) * d1); + int k1 = (int) Math.round(MathUtil.cos(d0) * d1); + int l1 = (int) Math.round(MathUtil.sin(d0) * d1); int i2 = SectionPos.sectionToBlockCoord(k1, 8); int j2 = SectionPos.sectionToBlockCoord(l1, 8); diff --git a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSChunkGeneratorDelegate.java index c35bae020..ea8b2267d 100644 --- a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSChunkGeneratorDelegate.java +++ b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSChunkGeneratorDelegate.java @@ -1,11 +1,5 @@ package com.dfsek.terra.bukkit.nms.v1_19_R1; -import com.dfsek.terra.bukkit.config.PreLoadCompatibilityOptions; - -import com.dfsek.terra.bukkit.world.BukkitWorldProperties; - -import com.dfsek.terra.bukkit.world.block.data.BukkitBlockState; - import com.mojang.datafixers.util.Pair; import com.mojang.serialization.Codec; import it.unimi.dsi.fastutil.objects.Object2ObjectArrayMap; @@ -24,12 +18,9 @@ import net.minecraft.world.level.WorldGenLevel; import net.minecraft.world.level.biome.Biome; import net.minecraft.world.level.biome.BiomeManager; import net.minecraft.world.level.block.Blocks; -import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.level.chunk.ChunkAccess; import net.minecraft.world.level.chunk.ChunkGenerator; import net.minecraft.world.level.levelgen.Beardifier; -import net.minecraft.world.level.levelgen.DensityFunction; -import net.minecraft.world.level.levelgen.DensityFunction.FunctionContext; import net.minecraft.world.level.levelgen.DensityFunction.SinglePointContext; import net.minecraft.world.level.levelgen.GenerationStep.Carving; import net.minecraft.world.level.levelgen.Heightmap.Types; @@ -55,9 +46,13 @@ import java.util.concurrent.Executor; import java.util.stream.Stream; import com.dfsek.terra.api.config.ConfigPack; +import com.dfsek.terra.api.util.MathUtil; import com.dfsek.terra.api.util.generic.Lazy; import com.dfsek.terra.api.world.biome.generation.BiomeProvider; import com.dfsek.terra.api.world.info.WorldProperties; +import com.dfsek.terra.bukkit.config.PreLoadCompatibilityOptions; +import com.dfsek.terra.bukkit.world.BukkitWorldProperties; +import com.dfsek.terra.bukkit.world.block.data.BukkitBlockState; public class NMSChunkGeneratorDelegate extends ChunkGenerator { @@ -262,8 +257,8 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { for(int j1 = 0; j1 < j; ++j1) { double d1 = (double) (4 * i + i * i1 * 6) + (randomsource.nextDouble() - 0.5D) * (double) i * 2.5D; - int k1 = (int) Math.round(Math.cos(d0) * d1); - int l1 = (int) Math.round(Math.sin(d0) * d1); + int k1 = (int) Math.round(MathUtil.cos(d0) * d1); + int l1 = (int) Math.round(MathUtil.sin(d0) * d1); int i2 = SectionPos.sectionToBlockCoord(k1, 8); int j2 = SectionPos.sectionToBlockCoord(l1, 8); diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeInjector.java index 20a426949..efcdf004a 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeInjector.java @@ -2,7 +2,6 @@ package com.dfsek.terra.bukkit.nms.v1_19_R2; import net.minecraft.core.Holder; import net.minecraft.core.Registry; -import net.minecraft.resources.ResourceKey; import net.minecraft.resources.ResourceLocation; import net.minecraft.world.level.biome.Biome; import net.minecraft.world.level.biome.BiomeSpecialEffects; @@ -10,7 +9,6 @@ import net.minecraft.world.level.biome.BiomeSpecialEffects; import java.util.Locale; import java.util.Objects; import java.util.Optional; -import java.util.function.Function; import com.dfsek.terra.api.config.ConfigPack; import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/Reflection.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/Reflection.java index c65df8ca1..11236d132 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/Reflection.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/Reflection.java @@ -12,8 +12,6 @@ import xyz.jpenilla.reflectionremapper.proxy.annotation.FieldSetter; import xyz.jpenilla.reflectionremapper.proxy.annotation.MethodName; import xyz.jpenilla.reflectionremapper.proxy.annotation.Proxies; -import java.util.Objects; - public class Reflection { public static final MappedRegistryProxy MAPPED_REGISTRY; diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/RegistryFetcher.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/RegistryFetcher.java index f0c776f48..904fba60b 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/RegistryFetcher.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/RegistryFetcher.java @@ -5,7 +5,6 @@ import net.minecraft.core.registries.Registries; import net.minecraft.resources.ResourceKey; import net.minecraft.server.dedicated.DedicatedServer; import net.minecraft.world.level.biome.Biome; -import net.minecraft.world.level.levelgen.structure.StructureSet; import org.bukkit.Bukkit; import org.bukkit.craftbukkit.v1_19_R2.CraftServer; diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeInjector.java index f7bedfd0f..2c328f26d 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeInjector.java @@ -1,9 +1,7 @@ package com.dfsek.terra.bukkit.nms.v1_19_R3; import net.minecraft.core.Holder; -import java.util.stream.Stream; import net.minecraft.core.Registry; -import net.minecraft.resources.ResourceKey; import net.minecraft.resources.ResourceLocation; import net.minecraft.world.level.biome.Biome; import net.minecraft.world.level.biome.BiomeSpecialEffects; @@ -11,14 +9,10 @@ import net.minecraft.world.level.biome.BiomeSpecialEffects; import java.util.Locale; import java.util.Objects; import java.util.Optional; -import java.util.function.Function; import com.dfsek.terra.api.config.ConfigPack; import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; -import static net.minecraft.world.level.biome.Biome.ClimateSettings; -import static net.minecraft.world.level.biome.Biome.Precipitation; - public class NMSBiomeInjector { public static Optional> getEntry(Registry registry, ResourceLocation identifier) { diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeProvider.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeProvider.java index 52711f0ec..3040d1956 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeProvider.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeProvider.java @@ -2,13 +2,14 @@ package com.dfsek.terra.bukkit.nms.v1_19_R3; import com.mojang.serialization.Codec; import net.minecraft.core.Holder; -import java.util.stream.Stream; import net.minecraft.core.Registry; import net.minecraft.world.level.biome.Biome; import net.minecraft.world.level.biome.BiomeSource; import net.minecraft.world.level.biome.Climate.Sampler; import org.jetbrains.annotations.NotNull; +import java.util.stream.Stream; + import com.dfsek.terra.api.world.biome.generation.BiomeProvider; import com.dfsek.terra.bukkit.world.BukkitPlatformBiome; diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/Reflection.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/Reflection.java index a10837e11..beb2c1e75 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/Reflection.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/Reflection.java @@ -12,8 +12,6 @@ import xyz.jpenilla.reflectionremapper.proxy.annotation.FieldSetter; import xyz.jpenilla.reflectionremapper.proxy.annotation.MethodName; import xyz.jpenilla.reflectionremapper.proxy.annotation.Proxies; -import java.util.Objects; - public class Reflection { public static final MappedRegistryProxy MAPPED_REGISTRY; diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/RegistryFetcher.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/RegistryFetcher.java index 4c5c704b1..5147eb360 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/RegistryFetcher.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/RegistryFetcher.java @@ -5,7 +5,6 @@ import net.minecraft.core.registries.Registries; import net.minecraft.resources.ResourceKey; import net.minecraft.server.dedicated.DedicatedServer; import net.minecraft.world.level.biome.Biome; -import net.minecraft.world.level.levelgen.structure.StructureSet; import org.bukkit.Bukkit; import org.bukkit.craftbukkit.v1_19_R3.CraftServer; diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java index d0c32c7d5..36d43b0ec 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java @@ -1,9 +1,7 @@ package com.dfsek.terra.bukkit.nms.v1_20_R1; import net.minecraft.core.Holder; -import java.util.stream.Stream; import net.minecraft.core.Registry; -import net.minecraft.resources.ResourceKey; import net.minecraft.resources.ResourceLocation; import net.minecraft.world.level.biome.Biome; import net.minecraft.world.level.biome.BiomeSpecialEffects; @@ -11,14 +9,10 @@ import net.minecraft.world.level.biome.BiomeSpecialEffects; import java.util.Locale; import java.util.Objects; import java.util.Optional; -import java.util.function.Function; import com.dfsek.terra.api.config.ConfigPack; import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; -import static net.minecraft.world.level.biome.Biome.ClimateSettings; -import static net.minecraft.world.level.biome.Biome.Precipitation; - public class NMSBiomeInjector { public static Optional> getEntry(Registry registry, ResourceLocation identifier) { diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java index 2f29ac3ef..4f0cbea1a 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java @@ -2,13 +2,14 @@ package com.dfsek.terra.bukkit.nms.v1_20_R1; import com.mojang.serialization.Codec; import net.minecraft.core.Holder; -import java.util.stream.Stream; import net.minecraft.core.Registry; import net.minecraft.world.level.biome.Biome; import net.minecraft.world.level.biome.BiomeSource; import net.minecraft.world.level.biome.Climate.Sampler; import org.jetbrains.annotations.NotNull; +import java.util.stream.Stream; + import com.dfsek.terra.api.world.biome.generation.BiomeProvider; import com.dfsek.terra.bukkit.world.BukkitPlatformBiome; diff --git a/platforms/cli/build.gradle.kts b/platforms/cli/build.gradle.kts index 945bfbc0e..7e35aa714 100644 --- a/platforms/cli/build.gradle.kts +++ b/platforms/cli/build.gradle.kts @@ -14,7 +14,7 @@ dependencies { shadedImplementation("ch.qos.logback:logback-classic:${Versions.CLI.logback}") - implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama) + } tasks.withType { diff --git a/platforms/cli/src/main/java/com/dfsek/terra/cli/world/CLIWorld.java b/platforms/cli/src/main/java/com/dfsek/terra/cli/world/CLIWorld.java index e281efd0e..00c5f17d3 100644 --- a/platforms/cli/src/main/java/com/dfsek/terra/cli/world/CLIWorld.java +++ b/platforms/cli/src/main/java/com/dfsek/terra/cli/world/CLIWorld.java @@ -1,7 +1,6 @@ package com.dfsek.terra.cli.world; import com.google.common.collect.Streams; -import net.jafama.FastMath; import net.querz.mca.MCAFile; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -119,8 +118,8 @@ public class CLIWorld implements ServerWorld, NBTSerializable> { diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/ProtoPlatformBiome.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/ProtoPlatformBiome.java index 11bbae507..30f19bac4 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/ProtoPlatformBiome.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/ProtoPlatformBiome.java @@ -17,10 +17,10 @@ package com.dfsek.terra.mod.config; +import net.minecraft.registry.Registry; import net.minecraft.registry.RegistryKey; import net.minecraft.registry.entry.RegistryEntry; import net.minecraft.util.Identifier; -import net.minecraft.registry.Registry; import net.minecraft.world.biome.Biome; import java.util.Objects; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VanillaBiomeProperties.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VanillaBiomeProperties.java index feb3680d2..2015f7019 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VanillaBiomeProperties.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VanillaBiomeProperties.java @@ -8,7 +8,6 @@ import net.minecraft.sound.BiomeMoodSound; import net.minecraft.sound.MusicSound; import net.minecraft.sound.SoundEvent; import net.minecraft.village.VillagerType; -import net.minecraft.world.biome.Biome.Precipitation; import net.minecraft.world.biome.Biome.TemperatureModifier; import net.minecraft.world.biome.BiomeEffects.GrassColorModifier; import net.minecraft.world.biome.BiomeParticleConfig; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VillagerTypeTemplate.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VillagerTypeTemplate.java index 9aaf3362b..c998d8abf 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VillagerTypeTemplate.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VillagerTypeTemplate.java @@ -5,7 +5,6 @@ import com.dfsek.tectonic.api.config.template.annotations.Value; import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; import net.minecraft.registry.Registries; import net.minecraft.util.Identifier; -import net.minecraft.registry.Registry; import net.minecraft.village.VillagerType; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/data/Codecs.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/data/Codecs.java index 890e3e2b5..e7c0d5002 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/data/Codecs.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/data/Codecs.java @@ -2,8 +2,6 @@ package com.dfsek.terra.mod.data; import com.mojang.serialization.Codec; import com.mojang.serialization.codecs.RecordCodecBuilder; -import net.minecraft.registry.RegistryKeys; -import net.minecraft.registry.RegistryOps; import net.minecraft.world.gen.chunk.ChunkGeneratorSettings; import com.dfsek.terra.api.config.ConfigPack; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/MinecraftChunkGeneratorWrapper.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/MinecraftChunkGeneratorWrapper.java index 75fd4f498..fd1ee7cf9 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/MinecraftChunkGeneratorWrapper.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/MinecraftChunkGeneratorWrapper.java @@ -17,20 +17,16 @@ package com.dfsek.terra.mod.generation; -import com.dfsek.terra.mod.util.SeedHack; - import com.mojang.serialization.Codec; import net.minecraft.block.BlockState; import net.minecraft.block.Blocks; import net.minecraft.registry.entry.RegistryEntry; -import net.minecraft.structure.StructureSet; import net.minecraft.util.Util; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.ChunkPos; import net.minecraft.util.math.random.CheckedRandom; import net.minecraft.util.math.random.ChunkRandom; import net.minecraft.util.math.random.RandomSeed; -import net.minecraft.registry.Registry; import net.minecraft.world.ChunkRegion; import net.minecraft.world.HeightLimitView; import net.minecraft.world.Heightmap.Type; @@ -51,7 +47,6 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.List; -import java.util.Optional; import java.util.concurrent.CompletableFuture; import java.util.concurrent.Executor; @@ -67,6 +62,7 @@ import com.dfsek.terra.mod.config.PreLoadCompatibilityOptions; import com.dfsek.terra.mod.data.Codecs; import com.dfsek.terra.mod.mixin.access.StructureAccessorAccessor; import com.dfsek.terra.mod.util.MinecraftAdapter; +import com.dfsek.terra.mod.util.SeedHack; public class MinecraftChunkGeneratorWrapper extends net.minecraft.world.gen.chunk.ChunkGenerator implements GeneratorWrapper { diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/TerraBiomeSource.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/TerraBiomeSource.java index d4a285edd..4bd2866ae 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/TerraBiomeSource.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/TerraBiomeSource.java @@ -18,7 +18,6 @@ package com.dfsek.terra.mod.generation; import com.mojang.serialization.Codec; -import net.minecraft.registry.Registry; import net.minecraft.registry.entry.RegistryEntry; import net.minecraft.world.biome.Biome; import net.minecraft.world.biome.source.BiomeSource; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftItemHandle.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftItemHandle.java index 66582857a..8bed0298a 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftItemHandle.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftItemHandle.java @@ -22,10 +22,10 @@ import com.mojang.brigadier.exceptions.CommandSyntaxException; import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.ItemStackArgumentType; import net.minecraft.registry.Registries; +import net.minecraft.registry.Registry; import net.minecraft.registry.RegistryKey; import net.minecraft.registry.RegistryWrapper; import net.minecraft.util.Identifier; -import net.minecraft.registry.Registry; import java.util.Set; import java.util.stream.Collectors; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftWorldHandle.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftWorldHandle.java index aabc38471..ba84f3129 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftWorldHandle.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftWorldHandle.java @@ -22,7 +22,6 @@ import net.minecraft.block.Blocks; import net.minecraft.command.argument.BlockArgumentParser; import net.minecraft.registry.Registries; import net.minecraft.util.Identifier; -import net.minecraft.registry.Registry; import org.jetbrains.annotations.NotNull; import com.dfsek.terra.api.block.state.BlockState; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/MobSpawnerBlockEntityMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/MobSpawnerBlockEntityMixin.java index 95fe9154c..7f8a6850b 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/MobSpawnerBlockEntityMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/MobSpawnerBlockEntityMixin.java @@ -24,7 +24,6 @@ import net.minecraft.block.entity.MobSpawnerBlockEntity; import net.minecraft.registry.Registries; import net.minecraft.util.Identifier; import net.minecraft.util.math.BlockPos; -import net.minecraft.registry.Registry; import net.minecraft.util.math.random.Random; import net.minecraft.world.MobSpawnerLogic; import org.jetbrains.annotations.NotNull; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/SignBlockEntityMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/SignBlockEntityMixin.java index fe8d2cbab..b0ba7b69e 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/SignBlockEntityMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/SignBlockEntityMixin.java @@ -21,7 +21,6 @@ import net.minecraft.block.entity.SignBlockEntity; import net.minecraft.block.entity.SignText; import net.minecraft.text.Text; import org.jetbrains.annotations.NotNull; -import org.spongepowered.asm.mixin.Final; import org.spongepowered.asm.mixin.Implements; import org.spongepowered.asm.mixin.Interface; import org.spongepowered.asm.mixin.Mixin; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/state/BlockStateMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/state/BlockStateMixin.java index 2ec3cf649..a666b3491 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/state/BlockStateMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/state/BlockStateMixin.java @@ -7,7 +7,6 @@ import net.minecraft.block.AbstractBlock.AbstractBlockState; import net.minecraft.block.Block; import net.minecraft.registry.Registries; import net.minecraft.state.State; -import net.minecraft.registry.Registry; import org.spongepowered.asm.mixin.Implements; import org.spongepowered.asm.mixin.Interface; import org.spongepowered.asm.mixin.Intrinsic; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java index 2cf8123ea..0cc130471 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java @@ -17,7 +17,6 @@ package com.dfsek.terra.mod.mixin.implementations.terra.chunk; -import net.minecraft.block.Block; import net.minecraft.util.math.BlockPos; import net.minecraft.world.chunk.Chunk.TickSchedulers; import net.minecraft.world.chunk.WorldChunk; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/EnchantmentMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/EnchantmentMixin.java index 5b4b3eaf7..f73b91cfe 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/EnchantmentMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/EnchantmentMixin.java @@ -19,8 +19,6 @@ package com.dfsek.terra.mod.mixin.implementations.terra.inventory.meta; import net.minecraft.enchantment.Enchantment; import net.minecraft.registry.Registries; -import net.minecraft.registry.Registry; -import net.minecraft.registry.RegistryKeys; import org.spongepowered.asm.mixin.Implements; import org.spongepowered.asm.mixin.Interface; import org.spongepowered.asm.mixin.Mixin; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/ItemStackMetaMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/ItemStackMetaMixin.java index 0391cd4ef..bb8159c99 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/ItemStackMetaMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/ItemStackMetaMixin.java @@ -21,7 +21,6 @@ import net.minecraft.item.ItemStack; import net.minecraft.nbt.NbtCompound; import net.minecraft.nbt.NbtList; import net.minecraft.registry.Registries; -import net.minecraft.registry.Registry; import org.spongepowered.asm.mixin.Implements; import org.spongepowered.asm.mixin.Interface; import org.spongepowered.asm.mixin.Intrinsic; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/lifecycle/DataPackContentsMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/lifecycle/DataPackContentsMixin.java index d4a27e750..81a9c2cae 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/lifecycle/DataPackContentsMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/lifecycle/DataPackContentsMixin.java @@ -1,7 +1,6 @@ package com.dfsek.terra.mod.mixin.lifecycle; import net.minecraft.registry.DynamicRegistryManager; -import net.minecraft.registry.Registries; import net.minecraft.registry.Registry; import net.minecraft.registry.RegistryKeys; import net.minecraft.server.DataPackContents; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftUtil.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftUtil.java index 803b78b0b..2470f139f 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftUtil.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftUtil.java @@ -4,12 +4,12 @@ import net.minecraft.block.entity.LootableContainerBlockEntity; import net.minecraft.block.entity.MobSpawnerBlockEntity; import net.minecraft.block.entity.SignBlockEntity; import net.minecraft.registry.Registries; +import net.minecraft.registry.Registry; import net.minecraft.registry.RegistryKey; import net.minecraft.registry.RegistryKeys; import net.minecraft.registry.entry.RegistryEntry; import net.minecraft.util.Identifier; import net.minecraft.util.math.BlockPos; -import net.minecraft.registry.Registry; import net.minecraft.world.WorldAccess; import net.minecraft.world.biome.Biome; import net.minecraft.world.biome.Biome.Builder; @@ -25,7 +25,6 @@ import java.util.Locale; import java.util.Map; import java.util.Objects; import java.util.Optional; -import java.util.function.Function; import com.dfsek.terra.api.block.entity.BlockEntity; import com.dfsek.terra.api.block.entity.Container; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/TagUtil.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/TagUtil.java index 81289fdfb..feb3826f1 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/TagUtil.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/TagUtil.java @@ -1,8 +1,8 @@ package com.dfsek.terra.mod.util; import com.google.common.collect.ImmutableMap; -import net.minecraft.registry.entry.RegistryEntry; import net.minecraft.registry.Registry; +import net.minecraft.registry.entry.RegistryEntry; import net.minecraft.registry.tag.TagKey; import net.minecraft.registry.tag.WorldPresetTags; import net.minecraft.world.biome.Biome; diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java index 4350f31c0..bc481f560 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java @@ -1,18 +1,14 @@ package com.dfsek.terra.lifecycle; import cloud.commandframework.execution.CommandExecutionCoordinator; - import cloud.commandframework.fabric.FabricServerCommandManager; - -import com.dfsek.terra.api.command.CommandSender; -import com.dfsek.terra.api.event.events.platform.CommandRegistrationEvent; - -import com.dfsek.terra.mod.MinecraftAddon; - import net.minecraft.server.command.ServerCommandSource; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import com.dfsek.terra.api.command.CommandSender; +import com.dfsek.terra.api.event.events.platform.CommandRegistrationEvent; + public class LifecycleEntryPoint { private static final Logger logger = LoggerFactory.getLogger(LifecycleEntryPoint.class); diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java index 9e0e081d3..4bf538144 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java @@ -3,11 +3,7 @@ package com.dfsek.terra.lifecycle; import ca.solostudios.strata.Versions; import ca.solostudios.strata.parser.tokenizer.ParseException; import ca.solostudios.strata.version.Version; - -import com.dfsek.terra.lifecycle.util.BiomeUtil; - import net.minecraft.MinecraftVersion; -import net.minecraft.registry.Registries; import net.minecraft.registry.Registry; import net.minecraft.registry.RegistryKeys; import net.minecraft.server.MinecraftServer; @@ -21,11 +17,12 @@ import org.slf4j.LoggerFactory; import java.util.ArrayList; import java.util.Collection; import java.util.List; -import java.util.stream.Stream; import java.util.concurrent.atomic.AtomicReference; +import java.util.stream.Stream; import com.dfsek.terra.addon.EphemeralAddon; import com.dfsek.terra.api.addon.BaseAddon; +import com.dfsek.terra.lifecycle.util.BiomeUtil; import com.dfsek.terra.mod.CommonPlatform; import com.dfsek.terra.mod.ModPlatform; import com.dfsek.terra.mod.generation.MinecraftChunkGeneratorWrapper; diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/NoiseConfigMixin.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/NoiseConfigMixin.java index e8091826a..714fa7246 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/NoiseConfigMixin.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/NoiseConfigMixin.java @@ -2,7 +2,6 @@ package com.dfsek.terra.lifecycle.mixin; import net.minecraft.registry.RegistryEntryLookup; import net.minecraft.util.math.noise.DoublePerlinNoiseSampler; -import net.minecraft.registry.Registry; import net.minecraft.world.biome.source.util.MultiNoiseUtil.MultiNoiseSampler; import net.minecraft.world.gen.chunk.ChunkGeneratorSettings; import net.minecraft.world.gen.noise.NoiseConfig; diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/RegistryMixin.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/RegistryMixin.java index a2d516931..ce4e4bfe0 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/RegistryMixin.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/RegistryMixin.java @@ -1,7 +1,6 @@ package com.dfsek.terra.lifecycle.mixin; import net.minecraft.registry.Registries; -import net.minecraft.registry.Registry; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/SimpleRegistryMixin.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/SimpleRegistryMixin.java index 2da9f317d..f388e57b6 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/SimpleRegistryMixin.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/SimpleRegistryMixin.java @@ -1,9 +1,6 @@ package com.dfsek.terra.lifecycle.mixin; -import com.dfsek.terra.lifecycle.util.RegistryHack; - import net.minecraft.registry.SimpleRegistry; -import net.minecraft.registry.entry.RegistryEntry; import net.minecraft.registry.entry.RegistryEntry.Reference; import org.spongepowered.asm.mixin.Final; import org.spongepowered.asm.mixin.Mixin; @@ -11,6 +8,8 @@ import org.spongepowered.asm.mixin.Shadow; import java.util.Map; +import com.dfsek.terra.lifecycle.util.RegistryHack; + @Mixin(SimpleRegistry.class) public class SimpleRegistryMixin implements RegistryHack { diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/SaveLoadingMixin.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/SaveLoadingMixin.java index 260d3c4a2..953e23dc0 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/SaveLoadingMixin.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/SaveLoadingMixin.java @@ -1,9 +1,5 @@ package com.dfsek.terra.lifecycle.mixin.lifecycle; -import com.dfsek.terra.lifecycle.util.LifecycleUtil; - -import com.dfsek.terra.mod.util.MinecraftUtil; - import net.minecraft.registry.DynamicRegistryManager; import net.minecraft.registry.RegistryKeys; import net.minecraft.server.SaveLoading; @@ -11,6 +7,8 @@ import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.ModifyArg; +import com.dfsek.terra.mod.util.MinecraftUtil; + @Mixin(SaveLoading.class) public class SaveLoadingMixin { diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/BiomeUtil.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/BiomeUtil.java index 0eadea7f4..20ad6a17d 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/BiomeUtil.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/BiomeUtil.java @@ -1,10 +1,9 @@ package com.dfsek.terra.lifecycle.util; -import net.minecraft.registry.DynamicRegistryManager; +import net.minecraft.registry.Registry; import net.minecraft.registry.RegistryKey; import net.minecraft.registry.RegistryKeys; import net.minecraft.util.Identifier; -import net.minecraft.registry.Registry; import net.minecraft.village.VillagerType; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/RegistryUtil.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/RegistryUtil.java index 6c6ee4ad6..a22e449b5 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/RegistryUtil.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/RegistryUtil.java @@ -1,8 +1,8 @@ package com.dfsek.terra.lifecycle.util; import net.minecraft.registry.Registries; -import net.minecraft.util.Identifier; import net.minecraft.registry.Registry; +import net.minecraft.util.Identifier; import com.dfsek.terra.mod.data.Codecs; From 6f08908bb4fd902bf1d0168d2b78563394bbd9cd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Thu, 26 Oct 2023 10:43:13 -0600 Subject: [PATCH 52/83] merge ovre-v2 into ore(v1) --- common/addons/config-ore-v2/LICENSE | 21 -- common/addons/config-ore-v2/README.md | 3 - common/addons/config-ore-v2/build.gradle.kts | 5 - .../dfsek/terra/addons/ore/v2/OreAddon.java | 33 --- .../terra/addons/ore/v2/OreConfigType.java | 37 ---- .../dfsek/terra/addons/ore/v2/OreFactory.java | 24 -- .../terra/addons/ore/v2/OreTemplate.java | 80 ------- .../terra/addons/ore/v2/ores/VanillaOre.java | 206 ------------------ .../src/main/resources/terra.addon.yml | 12 - .../terra/addons/ore/ores/VanillaOre.java | 178 +++++++++++---- 10 files changed, 134 insertions(+), 465 deletions(-) delete mode 100644 common/addons/config-ore-v2/LICENSE delete mode 100644 common/addons/config-ore-v2/README.md delete mode 100644 common/addons/config-ore-v2/build.gradle.kts delete mode 100644 common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreAddon.java delete mode 100644 common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreConfigType.java delete mode 100644 common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreFactory.java delete mode 100644 common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java delete mode 100644 common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java delete mode 100644 common/addons/config-ore-v2/src/main/resources/terra.addon.yml diff --git a/common/addons/config-ore-v2/LICENSE b/common/addons/config-ore-v2/LICENSE deleted file mode 100644 index 64c1cd516..000000000 --- a/common/addons/config-ore-v2/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2020-2021 Polyhedral Development - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. \ No newline at end of file diff --git a/common/addons/config-ore-v2/README.md b/common/addons/config-ore-v2/README.md deleted file mode 100644 index 9171511a3..000000000 --- a/common/addons/config-ore-v2/README.md +++ /dev/null @@ -1,3 +0,0 @@ -# config-ore-v2 - -Registers the default configuration for Terra Ores, `ORE`. diff --git a/common/addons/config-ore-v2/build.gradle.kts b/common/addons/config-ore-v2/build.gradle.kts deleted file mode 100644 index d3eaff9fe..000000000 --- a/common/addons/config-ore-v2/build.gradle.kts +++ /dev/null @@ -1,5 +0,0 @@ -version = version("1.0.0") - -dependencies { - compileOnlyApi(project(":common:addons:manifest-addon-loader")) -} \ No newline at end of file diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreAddon.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreAddon.java deleted file mode 100644 index 9a3d3d05b..000000000 --- a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreAddon.java +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Copyright (c) 2020-2021 Polyhedral Development - * - * The Terra Core Addons are licensed under the terms of the MIT License. For more details, - * reference the LICENSE file in this module's root directory. - */ - -package com.dfsek.terra.addons.ore.v2; - -import com.dfsek.terra.addons.manifest.api.AddonInitializer; -import com.dfsek.terra.api.Platform; -import com.dfsek.terra.api.addon.BaseAddon; -import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent; -import com.dfsek.terra.api.event.functional.FunctionalEventHandler; -import com.dfsek.terra.api.inject.annotations.Inject; - - -public class OreAddon implements AddonInitializer { - @Inject - private Platform platform; - - @Inject - private BaseAddon addon; - - @Override - public void initialize() { - platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> event.getPack().registerConfigType(new OreConfigType(), addon.key("ORE"), 1)) - .failThrough(); - } -} diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreConfigType.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreConfigType.java deleted file mode 100644 index dd9c74f12..000000000 --- a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreConfigType.java +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright (c) 2020-2021 Polyhedral Development - * - * The Terra Core Addons are licensed under the terms of the MIT License. For more details, - * reference the LICENSE file in this module's root directory. - */ - -package com.dfsek.terra.addons.ore.v2; - -import com.dfsek.terra.api.Platform; -import com.dfsek.terra.api.config.ConfigFactory; -import com.dfsek.terra.api.config.ConfigPack; -import com.dfsek.terra.api.config.ConfigType; -import com.dfsek.terra.api.structure.Structure; -import com.dfsek.terra.api.util.reflection.TypeKey; - - -public class OreConfigType implements ConfigType { - public static final TypeKey ORE_TYPE_TOKEN = new TypeKey<>() { - }; - private final OreFactory factory = new OreFactory(); - - @Override - public OreTemplate getTemplate(ConfigPack pack, Platform platform) { - return new OreTemplate(); - } - - @Override - public ConfigFactory getFactory() { - return factory; - } - - @Override - public TypeKey getTypeKey() { - return ORE_TYPE_TOKEN; - } -} diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreFactory.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreFactory.java deleted file mode 100644 index 65b3f5d65..000000000 --- a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreFactory.java +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright (c) 2020-2021 Polyhedral Development - * - * The Terra Core Addons are licensed under the terms of the MIT License. For more details, - * reference the LICENSE file in this module's root directory. - */ - -package com.dfsek.terra.addons.ore.v2; - -import com.dfsek.terra.addons.ore.v2.ores.VanillaOre; -import com.dfsek.terra.api.Platform; -import com.dfsek.terra.api.block.state.BlockState; -import com.dfsek.terra.api.config.ConfigFactory; -import com.dfsek.terra.api.structure.Structure; - - -public class OreFactory implements ConfigFactory { - @Override - public VanillaOre build(OreTemplate config, Platform platform) { - BlockState m = config.getMaterial(); - return new VanillaOre(m, config.getSize(), config.getReplaceable(), config.doPhysics(), config.isExposed(), - config.getMaterialOverrides()); - } -} diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java deleted file mode 100644 index fa8f49b9e..000000000 --- a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java +++ /dev/null @@ -1,80 +0,0 @@ -/* - * Copyright (c) 2020-2021 Polyhedral Development - * - * The Terra Core Addons are licensed under the terms of the MIT License. For more details, - * reference the LICENSE file in this module's root directory. - */ - -package com.dfsek.terra.addons.ore.v2; - -import com.dfsek.tectonic.api.config.template.annotations.Default; -import com.dfsek.tectonic.api.config.template.annotations.Description; -import com.dfsek.tectonic.api.config.template.annotations.Final; -import com.dfsek.tectonic.api.config.template.annotations.Value; - -import java.util.HashMap; -import java.util.Map; - -import com.dfsek.terra.api.block.BlockType; -import com.dfsek.terra.api.block.state.BlockState; -import com.dfsek.terra.api.config.AbstractableTemplate; -import com.dfsek.terra.api.config.meta.Meta; -import com.dfsek.terra.api.util.collection.MaterialSet; - - -@SuppressWarnings({ "unused", "FieldMayBeFinal" }) -public class OreTemplate implements AbstractableTemplate { - @Value("id") - @Final - private String id; - - @Value("material") - private @Meta BlockState material; - - @Value("material-overrides") - @Default - private @Meta Map<@Meta BlockType, @Meta BlockState> materials = new HashMap<>(); - - @Value("replace") - private @Meta MaterialSet replaceable; - - @Value("physics") - @Default - private @Meta boolean physics = false; - - @Value("size") - private @Meta double size; - - @Value("exposed") - @Default - @Description("The chance that ore blocks bordering air will be discarded as candidates for ore. 0 = 0%, 1 = 100%") - private @Meta double exposed = 0.0f; - - public boolean doPhysics() { - return physics; - } - - public double getSize() { - return size; - } - - public BlockState getMaterial() { - return material; - } - - public MaterialSet getReplaceable() { - return replaceable; - } - - public String getID() { - return id; - } - - public Map getMaterialOverrides() { - return materials; - } - - public double isExposed() { - return exposed; - } -} diff --git a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java b/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java deleted file mode 100644 index 9f219f17f..000000000 --- a/common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java +++ /dev/null @@ -1,206 +0,0 @@ -/* - * Copyright (c) 2020-2021 Polyhedral Development - * - * The Terra Core Addons are licensed under the terms of the MIT License. For more details, - * reference the LICENSE file in this module's root directory. - */ - -package com.dfsek.terra.addons.ore.v2.ores; - -import java.util.BitSet; -import java.util.Map; -import java.util.Random; - -import com.dfsek.terra.api.block.BlockType; -import com.dfsek.terra.api.block.state.BlockState; -import com.dfsek.terra.api.structure.Structure; -import com.dfsek.terra.api.util.MathUtil; -import com.dfsek.terra.api.util.Rotation; -import com.dfsek.terra.api.util.collection.MaterialSet; -import com.dfsek.terra.api.util.vector.Vector3Int; -import com.dfsek.terra.api.world.WritableWorld; - - -public class VanillaOre implements Structure { - - private final BlockState material; - - private final double size; - private final MaterialSet replaceable; - private final boolean applyGravity; - private final double exposed; - private final Map materials; - - public VanillaOre(BlockState material, double size, MaterialSet replaceable, boolean applyGravity, - double exposed, Map materials) { - this.material = material; - this.size = size; - this.replaceable = replaceable; - this.applyGravity = applyGravity; - this.exposed = exposed; - this.materials = materials; - } - - protected static boolean shouldNotDiscard(Random random, double chance) { - if(chance <= 0.0F) { - return true; - } else if(chance >= 1.0F) { - return false; - } else { - return random.nextFloat() >= chance; - } - } - - public static double lerp(double t, double v0, double v1) { - return v0 + t * (v1 - v0); - } - - @Override - public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation) { - float randomRadian = random.nextFloat() * (float) Math.PI; - double eigthSize = size / 8.0F; - - // Place points to form a line segment - double startX = (double) location.getX() + MathUtil.sin(randomRadian) * eigthSize; - double endX = (double) location.getX() - MathUtil.sin(randomRadian) * eigthSize; - - double startZ = (double) location.getZ() + MathUtil.cos(randomRadian) * eigthSize; - double endZ = (double) location.getZ() - MathUtil.cos(randomRadian) * eigthSize; - - double startY = location.getY() + random.nextInt(3) - 2; - double endY = location.getY() + random.nextInt(3) - 2; - - int sizeInt = (int) size; - double[] points = new double[sizeInt * 4]; - - // Compute initial point positions and radius - for(int i = 0; i < sizeInt; ++i) { - float t = (float) i / (float) sizeInt; - double xt = lerp(t, startX, endX); - double yt = lerp(t, startY, endY); - double zt = lerp(t, startZ, endZ); - double roll = random.nextDouble() * size / 16.0; - // Taper radius closer to line ends - double radius = ((MathUtil.sin((float) Math.PI * t) + 1.0F) * roll + 1.0) / 2.0; - points[i * 4] = xt; - points[i * 4 + 1] = yt; - points[i * 4 + 2] = zt; - points[i * 4 + 3] = radius; - } - - // Compare every point to every other point - for(int a = 0; a < sizeInt - 1; ++a) { - double radiusA = points[a * 4 + 3]; - if(radiusA > 0.0) { - for(int b = a + 1; b < sizeInt; ++b) { - double radiusB = points[b * 4 + 3]; - if(radiusB > 0.0) { - double dxt = points[a * 4] - points[b * 4]; - double dyt = points[a * 4 + 1] - points[b * 4 + 1]; - double dzt = points[a * 4 + 2] - points[b * 4 + 2]; - double dRadius = radiusA - radiusB; - - // If the radius difference is greater than the distance between the two points - if(dRadius * dRadius > dxt * dxt + dyt * dyt + dzt * dzt) { - // Set smaller of two radii to -1 - if(dRadius > 0.0) { - points[b * 4 + 3] = -1.0; - } else { - points[a * 4 + 3] = -1.0; - } - } - } - } - } - } - - int outset = (int) Math.ceil((size / 16.0F * 2.0F + 1.0F) / 2.0F); - int x = (int) (location.getX() - Math.ceil(eigthSize) - outset); - int y = location.getY() - 2 - outset; - int z = (int) (location.getZ() - Math.ceil(eigthSize) - outset); - - int horizontalSize = (int) (2 * (Math.ceil(eigthSize) + outset)); - int verticalSize = 2 * (2 + outset); - - int sphereCount = 0; - BitSet visited = new BitSet(horizontalSize * verticalSize * horizontalSize); - - // Generate a sphere at each point - for(int i = 0; i < sizeInt; ++i) { - double radius = points[i * 4 + 3]; - if(radius > 0.0) { - double xt = points[i * 4]; - double yt = points[i * 4 + 1]; - double zt = points[i * 4 + 2]; - - int xLowerBound = (int) Math.max(Math.floor(xt - radius), x); - int xUpperBound = (int) Math.max(Math.floor(xt + radius), xLowerBound); - - int yLowerBound = (int) Math.max(Math.floor(yt - radius), y); - int yUpperBound = (int) Math.max(Math.floor(yt + radius), yLowerBound); - - int zLowerBound = (int) Math.max(Math.floor(zt - radius), z); - int zUpperBound = (int) Math.max(Math.floor(zt + radius), zLowerBound); - - // Iterate over coordinates within bounds - for(int xi = xLowerBound; xi <= xUpperBound; ++xi) { - double dx = ((double) xi + 0.5 - xt) / radius; - if(dx * dx < 1.0) { - for(int yi = yLowerBound; yi <= yUpperBound; ++yi) { - double dy = ((double) yi + 0.5 - yt) / radius; - if(dx * dx + dy * dy < 1.0) { - for(int zi = zLowerBound; zi <= zUpperBound; ++zi) { - double dz = ((double) zi + 0.5 - zt) / radius; - - // If position is inside the sphere - if(dx * dx + dy * dy + dz * dz < 1.0 && !(yi < world.getMinHeight() || yi >= world.getMaxHeight())) { - int index = xi - x + (yi - y) * horizontalSize + (zi - z) * horizontalSize * verticalSize; - if(!visited.get(index)) { // Skip blocks that have already been visited - - visited.set(index); - BlockType block = world.getBlockState(xi, yi, zi).getBlockType(); - if(shouldPlace(block, random, world, xi, yi, zi)) { - world.setBlockState(xi, yi, zi, getMaterial(block), isApplyGravity()); - ++sphereCount; - break; - } - } - } - } - } - } - } - } - } - } - - return sphereCount > 0; - } - - public boolean shouldPlace(BlockType type, Random random, WritableWorld world, int x, int y, int z) { - if(!getReplaceable().contains(type)) { - return false; - } else if(shouldNotDiscard(random, exposed)) { - return true; - } else { - return !(world.getBlockState(x, y, z - 1).isAir() || - world.getBlockState(x, y, z + 1).isAir() || - world.getBlockState(x, y - 1, z).isAir() || - world.getBlockState(x, y + 1, z).isAir() || - world.getBlockState(x - 1, y, z).isAir() || - world.getBlockState(x + 1, y, z).isAir()); - } - } - - public BlockState getMaterial(BlockType replace) { - return materials.getOrDefault(replace, material); - } - - public MaterialSet getReplaceable() { - return replaceable; - } - - public boolean isApplyGravity() { - return applyGravity; - } -} diff --git a/common/addons/config-ore-v2/src/main/resources/terra.addon.yml b/common/addons/config-ore-v2/src/main/resources/terra.addon.yml deleted file mode 100644 index 72f4b24b9..000000000 --- a/common/addons/config-ore-v2/src/main/resources/terra.addon.yml +++ /dev/null @@ -1,12 +0,0 @@ -schema-version: 1 -contributors: - - Terra contributors -id: config-ore-v2 -version: @VERSION@ -entrypoints: - - "com.dfsek.terra.addons.ore.v2.OreAddon" -website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org -license: MIT License \ No newline at end of file diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java index 224d0b502..0e09ffcb7 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java @@ -7,6 +7,7 @@ package com.dfsek.terra.addons.ore.ores; +import java.util.BitSet; import java.util.Map; import java.util.Random; @@ -40,57 +41,130 @@ public class VanillaOre implements Structure { this.materials = materials; } + protected static boolean shouldNotDiscard(Random random, double chance) { + if(chance <= 0.0F) { + return true; + } else if(chance >= 1.0F) { + return false; + } else { + return random.nextFloat() >= chance; + } + } + + public static double lerp(double t, double v0, double v1) { + return v0 + t * (v1 - v0); + } + @Override public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation) { - int centerX = location.getX(); - int centerZ = location.getZ(); - int centerY = location.getY(); + float randomRadian = random.nextFloat() * (float) Math.PI; + double eigthSize = size / 8.0F; + // Place points to form a line segment + double startX = (double) location.getX() + MathUtil.sin(randomRadian) * eigthSize; + double endX = (double) location.getX() - MathUtil.sin(randomRadian) * eigthSize; - float f = random.nextFloat() * (float) Math.PI; + double startZ = (double) location.getZ() + MathUtil.cos(randomRadian) * eigthSize; + double endZ = (double) location.getZ() - MathUtil.cos(randomRadian) * eigthSize; - double d1 = centerX + 8 + MathUtil.sin(f) * size / 8.0F; - double d2 = centerX + 8 - MathUtil.sin(f) * size / 8.0F; - double d3 = centerZ + 8 + MathUtil.cos(f) * size / 8.0F; - double d4 = centerZ + 8 - MathUtil.cos(f) * size / 8.0F; + double startY = location.getY() + random.nextInt(3) - 2; + double endY = location.getY() + random.nextInt(3) - 2; - double d5 = centerY + random.nextInt(3) - 2D; - double d6 = centerY + random.nextInt(3) - 2D; + int sizeInt = (int) size; + double[] points = new double[sizeInt * 4]; - for(int i = 0; i < size; i++) { - float iFactor = (float) i / (float) size; - - double d10 = random.nextDouble() * size / 16.0D; - double d11 = (MathUtil.sin(Math.PI * iFactor) + 1.0) * d10 + 1.0; - double d12 = (MathUtil.sin(Math.PI * iFactor) + 1.0) * d10 + 1.0; - - int xStart = (int) Math.round(Math.floor(d1 + (d2 - d1) * iFactor - d11 / 2.0D)); - int yStart = (int) Math.round(Math.floor(d5 + (d6 - d5) * iFactor - d12 / 2.0D)); - int zStart = (int) Math.round(Math.floor(d3 + (d4 - d3) * iFactor - d11 / 2.0D)); - - int xEnd = (int) Math.round(Math.floor(d1 + (d2 - d1) * iFactor + d11 / 2.0D)); - int yEnd = (int) Math.round(Math.floor(d5 + (d6 - d5) * iFactor + d12 / 2.0D)); - int zEnd = (int) Math.round(Math.floor(d3 + (d4 - d3) * iFactor + d11 / 2.0D)); - - for(int x = xStart; x <= xEnd; x++) { - double d13 = (x + 0.5D - (d1 + (d2 - d1) * iFactor)) / (d11 / 2.0D); + // Compute initial point positions and radius + for(int i = 0; i < sizeInt; ++i) { + float t = (float) i / (float) sizeInt; + double xt = lerp(t, startX, endX); + double yt = lerp(t, startY, endY); + double zt = lerp(t, startZ, endZ); + double roll = random.nextDouble() * size / 16.0; + // Taper radius closer to line ends + double radius = ((MathUtil.sin((float) Math.PI * t) + 1.0F) * roll + 1.0) / 2.0; + points[i * 4] = xt; + points[i * 4 + 1] = yt; + points[i * 4 + 2] = zt; + points[i * 4 + 3] = radius; + } + + // Compare every point to every other point + for(int a = 0; a < sizeInt - 1; ++a) { + double radiusA = points[a * 4 + 3]; + if(radiusA > 0.0) { + for(int b = a + 1; b < sizeInt; ++b) { + double radiusB = points[b * 4 + 3]; + if(radiusB > 0.0) { + double dxt = points[a * 4] - points[b * 4]; + double dyt = points[a * 4 + 1] - points[b * 4 + 1]; + double dzt = points[a * 4 + 2] - points[b * 4 + 2]; + double dRadius = radiusA - radiusB; + + // If the radius difference is greater than the distance between the two points + if(dRadius * dRadius > dxt * dxt + dyt * dyt + dzt * dzt) { + // Set smaller of two radii to -1 + if(dRadius > 0.0) { + points[b * 4 + 3] = -1.0; + } else { + points[a * 4 + 3] = -1.0; + } + } + } + } + } + } + + int outset = (int) Math.ceil((size / 16.0F * 2.0F + 1.0F) / 2.0F); + int x = (int) (location.getX() - Math.ceil(eigthSize) - outset); + int y = location.getY() - 2 - outset; + int z = (int) (location.getZ() - Math.ceil(eigthSize) - outset); + + int horizontalSize = (int) (2 * (Math.ceil(eigthSize) + outset)); + int verticalSize = 2 * (2 + outset); + + int sphereCount = 0; + BitSet visited = new BitSet(horizontalSize * verticalSize * horizontalSize); + + // Generate a sphere at each point + for(int i = 0; i < sizeInt; ++i) { + double radius = points[i * 4 + 3]; + if(radius > 0.0) { + double xt = points[i * 4]; + double yt = points[i * 4 + 1]; + double zt = points[i * 4 + 2]; - if(d13 * d13 < 1.0D) { - for(int y = yStart; y <= yEnd; y++) { - double d14 = (y + 0.5D - (d5 + (d6 - d5) * iFactor)) / (d12 / 2.0D); - if(d13 * d13 + d14 * d14 < 1.0D) { - for(int z = zStart; z <= zEnd; z++) { - double d15 = (z + 0.5D - (d3 + (d4 - d3) * iFactor)) / (d11 / 2.0D); - if(y >= world.getMaxHeight() || y < world.getMinHeight()) continue; - BlockType block = world.getBlockState(x, y, z).getBlockType(); - if((d13 * d13 + d14 * d14 + d15 * d15 < 1.0D) && getReplaceable().contains(block)) { - if(exposed > random.nextDouble() || !(world.getBlockState(x, y, z - 1).isAir() || - world.getBlockState(x, y, z + 1).isAir() || - world.getBlockState(x, y - 1, z).isAir() || - world.getBlockState(x, y + 1, z).isAir() || - world.getBlockState(x - 1, y, z).isAir() || - world.getBlockState(x + 1, y, z).isAir())) { - world.setBlockState(x, y, z, getMaterial(block), isApplyGravity()); + int xLowerBound = (int) Math.max(Math.floor(xt - radius), x); + int xUpperBound = (int) Math.max(Math.floor(xt + radius), xLowerBound); + + int yLowerBound = (int) Math.max(Math.floor(yt - radius), y); + int yUpperBound = (int) Math.max(Math.floor(yt + radius), yLowerBound); + + int zLowerBound = (int) Math.max(Math.floor(zt - radius), z); + int zUpperBound = (int) Math.max(Math.floor(zt + radius), zLowerBound); + + // Iterate over coordinates within bounds + for(int xi = xLowerBound; xi <= xUpperBound; ++xi) { + double dx = ((double) xi + 0.5 - xt) / radius; + if(dx * dx < 1.0) { + for(int yi = yLowerBound; yi <= yUpperBound; ++yi) { + double dy = ((double) yi + 0.5 - yt) / radius; + if(dx * dx + dy * dy < 1.0) { + for(int zi = zLowerBound; zi <= zUpperBound; ++zi) { + double dz = ((double) zi + 0.5 - zt) / radius; + + // If position is inside the sphere + if(dx * dx + dy * dy + dz * dz < 1.0 && !(yi < world.getMinHeight() || yi >= world.getMaxHeight())) { + int index = xi - x + (yi - y) * horizontalSize + (zi - z) * horizontalSize * verticalSize; + if(!visited.get(index)) { // Skip blocks that have already been visited + + visited.set(index); + BlockType block = world.getBlockState(xi, yi, zi).getBlockType(); + if(shouldPlace(block, random, world, xi, yi, zi)) { + world.setBlockState(xi, yi, zi, getMaterial(block), isApplyGravity()); + ++sphereCount; + break; + } + } } } } @@ -99,7 +173,23 @@ public class VanillaOre implements Structure { } } } - return true; + + return sphereCount > 0; + } + + public boolean shouldPlace(BlockType type, Random random, WritableWorld world, int x, int y, int z) { + if(!getReplaceable().contains(type)) { + return false; + } else if(shouldNotDiscard(random, exposed)) { + return true; + } else { + return !(world.getBlockState(x, y, z - 1).isAir() || + world.getBlockState(x, y, z + 1).isAir() || + world.getBlockState(x, y - 1, z).isAir() || + world.getBlockState(x, y + 1, z).isAir() || + world.getBlockState(x - 1, y, z).isAir() || + world.getBlockState(x + 1, y, z).isAir()); + } } public BlockState getMaterial(BlockType replace) { From 5d12a560f1d052d7506756e499295b39d3b43bf3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Thu, 26 Oct 2023 11:08:36 -0600 Subject: [PATCH 53/83] add zero and unit vectors --- .../main/java/com/dfsek/terra/api/util/vector/Vector2.java | 5 +++-- .../java/com/dfsek/terra/api/util/vector/Vector2Int.java | 3 +-- .../main/java/com/dfsek/terra/api/util/vector/Vector3.java | 6 +++--- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java index 057ab22aa..48d796274 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java @@ -14,8 +14,9 @@ import com.dfsek.terra.api.util.MathUtil; * oh yeah */ public class Vector2 { - protected double x; - protected double z; + private static final Vector2 ZERO = new Vector2(0, 0); + private static final Vector2 UNIT = new Vector2(0, 1); + protected double x, z; /** * Create a vector with a given X and Z component diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2Int.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2Int.java index 09ce8715d..1a64414c8 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2Int.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2Int.java @@ -9,8 +9,7 @@ import com.dfsek.terra.api.util.Rotation; public class Vector2Int { private static final Vector2Int ZERO = new Vector2Int(0, 0); private static final Vector2Int UNIT = new Vector2Int(0, 1); - protected int x; - protected int z; + protected int x, z; protected Vector2Int(int x, int z) { this.x = x; diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java index 1c024eaf1..f065d0366 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java @@ -13,9 +13,9 @@ import com.dfsek.terra.api.util.MathUtil; public class Vector3 { - protected double x; - protected double y; - protected double z; + private static final Vector3 ZERO = new Vector3(0, 0, 0); + private static final Vector3 UNIT = new Vector3(0, 1, 0); + protected double x, y, z; private Vector3(double x, double y, double z) { this.x = x; From c41bf55b7b59da0709ab6880b0e9083051a41d81 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Thu, 26 Oct 2023 12:53:55 -0600 Subject: [PATCH 54/83] implement missing methods from last comit --- .../main/java/com/dfsek/terra/api/util/vector/Vector2.java | 7 +++++++ .../main/java/com/dfsek/terra/api/util/vector/Vector3.java | 7 +++++++ 2 files changed, 14 insertions(+) diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java index 48d796274..191b0e449 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java @@ -28,6 +28,13 @@ public class Vector2 { this.x = x; this.z = z; } + public static Vector2 zero() { + return ZERO; + } + + public static Vector2 unit() { + return UNIT; + } public static Vector2 of(double x, double z) { return new Vector2(x, z); diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java index f065d0366..bce63c2ea 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java @@ -22,6 +22,13 @@ public class Vector3 { this.y = y; this.z = z; } + public static Vector3 zero() { + return ZERO; + } + + public static Vector3 unit() { + return UNIT; + } public static Vector3 of(double x, double y, double z) { return new Vector3(x, y, z); From 648da95e7d1b235e19c709ebb4a829b5ba679939 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB?= Date: Sun, 29 Oct 2023 23:33:50 +0000 Subject: [PATCH 55/83] Scattered ore (#424) * Scattered Ore Impl * remove break * remove another break * sphereCount -> blockCount --------- Co-authored-by: Astrash --- .../com/dfsek/terra/addons/ore/OreAddon.java | 6 +- .../addons/ore/ScatteredOreConfigType.java | 37 +++++++++++ .../terra/addons/ore/ScatteredOreFactory.java | 27 ++++++++ .../addons/ore/ScatteredOreTemplate.java | 34 ++++++++++ .../terra/addons/ore/ores/VanillaOre.java | 65 ++++++------------- .../addons/ore/ores/VanillaScatteredOre.java | 56 ++++++++++++++++ .../addons/ore/utils/VanillaOreUtils.java | 37 +++++++++++ 7 files changed, 212 insertions(+), 50 deletions(-) create mode 100644 common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreConfigType.java create mode 100644 common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java create mode 100644 common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreTemplate.java create mode 100644 common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java create mode 100644 common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java index ff2ddf54c..2765391b4 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java @@ -19,8 +19,6 @@ import org.slf4j.LoggerFactory; public class OreAddon implements AddonInitializer { - private static final Logger logger = LoggerFactory.getLogger(OreAddon.class); - @Inject private Platform platform; @@ -33,9 +31,7 @@ public class OreAddon implements AddonInitializer { .getHandler(FunctionalEventHandler.class) .register(addon, ConfigPackPreLoadEvent.class) .then(event -> event.getPack().registerConfigType(new OreConfigType(), addon.key("ORE"), 1)) + .then(event -> event.getPack().registerConfigType(new ScatteredOreConfigType(), addon.key("SCATTERED_ORE"), 1)) .failThrough(); - - if(platform.getTerraConfig().isDebugLog()) - logger.warn("The ore-config addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the ore-config-v2 addon for future pack development instead."); } } diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreConfigType.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreConfigType.java new file mode 100644 index 000000000..e777c09b9 --- /dev/null +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreConfigType.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore; + +import com.dfsek.terra.api.Platform; +import com.dfsek.terra.api.config.ConfigFactory; +import com.dfsek.terra.api.config.ConfigPack; +import com.dfsek.terra.api.config.ConfigType; +import com.dfsek.terra.api.structure.Structure; +import com.dfsek.terra.api.util.reflection.TypeKey; + + +public class ScatteredOreConfigType implements ConfigType { + public static final TypeKey ORE_TYPE_TOKEN = new TypeKey<>() { + }; + private final ScatteredOreFactory factory = new ScatteredOreFactory(); + + @Override + public ScatteredOreTemplate getTemplate(ConfigPack pack, Platform platform) { + return new ScatteredOreTemplate(); + } + + @Override + public ConfigFactory getFactory() { + return factory; + } + + @Override + public TypeKey getTypeKey() { + return ORE_TYPE_TOKEN; + } +} diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java new file mode 100644 index 000000000..171c85127 --- /dev/null +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore; + +import com.dfsek.tectonic.api.exception.LoadException; + +import com.dfsek.terra.addons.ore.ores.VanillaOre; +import com.dfsek.terra.addons.ore.ores.VanillaScatteredOre; +import com.dfsek.terra.api.Platform; +import com.dfsek.terra.api.block.state.BlockState; +import com.dfsek.terra.api.config.ConfigFactory; +import com.dfsek.terra.api.structure.Structure; + + +public class ScatteredOreFactory implements ConfigFactory { + @Override + public Structure build(ScatteredOreTemplate config, Platform platform) throws LoadException { + BlockState m = config.getMaterial(); + return new VanillaScatteredOre(m, config.getSize(), config.getReplaceable(), config.doPhysics(), config.isExposed(), + config.getMaterialOverrides(), config.getSpread()); + } +} diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreTemplate.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreTemplate.java new file mode 100644 index 000000000..9c98552a5 --- /dev/null +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreTemplate.java @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2020-2021 Polyhedral Development + * + * The Terra Core Addons are licensed under the terms of the MIT License. For more details, + * reference the LICENSE file in this module's root directory. + */ + +package com.dfsek.terra.addons.ore; + +import com.dfsek.tectonic.api.config.template.annotations.Default; +import com.dfsek.tectonic.api.config.template.annotations.Description; +import com.dfsek.tectonic.api.config.template.annotations.Final; +import com.dfsek.tectonic.api.config.template.annotations.Value; + +import com.dfsek.terra.api.block.BlockType; +import com.dfsek.terra.api.block.state.BlockState; +import com.dfsek.terra.api.config.AbstractableTemplate; +import com.dfsek.terra.api.config.meta.Meta; +import com.dfsek.terra.api.util.collection.MaterialSet; + +import java.util.HashMap; +import java.util.Map; + + +@SuppressWarnings({ "unused", "FieldMayBeFinal" }) +public class ScatteredOreTemplate extends OreTemplate { + @Value("size") + private @Meta int spread = 7; + + + public int getSpread() { + return spread; + } +} diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java index 0e09ffcb7..05a9e4a92 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java @@ -20,16 +20,18 @@ import com.dfsek.terra.api.util.collection.MaterialSet; import com.dfsek.terra.api.util.vector.Vector3Int; import com.dfsek.terra.api.world.WritableWorld; +import static com.dfsek.terra.addons.ore.utils.VanillaOreUtils.shouldPlace; + public class VanillaOre implements Structure { - private final BlockState material; + protected final BlockState material; - private final double size; - private final MaterialSet replaceable; - private final boolean applyGravity; - private final double exposed; - private final Map materials; + protected final double size; + protected final MaterialSet replaceable; + protected final boolean applyGravity; + protected final double exposed; + protected final Map materials; public VanillaOre(BlockState material, double size, MaterialSet replaceable, boolean applyGravity, double exposed, Map materials) { @@ -41,16 +43,6 @@ public class VanillaOre implements Structure { this.materials = materials; } - protected static boolean shouldNotDiscard(Random random, double chance) { - if(chance <= 0.0F) { - return true; - } else if(chance >= 1.0F) { - return false; - } else { - return random.nextFloat() >= chance; - } - } - public static double lerp(double t, double v0, double v1) { return v0 + t * (v1 - v0); } @@ -58,14 +50,14 @@ public class VanillaOre implements Structure { @Override public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation) { float randomRadian = random.nextFloat() * (float) Math.PI; - double eigthSize = size / 8.0F; + double eighthSize = size / 8.0F; // Place points to form a line segment - double startX = (double) location.getX() + MathUtil.sin(randomRadian) * eigthSize; - double endX = (double) location.getX() - MathUtil.sin(randomRadian) * eigthSize; + double startX = (double) location.getX() + MathUtil.sin(randomRadian) * eighthSize; + double endX = (double) location.getX() - MathUtil.sin(randomRadian) * eighthSize; - double startZ = (double) location.getZ() + MathUtil.cos(randomRadian) * eigthSize; - double endZ = (double) location.getZ() - MathUtil.cos(randomRadian) * eigthSize; + double startZ = (double) location.getZ() + MathUtil.cos(randomRadian) * eighthSize; + double endZ = (double) location.getZ() - MathUtil.cos(randomRadian) * eighthSize; double startY = location.getY() + random.nextInt(3) - 2; double endY = location.getY() + random.nextInt(3) - 2; @@ -115,14 +107,14 @@ public class VanillaOre implements Structure { } int outset = (int) Math.ceil((size / 16.0F * 2.0F + 1.0F) / 2.0F); - int x = (int) (location.getX() - Math.ceil(eigthSize) - outset); + int x = (int) (location.getX() - Math.ceil(eighthSize) - outset); int y = location.getY() - 2 - outset; - int z = (int) (location.getZ() - Math.ceil(eigthSize) - outset); + int z = (int) (location.getZ() - Math.ceil(eighthSize) - outset); - int horizontalSize = (int) (2 * (Math.ceil(eigthSize) + outset)); + int horizontalSize = (int) (2 * (Math.ceil(eighthSize) + outset)); int verticalSize = 2 * (2 + outset); - int sphereCount = 0; + int blockCount = 0; BitSet visited = new BitSet(horizontalSize * verticalSize * horizontalSize); // Generate a sphere at each point @@ -159,10 +151,9 @@ public class VanillaOre implements Structure { visited.set(index); BlockType block = world.getBlockState(xi, yi, zi).getBlockType(); - if(shouldPlace(block, random, world, xi, yi, zi)) { + if(shouldPlace(getReplaceable(), block, exposed, random, world, xi, yi, zi)) { world.setBlockState(xi, yi, zi, getMaterial(block), isApplyGravity()); - ++sphereCount; - break; + ++blockCount; } } } @@ -174,24 +165,8 @@ public class VanillaOre implements Structure { } } - return sphereCount > 0; + return blockCount > 0; } - - public boolean shouldPlace(BlockType type, Random random, WritableWorld world, int x, int y, int z) { - if(!getReplaceable().contains(type)) { - return false; - } else if(shouldNotDiscard(random, exposed)) { - return true; - } else { - return !(world.getBlockState(x, y, z - 1).isAir() || - world.getBlockState(x, y, z + 1).isAir() || - world.getBlockState(x, y - 1, z).isAir() || - world.getBlockState(x, y + 1, z).isAir() || - world.getBlockState(x - 1, y, z).isAir() || - world.getBlockState(x + 1, y, z).isAir()); - } - } - public BlockState getMaterial(BlockType replace) { return materials.getOrDefault(replace, material); } diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java new file mode 100644 index 000000000..fb30cff76 --- /dev/null +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java @@ -0,0 +1,56 @@ +package com.dfsek.terra.addons.ore.ores; + +import com.dfsek.terra.addons.ore.utils.VanillaOreUtils; +import com.dfsek.terra.api.block.BlockType; +import com.dfsek.terra.api.block.state.BlockState; +import com.dfsek.terra.api.structure.Structure; +import com.dfsek.terra.api.util.Rotation; +import com.dfsek.terra.api.util.collection.MaterialSet; +import com.dfsek.terra.api.util.vector.Vector3; +import com.dfsek.terra.api.util.vector.Vector3Int; +import com.dfsek.terra.api.world.WritableWorld; + +import java.util.Map; +import java.util.Random; + +import static com.dfsek.terra.addons.ore.utils.VanillaOreUtils.shouldPlace; + + +public class VanillaScatteredOre extends VanillaOre { + protected final int spread; + public VanillaScatteredOre(BlockState material, double size, MaterialSet replaceable, boolean applyGravity, double exposed, + Map materials, int spread) { + super(material, size, replaceable, applyGravity, exposed, materials); + + this.spread = spread; + } + + @Override + public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation) { + int i = random.nextInt((int) (size + 1)); + Vector3Int.Mutable mutable = Vector3Int.zero().mutable(); + + for(int j = 0; j < i; ++j) { + this.setPos(mutable, random, location, Math.min(j, spread)); + BlockType block = world.getBlockState(mutable).getBlockType(); + if (shouldPlace(getReplaceable(), block, exposed, random, world, mutable.getX(), mutable.getY(), mutable.getZ())) { + world.setBlockState(mutable, getMaterial(block), isApplyGravity()); + } + } + + return true; + } + + private void setPos(Vector3Int.Mutable mutable, Random random, Vector3Int location, int spread) { + int x = this.getSpread(random, spread); + int y = this.getSpread(random, spread); + int z = this.getSpread(random, spread); + mutable.setX(location.getX() + x); + mutable.setY(location.getY() + y); + mutable.setZ(location.getZ() + z); + } + + private int getSpread(Random random, int spread) { + return Math.round((random.nextFloat() - random.nextFloat()) * (float)spread); + } +} diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java new file mode 100644 index 000000000..c03ce3752 --- /dev/null +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java @@ -0,0 +1,37 @@ +package com.dfsek.terra.addons.ore.utils; + +import com.dfsek.terra.api.block.BlockType; +import com.dfsek.terra.api.util.collection.MaterialSet; +import com.dfsek.terra.api.world.WritableWorld; + +import java.util.Random; + + +public class VanillaOreUtils { + protected static boolean shouldNotDiscard(Random random, double chance) { + if(chance <= 0.0F) { + return true; + } else if(chance >= 1.0F) { + return false; + } else { + return random.nextFloat() >= chance; + } + } + + public static boolean shouldPlace(MaterialSet replaceable, BlockType type, Double exposed, Random random, WritableWorld world, int x, int y, int z) { + if(!replaceable.contains(type)) { + return false; + } else if(shouldNotDiscard(random, exposed)) { + return true; + } else { + return !(world.getBlockState(x, y, z - 1).isAir() || + world.getBlockState(x, y, z + 1).isAir() || + world.getBlockState(x, y - 1, z).isAir() || + world.getBlockState(x, y + 1, z).isAir() || + world.getBlockState(x - 1, y, z).isAir() || + world.getBlockState(x + 1, y, z).isAir()); + } + } + +} + From c98d39c5d7ce4dc7aa9e496fa3e50d8120439e57 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Thu, 2 Nov 2023 18:42:51 -0600 Subject: [PATCH 56/83] Update licence year --- LICENSE | 2 +- common/addons/api-addon-loader/LICENSE | 2 +- .../java/com/dfsek/terra/addon/loader/ApiAddonClassLoader.java | 2 +- .../main/java/com/dfsek/terra/addon/loader/ApiAddonLoader.java | 2 +- common/addons/biome-provider-image-v2/LICENSE | 2 +- .../dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java | 2 +- .../terra/addons/biome/image/v2/ImageBiomeProviderAddon.java | 2 +- .../addons/biome/image/v2/config/ImageProviderTemplate.java | 2 +- common/addons/biome-provider-image/LICENSE | 2 +- .../com/dfsek/terra/addons/biome/image/ImageBiomeProvider.java | 2 +- .../dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java | 2 +- .../dfsek/terra/addons/biome/image/ImageProviderTemplate.java | 2 +- common/addons/biome-provider-pipeline-v2/LICENSE | 2 +- .../terra/addons/biome/pipeline/v2/BiomePipelineAddon.java | 2 +- .../addons/biome/pipeline/v2/config/BiomePipelineTemplate.java | 2 +- .../biome/pipeline/v2/config/source/SamplerSourceTemplate.java | 2 +- .../addons/biome/pipeline/v2/config/source/SourceTemplate.java | 2 +- .../addons/biome/pipeline/v2/config/stage/StageTemplate.java | 2 +- .../v2/config/stage/expander/ExpanderStageTemplate.java | 2 +- .../v2/config/stage/mutator/BorderListStageTemplate.java | 2 +- .../pipeline/v2/config/stage/mutator/BorderStageTemplate.java | 2 +- .../v2/config/stage/mutator/ReplaceListStageTemplate.java | 2 +- .../pipeline/v2/config/stage/mutator/ReplaceStageTemplate.java | 2 +- .../pipeline/v2/config/stage/mutator/SmoothStageTemplate.java | 2 +- .../biome/pipeline/v2/stage/mutators/BorderListStage.java | 2 +- .../addons/biome/pipeline/v2/stage/mutators/BorderStage.java | 2 +- .../biome/pipeline/v2/stage/mutators/ReplaceListStage.java | 2 +- .../addons/biome/pipeline/v2/stage/mutators/ReplaceStage.java | 2 +- .../addons/biome/pipeline/v2/stage/mutators/SmoothStage.java | 2 +- common/addons/biome-provider-pipeline/LICENSE | 2 +- .../com/dfsek/terra/addons/biome/pipeline/BiomeHolderImpl.java | 2 +- .../com/dfsek/terra/addons/biome/pipeline/BiomePipeline.java | 2 +- .../dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java | 2 +- .../terra/addons/biome/pipeline/BiomePipelineProvider.java | 2 +- .../com/dfsek/terra/addons/biome/pipeline/api/BiomeHolder.java | 2 +- .../com/dfsek/terra/addons/biome/pipeline/api/stage/Stage.java | 2 +- .../addons/biome/pipeline/api/stage/type/BiomeExpander.java | 2 +- .../addons/biome/pipeline/api/stage/type/BiomeMutator.java | 2 +- .../addons/biome/pipeline/config/BiomePipelineTemplate.java | 2 +- .../addons/biome/pipeline/config/BiomeProviderTemplate.java | 2 +- .../addons/biome/pipeline/config/SamplerSourceTemplate.java | 2 +- .../terra/addons/biome/pipeline/config/SourceTemplate.java | 2 +- .../terra/addons/biome/pipeline/config/stage/StageTemplate.java | 2 +- .../pipeline/config/stage/expander/ExpanderStageTemplate.java | 2 +- .../config/stage/mutator/BorderListMutatorTemplate.java | 2 +- .../pipeline/config/stage/mutator/BorderMutatorTemplate.java | 2 +- .../config/stage/mutator/ReplaceListMutatorTemplate.java | 2 +- .../pipeline/config/stage/mutator/ReplaceMutatorTemplate.java | 2 +- .../pipeline/config/stage/mutator/SmoothMutatorTemplate.java | 2 +- .../terra/addons/biome/pipeline/expand/FractalExpander.java | 2 +- .../terra/addons/biome/pipeline/mutator/BorderListMutator.java | 2 +- .../terra/addons/biome/pipeline/mutator/BorderMutator.java | 2 +- .../terra/addons/biome/pipeline/mutator/ReplaceListMutator.java | 2 +- .../terra/addons/biome/pipeline/mutator/ReplaceMutator.java | 2 +- .../terra/addons/biome/pipeline/mutator/SmoothMutator.java | 2 +- .../dfsek/terra/addons/biome/pipeline/source/BiomeSource.java | 2 +- .../dfsek/terra/addons/biome/pipeline/source/SamplerSource.java | 2 +- .../dfsek/terra/addons/biome/pipeline/stages/ExpanderStage.java | 2 +- .../dfsek/terra/addons/biome/pipeline/stages/MutatorStage.java | 2 +- common/addons/biome-provider-single/LICENSE | 2 +- .../dfsek/terra/addons/biome/single/SingleBiomeProvider.java | 2 +- .../terra/addons/biome/single/SingleBiomeProviderAddon.java | 2 +- .../terra/addons/biome/single/SingleBiomeProviderTemplate.java | 2 +- common/addons/chunk-generator-noise-3d/LICENSE | 2 +- .../terra/addons/chunkgenerator/NoiseChunkGenerator3DAddon.java | 2 +- .../chunkgenerator/config/palette/BiomePaletteTemplate.java | 2 +- .../addons/chunkgenerator/generation/NoiseChunkGenerator3D.java | 2 +- .../addons/chunkgenerator/generation/math/PaletteUtil.java | 2 +- .../generation/math/interpolation/ChunkInterpolator.java | 2 +- .../generation/math/interpolation/ElevationInterpolator.java | 2 +- .../generation/math/interpolation/Interpolator.java | 2 +- .../generation/math/interpolation/Interpolator3.java | 2 +- .../chunkgenerator/generation/math/samplers/Sampler3D.java | 2 +- .../terra/addons/chunkgenerator/palette/BiomePaletteInfo.java | 2 +- .../terra/addons/chunkgenerator/palette/PaletteHolder.java | 2 +- .../chunkgenerator/palette/slant/MultipleSlantHolder.java | 2 +- common/addons/config-biome/LICENSE | 2 +- .../src/main/java/com/dfsek/terra/addons/biome/BiomeAddon.java | 2 +- .../main/java/com/dfsek/terra/addons/biome/BiomeConfigType.java | 2 +- .../main/java/com/dfsek/terra/addons/biome/BiomeFactory.java | 2 +- .../main/java/com/dfsek/terra/addons/biome/BiomeTemplate.java | 2 +- .../java/com/dfsek/terra/addons/biome/PaletteSettingsImpl.java | 2 +- .../java/com/dfsek/terra/addons/biome/UserDefinedBiome.java | 2 +- .../java/com/dfsek/terra/addons/biome/holder/PaletteHolder.java | 2 +- .../dfsek/terra/addons/biome/holder/PaletteHolderBuilder.java | 2 +- common/addons/config-distributors/LICENSE | 2 +- .../terra/addons/feature/distributor/DistributorAddon.java | 2 +- .../feature/distributor/config/AndDistributorTemplate.java | 2 +- .../feature/distributor/config/NoDistributorTemplate.java | 2 +- .../feature/distributor/config/OrDistributorTemplate.java | 2 +- .../feature/distributor/config/PointSetDistributorTemplate.java | 2 +- .../feature/distributor/config/SamplerDistributorTemplate.java | 2 +- .../feature/distributor/config/XorDistributorTemplate.java | 2 +- .../feature/distributor/config/YesDistributorTemplate.java | 2 +- .../feature/distributor/distributors/PointSetDistributor.java | 2 +- .../feature/distributor/distributors/SamplerDistributor.java | 2 +- .../com/dfsek/terra/addons/feature/distributor/util/Point.java | 2 +- .../terra/addons/feature/distributor/util/PointTemplate.java | 2 +- common/addons/config-feature/LICENSE | 2 +- .../java/com/dfsek/terra/addons/feature/ConfiguredFeature.java | 2 +- .../main/java/com/dfsek/terra/addons/feature/FeatureAddon.java | 2 +- .../java/com/dfsek/terra/addons/feature/FeatureConfigType.java | 2 +- .../java/com/dfsek/terra/addons/feature/FeatureFactory.java | 2 +- .../java/com/dfsek/terra/addons/feature/FeatureTemplate.java | 2 +- common/addons/config-flora/LICENSE | 2 +- .../src/main/java/com/dfsek/terra/addons/flora/FloraAddon.java | 2 +- .../main/java/com/dfsek/terra/addons/flora/FloraConfigType.java | 2 +- .../main/java/com/dfsek/terra/addons/flora/FloraFactory.java | 2 +- .../main/java/com/dfsek/terra/addons/flora/FloraTemplate.java | 2 +- .../com/dfsek/terra/addons/flora/config/BlockLayerTemplate.java | 2 +- .../java/com/dfsek/terra/addons/flora/flora/gen/BlockLayer.java | 2 +- .../java/com/dfsek/terra/addons/flora/flora/gen/TerraFlora.java | 2 +- common/addons/config-locators/LICENSE | 2 +- .../com/dfsek/terra/addons/feature/locator/LocatorAddon.java | 2 +- .../feature/locator/config/AdjacentPatternLocatorTemplate.java | 2 +- .../terra/addons/feature/locator/config/AndLocatorTemplate.java | 2 +- .../feature/locator/config/GaussianRandomLocatorTemplate.java | 2 +- .../terra/addons/feature/locator/config/OrLocatorTemplate.java | 2 +- .../addons/feature/locator/config/PatternLocatorTemplate.java | 2 +- .../addons/feature/locator/config/RandomLocatorTemplate.java | 2 +- .../addons/feature/locator/config/Sampler3DLocatorTemplate.java | 2 +- .../addons/feature/locator/config/SamplerLocatorTemplate.java | 2 +- .../addons/feature/locator/config/SurfaceLocatorTemplate.java | 2 +- .../terra/addons/feature/locator/config/TopLocatorTemplate.java | 2 +- .../terra/addons/feature/locator/config/XorLocatorTemplate.java | 2 +- .../feature/locator/config/pattern/AirMatchPatternTemplate.java | 2 +- .../feature/locator/config/pattern/AndPatternTemplate.java | 2 +- .../locator/config/pattern/BlockSetMatchPatternTemplate.java | 2 +- .../feature/locator/config/pattern/NotPatternTemplate.java | 2 +- .../feature/locator/config/pattern/OrPatternTemplate.java | 2 +- .../locator/config/pattern/SingleBlockMatchPatternTemplate.java | 2 +- .../locator/config/pattern/SolidMatchPatternTemplate.java | 2 +- .../feature/locator/config/pattern/XorPatternTemplate.java | 2 +- .../addons/feature/locator/locators/AdjacentPatternLocator.java | 2 +- .../addons/feature/locator/locators/GaussianRandomLocator.java | 2 +- .../terra/addons/feature/locator/locators/PatternLocator.java | 2 +- .../terra/addons/feature/locator/locators/RandomLocator.java | 2 +- .../terra/addons/feature/locator/locators/Sampler3DLocator.java | 2 +- .../terra/addons/feature/locator/locators/SamplerLocator.java | 2 +- .../terra/addons/feature/locator/locators/SurfaceLocator.java | 2 +- .../dfsek/terra/addons/feature/locator/locators/TopLocator.java | 2 +- .../terra/addons/feature/locator/patterns/MatchPattern.java | 2 +- .../dfsek/terra/addons/feature/locator/patterns/Pattern.java | 2 +- common/addons/config-noise-function/LICENSE | 2 +- .../src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java | 2 +- .../com/dfsek/terra/addons/noise/NoiseConfigPackTemplate.java | 2 +- .../addons/noise/config/DimensionApplicableNoiseSampler.java | 2 +- .../terra/addons/noise/config/templates/DomainWarpTemplate.java | 2 +- .../terra/addons/noise/config/templates/FunctionTemplate.java | 2 +- .../addons/noise/config/templates/ImageSamplerTemplate.java | 2 +- .../terra/addons/noise/config/templates/KernelTemplate.java | 2 +- .../terra/addons/noise/config/templates/SamplerTemplate.java | 2 +- .../noise/config/templates/noise/CellularNoiseTemplate.java | 2 +- .../noise/config/templates/noise/ConstantNoiseTemplate.java | 2 +- .../config/templates/noise/ExpressionFunctionTemplate.java | 2 +- .../addons/noise/config/templates/noise/GaborNoiseTemplate.java | 2 +- .../addons/noise/config/templates/noise/NoiseTemplate.java | 2 +- .../noise/config/templates/noise/SimpleNoiseTemplate.java | 2 +- .../config/templates/noise/fractal/BrownianMotionTemplate.java | 2 +- .../noise/config/templates/noise/fractal/FractalTemplate.java | 2 +- .../noise/config/templates/noise/fractal/PingPongTemplate.java | 2 +- .../config/templates/noise/fractal/RidgedFractalTemplate.java | 2 +- .../config/templates/normalizer/ClampNormalizerTemplate.java | 2 +- .../templates/normalizer/ExpressionNormalizerTemplate.java | 2 +- .../config/templates/normalizer/LinearNormalizerTemplate.java | 2 +- .../config/templates/normalizer/NormalNormalizerTemplate.java | 2 +- .../noise/config/templates/normalizer/NormalizerTemplate.java | 2 +- .../dfsek/terra/addons/noise/normalizer/ClampNormalizer.java | 2 +- .../dfsek/terra/addons/noise/normalizer/LinearNormalizer.java | 2 +- .../dfsek/terra/addons/noise/normalizer/NormalNormalizer.java | 2 +- .../com/dfsek/terra/addons/noise/normalizer/Normalizer.java | 2 +- .../addons/noise/paralithic/defined/UserDefinedFunction.java | 2 +- .../terra/addons/noise/paralithic/noise/NoiseFunction2.java | 2 +- .../terra/addons/noise/paralithic/noise/NoiseFunction3.java | 2 +- .../dfsek/terra/addons/noise/paralithic/noise/SeedContext.java | 2 +- .../dfsek/terra/addons/noise/samplers/DomainWarpedSampler.java | 2 +- .../com/dfsek/terra/addons/noise/samplers/ImageSampler.java | 2 +- .../com/dfsek/terra/addons/noise/samplers/KernelSampler.java | 2 +- .../terra/addons/noise/samplers/noise/CellularSampler.java | 2 +- .../terra/addons/noise/samplers/noise/ConstantSampler.java | 2 +- .../terra/addons/noise/samplers/noise/ExpressionFunction.java | 2 +- .../terra/addons/noise/samplers/noise/GaborNoiseSampler.java | 2 +- .../dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java | 2 +- .../noise/samplers/noise/fractal/BrownianMotionSampler.java | 2 +- .../noise/samplers/noise/fractal/FractalNoiseFunction.java | 2 +- .../addons/noise/samplers/noise/fractal/PingPongSampler.java | 2 +- .../noise/samplers/noise/fractal/RidgedFractalSampler.java | 2 +- .../noise/samplers/noise/random/GaussianNoiseSampler.java | 2 +- .../noise/samplers/noise/random/PositiveWhiteNoiseSampler.java | 2 +- .../addons/noise/samplers/noise/random/WhiteNoiseSampler.java | 2 +- .../noise/samplers/noise/simplex/OpenSimplex2SSampler.java | 2 +- .../noise/samplers/noise/simplex/OpenSimplex2Sampler.java | 2 +- .../addons/noise/samplers/noise/simplex/PerlinSampler.java | 2 +- .../addons/noise/samplers/noise/simplex/SimplexSampler.java | 2 +- .../noise/samplers/noise/simplex/SimplexStyleSampler.java | 2 +- .../addons/noise/samplers/noise/value/ValueCubicSampler.java | 2 +- .../terra/addons/noise/samplers/noise/value/ValueSampler.java | 2 +- .../addons/noise/samplers/noise/value/ValueStyleNoise.java | 2 +- .../terra/addons/numberpredicate/NumberPredicateAddon.java | 2 +- common/addons/config-ore/LICENSE | 2 +- .../src/main/java/com/dfsek/terra/addons/ore/OreAddon.java | 2 +- .../src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java | 2 +- .../src/main/java/com/dfsek/terra/addons/ore/OreFactory.java | 2 +- .../src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java | 2 +- .../java/com/dfsek/terra/addons/ore/ScatteredOreConfigType.java | 2 +- .../java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java | 2 +- .../java/com/dfsek/terra/addons/ore/ScatteredOreTemplate.java | 2 +- .../main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java | 2 +- common/addons/config-palette/LICENSE | 2 +- .../main/java/com/dfsek/terra/addons/palette/PaletteAddon.java | 2 +- .../java/com/dfsek/terra/addons/palette/PaletteConfigType.java | 2 +- .../java/com/dfsek/terra/addons/palette/PaletteFactory.java | 2 +- .../java/com/dfsek/terra/addons/palette/PaletteTemplate.java | 2 +- .../com/dfsek/terra/addons/palette/palette/PaletteImpl.java | 2 +- .../dfsek/terra/addons/palette/palette/PaletteLayerHolder.java | 2 +- .../dfsek/terra/addons/palette/palette/PaletteLayerLoader.java | 2 +- common/addons/config-structure/LICENSE | 2 +- .../java/com/dfsek/terra/addons/structure/BiomeStructures.java | 2 +- .../dfsek/terra/addons/structure/BiomeStructuresTemplate.java | 2 +- .../java/com/dfsek/terra/addons/structure/StructureAddon.java | 2 +- .../com/dfsek/terra/addons/structure/StructureConfigType.java | 2 +- .../java/com/dfsek/terra/addons/structure/StructureFactory.java | 2 +- .../com/dfsek/terra/addons/structure/StructureTemplate.java | 2 +- .../java/com/dfsek/terra/addons/structure/TerraStructure.java | 2 +- .../com/dfsek/terra/addons/structure/structures/loot/Entry.java | 2 +- .../terra/addons/structure/structures/loot/LootTableImpl.java | 2 +- .../com/dfsek/terra/addons/structure/structures/loot/Pool.java | 2 +- .../structure/structures/loot/functions/AmountFunction.java | 2 +- .../structure/structures/loot/functions/DamageFunction.java | 2 +- .../structure/structures/loot/functions/EnchantFunction.java | 2 +- .../structure/structures/loot/functions/LootFunction.java | 2 +- common/addons/generation-stage-feature/LICENSE | 2 +- .../terra/addons/generation/feature/FeatureGenerationAddon.java | 2 +- .../terra/addons/generation/feature/FeatureGenerationStage.java | 2 +- .../terra/addons/generation/feature/config/BiomeFeatures.java | 2 +- common/addons/generation-stage-structure/LICENSE | 2 +- common/addons/language-yaml/LICENSE | 2 +- .../src/main/java/com/dfsek/terra/addons/yaml/YamlAddon.java | 2 +- common/addons/manifest-addon-loader/LICENSE | 2 +- .../com/dfsek/terra/addons/manifest/api/AddonInitializer.java | 2 +- .../com/dfsek/terra/addons/manifest/impl/ManifestAddon.java | 2 +- .../terra/addons/manifest/impl/ManifestAddonClassLoader.java | 2 +- .../dfsek/terra/addons/manifest/impl/ManifestAddonLoader.java | 2 +- .../dfsek/terra/addons/manifest/impl/config/AddonManifest.java | 2 +- .../dfsek/terra/addons/manifest/impl/config/WebsiteConfig.java | 2 +- .../addons/manifest/impl/config/loaders/VersionLoader.java | 2 +- .../addons/manifest/impl/config/loaders/VersionRangeLoader.java | 2 +- .../terra/addons/manifest/impl/exception/AddonException.java | 2 +- .../terra/addons/manifest/impl/exception/ManifestException.java | 2 +- .../manifest/impl/exception/ManifestNotPresentException.java | 2 +- common/addons/palette-block-shortcut/LICENSE | 2 +- common/addons/structure-block-shortcut/LICENSE | 2 +- common/addons/structure-sponge-loader/LICENSE | 2 +- .../com/dfsek/terra/addons/sponge/SpongeSchematicAddon.java | 2 +- .../java/com/dfsek/terra/addons/sponge/SpongeStructure.java | 2 +- common/addons/structure-terrascript-loader/LICENSE | 2 +- .../com/dfsek/terra/addons/terrascript/TerraScriptAddon.java | 2 +- .../java/com/dfsek/terra/addons/terrascript/parser/Parser.java | 2 +- .../com/dfsek/terra/addons/terrascript/parser/ParserUtil.java | 2 +- .../addons/terrascript/parser/exceptions/ParseException.java | 2 +- .../com/dfsek/terra/addons/terrascript/parser/lang/Block.java | 2 +- .../addons/terrascript/parser/lang/ImplementationArguments.java | 2 +- .../com/dfsek/terra/addons/terrascript/parser/lang/Item.java | 2 +- .../com/dfsek/terra/addons/terrascript/parser/lang/Keyword.java | 2 +- .../dfsek/terra/addons/terrascript/parser/lang/Returnable.java | 2 +- .../dfsek/terra/addons/terrascript/parser/lang/Statement.java | 2 +- .../terrascript/parser/lang/constants/BooleanConstant.java | 2 +- .../terrascript/parser/lang/constants/ConstantExpression.java | 2 +- .../terrascript/parser/lang/constants/NumericConstant.java | 2 +- .../terrascript/parser/lang/constants/StringConstant.java | 2 +- .../addons/terrascript/parser/lang/functions/Function.java | 2 +- .../terrascript/parser/lang/functions/FunctionBuilder.java | 2 +- .../terrascript/parser/lang/keywords/flow/BreakKeyword.java | 2 +- .../terrascript/parser/lang/keywords/flow/ContinueKeyword.java | 2 +- .../terrascript/parser/lang/keywords/flow/FailKeyword.java | 2 +- .../terrascript/parser/lang/keywords/flow/ReturnKeyword.java | 2 +- .../terrascript/parser/lang/keywords/looplike/ForKeyword.java | 2 +- .../terrascript/parser/lang/keywords/looplike/IfKeyword.java | 2 +- .../terrascript/parser/lang/keywords/looplike/WhileKeyword.java | 2 +- .../terrascript/parser/lang/operations/BinaryOperation.java | 2 +- .../terrascript/parser/lang/operations/BooleanAndOperation.java | 2 +- .../terrascript/parser/lang/operations/BooleanNotOperation.java | 2 +- .../terrascript/parser/lang/operations/BooleanOrOperation.java | 2 +- .../parser/lang/operations/ConcatenationOperation.java | 2 +- .../terrascript/parser/lang/operations/DivisionOperation.java | 2 +- .../terrascript/parser/lang/operations/ModuloOperation.java | 2 +- .../parser/lang/operations/MultiplicationOperation.java | 2 +- .../terrascript/parser/lang/operations/NegationOperation.java | 2 +- .../parser/lang/operations/NumberAdditionOperation.java | 2 +- .../parser/lang/operations/SubtractionOperation.java | 2 +- .../terrascript/parser/lang/operations/UnaryOperation.java | 2 +- .../parser/lang/operations/statements/EqualsStatement.java | 2 +- .../operations/statements/GreaterOrEqualsThanStatement.java | 2 +- .../parser/lang/operations/statements/GreaterThanStatement.java | 2 +- .../lang/operations/statements/LessThanOrEqualsStatement.java | 2 +- .../parser/lang/operations/statements/LessThanStatement.java | 2 +- .../parser/lang/operations/statements/NotEqualsStatement.java | 2 +- .../terrascript/parser/lang/variables/BooleanVariable.java | 2 +- .../terrascript/parser/lang/variables/NumberVariable.java | 2 +- .../terrascript/parser/lang/variables/StringVariable.java | 2 +- .../addons/terrascript/parser/lang/variables/Variable.java | 2 +- .../parser/lang/variables/assign/VariableAssignmentNode.java | 2 +- .../parser/lang/variables/reference/VariableReferenceNode.java | 2 +- .../dfsek/terra/addons/terrascript/script/StructureScript.java | 2 +- .../addons/terrascript/script/TerraImplementationArguments.java | 2 +- .../script/builders/BinaryNumberFunctionBuilder.java | 2 +- .../terrascript/script/builders/BiomeFunctionBuilder.java | 2 +- .../terrascript/script/builders/BlockFunctionBuilder.java | 2 +- .../terrascript/script/builders/CheckBlockFunctionBuilder.java | 2 +- .../terrascript/script/builders/EntityFunctionBuilder.java | 2 +- .../terrascript/script/builders/GetMarkFunctionBuilder.java | 2 +- .../addons/terrascript/script/builders/LootFunctionBuilder.java | 2 +- .../addons/terrascript/script/builders/PullFunctionBuilder.java | 2 +- .../terrascript/script/builders/RandomFunctionBuilder.java | 2 +- .../terrascript/script/builders/RecursionsFunctionBuilder.java | 2 +- .../terrascript/script/builders/SetMarkFunctionBuilder.java | 2 +- .../terrascript/script/builders/StateFunctionBuilder.java | 2 +- .../terrascript/script/builders/StructureFunctionBuilder.java | 2 +- .../script/builders/UnaryBooleanFunctionBuilder.java | 2 +- .../terrascript/script/builders/UnaryNumberFunctionBuilder.java | 2 +- .../terrascript/script/builders/UnaryStringFunctionBuilder.java | 2 +- .../terrascript/script/builders/ZeroArgFunctionBuilder.java | 2 +- .../addons/terrascript/script/functions/BiomeFunction.java | 2 +- .../addons/terrascript/script/functions/BlockFunction.java | 2 +- .../addons/terrascript/script/functions/CheckBlockFunction.java | 2 +- .../addons/terrascript/script/functions/EntityFunction.java | 2 +- .../addons/terrascript/script/functions/GetMarkFunction.java | 2 +- .../terra/addons/terrascript/script/functions/LootFunction.java | 2 +- .../terra/addons/terrascript/script/functions/PullFunction.java | 2 +- .../addons/terrascript/script/functions/RandomFunction.java | 2 +- .../addons/terrascript/script/functions/RecursionsFunction.java | 2 +- .../addons/terrascript/script/functions/SetMarkFunction.java | 2 +- .../addons/terrascript/script/functions/StateFunction.java | 2 +- .../addons/terrascript/script/functions/StructureFunction.java | 2 +- .../java/com/dfsek/terra/addons/terrascript/tokenizer/Char.java | 2 +- .../com/dfsek/terra/addons/terrascript/tokenizer/Lookahead.java | 2 +- .../com/dfsek/terra/addons/terrascript/tokenizer/Position.java | 2 +- .../com/dfsek/terra/addons/terrascript/tokenizer/Token.java | 2 +- .../com/dfsek/terra/addons/terrascript/tokenizer/Tokenizer.java | 2 +- .../addons/terrascript/tokenizer/exceptions/EOFException.java | 2 +- .../terrascript/tokenizer/exceptions/FormatException.java | 2 +- .../terrascript/tokenizer/exceptions/TokenizerException.java | 2 +- .../src/test/java/structure/LookaheadTest.java | 2 +- .../src/test/java/structure/ParserTest.java | 2 +- .../com/dfsek/terra/addon/terrascript/check/CheckFunction.java | 2 +- .../terra/addon/terrascript/check/CheckFunctionBuilder.java | 2 +- common/api/src/main/java/com/dfsek/terra/api/Handle.java | 2 +- common/api/src/main/java/com/dfsek/terra/api/Platform.java | 2 +- .../api/src/main/java/com/dfsek/terra/api/addon/BaseAddon.java | 2 +- .../com/dfsek/terra/api/addon/bootstrap/BootstrapBaseAddon.java | 2 +- .../api/src/main/java/com/dfsek/terra/api/block/BlockType.java | 2 +- .../main/java/com/dfsek/terra/api/block/entity/BlockEntity.java | 2 +- .../main/java/com/dfsek/terra/api/block/entity/Container.java | 2 +- .../main/java/com/dfsek/terra/api/block/entity/MobSpawner.java | 2 +- .../main/java/com/dfsek/terra/api/block/entity/SerialState.java | 2 +- .../src/main/java/com/dfsek/terra/api/block/entity/Sign.java | 2 +- .../main/java/com/dfsek/terra/api/block/state/BlockState.java | 2 +- .../com/dfsek/terra/api/block/state/properties/Property.java | 2 +- .../terra/api/block/state/properties/base/BooleanProperty.java | 2 +- .../terra/api/block/state/properties/base/EnumProperty.java | 2 +- .../terra/api/block/state/properties/base/IntProperty.java | 2 +- .../com/dfsek/terra/api/block/state/properties/enums/Axis.java | 2 +- .../dfsek/terra/api/block/state/properties/enums/Direction.java | 2 +- .../com/dfsek/terra/api/block/state/properties/enums/Half.java | 2 +- .../dfsek/terra/api/block/state/properties/enums/RailShape.java | 2 +- .../api/block/state/properties/enums/RedstoneConnection.java | 2 +- .../terra/api/block/state/properties/enums/WallHeight.java | 2 +- .../main/java/com/dfsek/terra/api/command/CommandSender.java | 2 +- .../java/com/dfsek/terra/api/config/AbstractableTemplate.java | 2 +- .../src/main/java/com/dfsek/terra/api/config/ConfigFactory.java | 2 +- .../src/main/java/com/dfsek/terra/api/config/ConfigPack.java | 2 +- .../src/main/java/com/dfsek/terra/api/config/ConfigType.java | 2 +- common/api/src/main/java/com/dfsek/terra/api/config/Loader.java | 2 +- .../src/main/java/com/dfsek/terra/api/config/PluginConfig.java | 2 +- .../api/src/main/java/com/dfsek/terra/api/config/meta/Meta.java | 2 +- common/api/src/main/java/com/dfsek/terra/api/entity/Entity.java | 2 +- .../src/main/java/com/dfsek/terra/api/entity/EntityType.java | 2 +- common/api/src/main/java/com/dfsek/terra/api/entity/Player.java | 2 +- .../src/main/java/com/dfsek/terra/api/event/EventHandler.java | 2 +- .../src/main/java/com/dfsek/terra/api/event/EventManager.java | 2 +- .../com/dfsek/terra/api/event/events/AbstractCancellable.java | 2 +- .../main/java/com/dfsek/terra/api/event/events/Cancellable.java | 2 +- .../src/main/java/com/dfsek/terra/api/event/events/Event.java | 2 +- .../java/com/dfsek/terra/api/event/events/FailThroughEvent.java | 2 +- .../main/java/com/dfsek/terra/api/event/events/PackEvent.java | 2 +- .../terra/api/event/events/config/ConfigurationLoadEvent.java | 2 +- .../terra/api/event/events/config/pack/ConfigPackLoadEvent.java | 2 +- .../api/event/events/config/pack/ConfigPackPostLoadEvent.java | 2 +- .../api/event/events/config/pack/ConfigPackPreLoadEvent.java | 2 +- .../terra/api/event/events/config/type/ConfigTypeLoadEvent.java | 2 +- .../api/event/events/config/type/ConfigTypePostLoadEvent.java | 2 +- .../api/event/events/config/type/ConfigTypePreLoadEvent.java | 2 +- .../api/event/events/platform/PlatformInitializationEvent.java | 2 +- .../api/event/events/world/generation/EntitySpawnEvent.java | 2 +- .../api/event/events/world/generation/LootPopulateEvent.java | 2 +- .../java/com/dfsek/terra/api/event/functional/EventContext.java | 2 +- .../terra/api/event/functional/FunctionalEventHandler.java | 2 +- .../src/main/java/com/dfsek/terra/api/handle/ItemHandle.java | 2 +- .../src/main/java/com/dfsek/terra/api/handle/WorldHandle.java | 2 +- .../api/src/main/java/com/dfsek/terra/api/inject/Injector.java | 2 +- .../java/com/dfsek/terra/api/inject/annotations/Inject.java | 2 +- .../dfsek/terra/api/inject/exception/InjectionException.java | 2 +- .../main/java/com/dfsek/terra/api/inject/impl/InjectorImpl.java | 2 +- .../com/dfsek/terra/api/inventory/BlockInventoryHolder.java | 2 +- .../src/main/java/com/dfsek/terra/api/inventory/Inventory.java | 2 +- .../java/com/dfsek/terra/api/inventory/InventoryHolder.java | 2 +- .../api/src/main/java/com/dfsek/terra/api/inventory/Item.java | 2 +- .../src/main/java/com/dfsek/terra/api/inventory/ItemStack.java | 2 +- .../java/com/dfsek/terra/api/inventory/item/Damageable.java | 2 +- .../java/com/dfsek/terra/api/inventory/item/Enchantment.java | 2 +- .../main/java/com/dfsek/terra/api/inventory/item/ItemMeta.java | 2 +- .../src/main/java/com/dfsek/terra/api/noise/NoiseSampler.java | 2 +- .../src/main/java/com/dfsek/terra/api/profiler/Profiler.java | 2 +- .../api/src/main/java/com/dfsek/terra/api/profiler/Timings.java | 2 +- .../src/main/java/com/dfsek/terra/api/properties/Context.java | 2 +- .../main/java/com/dfsek/terra/api/properties/Properties.java | 2 +- .../java/com/dfsek/terra/api/properties/PropertyHolder.java | 2 +- .../java/com/dfsek/terra/api/properties/annotations/Linked.java | 2 +- .../main/java/com/dfsek/terra/api/registry/CheckedRegistry.java | 2 +- .../main/java/com/dfsek/terra/api/registry/OpenRegistry.java | 2 +- .../src/main/java/com/dfsek/terra/api/registry/Registry.java | 2 +- .../terra/api/registry/exception/DuplicateEntryException.java | 2 +- .../com/dfsek/terra/api/registry/key/StringIdentifiable.java | 2 +- .../java/com/dfsek/terra/api/registry/meta/RegistryHolder.java | 2 +- .../src/main/java/com/dfsek/terra/api/structure/LootTable.java | 2 +- .../src/main/java/com/dfsek/terra/api/structure/Structure.java | 2 +- .../main/java/com/dfsek/terra/api/structure/StructureSpawn.java | 2 +- .../terra/api/structure/configured/ConfiguredStructure.java | 2 +- .../com/dfsek/terra/api/structure/feature/BinaryColumn.java | 2 +- .../java/com/dfsek/terra/api/structure/feature/Distributor.java | 2 +- .../java/com/dfsek/terra/api/structure/feature/Feature.java | 2 +- .../java/com/dfsek/terra/api/structure/feature/Locator.java | 2 +- .../com/dfsek/terra/api/tectonic/ConfigLoadingDelegate.java | 2 +- .../main/java/com/dfsek/terra/api/tectonic/LoaderRegistrar.java | 2 +- .../src/main/java/com/dfsek/terra/api/transform/Transform.java | 2 +- .../main/java/com/dfsek/terra/api/transform/Transformer.java | 2 +- .../src/main/java/com/dfsek/terra/api/transform/Validator.java | 2 +- .../terra/api/transform/exception/AttemptsFailedException.java | 2 +- .../dfsek/terra/api/transform/exception/TransformException.java | 2 +- .../src/main/java/com/dfsek/terra/api/util/ConstantRange.java | 2 +- common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java | 2 +- .../src/main/java/com/dfsek/terra/api/util/PopulationUtil.java | 2 +- common/api/src/main/java/com/dfsek/terra/api/util/Range.java | 2 +- common/api/src/main/java/com/dfsek/terra/api/util/Rotation.java | 2 +- .../src/main/java/com/dfsek/terra/api/util/RotationUtil.java | 2 +- .../api/src/main/java/com/dfsek/terra/api/util/StringUtil.java | 2 +- .../java/com/dfsek/terra/api/util/collection/MaterialSet.java | 2 +- .../dfsek/terra/api/util/collection/ProbabilityCollection.java | 2 +- .../main/java/com/dfsek/terra/api/util/generic/Construct.java | 2 +- .../src/main/java/com/dfsek/terra/api/util/generic/Lazy.java | 2 +- .../java/com/dfsek/terra/api/util/generic/either/Either.java | 2 +- .../main/java/com/dfsek/terra/api/util/generic/pair/Pair.java | 2 +- .../java/com/dfsek/terra/api/util/mutable/MutableBoolean.java | 2 +- .../java/com/dfsek/terra/api/util/mutable/MutableDouble.java | 2 +- .../java/com/dfsek/terra/api/util/mutable/MutableInteger.java | 2 +- .../java/com/dfsek/terra/api/util/mutable/MutableNumber.java | 2 +- .../java/com/dfsek/terra/api/util/mutable/MutablePrimitive.java | 2 +- .../java/com/dfsek/terra/api/util/mutable/package-info.java | 2 +- .../com/dfsek/terra/api/util/reflection/ReflectionUtil.java | 2 +- .../main/java/com/dfsek/terra/api/util/reflection/TypeKey.java | 2 +- .../src/main/java/com/dfsek/terra/api/util/vector/Vector2.java | 2 +- .../src/main/java/com/dfsek/terra/api/util/vector/Vector3.java | 2 +- .../src/main/java/com/dfsek/terra/api/world/ServerWorld.java | 2 +- .../src/main/java/com/dfsek/terra/api/world/biome/Biome.java | 2 +- .../java/com/dfsek/terra/api/world/biome/PaletteSettings.java | 2 +- .../java/com/dfsek/terra/api/world/biome/PlatformBiome.java | 2 +- .../dfsek/terra/api/world/biome/generation/BiomeProvider.java | 2 +- .../src/main/java/com/dfsek/terra/api/world/chunk/Chunk.java | 2 +- .../main/java/com/dfsek/terra/api/world/chunk/ChunkAccess.java | 2 +- .../dfsek/terra/api/world/chunk/generation/ChunkGenerator.java | 2 +- .../com/dfsek/terra/api/world/chunk/generation/ProtoChunk.java | 2 +- .../terra/api/world/chunk/generation/stage/Chunkified.java | 2 +- .../terra/api/world/chunk/generation/stage/GenerationStage.java | 2 +- .../com/dfsek/terra/api/world/chunk/generation/util/Column.java | 2 +- .../terra/api/world/chunk/generation/util/GeneratorWrapper.java | 2 +- .../dfsek/terra/api/world/chunk/generation/util/Palette.java | 2 +- .../chunk/generation/util/provider/ChunkGeneratorProvider.java | 2 +- .../chunk/generation/util/provider/GenerationStageProvider.java | 2 +- 478 files changed, 478 insertions(+), 478 deletions(-) diff --git a/LICENSE b/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/api-addon-loader/LICENSE b/common/addons/api-addon-loader/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/api-addon-loader/LICENSE +++ b/common/addons/api-addon-loader/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonClassLoader.java b/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonClassLoader.java index 2bcfb9236..b6fc722fe 100644 --- a/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonClassLoader.java +++ b/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonClassLoader.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonLoader.java b/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonLoader.java index b8350c778..9af4d9ab8 100644 --- a/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonLoader.java +++ b/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonLoader.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-image-v2/LICENSE b/common/addons/biome-provider-image-v2/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/biome-provider-image-v2/LICENSE +++ b/common/addons/biome-provider-image-v2/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java index 8b5ec2e5b..6635f5902 100644 --- a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java +++ b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProviderAddon.java b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProviderAddon.java index c719f86be..ba4bce73c 100644 --- a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProviderAddon.java +++ b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProviderAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/ImageProviderTemplate.java b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/ImageProviderTemplate.java index 80f7f87e1..54d9f0327 100644 --- a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/ImageProviderTemplate.java +++ b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/ImageProviderTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-image/LICENSE b/common/addons/biome-provider-image/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/biome-provider-image/LICENSE +++ b/common/addons/biome-provider-image/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProvider.java b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProvider.java index 3af73c043..2dfe4cba0 100644 --- a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProvider.java +++ b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProvider.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java index 142b7e034..27ac28df4 100644 --- a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java +++ b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageProviderTemplate.java b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageProviderTemplate.java index 6bb683eca..8b0681a1d 100644 --- a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageProviderTemplate.java +++ b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageProviderTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/LICENSE b/common/addons/biome-provider-pipeline-v2/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/biome-provider-pipeline-v2/LICENSE +++ b/common/addons/biome-provider-pipeline-v2/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineAddon.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineAddon.java index 3add75092..0ea11be4a 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineAddon.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java index 007add35d..f9ea854a5 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/source/SamplerSourceTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/source/SamplerSourceTemplate.java index dbfb1ef31..97069ebec 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/source/SamplerSourceTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/source/SamplerSourceTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/source/SourceTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/source/SourceTemplate.java index ba61f8940..2c87fc98f 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/source/SourceTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/source/SourceTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/StageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/StageTemplate.java index c1cea771e..d3bbe528c 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/StageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/StageTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/expander/ExpanderStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/expander/ExpanderStageTemplate.java index 4478c987e..7c1b58ad4 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/expander/ExpanderStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/expander/ExpanderStageTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderListStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderListStageTemplate.java index 0d0aa4c2d..117934d65 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderListStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderListStageTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderStageTemplate.java index e2ffa7872..60d91af3c 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderStageTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceListStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceListStageTemplate.java index 179707d21..4583a267b 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceListStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceListStageTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceStageTemplate.java index 397b2c78b..30429317e 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceStageTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/SmoothStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/SmoothStageTemplate.java index c7a5b4feb..8f897c0ab 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/SmoothStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/SmoothStageTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderListStage.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderListStage.java index 2587bc792..340ff155a 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderListStage.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderListStage.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderStage.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderStage.java index 274ef1ff9..1ee2c0416 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderStage.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderStage.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceListStage.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceListStage.java index 372127546..bc3a6db1a 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceListStage.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceListStage.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceStage.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceStage.java index b7a2fd684..8ddab6fc4 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceStage.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceStage.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/SmoothStage.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/SmoothStage.java index 92bbee433..20b664539 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/SmoothStage.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/SmoothStage.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/LICENSE b/common/addons/biome-provider-pipeline/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/biome-provider-pipeline/LICENSE +++ b/common/addons/biome-provider-pipeline/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomeHolderImpl.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomeHolderImpl.java index 57304011b..cd38f61a4 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomeHolderImpl.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomeHolderImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipeline.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipeline.java index 8a4be5d7d..311fd8f46 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipeline.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipeline.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java index 0200f17ad..a4016a51a 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java index 9222f2128..d4dd96264 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/BiomeHolder.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/BiomeHolder.java index 26bb63315..a5a51a6c5 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/BiomeHolder.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/BiomeHolder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/Stage.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/Stage.java index fb4b1007b..f82fb8438 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/Stage.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/Stage.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/type/BiomeExpander.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/type/BiomeExpander.java index c3e721c08..4fcb9feeb 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/type/BiomeExpander.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/type/BiomeExpander.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/type/BiomeMutator.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/type/BiomeMutator.java index f7cc3b7bd..cc5453efa 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/type/BiomeMutator.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/type/BiomeMutator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomePipelineTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomePipelineTemplate.java index e35d621e2..d1a6774eb 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomePipelineTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomePipelineTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomeProviderTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomeProviderTemplate.java index 1412485fe..f42fd7c20 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomeProviderTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomeProviderTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/SamplerSourceTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/SamplerSourceTemplate.java index 2ba70b608..469a94c92 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/SamplerSourceTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/SamplerSourceTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/SourceTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/SourceTemplate.java index c80ec0cee..6f04cfd47 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/SourceTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/SourceTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/StageTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/StageTemplate.java index ba4bee85d..ec326ed0c 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/StageTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/StageTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/expander/ExpanderStageTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/expander/ExpanderStageTemplate.java index 8f66315ef..9c13e1fd2 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/expander/ExpanderStageTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/expander/ExpanderStageTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderListMutatorTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderListMutatorTemplate.java index fcf523e44..8dc5542a6 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderListMutatorTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderListMutatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderMutatorTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderMutatorTemplate.java index 4db9e4e99..4382334be 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderMutatorTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderMutatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceListMutatorTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceListMutatorTemplate.java index 5713b3ff0..6e1233856 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceListMutatorTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceListMutatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceMutatorTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceMutatorTemplate.java index dae592e2b..83610a08f 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceMutatorTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceMutatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/SmoothMutatorTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/SmoothMutatorTemplate.java index b26dce902..8959a229a 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/SmoothMutatorTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/SmoothMutatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/expand/FractalExpander.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/expand/FractalExpander.java index 50d36a5c4..ce63329ef 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/expand/FractalExpander.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/expand/FractalExpander.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderListMutator.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderListMutator.java index 59f6dd9b4..249b3fe62 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderListMutator.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderListMutator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderMutator.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderMutator.java index 5755719f4..fef5b3d03 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderMutator.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderMutator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceListMutator.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceListMutator.java index 51a74c285..e6dff1b50 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceListMutator.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceListMutator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceMutator.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceMutator.java index cec3e5e9e..979679826 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceMutator.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceMutator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/SmoothMutator.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/SmoothMutator.java index 4785216e8..97395266b 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/SmoothMutator.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/SmoothMutator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/BiomeSource.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/BiomeSource.java index d56151f07..96cb20ef7 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/BiomeSource.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/BiomeSource.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/SamplerSource.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/SamplerSource.java index 62656ac17..2dff2c198 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/SamplerSource.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/SamplerSource.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/ExpanderStage.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/ExpanderStage.java index e99c13e6b..c0219faa4 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/ExpanderStage.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/ExpanderStage.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/MutatorStage.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/MutatorStage.java index 8a9a06aae..86d679a78 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/MutatorStage.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/MutatorStage.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-single/LICENSE b/common/addons/biome-provider-single/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/biome-provider-single/LICENSE +++ b/common/addons/biome-provider-single/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProvider.java b/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProvider.java index 11524b9de..89e88c3fd 100644 --- a/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProvider.java +++ b/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProvider.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderAddon.java b/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderAddon.java index ecf4a9c7b..2362cc028 100644 --- a/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderAddon.java +++ b/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderTemplate.java b/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderTemplate.java index 707553ccd..f0f329275 100644 --- a/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderTemplate.java +++ b/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/chunk-generator-noise-3d/LICENSE b/common/addons/chunk-generator-noise-3d/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/chunk-generator-noise-3d/LICENSE +++ b/common/addons/chunk-generator-noise-3d/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/NoiseChunkGenerator3DAddon.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/NoiseChunkGenerator3DAddon.java index ce1ec9650..fed22e1c9 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/NoiseChunkGenerator3DAddon.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/NoiseChunkGenerator3DAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java index 533f06928..0bb19e962 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java index 106aef8fa..6de99aeff 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/PaletteUtil.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/PaletteUtil.java index ca6798c73..b2afe23e7 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/PaletteUtil.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/PaletteUtil.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java index dc4d6dcc7..d846ac53f 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ElevationInterpolator.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ElevationInterpolator.java index d4664673b..1328bc2de 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ElevationInterpolator.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ElevationInterpolator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator.java index e96e15879..7fd8bb54b 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator3.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator3.java index 804770b42..3650ca592 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator3.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator3.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/Sampler3D.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/Sampler3D.java index a4d6545d6..9ed0c322e 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/Sampler3D.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/Sampler3D.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/BiomePaletteInfo.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/BiomePaletteInfo.java index a75eeef5f..56555afef 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/BiomePaletteInfo.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/BiomePaletteInfo.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java index 3a3c2089b..327d6fe47 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/MultipleSlantHolder.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/MultipleSlantHolder.java index 928edb2c2..6f04a2df7 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/MultipleSlantHolder.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/MultipleSlantHolder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-biome/LICENSE b/common/addons/config-biome/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/config-biome/LICENSE +++ b/common/addons/config-biome/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeAddon.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeAddon.java index e850400e8..f09a4726d 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeAddon.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeConfigType.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeConfigType.java index ccf3c09a6..a0eb0c922 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeConfigType.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeConfigType.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeFactory.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeFactory.java index 0f84c609c..0ab3612c6 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeFactory.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeFactory.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeTemplate.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeTemplate.java index 656a3949a..f970caca9 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeTemplate.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/PaletteSettingsImpl.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/PaletteSettingsImpl.java index 82cd6e902..f0ff9ba20 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/PaletteSettingsImpl.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/PaletteSettingsImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/UserDefinedBiome.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/UserDefinedBiome.java index cf0d09ac4..ab82f0ef4 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/UserDefinedBiome.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/UserDefinedBiome.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolder.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolder.java index 416263f8d..31515ad5f 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolder.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolderBuilder.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolderBuilder.java index c2a082038..fe2dd0c3f 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolderBuilder.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolderBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-distributors/LICENSE b/common/addons/config-distributors/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/config-distributors/LICENSE +++ b/common/addons/config-distributors/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/DistributorAddon.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/DistributorAddon.java index 2227a499d..714f44f1a 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/DistributorAddon.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/DistributorAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/AndDistributorTemplate.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/AndDistributorTemplate.java index 960feb0dd..0d07682b3 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/AndDistributorTemplate.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/AndDistributorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/NoDistributorTemplate.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/NoDistributorTemplate.java index bf2ba424f..eecc77b77 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/NoDistributorTemplate.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/NoDistributorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/OrDistributorTemplate.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/OrDistributorTemplate.java index e7a754085..f332bb64e 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/OrDistributorTemplate.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/OrDistributorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/PointSetDistributorTemplate.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/PointSetDistributorTemplate.java index a36f09dac..befa639d6 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/PointSetDistributorTemplate.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/PointSetDistributorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/SamplerDistributorTemplate.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/SamplerDistributorTemplate.java index 53bc81751..c670ead7c 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/SamplerDistributorTemplate.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/SamplerDistributorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/XorDistributorTemplate.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/XorDistributorTemplate.java index 663d1ce7e..8272ec949 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/XorDistributorTemplate.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/XorDistributorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/YesDistributorTemplate.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/YesDistributorTemplate.java index 16cf8b23e..a4bae8e4f 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/YesDistributorTemplate.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/YesDistributorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PointSetDistributor.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PointSetDistributor.java index 19af51ec2..037906f4a 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PointSetDistributor.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PointSetDistributor.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/SamplerDistributor.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/SamplerDistributor.java index ebe0dfdc4..e1d64d0cc 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/SamplerDistributor.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/SamplerDistributor.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/Point.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/Point.java index ec06b2071..6cd6c82bc 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/Point.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/Point.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/PointTemplate.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/PointTemplate.java index 2f74a4048..9455a261b 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/PointTemplate.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/PointTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-feature/LICENSE b/common/addons/config-feature/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/config-feature/LICENSE +++ b/common/addons/config-feature/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/ConfiguredFeature.java b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/ConfiguredFeature.java index 5ce901736..6f7280d82 100644 --- a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/ConfiguredFeature.java +++ b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/ConfiguredFeature.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureAddon.java b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureAddon.java index 07d8ba9d9..ed06a7a7f 100644 --- a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureAddon.java +++ b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureConfigType.java b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureConfigType.java index 8c241d97d..caf0f6b63 100644 --- a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureConfigType.java +++ b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureConfigType.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureFactory.java b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureFactory.java index 81c03ade5..981dee045 100644 --- a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureFactory.java +++ b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureFactory.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureTemplate.java b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureTemplate.java index 06ba2dd6f..3e98c4525 100644 --- a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureTemplate.java +++ b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-flora/LICENSE b/common/addons/config-flora/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/config-flora/LICENSE +++ b/common/addons/config-flora/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraAddon.java b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraAddon.java index 68b43b364..b3e4a4c35 100644 --- a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraAddon.java +++ b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraConfigType.java b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraConfigType.java index 1a2b3085a..259f5aa49 100644 --- a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraConfigType.java +++ b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraConfigType.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraFactory.java b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraFactory.java index 96bd55087..72c695829 100644 --- a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraFactory.java +++ b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraFactory.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraTemplate.java b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraTemplate.java index 2fe1b02d1..52a5e06ee 100644 --- a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraTemplate.java +++ b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/config/BlockLayerTemplate.java b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/config/BlockLayerTemplate.java index 5c5cde303..dec0b5087 100644 --- a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/config/BlockLayerTemplate.java +++ b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/config/BlockLayerTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/BlockLayer.java b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/BlockLayer.java index d2694adcc..8af76ec70 100644 --- a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/BlockLayer.java +++ b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/BlockLayer.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/TerraFlora.java b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/TerraFlora.java index b9c345677..5707d392f 100644 --- a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/TerraFlora.java +++ b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/TerraFlora.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/LICENSE b/common/addons/config-locators/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/config-locators/LICENSE +++ b/common/addons/config-locators/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/LocatorAddon.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/LocatorAddon.java index a0166076e..4157d4027 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/LocatorAddon.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/LocatorAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AdjacentPatternLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AdjacentPatternLocatorTemplate.java index 3db17212b..8eddcf37b 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AdjacentPatternLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AdjacentPatternLocatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AndLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AndLocatorTemplate.java index 4463c6973..cb7a4d7e8 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AndLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AndLocatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/GaussianRandomLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/GaussianRandomLocatorTemplate.java index 80af89793..29f5cbc2d 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/GaussianRandomLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/GaussianRandomLocatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/OrLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/OrLocatorTemplate.java index 3c56dfe24..fbea60548 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/OrLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/OrLocatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/PatternLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/PatternLocatorTemplate.java index 34d0a1e62..d46798288 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/PatternLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/PatternLocatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/RandomLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/RandomLocatorTemplate.java index 9bdb3f6db..026729bc9 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/RandomLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/RandomLocatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/Sampler3DLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/Sampler3DLocatorTemplate.java index 9a57fd14c..1ea0277cc 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/Sampler3DLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/Sampler3DLocatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SamplerLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SamplerLocatorTemplate.java index 6f27af76e..6e1a16cb8 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SamplerLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SamplerLocatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SurfaceLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SurfaceLocatorTemplate.java index 991bdb050..ec1c936aa 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SurfaceLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SurfaceLocatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/TopLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/TopLocatorTemplate.java index 9b2e82f06..2cc582143 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/TopLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/TopLocatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/XorLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/XorLocatorTemplate.java index d8c400660..51b4e930e 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/XorLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/XorLocatorTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AirMatchPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AirMatchPatternTemplate.java index 8099fba9d..763cb5d01 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AirMatchPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AirMatchPatternTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AndPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AndPatternTemplate.java index 84e443466..34de500ce 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AndPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AndPatternTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/BlockSetMatchPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/BlockSetMatchPatternTemplate.java index c08391727..216701a40 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/BlockSetMatchPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/BlockSetMatchPatternTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/NotPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/NotPatternTemplate.java index c4d66a2d9..17a413aac 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/NotPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/NotPatternTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/OrPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/OrPatternTemplate.java index 9c3d1d1fd..429bec379 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/OrPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/OrPatternTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SingleBlockMatchPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SingleBlockMatchPatternTemplate.java index f3f5ddaeb..a89a54a99 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SingleBlockMatchPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SingleBlockMatchPatternTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SolidMatchPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SolidMatchPatternTemplate.java index fa56d6c3e..ba6395ad2 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SolidMatchPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SolidMatchPatternTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/XorPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/XorPatternTemplate.java index 16479a279..e15c97a75 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/XorPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/XorPatternTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/AdjacentPatternLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/AdjacentPatternLocator.java index 439c85ad1..ab11dd727 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/AdjacentPatternLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/AdjacentPatternLocator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/GaussianRandomLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/GaussianRandomLocator.java index 16fb827e5..06d3987f1 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/GaussianRandomLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/GaussianRandomLocator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/PatternLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/PatternLocator.java index 0d748aea3..c43eb86ad 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/PatternLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/PatternLocator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/RandomLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/RandomLocator.java index fc86878ff..fc82ef7ef 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/RandomLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/RandomLocator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/Sampler3DLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/Sampler3DLocator.java index f4691cd36..eddbf9839 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/Sampler3DLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/Sampler3DLocator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SamplerLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SamplerLocator.java index e5c43a122..800ea3d36 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SamplerLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SamplerLocator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SurfaceLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SurfaceLocator.java index 03cccd404..3fac2e7d1 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SurfaceLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SurfaceLocator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/TopLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/TopLocator.java index 7706f1ee1..9dbac41ca 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/TopLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/TopLocator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/MatchPattern.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/MatchPattern.java index 2f83ab30f..0832fee15 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/MatchPattern.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/MatchPattern.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/Pattern.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/Pattern.java index 4c2d0de67..04a95e929 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/Pattern.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/Pattern.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/LICENSE b/common/addons/config-noise-function/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/config-noise-function/LICENSE +++ b/common/addons/config-noise-function/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java index 7783ca5b7..ec5b4a675 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseConfigPackTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseConfigPackTemplate.java index 155f4c45c..18c7240bb 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseConfigPackTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseConfigPackTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/DimensionApplicableNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/DimensionApplicableNoiseSampler.java index 9c54e81e7..392994120 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/DimensionApplicableNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/DimensionApplicableNoiseSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/DomainWarpTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/DomainWarpTemplate.java index 375059cba..442a54a64 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/DomainWarpTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/DomainWarpTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/FunctionTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/FunctionTemplate.java index a7a18efdd..e83dfb9aa 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/FunctionTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/FunctionTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/ImageSamplerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/ImageSamplerTemplate.java index bbccae810..8d37ad27b 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/ImageSamplerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/ImageSamplerTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/KernelTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/KernelTemplate.java index 2d5f8e4fe..baae3f0cb 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/KernelTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/KernelTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/SamplerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/SamplerTemplate.java index 4253d9df1..ac4421687 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/SamplerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/SamplerTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/CellularNoiseTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/CellularNoiseTemplate.java index 48468b995..2d282e289 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/CellularNoiseTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/CellularNoiseTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ConstantNoiseTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ConstantNoiseTemplate.java index bff00602a..16272bd45 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ConstantNoiseTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ConstantNoiseTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java index e401aa0cf..d062cbaae 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/GaborNoiseTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/GaborNoiseTemplate.java index 681fb3bfb..0d27ec7f6 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/GaborNoiseTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/GaborNoiseTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/NoiseTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/NoiseTemplate.java index c5ca4a058..c039c597f 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/NoiseTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/NoiseTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/SimpleNoiseTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/SimpleNoiseTemplate.java index 241997fd7..6f098eb89 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/SimpleNoiseTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/SimpleNoiseTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/BrownianMotionTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/BrownianMotionTemplate.java index a35e2e6b5..d4fae6e9c 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/BrownianMotionTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/BrownianMotionTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/FractalTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/FractalTemplate.java index f0534c098..af7e7d18f 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/FractalTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/FractalTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/PingPongTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/PingPongTemplate.java index 319cc9d54..f37fa3297 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/PingPongTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/PingPongTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/RidgedFractalTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/RidgedFractalTemplate.java index ccf0eaa67..7d3cd340f 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/RidgedFractalTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/RidgedFractalTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ClampNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ClampNormalizerTemplate.java index cc4603f73..87f1511f4 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ClampNormalizerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ClampNormalizerTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java index 217147efc..e0b40b69f 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/LinearNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/LinearNormalizerTemplate.java index b6d22d280..61bb3f073 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/LinearNormalizerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/LinearNormalizerTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/NormalNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/NormalNormalizerTemplate.java index b60f3d9e4..e1278d90e 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/NormalNormalizerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/NormalNormalizerTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/NormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/NormalizerTemplate.java index 608377de0..9dbbb5e51 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/NormalizerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/NormalizerTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ClampNormalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ClampNormalizer.java index 531a11749..f195bfddb 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ClampNormalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ClampNormalizer.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/LinearNormalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/LinearNormalizer.java index aaa598948..a13d3dab6 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/LinearNormalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/LinearNormalizer.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/NormalNormalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/NormalNormalizer.java index 165157119..3e2ee7ceb 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/NormalNormalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/NormalNormalizer.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/Normalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/Normalizer.java index 526afe137..2489cb84b 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/Normalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/Normalizer.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/defined/UserDefinedFunction.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/defined/UserDefinedFunction.java index a087012ca..4d5bf9544 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/defined/UserDefinedFunction.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/defined/UserDefinedFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction2.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction2.java index ccd2b419f..466845cf6 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction2.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction2.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction3.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction3.java index f56015f90..04a93b8b5 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction3.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction3.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/SeedContext.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/SeedContext.java index d5fc7128d..31fd42ca5 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/SeedContext.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/SeedContext.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/DomainWarpedSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/DomainWarpedSampler.java index 2ead08442..b23adce4c 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/DomainWarpedSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/DomainWarpedSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/ImageSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/ImageSampler.java index bd60744ad..8d9195b5e 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/ImageSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/ImageSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/KernelSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/KernelSampler.java index 05997df7f..b2a2b76fe 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/KernelSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/KernelSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java index 89efaf376..1fe86f21a 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ConstantSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ConstantSampler.java index 9aa9c85d1..93d5633e6 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ConstantSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ConstantSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ExpressionFunction.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ExpressionFunction.java index c2d93ed2f..eed78c01e 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ExpressionFunction.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ExpressionFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java index 458d5fbfe..c9a729a39 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java index 545b59385..890714272 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/BrownianMotionSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/BrownianMotionSampler.java index a51c574c3..3cc8f6c94 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/BrownianMotionSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/BrownianMotionSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/FractalNoiseFunction.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/FractalNoiseFunction.java index e52e6eff4..4db8df0cd 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/FractalNoiseFunction.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/FractalNoiseFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/PingPongSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/PingPongSampler.java index e8fd2a114..dd73222e3 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/PingPongSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/PingPongSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/RidgedFractalSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/RidgedFractalSampler.java index 19800bed8..3990ac4cd 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/RidgedFractalSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/RidgedFractalSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/GaussianNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/GaussianNoiseSampler.java index 11047a8fc..95b700b95 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/GaussianNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/GaussianNoiseSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/PositiveWhiteNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/PositiveWhiteNoiseSampler.java index d4b4ddd94..0cbbba151 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/PositiveWhiteNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/PositiveWhiteNoiseSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/WhiteNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/WhiteNoiseSampler.java index 4c98e04e1..b63665520 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/WhiteNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/WhiteNoiseSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2SSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2SSampler.java index be20803a8..41502af11 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2SSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2SSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2Sampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2Sampler.java index 5c5256478..56eb4eb32 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2Sampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2Sampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/PerlinSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/PerlinSampler.java index 7b8866c44..bc7e53962 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/PerlinSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/PerlinSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexSampler.java index 5066f1488..76861b2f4 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexStyleSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexStyleSampler.java index 9d6a3e083..b6c9b5e3e 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexStyleSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexStyleSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java index ab4074a5c..0c2e8b335 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueSampler.java index c4912d90f..128f4e35a 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueStyleNoise.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueStyleNoise.java index 24ac89c8b..2cadfe0d1 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueStyleNoise.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueStyleNoise.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java b/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java index e81da028d..95e1ac8bd 100644 --- a/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java +++ b/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-ore/LICENSE b/common/addons/config-ore/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/config-ore/LICENSE +++ b/common/addons/config-ore/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java index 2765391b4..e315e3307 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java index 2bdc87bdd..af4a7b709 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java index 9d8b1055a..cab726f01 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java index 8bfbc82d3..3456e711b 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreConfigType.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreConfigType.java index e777c09b9..71b3ef759 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreConfigType.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreConfigType.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java index 171c85127..4fbfdfa54 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreTemplate.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreTemplate.java index 9c98552a5..ecb81a0b9 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreTemplate.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java index 05a9e4a92..f2485c2c0 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-palette/LICENSE b/common/addons/config-palette/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/config-palette/LICENSE +++ b/common/addons/config-palette/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteAddon.java b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteAddon.java index 78744e42d..7c10c8999 100644 --- a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteAddon.java +++ b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteConfigType.java b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteConfigType.java index 9df70cb97..9ac076127 100644 --- a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteConfigType.java +++ b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteConfigType.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteFactory.java b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteFactory.java index efcfbd425..74ee564dd 100644 --- a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteFactory.java +++ b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteFactory.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteTemplate.java b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteTemplate.java index 7147284d1..c7cd3b6ee 100644 --- a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteTemplate.java +++ b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteImpl.java b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteImpl.java index ede31d7ea..642f78142 100644 --- a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteImpl.java +++ b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerHolder.java b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerHolder.java index 30ffb5e81..2bf6d5fa1 100644 --- a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerHolder.java +++ b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerHolder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerLoader.java b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerLoader.java index 0e12682ab..ef4689dff 100644 --- a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerLoader.java +++ b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerLoader.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-structure/LICENSE b/common/addons/config-structure/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/config-structure/LICENSE +++ b/common/addons/config-structure/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructures.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructures.java index 16a0e84b6..3fb9a175b 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructures.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructures.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructuresTemplate.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructuresTemplate.java index 02a656695..d7d34e93a 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructuresTemplate.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructuresTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureAddon.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureAddon.java index d578b7721..6ba93bb38 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureAddon.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureConfigType.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureConfigType.java index a6a4c5f7d..f4c124753 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureConfigType.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureConfigType.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureFactory.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureFactory.java index 8b0a8f05e..eac1bc6ce 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureFactory.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureFactory.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureTemplate.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureTemplate.java index 48dd223df..9868a39f2 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureTemplate.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/TerraStructure.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/TerraStructure.java index cef38f2b9..9293a72b5 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/TerraStructure.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/TerraStructure.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Entry.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Entry.java index 01344af73..20046dfde 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Entry.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Entry.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/LootTableImpl.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/LootTableImpl.java index c817c2d2d..e9bba93e6 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/LootTableImpl.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/LootTableImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Pool.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Pool.java index 64200dd05..a59b29957 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Pool.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Pool.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/AmountFunction.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/AmountFunction.java index 8fd59a5ee..85a95a750 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/AmountFunction.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/AmountFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/DamageFunction.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/DamageFunction.java index 09eda7417..7eb0cb028 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/DamageFunction.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/DamageFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/EnchantFunction.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/EnchantFunction.java index 2e3f4b515..4d11a49e1 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/EnchantFunction.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/EnchantFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/LootFunction.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/LootFunction.java index ebe0fd550..a881ca634 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/LootFunction.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/LootFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/generation-stage-feature/LICENSE b/common/addons/generation-stage-feature/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/generation-stage-feature/LICENSE +++ b/common/addons/generation-stage-feature/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationAddon.java b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationAddon.java index ac0475d7e..f58dfd692 100644 --- a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationAddon.java +++ b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationStage.java b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationStage.java index 5408b26e4..c0b3d715a 100644 --- a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationStage.java +++ b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationStage.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/config/BiomeFeatures.java b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/config/BiomeFeatures.java index 473b7f782..0d4d333ed 100644 --- a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/config/BiomeFeatures.java +++ b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/config/BiomeFeatures.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/generation-stage-structure/LICENSE b/common/addons/generation-stage-structure/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/generation-stage-structure/LICENSE +++ b/common/addons/generation-stage-structure/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/language-yaml/LICENSE b/common/addons/language-yaml/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/language-yaml/LICENSE +++ b/common/addons/language-yaml/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/language-yaml/src/main/java/com/dfsek/terra/addons/yaml/YamlAddon.java b/common/addons/language-yaml/src/main/java/com/dfsek/terra/addons/yaml/YamlAddon.java index dc5772dc3..44565157b 100644 --- a/common/addons/language-yaml/src/main/java/com/dfsek/terra/addons/yaml/YamlAddon.java +++ b/common/addons/language-yaml/src/main/java/com/dfsek/terra/addons/yaml/YamlAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/manifest-addon-loader/LICENSE b/common/addons/manifest-addon-loader/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/manifest-addon-loader/LICENSE +++ b/common/addons/manifest-addon-loader/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/api/AddonInitializer.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/api/AddonInitializer.java index e9b596996..8f195d62c 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/api/AddonInitializer.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/api/AddonInitializer.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddon.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddon.java index a0c23f284..9175027ec 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddon.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonClassLoader.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonClassLoader.java index 6a2923a3b..a0095f374 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonClassLoader.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonClassLoader.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonLoader.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonLoader.java index 00a54a226..50d571f9f 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonLoader.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonLoader.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/AddonManifest.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/AddonManifest.java index 0e225b712..4739bb145 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/AddonManifest.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/AddonManifest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/WebsiteConfig.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/WebsiteConfig.java index 669fc7c18..500d753dc 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/WebsiteConfig.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/WebsiteConfig.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/loaders/VersionLoader.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/loaders/VersionLoader.java index 23e6bc1ce..263c691d3 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/loaders/VersionLoader.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/loaders/VersionLoader.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/loaders/VersionRangeLoader.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/loaders/VersionRangeLoader.java index 5adaf3663..1f7d4d983 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/loaders/VersionRangeLoader.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/loaders/VersionRangeLoader.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/AddonException.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/AddonException.java index 9fa06a2e4..ff9b5187f 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/AddonException.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/AddonException.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestException.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestException.java index d076c8875..d0215fc82 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestException.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestException.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestNotPresentException.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestNotPresentException.java index 010dcb86a..3a197467c 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestNotPresentException.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestNotPresentException.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/palette-block-shortcut/LICENSE b/common/addons/palette-block-shortcut/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/palette-block-shortcut/LICENSE +++ b/common/addons/palette-block-shortcut/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/structure-block-shortcut/LICENSE b/common/addons/structure-block-shortcut/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/structure-block-shortcut/LICENSE +++ b/common/addons/structure-block-shortcut/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/structure-sponge-loader/LICENSE b/common/addons/structure-sponge-loader/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/structure-sponge-loader/LICENSE +++ b/common/addons/structure-sponge-loader/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeSchematicAddon.java b/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeSchematicAddon.java index bd46330ac..ce5a02453 100644 --- a/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeSchematicAddon.java +++ b/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeSchematicAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeStructure.java b/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeStructure.java index 49bde23fb..f5f9770c9 100644 --- a/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeStructure.java +++ b/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeStructure.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/LICENSE b/common/addons/structure-terrascript-loader/LICENSE index 64c1cd516..22b8e06e5 100644 --- a/common/addons/structure-terrascript-loader/LICENSE +++ b/common/addons/structure-terrascript-loader/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2020-2021 Polyhedral Development +Copyright (c) 2020-2023 Polyhedral Development Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/TerraScriptAddon.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/TerraScriptAddon.java index f2e1d0055..f283c40a1 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/TerraScriptAddon.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/TerraScriptAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/Parser.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/Parser.java index 2b344343a..7c4a47639 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/Parser.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/Parser.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/ParserUtil.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/ParserUtil.java index 6a7f0c7bf..1475b2da2 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/ParserUtil.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/ParserUtil.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/exceptions/ParseException.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/exceptions/ParseException.java index 59fdb01ae..d72c58aac 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/exceptions/ParseException.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/exceptions/ParseException.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Block.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Block.java index 65a8dbf7e..d67e6a437 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Block.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Block.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/ImplementationArguments.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/ImplementationArguments.java index a0f78aefb..18c82e574 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/ImplementationArguments.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/ImplementationArguments.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Item.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Item.java index 27947c291..6c85741ad 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Item.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Item.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Keyword.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Keyword.java index 56bb8bfd8..e2be6b0aa 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Keyword.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Keyword.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Returnable.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Returnable.java index ac6578f4c..fd0012754 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Returnable.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Returnable.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Statement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Statement.java index 14300e5fa..8651cff52 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Statement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Statement.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/BooleanConstant.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/BooleanConstant.java index 3782344d1..c51bf5870 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/BooleanConstant.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/BooleanConstant.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/ConstantExpression.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/ConstantExpression.java index dc783a628..a87900658 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/ConstantExpression.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/ConstantExpression.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/NumericConstant.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/NumericConstant.java index 296b0c3e4..721ecd560 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/NumericConstant.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/NumericConstant.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/StringConstant.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/StringConstant.java index 3e44bea10..d0df4dc0b 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/StringConstant.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/StringConstant.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/Function.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/Function.java index 9c1da1155..004c66f1b 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/Function.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/Function.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/FunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/FunctionBuilder.java index d43121c6f..808e81691 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/FunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/FunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/BreakKeyword.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/BreakKeyword.java index b70b656ee..3782ef4ee 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/BreakKeyword.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/BreakKeyword.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ContinueKeyword.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ContinueKeyword.java index f7b03d3b4..a6f19fec9 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ContinueKeyword.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ContinueKeyword.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/FailKeyword.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/FailKeyword.java index 4f6a82f50..c70b7038b 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/FailKeyword.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/FailKeyword.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ReturnKeyword.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ReturnKeyword.java index 997098af1..0e624d1b6 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ReturnKeyword.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ReturnKeyword.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/ForKeyword.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/ForKeyword.java index 49f874724..c96b2d6b8 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/ForKeyword.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/ForKeyword.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/IfKeyword.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/IfKeyword.java index f49cab112..f1687bfac 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/IfKeyword.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/IfKeyword.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/WhileKeyword.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/WhileKeyword.java index d5126e7db..5085a4683 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/WhileKeyword.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/WhileKeyword.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BinaryOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BinaryOperation.java index fdacebe4c..7b1f5c313 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BinaryOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BinaryOperation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanAndOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanAndOperation.java index 94a08bbe6..cf51cf84c 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanAndOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanAndOperation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanNotOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanNotOperation.java index a65e00184..890257146 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanNotOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanNotOperation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanOrOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanOrOperation.java index 4722e175c..85fecf29f 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanOrOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanOrOperation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ConcatenationOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ConcatenationOperation.java index 1ff9d11b1..d12835f6b 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ConcatenationOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ConcatenationOperation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/DivisionOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/DivisionOperation.java index 793012549..2cbd44691 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/DivisionOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/DivisionOperation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ModuloOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ModuloOperation.java index b305f4c90..71225b1e4 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ModuloOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ModuloOperation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/MultiplicationOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/MultiplicationOperation.java index 2a2cdbfe6..40480d113 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/MultiplicationOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/MultiplicationOperation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NegationOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NegationOperation.java index 32d8f39b6..e74959243 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NegationOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NegationOperation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NumberAdditionOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NumberAdditionOperation.java index 075a27619..fb4af8020 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NumberAdditionOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NumberAdditionOperation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/SubtractionOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/SubtractionOperation.java index 9a11c430f..f2905ae88 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/SubtractionOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/SubtractionOperation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/UnaryOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/UnaryOperation.java index d83ab0ad2..13ec08b8b 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/UnaryOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/UnaryOperation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java index 1e96a9b0f..61d96d36a 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterOrEqualsThanStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterOrEqualsThanStatement.java index d25f6bd0d..693f1fdde 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterOrEqualsThanStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterOrEqualsThanStatement.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterThanStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterThanStatement.java index 8e5cc4aee..82c317c19 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterThanStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterThanStatement.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanOrEqualsStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanOrEqualsStatement.java index 891210395..ad03a9793 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanOrEqualsStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanOrEqualsStatement.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanStatement.java index 969f0e27e..39941c6c4 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanStatement.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/NotEqualsStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/NotEqualsStatement.java index 44eae0ef2..43373d7fe 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/NotEqualsStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/NotEqualsStatement.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/BooleanVariable.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/BooleanVariable.java index 205c99e6f..7131aa578 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/BooleanVariable.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/BooleanVariable.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/NumberVariable.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/NumberVariable.java index 698afdd4d..bab6fbae3 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/NumberVariable.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/NumberVariable.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/StringVariable.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/StringVariable.java index 3ed471cd6..a08fa40bd 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/StringVariable.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/StringVariable.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/Variable.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/Variable.java index 4bf0d6752..0deaad477 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/Variable.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/Variable.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/VariableAssignmentNode.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/VariableAssignmentNode.java index ebca757b5..9b652793f 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/VariableAssignmentNode.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/VariableAssignmentNode.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/VariableReferenceNode.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/VariableReferenceNode.java index ecfebedca..720b121e9 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/VariableReferenceNode.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/VariableReferenceNode.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java index 1a70cf4b8..032108784 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/TerraImplementationArguments.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/TerraImplementationArguments.java index b9b9af058..b807b07db 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/TerraImplementationArguments.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/TerraImplementationArguments.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BinaryNumberFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BinaryNumberFunctionBuilder.java index 0e55e4d3d..551b4ebe1 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BinaryNumberFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BinaryNumberFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BiomeFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BiomeFunctionBuilder.java index 98d5e951b..b68fb4c8b 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BiomeFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BiomeFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java index c2b6dc965..88183c088 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/CheckBlockFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/CheckBlockFunctionBuilder.java index 2e32cf363..da5f9a633 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/CheckBlockFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/CheckBlockFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/EntityFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/EntityFunctionBuilder.java index 305105180..9c980a84f 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/EntityFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/EntityFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/GetMarkFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/GetMarkFunctionBuilder.java index c38c406d4..9960d8a4e 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/GetMarkFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/GetMarkFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/LootFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/LootFunctionBuilder.java index 293b5278c..b1c5fb6ba 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/LootFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/LootFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/PullFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/PullFunctionBuilder.java index ff970735d..1d3e5e67b 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/PullFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/PullFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RandomFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RandomFunctionBuilder.java index 6cfeaa52d..0c3b47534 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RandomFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RandomFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RecursionsFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RecursionsFunctionBuilder.java index f4b34673e..9d228b37a 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RecursionsFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RecursionsFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/SetMarkFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/SetMarkFunctionBuilder.java index 52babac7f..bb1d35949 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/SetMarkFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/SetMarkFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StateFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StateFunctionBuilder.java index cecd17112..6158c0371 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StateFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StateFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StructureFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StructureFunctionBuilder.java index 69b05554d..2be864efe 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StructureFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StructureFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryBooleanFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryBooleanFunctionBuilder.java index 922f4842f..427a663fe 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryBooleanFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryBooleanFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryNumberFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryNumberFunctionBuilder.java index c20bf2479..28c0ad892 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryNumberFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryNumberFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryStringFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryStringFunctionBuilder.java index 8bc6d7fd1..9e8cf4926 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryStringFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryStringFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/ZeroArgFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/ZeroArgFunctionBuilder.java index da7806051..40a2f1b74 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/ZeroArgFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/ZeroArgFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BiomeFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BiomeFunction.java index 865cad586..d8329c5ff 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BiomeFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BiomeFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java index 85be45515..6fab3af63 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/CheckBlockFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/CheckBlockFunction.java index ef3518462..7c94d2a63 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/CheckBlockFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/CheckBlockFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/EntityFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/EntityFunction.java index 9fd51ceac..d2edbb5db 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/EntityFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/EntityFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/GetMarkFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/GetMarkFunction.java index d29b900bf..8f6a31868 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/GetMarkFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/GetMarkFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java index 17808f8a0..446466c8e 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/PullFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/PullFunction.java index 26511fd85..e80ac5df6 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/PullFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/PullFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RandomFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RandomFunction.java index 3170d2645..3a8fc113e 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RandomFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RandomFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RecursionsFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RecursionsFunction.java index 6343c1002..7dce74c61 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RecursionsFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RecursionsFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/SetMarkFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/SetMarkFunction.java index 1ab0782ee..78eb6ddc8 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/SetMarkFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/SetMarkFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java index 1d0e899bf..640d52ecc 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StructureFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StructureFunction.java index 1ec4886f5..6a96da6be 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StructureFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StructureFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Char.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Char.java index c9a361492..5e0868160 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Char.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Char.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Lookahead.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Lookahead.java index 4778b70af..d1fcd9010 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Lookahead.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Lookahead.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Position.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Position.java index 9e5c7c675..cb59f7dda 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Position.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Position.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Token.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Token.java index 6ab278807..2d636aed2 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Token.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Token.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Tokenizer.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Tokenizer.java index 16ede7b3a..4761f708b 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Tokenizer.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Tokenizer.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/EOFException.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/EOFException.java index bd9097946..89aff7c8f 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/EOFException.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/EOFException.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/FormatException.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/FormatException.java index 067b49b70..4b2cc4847 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/FormatException.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/FormatException.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/TokenizerException.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/TokenizerException.java index 079f17226..d7e8e2b3c 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/TokenizerException.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/TokenizerException.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/test/java/structure/LookaheadTest.java b/common/addons/structure-terrascript-loader/src/test/java/structure/LookaheadTest.java index e428f67cf..1a5fea53c 100644 --- a/common/addons/structure-terrascript-loader/src/test/java/structure/LookaheadTest.java +++ b/common/addons/structure-terrascript-loader/src/test/java/structure/LookaheadTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/structure-terrascript-loader/src/test/java/structure/ParserTest.java b/common/addons/structure-terrascript-loader/src/test/java/structure/ParserTest.java index fc0fcf532..ea50a897d 100644 --- a/common/addons/structure-terrascript-loader/src/test/java/structure/ParserTest.java +++ b/common/addons/structure-terrascript-loader/src/test/java/structure/ParserTest.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunction.java b/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunction.java index b1a5e6024..485bc4cf9 100644 --- a/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunction.java +++ b/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunctionBuilder.java b/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunctionBuilder.java index dc0a0b1da..6757596d6 100644 --- a/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunctionBuilder.java +++ b/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunctionBuilder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra Core Addons are licensed under the terms of the MIT License. For more details, * reference the LICENSE file in this module's root directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/Handle.java b/common/api/src/main/java/com/dfsek/terra/api/Handle.java index 293e53ce7..2bd59fbb1 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/Handle.java +++ b/common/api/src/main/java/com/dfsek/terra/api/Handle.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/Platform.java b/common/api/src/main/java/com/dfsek/terra/api/Platform.java index 080998b31..a6ed29a54 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/Platform.java +++ b/common/api/src/main/java/com/dfsek/terra/api/Platform.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/addon/BaseAddon.java b/common/api/src/main/java/com/dfsek/terra/api/addon/BaseAddon.java index 0672261ca..67b446c2e 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/addon/BaseAddon.java +++ b/common/api/src/main/java/com/dfsek/terra/api/addon/BaseAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/addon/bootstrap/BootstrapBaseAddon.java b/common/api/src/main/java/com/dfsek/terra/api/addon/bootstrap/BootstrapBaseAddon.java index f8f58c3f3..03aa177ae 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/addon/bootstrap/BootstrapBaseAddon.java +++ b/common/api/src/main/java/com/dfsek/terra/api/addon/bootstrap/BootstrapBaseAddon.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/BlockType.java b/common/api/src/main/java/com/dfsek/terra/api/block/BlockType.java index 78c20cd5e..2f71af6b9 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/BlockType.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/BlockType.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/entity/BlockEntity.java b/common/api/src/main/java/com/dfsek/terra/api/block/entity/BlockEntity.java index 313e0f888..12ee49056 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/entity/BlockEntity.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/entity/BlockEntity.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/entity/Container.java b/common/api/src/main/java/com/dfsek/terra/api/block/entity/Container.java index 3b2a8588a..5cbcba323 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/entity/Container.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/entity/Container.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/entity/MobSpawner.java b/common/api/src/main/java/com/dfsek/terra/api/block/entity/MobSpawner.java index b64e7ed5c..a06427c83 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/entity/MobSpawner.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/entity/MobSpawner.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/entity/SerialState.java b/common/api/src/main/java/com/dfsek/terra/api/block/entity/SerialState.java index 17af01361..4c654d482 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/entity/SerialState.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/entity/SerialState.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/entity/Sign.java b/common/api/src/main/java/com/dfsek/terra/api/block/entity/Sign.java index 4f48c2b99..230088e67 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/entity/Sign.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/entity/Sign.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/BlockState.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/BlockState.java index 039f078d0..9b7328683 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/BlockState.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/BlockState.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/Property.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/Property.java index 3bebb4771..d3456a771 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/Property.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/Property.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/BooleanProperty.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/BooleanProperty.java index e005145e0..f22df1f42 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/BooleanProperty.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/BooleanProperty.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/EnumProperty.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/EnumProperty.java index df0f3b52c..42bc7259d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/EnumProperty.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/EnumProperty.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/IntProperty.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/IntProperty.java index b671e4689..bc4cc7601 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/IntProperty.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/IntProperty.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Axis.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Axis.java index f57362ef1..cddd00f54 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Axis.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Axis.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Direction.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Direction.java index 5cdacf976..47ba1a47f 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Direction.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Direction.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Half.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Half.java index 160710629..7070f3d16 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Half.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Half.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/RailShape.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/RailShape.java index 6030b699c..ed3864c69 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/RailShape.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/RailShape.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/RedstoneConnection.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/RedstoneConnection.java index 12b5899c8..a3f674e17 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/RedstoneConnection.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/RedstoneConnection.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/WallHeight.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/WallHeight.java index e9940eace..956ea2082 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/WallHeight.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/WallHeight.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/command/CommandSender.java b/common/api/src/main/java/com/dfsek/terra/api/command/CommandSender.java index 8d0ff260a..81320a0b9 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/command/CommandSender.java +++ b/common/api/src/main/java/com/dfsek/terra/api/command/CommandSender.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/config/AbstractableTemplate.java b/common/api/src/main/java/com/dfsek/terra/api/config/AbstractableTemplate.java index 144183a6f..5910b1f25 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/config/AbstractableTemplate.java +++ b/common/api/src/main/java/com/dfsek/terra/api/config/AbstractableTemplate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/config/ConfigFactory.java b/common/api/src/main/java/com/dfsek/terra/api/config/ConfigFactory.java index abbffc7d9..a8c94eca8 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/config/ConfigFactory.java +++ b/common/api/src/main/java/com/dfsek/terra/api/config/ConfigFactory.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/config/ConfigPack.java b/common/api/src/main/java/com/dfsek/terra/api/config/ConfigPack.java index 860a742be..b70ce84b4 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/config/ConfigPack.java +++ b/common/api/src/main/java/com/dfsek/terra/api/config/ConfigPack.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/config/ConfigType.java b/common/api/src/main/java/com/dfsek/terra/api/config/ConfigType.java index 7c3e604c1..25bcacb98 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/config/ConfigType.java +++ b/common/api/src/main/java/com/dfsek/terra/api/config/ConfigType.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/config/Loader.java b/common/api/src/main/java/com/dfsek/terra/api/config/Loader.java index 1d540c3fc..196678e4f 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/config/Loader.java +++ b/common/api/src/main/java/com/dfsek/terra/api/config/Loader.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/config/PluginConfig.java b/common/api/src/main/java/com/dfsek/terra/api/config/PluginConfig.java index f70b61ff0..30c1c7e1f 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/config/PluginConfig.java +++ b/common/api/src/main/java/com/dfsek/terra/api/config/PluginConfig.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/config/meta/Meta.java b/common/api/src/main/java/com/dfsek/terra/api/config/meta/Meta.java index 874b9900a..4df20e7d8 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/config/meta/Meta.java +++ b/common/api/src/main/java/com/dfsek/terra/api/config/meta/Meta.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/entity/Entity.java b/common/api/src/main/java/com/dfsek/terra/api/entity/Entity.java index 0f11b746e..e2bf23009 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/entity/Entity.java +++ b/common/api/src/main/java/com/dfsek/terra/api/entity/Entity.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/entity/EntityType.java b/common/api/src/main/java/com/dfsek/terra/api/entity/EntityType.java index b873e69f4..c0bcfbedc 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/entity/EntityType.java +++ b/common/api/src/main/java/com/dfsek/terra/api/entity/EntityType.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/entity/Player.java b/common/api/src/main/java/com/dfsek/terra/api/entity/Player.java index 972d7e265..f71c38aa6 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/entity/Player.java +++ b/common/api/src/main/java/com/dfsek/terra/api/entity/Player.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/EventHandler.java b/common/api/src/main/java/com/dfsek/terra/api/event/EventHandler.java index 6c9c71fd6..011f27614 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/EventHandler.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/EventHandler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/EventManager.java b/common/api/src/main/java/com/dfsek/terra/api/event/EventManager.java index b602f3911..9fa7b9c01 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/EventManager.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/EventManager.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/AbstractCancellable.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/AbstractCancellable.java index 188f078c9..0a27a8f2a 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/AbstractCancellable.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/AbstractCancellable.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/Cancellable.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/Cancellable.java index 4a832b817..6a49c0612 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/Cancellable.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/Cancellable.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/Event.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/Event.java index 3051c744f..145957333 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/Event.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/Event.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/FailThroughEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/FailThroughEvent.java index 0c1f35382..3cd44267b 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/FailThroughEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/FailThroughEvent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/PackEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/PackEvent.java index cb7ebe079..cc621fb57 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/PackEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/PackEvent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/ConfigurationLoadEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/ConfigurationLoadEvent.java index 55f5f969f..e7529e7fd 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/ConfigurationLoadEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/ConfigurationLoadEvent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackLoadEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackLoadEvent.java index 47664bbfe..9c83d6e0e 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackLoadEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackLoadEvent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackPostLoadEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackPostLoadEvent.java index 95a504798..b565d3c7d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackPostLoadEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackPostLoadEvent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackPreLoadEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackPreLoadEvent.java index 8e09c3fe1..96816ee4f 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackPreLoadEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackPreLoadEvent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypeLoadEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypeLoadEvent.java index 8dd7db191..28caacfee 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypeLoadEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypeLoadEvent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypePostLoadEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypePostLoadEvent.java index f3b72ccd2..358e0ea3a 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypePostLoadEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypePostLoadEvent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypePreLoadEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypePreLoadEvent.java index 084d68a0a..0028b0f04 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypePreLoadEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypePreLoadEvent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/platform/PlatformInitializationEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/platform/PlatformInitializationEvent.java index d94ee750c..39b7c6546 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/platform/PlatformInitializationEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/platform/PlatformInitializationEvent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/EntitySpawnEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/EntitySpawnEvent.java index 2efc4ac24..088b0d661 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/EntitySpawnEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/EntitySpawnEvent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/LootPopulateEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/LootPopulateEvent.java index e956c5067..9b11ac248 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/LootPopulateEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/LootPopulateEvent.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/functional/EventContext.java b/common/api/src/main/java/com/dfsek/terra/api/event/functional/EventContext.java index 54750cc8b..52670bb3c 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/functional/EventContext.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/functional/EventContext.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/functional/FunctionalEventHandler.java b/common/api/src/main/java/com/dfsek/terra/api/event/functional/FunctionalEventHandler.java index 9ec9c62c9..6f6a203de 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/functional/FunctionalEventHandler.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/functional/FunctionalEventHandler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/handle/ItemHandle.java b/common/api/src/main/java/com/dfsek/terra/api/handle/ItemHandle.java index 2cc69db77..9aaf2e141 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/handle/ItemHandle.java +++ b/common/api/src/main/java/com/dfsek/terra/api/handle/ItemHandle.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/handle/WorldHandle.java b/common/api/src/main/java/com/dfsek/terra/api/handle/WorldHandle.java index 4f28b254e..3518b9685 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/handle/WorldHandle.java +++ b/common/api/src/main/java/com/dfsek/terra/api/handle/WorldHandle.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/inject/Injector.java b/common/api/src/main/java/com/dfsek/terra/api/inject/Injector.java index 50caaf420..f7db74d83 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inject/Injector.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inject/Injector.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/inject/annotations/Inject.java b/common/api/src/main/java/com/dfsek/terra/api/inject/annotations/Inject.java index 28936aef2..78b0e746d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inject/annotations/Inject.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inject/annotations/Inject.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/inject/exception/InjectionException.java b/common/api/src/main/java/com/dfsek/terra/api/inject/exception/InjectionException.java index 4275d7a5a..f0ebef673 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inject/exception/InjectionException.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inject/exception/InjectionException.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/inject/impl/InjectorImpl.java b/common/api/src/main/java/com/dfsek/terra/api/inject/impl/InjectorImpl.java index 9c17501a5..c34965101 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inject/impl/InjectorImpl.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inject/impl/InjectorImpl.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/inventory/BlockInventoryHolder.java b/common/api/src/main/java/com/dfsek/terra/api/inventory/BlockInventoryHolder.java index 267a1ffec..3e961e42a 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inventory/BlockInventoryHolder.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inventory/BlockInventoryHolder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/inventory/Inventory.java b/common/api/src/main/java/com/dfsek/terra/api/inventory/Inventory.java index 8f0888ac7..5a7e3a508 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inventory/Inventory.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inventory/Inventory.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/inventory/InventoryHolder.java b/common/api/src/main/java/com/dfsek/terra/api/inventory/InventoryHolder.java index bf62a1c79..304e448c9 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inventory/InventoryHolder.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inventory/InventoryHolder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/inventory/Item.java b/common/api/src/main/java/com/dfsek/terra/api/inventory/Item.java index 36d27c08d..1943f878f 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inventory/Item.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inventory/Item.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/inventory/ItemStack.java b/common/api/src/main/java/com/dfsek/terra/api/inventory/ItemStack.java index 0edc53c6e..2ab7a3dc5 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inventory/ItemStack.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inventory/ItemStack.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Damageable.java b/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Damageable.java index 9f950a3c9..62d03dbf4 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Damageable.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Damageable.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Enchantment.java b/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Enchantment.java index a836bc22b..3fa065abf 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Enchantment.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Enchantment.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/inventory/item/ItemMeta.java b/common/api/src/main/java/com/dfsek/terra/api/inventory/item/ItemMeta.java index 6094ce389..268c7ec94 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inventory/item/ItemMeta.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inventory/item/ItemMeta.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/noise/NoiseSampler.java b/common/api/src/main/java/com/dfsek/terra/api/noise/NoiseSampler.java index 5e6a5df0b..e01c469ba 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/noise/NoiseSampler.java +++ b/common/api/src/main/java/com/dfsek/terra/api/noise/NoiseSampler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/profiler/Profiler.java b/common/api/src/main/java/com/dfsek/terra/api/profiler/Profiler.java index 15d610a63..3d210d38c 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/profiler/Profiler.java +++ b/common/api/src/main/java/com/dfsek/terra/api/profiler/Profiler.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/profiler/Timings.java b/common/api/src/main/java/com/dfsek/terra/api/profiler/Timings.java index 199d4943f..bcd2d06c7 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/profiler/Timings.java +++ b/common/api/src/main/java/com/dfsek/terra/api/profiler/Timings.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/properties/Context.java b/common/api/src/main/java/com/dfsek/terra/api/properties/Context.java index 175ec60af..9eeaaf8b3 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/properties/Context.java +++ b/common/api/src/main/java/com/dfsek/terra/api/properties/Context.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/properties/Properties.java b/common/api/src/main/java/com/dfsek/terra/api/properties/Properties.java index 162828357..32e95ac9d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/properties/Properties.java +++ b/common/api/src/main/java/com/dfsek/terra/api/properties/Properties.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/properties/PropertyHolder.java b/common/api/src/main/java/com/dfsek/terra/api/properties/PropertyHolder.java index e48d50bed..0e8fbdf5d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/properties/PropertyHolder.java +++ b/common/api/src/main/java/com/dfsek/terra/api/properties/PropertyHolder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/properties/annotations/Linked.java b/common/api/src/main/java/com/dfsek/terra/api/properties/annotations/Linked.java index 230ab1841..1845ec5b3 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/properties/annotations/Linked.java +++ b/common/api/src/main/java/com/dfsek/terra/api/properties/annotations/Linked.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/CheckedRegistry.java b/common/api/src/main/java/com/dfsek/terra/api/registry/CheckedRegistry.java index dd79c7c4a..823db21b1 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/CheckedRegistry.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/CheckedRegistry.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/OpenRegistry.java b/common/api/src/main/java/com/dfsek/terra/api/registry/OpenRegistry.java index dcedae900..2f46830ac 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/OpenRegistry.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/OpenRegistry.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/Registry.java b/common/api/src/main/java/com/dfsek/terra/api/registry/Registry.java index 7ebde15d2..2d3589a2b 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/Registry.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/Registry.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/exception/DuplicateEntryException.java b/common/api/src/main/java/com/dfsek/terra/api/registry/exception/DuplicateEntryException.java index 123ec2da3..db4cee6e8 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/exception/DuplicateEntryException.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/exception/DuplicateEntryException.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/key/StringIdentifiable.java b/common/api/src/main/java/com/dfsek/terra/api/registry/key/StringIdentifiable.java index fe2a5b6db..70ccfb6d5 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/key/StringIdentifiable.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/key/StringIdentifiable.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/meta/RegistryHolder.java b/common/api/src/main/java/com/dfsek/terra/api/registry/meta/RegistryHolder.java index a42054538..fd765ebaa 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/meta/RegistryHolder.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/meta/RegistryHolder.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/structure/LootTable.java b/common/api/src/main/java/com/dfsek/terra/api/structure/LootTable.java index 162247c82..44827a26d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/structure/LootTable.java +++ b/common/api/src/main/java/com/dfsek/terra/api/structure/LootTable.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/structure/Structure.java b/common/api/src/main/java/com/dfsek/terra/api/structure/Structure.java index 479c77e38..d5f3ca7e2 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/structure/Structure.java +++ b/common/api/src/main/java/com/dfsek/terra/api/structure/Structure.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/structure/StructureSpawn.java b/common/api/src/main/java/com/dfsek/terra/api/structure/StructureSpawn.java index a06496817..09c4f785d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/structure/StructureSpawn.java +++ b/common/api/src/main/java/com/dfsek/terra/api/structure/StructureSpawn.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/structure/configured/ConfiguredStructure.java b/common/api/src/main/java/com/dfsek/terra/api/structure/configured/ConfiguredStructure.java index 452d0a902..c6280b570 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/structure/configured/ConfiguredStructure.java +++ b/common/api/src/main/java/com/dfsek/terra/api/structure/configured/ConfiguredStructure.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/BinaryColumn.java b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/BinaryColumn.java index bb985e83a..a14777751 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/BinaryColumn.java +++ b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/BinaryColumn.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Distributor.java b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Distributor.java index f037ed489..799b45e92 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Distributor.java +++ b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Distributor.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Feature.java b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Feature.java index 1cbc6f8ad..985e97321 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Feature.java +++ b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Feature.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Locator.java b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Locator.java index a5d4e6ca1..325ba10aa 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Locator.java +++ b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Locator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/tectonic/ConfigLoadingDelegate.java b/common/api/src/main/java/com/dfsek/terra/api/tectonic/ConfigLoadingDelegate.java index e0969eba3..5756419a6 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/tectonic/ConfigLoadingDelegate.java +++ b/common/api/src/main/java/com/dfsek/terra/api/tectonic/ConfigLoadingDelegate.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/tectonic/LoaderRegistrar.java b/common/api/src/main/java/com/dfsek/terra/api/tectonic/LoaderRegistrar.java index b63c4f101..ec70d4077 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/tectonic/LoaderRegistrar.java +++ b/common/api/src/main/java/com/dfsek/terra/api/tectonic/LoaderRegistrar.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/transform/Transform.java b/common/api/src/main/java/com/dfsek/terra/api/transform/Transform.java index 014747f0f..fe7741070 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/transform/Transform.java +++ b/common/api/src/main/java/com/dfsek/terra/api/transform/Transform.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/transform/Transformer.java b/common/api/src/main/java/com/dfsek/terra/api/transform/Transformer.java index 8ca8a904a..eb1427aee 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/transform/Transformer.java +++ b/common/api/src/main/java/com/dfsek/terra/api/transform/Transformer.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/transform/Validator.java b/common/api/src/main/java/com/dfsek/terra/api/transform/Validator.java index 9a9aecbdd..70aaefcf6 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/transform/Validator.java +++ b/common/api/src/main/java/com/dfsek/terra/api/transform/Validator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/transform/exception/AttemptsFailedException.java b/common/api/src/main/java/com/dfsek/terra/api/transform/exception/AttemptsFailedException.java index 8cc6bab87..2296dbab6 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/transform/exception/AttemptsFailedException.java +++ b/common/api/src/main/java/com/dfsek/terra/api/transform/exception/AttemptsFailedException.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/transform/exception/TransformException.java b/common/api/src/main/java/com/dfsek/terra/api/transform/exception/TransformException.java index ff80b6642..32312311e 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/transform/exception/TransformException.java +++ b/common/api/src/main/java/com/dfsek/terra/api/transform/exception/TransformException.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/ConstantRange.java b/common/api/src/main/java/com/dfsek/terra/api/util/ConstantRange.java index 405fdab28..a5db22b4c 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/ConstantRange.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/ConstantRange.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java index f4122e694..36bf0472e 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/PopulationUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/PopulationUtil.java index d8949a0c2..5a6016da8 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/PopulationUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/PopulationUtil.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/Range.java b/common/api/src/main/java/com/dfsek/terra/api/util/Range.java index c417b8183..25f22aa79 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/Range.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/Range.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/Rotation.java b/common/api/src/main/java/com/dfsek/terra/api/util/Rotation.java index 20b37881b..e12afaea7 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/Rotation.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/Rotation.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/RotationUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/RotationUtil.java index 6f9fb8048..4f951d0e0 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/RotationUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/RotationUtil.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/StringUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/StringUtil.java index ae9bd3ff0..d48753fb2 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/StringUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/StringUtil.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/collection/MaterialSet.java b/common/api/src/main/java/com/dfsek/terra/api/util/collection/MaterialSet.java index 25cf98eb1..1a13e836c 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/collection/MaterialSet.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/collection/MaterialSet.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java b/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java index f85344849..dd202560d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/generic/Construct.java b/common/api/src/main/java/com/dfsek/terra/api/util/generic/Construct.java index 678a98b2d..88ee6a751 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/generic/Construct.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/generic/Construct.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/generic/Lazy.java b/common/api/src/main/java/com/dfsek/terra/api/util/generic/Lazy.java index ca9735d03..ff45bfaa8 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/generic/Lazy.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/generic/Lazy.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/generic/either/Either.java b/common/api/src/main/java/com/dfsek/terra/api/util/generic/either/Either.java index 047fb8426..25022cf18 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/generic/either/Either.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/generic/either/Either.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/generic/pair/Pair.java b/common/api/src/main/java/com/dfsek/terra/api/util/generic/pair/Pair.java index c1ddf92d6..51e72ab80 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/generic/pair/Pair.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/generic/pair/Pair.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableBoolean.java b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableBoolean.java index eb6b07948..0d666d110 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableBoolean.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableBoolean.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableDouble.java b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableDouble.java index c3edfdd20..f6cd874bb 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableDouble.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableDouble.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableInteger.java b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableInteger.java index ed1abadd9..437e399c7 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableInteger.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableInteger.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableNumber.java b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableNumber.java index ce9fe2874..f2e739a9f 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableNumber.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableNumber.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutablePrimitive.java b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutablePrimitive.java index 5718aba48..5ed6cb095 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutablePrimitive.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutablePrimitive.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/package-info.java b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/package-info.java index c45a11ed4..fb53df1a7 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/package-info.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/package-info.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/reflection/ReflectionUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/reflection/ReflectionUtil.java index 11bbd8802..a79a4cefa 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/reflection/ReflectionUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/reflection/ReflectionUtil.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/reflection/TypeKey.java b/common/api/src/main/java/com/dfsek/terra/api/util/reflection/TypeKey.java index a3518c512..19ff4259c 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/reflection/TypeKey.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/reflection/TypeKey.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java index 191b0e449..0a139478a 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java index bce63c2ea..f346fb433 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/ServerWorld.java b/common/api/src/main/java/com/dfsek/terra/api/world/ServerWorld.java index 4fbda89b0..ba3e16196 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/ServerWorld.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/ServerWorld.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/biome/Biome.java b/common/api/src/main/java/com/dfsek/terra/api/world/biome/Biome.java index 7d2ec6189..027c715f7 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/biome/Biome.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/biome/Biome.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/biome/PaletteSettings.java b/common/api/src/main/java/com/dfsek/terra/api/world/biome/PaletteSettings.java index 5bd49361e..45a5c1a10 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/biome/PaletteSettings.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/biome/PaletteSettings.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/biome/PlatformBiome.java b/common/api/src/main/java/com/dfsek/terra/api/world/biome/PlatformBiome.java index 5eeff8306..d749b4089 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/biome/PlatformBiome.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/biome/PlatformBiome.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/BiomeProvider.java b/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/BiomeProvider.java index 01ffbda70..1fb7c5c92 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/BiomeProvider.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/BiomeProvider.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/Chunk.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/Chunk.java index 303ad1e2e..6482df935 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/Chunk.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/Chunk.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/ChunkAccess.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/ChunkAccess.java index ca10c9d04..ca88b131c 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/ChunkAccess.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/ChunkAccess.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ChunkGenerator.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ChunkGenerator.java index b88c8bc85..133077c91 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ChunkGenerator.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ChunkGenerator.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ProtoChunk.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ProtoChunk.java index 2de97241c..744bfda7f 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ProtoChunk.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ProtoChunk.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/stage/Chunkified.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/stage/Chunkified.java index 6d5679951..fe8d81f8c 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/stage/Chunkified.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/stage/Chunkified.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/stage/GenerationStage.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/stage/GenerationStage.java index a80789926..0d7401910 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/stage/GenerationStage.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/stage/GenerationStage.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/Column.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/Column.java index c92ca2311..658ec303f 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/Column.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/Column.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/GeneratorWrapper.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/GeneratorWrapper.java index 27cda9f01..fc7044a98 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/GeneratorWrapper.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/GeneratorWrapper.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/Palette.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/Palette.java index 0a15b7be2..19f948495 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/Palette.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/Palette.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/provider/ChunkGeneratorProvider.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/provider/ChunkGeneratorProvider.java index 32bcab044..1a169da02 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/provider/ChunkGeneratorProvider.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/provider/ChunkGeneratorProvider.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/provider/GenerationStageProvider.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/provider/GenerationStageProvider.java index eeb711f0e..470db1a22 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/provider/GenerationStageProvider.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/provider/GenerationStageProvider.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Polyhedral Development + * Copyright (c) 2020-2023 Polyhedral Development * * The Terra API is licensed under the terms of the MIT License. For more details, * reference the LICENSE file in the common/api directory. From d696e4fd248170cfd905fe695b7a4d1eb5eb479a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Thu, 2 Nov 2023 18:45:13 -0600 Subject: [PATCH 57/83] Optimize imports --- buildSrc/src/main/kotlin/DistributionConfig.kt | 1 - .../config-noise-function/build.gradle.kts | 2 -- .../numberpredicate/NumberPredicateAddon.java | 5 ----- .../com/dfsek/terra/addons/ore/OreAddon.java | 3 --- .../terra/addons/ore/ScatteredOreFactory.java | 1 - .../terra/addons/ore/ScatteredOreTemplate.java | 10 ---------- .../addons/ore/ores/VanillaScatteredOre.java | 17 +++++++---------- .../terra/addons/ore/utils/VanillaOreUtils.java | 4 ++-- .../terra/addons/image/ImageLibraryAddon.java | 4 ---- .../config/ImageLibraryPackConfigTemplate.java | 1 - .../addons/image/config/image/ImageCache.java | 7 +++---- .../feature/locator/slant/SlantLocator.java | 4 ++-- .../locator/slant/SlantLocatorAddon.java | 4 ++-- .../locator/slant/SlantLocatorTemplate.java | 4 ++-- .../build.gradle.kts | 2 -- .../com/dfsek/terra/bukkit/PlatformImpl.java | 2 -- .../dfsek/terra/bukkit/TerraBukkitPlugin.java | 2 +- .../com/dfsek/terra/bukkit/util/PaperUtil.java | 6 ++---- .../bukkit/nms/v1_20_R2/NMSBiomeProvider.java | 3 ++- 19 files changed, 23 insertions(+), 59 deletions(-) diff --git a/buildSrc/src/main/kotlin/DistributionConfig.kt b/buildSrc/src/main/kotlin/DistributionConfig.kt index 24750233f..59f16569b 100644 --- a/buildSrc/src/main/kotlin/DistributionConfig.kt +++ b/buildSrc/src/main/kotlin/DistributionConfig.kt @@ -9,7 +9,6 @@ import java.nio.file.StandardCopyOption import org.gradle.api.DefaultTask import org.gradle.api.Project import org.gradle.api.plugins.BasePluginExtension -import org.gradle.kotlin.dsl.TaskContainerScope import org.gradle.kotlin.dsl.apply import org.gradle.kotlin.dsl.configure import org.gradle.kotlin.dsl.extra diff --git a/common/addons/config-noise-function/build.gradle.kts b/common/addons/config-noise-function/build.gradle.kts index 887d158b7..af2284b48 100644 --- a/common/addons/config-noise-function/build.gradle.kts +++ b/common/addons/config-noise-function/build.gradle.kts @@ -1,5 +1,3 @@ -import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar - version = version("1.1.0") dependencies { diff --git a/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java b/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java index 95e1ac8bd..75e2e6faa 100644 --- a/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java +++ b/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java @@ -7,12 +7,7 @@ package com.dfsek.terra.addons.numberpredicate; -import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; - -import java.util.LinkedHashMap; -import java.util.Map; import java.util.function.DoublePredicate; -import java.util.function.Supplier; import com.dfsek.terra.addons.manifest.api.AddonInitializer; import com.dfsek.terra.api.Platform; diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java index e315e3307..7ce09f1d4 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java @@ -14,9 +14,6 @@ import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent; import com.dfsek.terra.api.event.functional.FunctionalEventHandler; import com.dfsek.terra.api.inject.annotations.Inject; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - public class OreAddon implements AddonInitializer { @Inject diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java index 4fbfdfa54..6023d3de9 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java @@ -9,7 +9,6 @@ package com.dfsek.terra.addons.ore; import com.dfsek.tectonic.api.exception.LoadException; -import com.dfsek.terra.addons.ore.ores.VanillaOre; import com.dfsek.terra.addons.ore.ores.VanillaScatteredOre; import com.dfsek.terra.api.Platform; import com.dfsek.terra.api.block.state.BlockState; diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreTemplate.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreTemplate.java index ecb81a0b9..caf923388 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreTemplate.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreTemplate.java @@ -7,19 +7,9 @@ package com.dfsek.terra.addons.ore; -import com.dfsek.tectonic.api.config.template.annotations.Default; -import com.dfsek.tectonic.api.config.template.annotations.Description; -import com.dfsek.tectonic.api.config.template.annotations.Final; import com.dfsek.tectonic.api.config.template.annotations.Value; -import com.dfsek.terra.api.block.BlockType; -import com.dfsek.terra.api.block.state.BlockState; -import com.dfsek.terra.api.config.AbstractableTemplate; import com.dfsek.terra.api.config.meta.Meta; -import com.dfsek.terra.api.util.collection.MaterialSet; - -import java.util.HashMap; -import java.util.Map; @SuppressWarnings({ "unused", "FieldMayBeFinal" }) diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java index fb30cff76..12dcda3ce 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java @@ -1,18 +1,15 @@ package com.dfsek.terra.addons.ore.ores; -import com.dfsek.terra.addons.ore.utils.VanillaOreUtils; -import com.dfsek.terra.api.block.BlockType; -import com.dfsek.terra.api.block.state.BlockState; -import com.dfsek.terra.api.structure.Structure; -import com.dfsek.terra.api.util.Rotation; -import com.dfsek.terra.api.util.collection.MaterialSet; -import com.dfsek.terra.api.util.vector.Vector3; -import com.dfsek.terra.api.util.vector.Vector3Int; -import com.dfsek.terra.api.world.WritableWorld; - import java.util.Map; import java.util.Random; +import com.dfsek.terra.api.block.BlockType; +import com.dfsek.terra.api.block.state.BlockState; +import com.dfsek.terra.api.util.Rotation; +import com.dfsek.terra.api.util.collection.MaterialSet; +import com.dfsek.terra.api.util.vector.Vector3Int; +import com.dfsek.terra.api.world.WritableWorld; + import static com.dfsek.terra.addons.ore.utils.VanillaOreUtils.shouldPlace; diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java index c03ce3752..aa8f0132d 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java @@ -1,11 +1,11 @@ package com.dfsek.terra.addons.ore.utils; +import java.util.Random; + import com.dfsek.terra.api.block.BlockType; import com.dfsek.terra.api.util.collection.MaterialSet; import com.dfsek.terra.api.world.WritableWorld; -import java.util.Random; - public class VanillaOreUtils { protected static boolean shouldNotDiscard(Random random, double chance) { diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java index 0e9739588..638056f7f 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java @@ -8,10 +8,6 @@ import com.dfsek.terra.addons.image.colorsampler.ColorSampler; import com.dfsek.terra.addons.image.config.ColorLoader; import com.dfsek.terra.addons.image.config.ColorLoader.ColorString; import com.dfsek.terra.addons.image.config.ImageLibraryPackConfigTemplate; -import com.dfsek.terra.addons.image.config.noisesampler.ChannelNoiseSamplerTemplate; -import com.dfsek.terra.addons.image.config.noisesampler.DistanceTransformNoiseSamplerTemplate; -import com.dfsek.terra.addons.image.config.image.ImageTemplate; -import com.dfsek.terra.addons.image.config.image.StitchedImageTemplate; import com.dfsek.terra.addons.image.config.colorsampler.ConstantColorSamplerTemplate; import com.dfsek.terra.addons.image.config.colorsampler.image.SingleImageColorSamplerTemplate; import com.dfsek.terra.addons.image.config.colorsampler.image.TileImageColorSamplerTemplate; diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java index b3a78caed..60d58cddd 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java @@ -1,7 +1,6 @@ package com.dfsek.terra.addons.image.config; import com.dfsek.tectonic.api.config.template.ConfigTemplate; - import com.dfsek.tectonic.api.config.template.annotations.Default; import com.dfsek.tectonic.api.config.template.annotations.Description; import com.dfsek.tectonic.api.config.template.annotations.Value; diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java index 7558d4bfa..54551504c 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java @@ -1,5 +1,8 @@ package com.dfsek.terra.addons.image.config.image; +import com.github.benmanes.caffeine.cache.Caffeine; +import com.github.benmanes.caffeine.cache.LoadingCache; + import javax.imageio.ImageIO; import java.io.FileNotFoundException; import java.io.IOException; @@ -12,12 +15,8 @@ import com.dfsek.terra.addons.image.image.SuppliedImage; import com.dfsek.terra.api.config.ConfigPack; import com.dfsek.terra.api.config.Loader; import com.dfsek.terra.api.properties.Properties; - import com.dfsek.terra.api.util.generic.Lazy; -import com.github.benmanes.caffeine.cache.Caffeine; -import com.github.benmanes.caffeine.cache.LoadingCache; - /* * Cache prevents configs from loading the same image multiple times into memory diff --git a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocator.java b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocator.java index 732ec540c..615c9ea22 100644 --- a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocator.java +++ b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocator.java @@ -1,5 +1,7 @@ package com.dfsek.terra.addon.feature.locator.slant; +import java.util.function.DoublePredicate; + import com.dfsek.terra.addons.chunkgenerator.generation.NoiseChunkGenerator3D; import com.dfsek.terra.api.structure.feature.BinaryColumn; import com.dfsek.terra.api.structure.feature.Locator; @@ -7,8 +9,6 @@ import com.dfsek.terra.api.world.World; import com.dfsek.terra.api.world.biome.generation.BiomeProvider; import com.dfsek.terra.api.world.chunk.generation.util.Column; -import java.util.function.DoublePredicate; - public class SlantLocator implements Locator { diff --git a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorAddon.java b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorAddon.java index 78df933d8..9391b0474 100644 --- a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorAddon.java +++ b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorAddon.java @@ -2,6 +2,8 @@ package com.dfsek.terra.addon.feature.locator.slant; import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; +import java.util.function.Supplier; + import com.dfsek.terra.addons.manifest.api.AddonInitializer; import com.dfsek.terra.api.Platform; import com.dfsek.terra.api.addon.BaseAddon; @@ -11,8 +13,6 @@ import com.dfsek.terra.api.inject.annotations.Inject; import com.dfsek.terra.api.structure.feature.Locator; import com.dfsek.terra.api.util.reflection.TypeKey; -import java.util.function.Supplier; - public class SlantLocatorAddon implements AddonInitializer { diff --git a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java index 82beba1dc..e79cef042 100644 --- a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java +++ b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java @@ -3,10 +3,10 @@ package com.dfsek.terra.addon.feature.locator.slant; import com.dfsek.tectonic.api.config.template.annotations.Value; import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; -import com.dfsek.terra.api.structure.feature.Locator; - import java.util.function.DoublePredicate; +import com.dfsek.terra.api.structure.feature.Locator; + public class SlantLocatorTemplate implements ObjectTemplate { diff --git a/common/addons/structure-terrascript-loader/build.gradle.kts b/common/addons/structure-terrascript-loader/build.gradle.kts index 7a6884eda..93e35b659 100644 --- a/common/addons/structure-terrascript-loader/build.gradle.kts +++ b/common/addons/structure-terrascript-loader/build.gradle.kts @@ -1,5 +1,3 @@ -import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar - version = version("1.1.0") dependencies { diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/PlatformImpl.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/PlatformImpl.java index 189f1d12f..ea09cd217 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/PlatformImpl.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/PlatformImpl.java @@ -20,7 +20,6 @@ package com.dfsek.terra.bukkit; import com.dfsek.tectonic.api.TypeRegistry; import com.dfsek.tectonic.api.depth.DepthTracker; import com.dfsek.tectonic.api.exception.LoadException; -import com.tcoded.folialib.wrapper.task.WrappedTask; import org.bukkit.Bukkit; import org.bukkit.entity.EntityType; import org.jetbrains.annotations.NotNull; @@ -30,7 +29,6 @@ import org.slf4j.LoggerFactory; import java.io.File; import java.util.List; import java.util.Locale; -import java.util.function.Consumer; import com.dfsek.terra.AbstractPlatform; import com.dfsek.terra.api.addon.BaseAddon; diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java index 0bbf6e2e5..1ab9731ac 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java @@ -21,6 +21,7 @@ import cloud.commandframework.brigadier.CloudBrigadierManager; import cloud.commandframework.bukkit.CloudBukkitCapabilities; import cloud.commandframework.execution.CommandExecutionCoordinator; import cloud.commandframework.paper.PaperCommandManager; +import com.tcoded.folialib.FoliaLib; import org.bukkit.Bukkit; import org.bukkit.generator.ChunkGenerator; import org.bukkit.plugin.java.JavaPlugin; @@ -42,7 +43,6 @@ import com.dfsek.terra.bukkit.nms.Initializer; import com.dfsek.terra.bukkit.util.PaperUtil; import com.dfsek.terra.bukkit.util.VersionUtil; import com.dfsek.terra.bukkit.world.BukkitAdapter; -import com.tcoded.folialib.FoliaLib; public class TerraBukkitPlugin extends JavaPlugin { diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/PaperUtil.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/PaperUtil.java index b5c029000..2cde19b1f 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/PaperUtil.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/PaperUtil.java @@ -17,11 +17,9 @@ package com.dfsek.terra.bukkit.util; -import com.dfsek.terra.bukkit.TerraBukkitPlugin; - import io.papermc.lib.PaperLib; -import org.bukkit.Bukkit; -import org.bukkit.plugin.java.JavaPlugin; + +import com.dfsek.terra.bukkit.TerraBukkitPlugin; import static io.papermc.lib.PaperLib.suggestPaper; diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeProvider.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeProvider.java index a6025e03f..bba17a5f8 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeProvider.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeProvider.java @@ -2,13 +2,14 @@ package com.dfsek.terra.bukkit.nms.v1_20_R2; import com.mojang.serialization.Codec; import net.minecraft.core.Holder; -import java.util.stream.Stream; import net.minecraft.core.Registry; import net.minecraft.world.level.biome.Biome; import net.minecraft.world.level.biome.BiomeSource; import net.minecraft.world.level.biome.Climate.Sampler; import org.jetbrains.annotations.NotNull; +import java.util.stream.Stream; + import com.dfsek.terra.api.world.biome.generation.BiomeProvider; import com.dfsek.terra.bukkit.world.BukkitPlatformBiome; From 81a96d6b769cf1173eeb16dea83b55916d9a089a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Thu, 2 Nov 2023 18:47:36 -0600 Subject: [PATCH 58/83] Reformat code --- .github/ISSUE_TEMPLATE/BUG_REPORT.md | 14 +- .github/ISSUE_TEMPLATE/config.yml | 18 +- build.gradle.kts | 18 +- buildSrc/build.gradle.kts | 4 +- .../src/main/kotlin/DistributionConfig.kt | 5 +- buildSrc/src/main/kotlin/Versions.kt | 3 +- .../src/main/resources/terra.addon.yml | 12 +- .../image/v2/ImageBiomeProviderAddon.java | 14 +- .../ClosestBiomeColorConverterTemplate.java | 2 +- .../ExactBiomeColorConverterTemplate.java | 6 +- .../src/main/resources/terra.addon.yml | 12 +- .../biome/image/ImageBiomeProviderAddon.java | 8 +- .../src/main/resources/terra.addon.yml | 10 +- .../biome-provider-pipeline-v2/README.md | 2 +- .../pipeline/v2/PipelineBiomeProvider.java | 9 +- .../pipeline/v2/api/biome/PipelineBiome.java | 4 +- .../v2/api/biome/SelfPipelineBiome.java | 2 +- .../v2/config/BiomePipelineTemplate.java | 16 +- .../pipeline/v2/pipeline/BiomeChunkImpl.java | 42 ++--- .../pipeline/v2/pipeline/PipelineImpl.java | 6 +- .../v2/stage/expander/FractalExpander.java | 8 +- .../v2/stage/mutators/BorderListStage.java | 7 +- .../v2/stage/mutators/SmoothStage.java | 2 +- .../src/main/resources/terra.addon.yml | 10 +- .../biome/pipeline/BiomePipelineAddon.java | 8 +- .../biome/pipeline/BiomePipelineProvider.java | 8 +- .../pipeline/api/delegate/SelfDelegate.java | 2 +- .../src/main/resources/terra.addon.yml | 10 +- .../src/main/resources/terra.addon.yml | 10 +- .../biome/query/BiomeQueryAPIAddon.java | 4 +- .../addons/biome/query/api/BiomeQueries.java | 2 +- .../src/main/resources/terra.addon.yml | 10 +- .../NoiseChunkGenerator3DAddon.java | 9 +- .../config/noise/ThreadLocalNoiseHolder.java | 2 +- .../config/palette/BiomePaletteTemplate.java | 9 +- .../math/interpolation/ChunkInterpolator.java | 2 +- .../chunkgenerator/palette/PaletteHolder.java | 19 +- .../palette/slant/MultipleSlantHolder.java | 3 +- .../palette/slant/SlantHolder.java | 169 +++++++++--------- .../palette/slant/SlantHolderImpl.java | 6 +- .../src/main/resources/terra.addon.yml | 10 +- .../commands/addons/AddonsCommandAddon.java | 6 +- .../src/main/resources/terra.addon.yml | 10 +- .../commands/packs/PacksCommandAddon.java | 6 +- .../src/main/resources/terra.addon.yml | 10 +- .../src/main/resources/terra.addon.yml | 10 +- .../structure/StructureCommandAddon.java | 2 +- .../src/main/resources/terra.addon.yml | 10 +- .../src/main/resources/terra.addon.yml | 10 +- .../feature/distributor/DistributorAddon.java | 4 +- .../src/main/resources/terra.addon.yml | 14 +- .../src/main/resources/terra.addon.yml | 12 +- .../src/main/resources/terra.addon.yml | 10 +- .../addons/feature/locator/LocatorAddon.java | 10 +- .../src/main/resources/terra.addon.yml | 14 +- .../dfsek/terra/addons/noise/NoiseAddon.java | 35 ++-- .../templates/TranslateSamplerTemplate.java | 2 +- .../noise/ExpressionFunctionTemplate.java | 9 +- .../ExpressionNormalizerTemplate.java | 9 +- .../terra/addons/noise/math/CubicSpline.java | 22 +-- .../addons/noise/paralithic/FunctionUtil.java | 5 +- .../noise/samplers/noise/DistanceSampler.java | 40 ++--- .../samplers/noise/GaborNoiseSampler.java | 8 +- .../noise/samplers/noise/NoiseFunction.java | 2 +- .../noise/value/ValueCubicSampler.java | 38 ++-- .../src/main/resources/terra.addon.yml | 10 +- .../DoublePredicateLoader.java | 2 +- .../numberpredicate/NumberPredicateAddon.java | 1 + .../src/main/resources/terra.addon.yml | 10 +- .../terra/addons/ore/ores/VanillaOre.java | 1 + .../addons/ore/ores/VanillaScatteredOre.java | 9 +- .../addons/ore/utils/VanillaOreUtils.java | 3 +- .../src/main/resources/terra.addon.yml | 10 +- .../src/main/resources/terra.addon.yml | 10 +- .../src/main/resources/terra.addon.yml | 10 +- .../feature/FeatureGenerationAddon.java | 10 +- .../src/main/resources/terra.addon.yml | 10 +- .../src/main/resources/terra.addon.yml | 10 +- .../src/main/resources/terra.addon.yml | 10 +- common/addons/library-image/build.gradle.kts | 1 - .../terra/addons/image/ImageLibraryAddon.java | 2 +- .../image/colorsampler/ColorSampler.java | 1 + .../image/transform/Alignment.java | 4 +- .../mutate/RotateColorSampler.java | 11 +- .../addons/image/config/ColorLoader.java | 22 +-- .../ImageLibraryPackConfigTemplate.java | 7 +- .../SingleImageColorSamplerTemplate.java | 2 +- .../image/TileImageColorSamplerTemplate.java | 2 +- .../mutate/TranslateColorSamplerTemplate.java | 2 +- .../addons/image/config/image/ImageCache.java | 4 +- .../image/config/image/ImageTemplate.java | 6 +- .../config/image/StitchedImageTemplate.java | 17 +- ...DistanceTransformNoiseSamplerTemplate.java | 3 +- .../converter/ClosestMatchColorConverter.java | 11 +- .../image/converter/ExactColorConverter.java | 4 +- .../mapping/BiomeDefinedColorMapping.java | 3 +- .../addons/image/image/StitchedImage.java | 6 +- .../addons/image/image/SuppliedImage.java | 1 + .../image/operator/DistanceTransform.java | 59 +++--- .../terra/addons/image/util/ColorUtil.java | 53 ++++-- .../terra/addons/image/util/MapUtil.java | 6 +- .../terra/addons/image/util/MathUtil.java | 4 +- .../src/main/resources/terra.addon.yml | 10 +- .../src/main/resources/terra.addon.yml | 12 +- .../src/main/resources/terra.addon.yml | 10 +- .../pipeline/image/PipelineImageAddon.java | 27 +-- ...stPipelineBiomeColorConverterTemplate.java | 2 +- ...ctPipelineBiomeColorConverterTemplate.java | 6 +- .../src/main/resources/terra.addon.yml | 10 +- .../src/main/resources/terra.addon.yml | 10 +- .../src/main/resources/terra.addon.yml | 8 +- .../addons/sponge/SpongeSchematicAddon.java | 2 +- .../src/main/resources/terra.addon.yml | 10 +- .../addons/terrascript/parser/Parser.java | 4 +- .../terrascript/parser/lang/Executable.java | 4 +- .../addons/terrascript/parser/lang/Scope.java | 6 +- .../lang/constants/BooleanConstant.java | 2 +- .../lang/constants/NumericConstant.java | 2 +- .../parser/lang/functions/Function.java | 4 +- .../lang/operations/BooleanOrOperation.java | 2 +- .../lang/operations/ModuloOperation.java | 2 +- .../operations/MultiplicationOperation.java | 2 +- .../operations/NumberAdditionOperation.java | 2 +- .../lang/operations/SubtractionOperation.java | 2 +- .../statements/EqualsStatement.java | 2 +- .../statements/LessThanOrEqualsStatement.java | 2 +- .../statements/LessThanStatement.java | 2 +- .../terrascript/script/StructureScript.java | 36 ++-- .../script/functions/LootFunction.java | 6 +- .../script/functions/StateFunction.java | 6 +- .../src/main/resources/terra.addon.yml | 10 +- .../src/main/resources/terra.addon.yml | 14 +- .../src/main/resources/terra.addon.yml | 14 +- common/api/build.gradle.kts | 4 +- .../java/com/dfsek/terra/api/Platform.java | 10 +- .../dfsek/terra/api/util/GeometryUtil.java | 2 +- .../com/dfsek/terra/api/util/MathUtil.java | 16 +- .../collection/ProbabilityCollection.java | 6 +- .../terra/api/util/generic/either/Either.java | 2 +- .../terra/api/util/generic/pair/Pair.java | 22 +-- .../api/util/reflection/ReflectionUtil.java | 2 +- .../dfsek/terra/api/util/vector/Vector2.java | 1 + .../terra/api/util/vector/Vector2Int.java | 14 +- .../dfsek/terra/api/util/vector/Vector3.java | 1 + .../generation/CachingBiomeProvider.java | 8 +- common/api/src/test/java/util/ColumnTest.java | 6 +- common/implementation/base/build.gradle.kts | 10 +- .../com/dfsek/terra/AbstractPlatform.java | 2 +- .../loaders/config/BufferedImageLoader.java | 3 +- .../MetaListLikePreprocessor.java | 3 +- .../base/src/main/resources/config.yml | 16 +- .../src/test/java/registry/RegistryTest.java | 6 +- .../base/src/test/resources/config.yml | 10 +- .../base/src/test/resources/meta.yml | 26 +-- .../base/src/test/resources/metaTarget.yml | 22 +-- .../terra/addon/BootstrapAddonLoader.java | 4 +- gradle.properties | 1 - platforms/bukkit/build.gradle.kts | 2 +- platforms/bukkit/common/build.gradle.kts | 8 +- .../com/dfsek/terra/bukkit/BukkitAddon.java | 8 +- .../dfsek/terra/bukkit/TerraBukkitPlugin.java | 2 +- .../generator/BukkitBlockPopulator.java | 5 +- .../BukkitChunkGeneratorWrapper.java | 10 +- .../bukkit/handles/BukkitWorldHandle.java | 3 +- .../terra/bukkit/world/BukkitProtoWorld.java | 2 +- .../bukkit/nms/v1_18_R2/AwfulBukkitHacks.java | 2 +- .../bukkit/nms/v1_18_R2/NMSBiomeInjector.java | 20 +-- .../terra/bukkit/nms/v1_18_R2/Reflection.java | 4 +- .../bukkit/nms/v1_19_R1/AwfulBukkitHacks.java | 2 +- .../bukkit/nms/v1_19_R1/NMSBiomeInjector.java | 8 +- .../v1_19_R1/NMSChunkGeneratorDelegate.java | 25 +-- .../terra/bukkit/nms/v1_19_R1/Reflection.java | 1 + .../bukkit/nms/v1_19_R2/NMSBiomeInjector.java | 8 +- .../bukkit/nms/v1_19_R2/NMSBiomeProvider.java | 4 +- .../v1_19_R2/NMSChunkGeneratorDelegate.java | 23 +-- .../nms/v1_19_R2/NMSInjectListener.java | 2 +- .../terra/bukkit/nms/v1_19_R2/Reflection.java | 2 + .../bukkit/nms/v1_19_R3/NMSBiomeInjector.java | 35 ++-- .../bukkit/nms/v1_19_R3/NMSBiomeProvider.java | 17 +- .../v1_19_R3/NMSChunkGeneratorDelegate.java | 23 +-- .../nms/v1_19_R3/NMSInjectListener.java | 2 +- .../terra/bukkit/nms/v1_19_R3/Reflection.java | 2 + .../bukkit/nms/v1_20_R1/NMSBiomeInjector.java | 35 ++-- .../bukkit/nms/v1_20_R1/NMSBiomeProvider.java | 17 +- .../v1_20_R1/NMSChunkGeneratorDelegate.java | 23 +-- .../nms/v1_20_R1/NMSInjectListener.java | 2 +- .../terra/bukkit/nms/v1_20_R1/Reflection.java | 2 + .../bukkit/nms/v1_20_R2/NMSBiomeInjector.java | 34 ++-- .../bukkit/nms/v1_20_R2/NMSBiomeProvider.java | 17 +- .../v1_20_R2/NMSChunkGeneratorDelegate.java | 23 +-- .../nms/v1_20_R2/NMSInjectListener.java | 2 +- .../terra/bukkit/nms/v1_20_R2/Reflection.java | 2 + platforms/cli/build.gradle.kts | 10 +- .../dfsek/terra/cli/block/CLIBlockState.java | 4 +- platforms/fabric/build.gradle.kts | 18 +- platforms/forge/build.gradle.kts | 22 +-- .../dfsek/terra/forge/AwfulForgeHacks.java | 4 +- .../mixin/lifecycle/NoiseConfigMixin.java | 3 +- .../com/dfsek/terra/forge/util/BiomeUtil.java | 6 +- platforms/merged/build.gradle.kts | 4 +- platforms/mixin-common/build.gradle.kts | 6 +- .../java/com/dfsek/terra/mod/ModPlatform.java | 5 +- .../config/BiomeParticleConfigTemplate.java | 4 +- .../java/com/dfsek/terra/mod/data/Codecs.java | 6 +- .../MinecraftChunkGeneratorWrapper.java | 3 +- .../mod/generation/TerraBiomeSource.java | 6 +- .../mod/handle/MinecraftWorldHandle.java | 3 +- .../entity/MobSpawnerBlockEntityMixin.java | 14 +- .../terra/chunk/WorldChunkMixin.java | 4 +- .../dfsek/terra/mod/util/MinecraftUtil.java | 3 +- .../com/dfsek/terra/mod/util/PresetUtil.java | 22 ++- .../com/dfsek/terra/mod/util/TagUtil.java | 2 +- platforms/mixin-lifecycle/build.gradle.kts | 12 +- .../terra/lifecycle/LifecycleEntryPoint.java | 8 +- .../terra/lifecycle/LifecyclePlatform.java | 27 ++- .../lifecycle/mixin/NoiseConfigMixin.java | 3 +- .../mixin/lifecycle/RegistryLoaderMixin.java | 3 +- .../dfsek/terra/lifecycle/util/BiomeUtil.java | 6 +- .../terra/lifecycle/util/LifecycleUtil.java | 5 +- .../terra/lifecycle/util/RegistryUtil.java | 2 +- .../resources/terra.lifecycle.mixins.json | 42 ++--- .../dfsek/terra/quilt/AwfulQuiltHacks.java | 6 +- .../com/dfsek/terra/quilt/QuiltAddon.java | 4 +- .../com/dfsek/terra/quilt/QuiltPlatform.java | 7 +- 224 files changed, 1156 insertions(+), 1075 deletions(-) diff --git a/.github/ISSUE_TEMPLATE/BUG_REPORT.md b/.github/ISSUE_TEMPLATE/BUG_REPORT.md index e5c4b0d4a..2c4abb380 100644 --- a/.github/ISSUE_TEMPLATE/BUG_REPORT.md +++ b/.github/ISSUE_TEMPLATE/BUG_REPORT.md @@ -51,13 +51,13 @@ assignees: "" -| Name | Value | -|------------------------------|-------| -| Terra Version | -| Platform / Platform Version | -| Any External Plugins or Mods | -| Terra Packs In Use | -| Terra Addons In Use | +| Name | Value | +|------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| Terra Version | +| Platform / Platform Version | +| Any External Plugins or Mods | +| Terra Packs In Use | +| Terra Addons In Use | ## Issue Description diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml index 4611034c8..329a48021 100644 --- a/.github/ISSUE_TEMPLATE/config.yml +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -1,11 +1,11 @@ blank_issues_enabled: false contact_links: - - name: Which Issue Template do I Choose? - url: https://github.com/PolyhedralDev/Terra/wiki/How-To-Choose-An-Issue-Template - about: Click this if you don't know which issue template to select. This will help you make sure you choose the right one and provide enough information for us to help you. - - name: Terra Wiki - url: https://github.com/PolyhedralDev/Terra/wiki - about: Documentation for all things Terra. - - name: Join the Support Discord - url: https://discord.dfsek.com - about: If you have a basic support question, join the Discord instead. \ No newline at end of file + - name: Which Issue Template do I Choose? + url: https://github.com/PolyhedralDev/Terra/wiki/How-To-Choose-An-Issue-Template + about: Click this if you don't know which issue template to select. This will help you make sure you choose the right one and provide enough information for us to help you. + - name: Terra Wiki + url: https://github.com/PolyhedralDev/Terra/wiki + about: Documentation for all things Terra. + - name: Join the Support Discord + url: https://discord.dfsek.com + about: If you have a basic support question, join the Discord instead. \ No newline at end of file diff --git a/build.gradle.kts b/build.gradle.kts index 0d71e84fc..73654719d 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -7,32 +7,32 @@ versionProjects(":platforms", version("6.4.0")) allprojects { group = "com.dfsek.terra" - + configureCompilation() configureDependencies() configurePublishing() - + tasks.withType().configureEach { options.isFork = true options.isIncremental = true } - + tasks.withType().configureEach { useJUnitPlatform() - + maxHeapSize = "2G" ignoreFailures = false failFast = true maxParallelForks = (Runtime.getRuntime().availableProcessors() - 1).takeIf { it > 0 } ?: 1 - + reports.html.required.set(false) reports.junitXml.required.set(false) } - + tasks.withType().configureEach { duplicatesStrategy = DuplicatesStrategy.EXCLUDE } - + tasks.withType().configureEach { duplicatesStrategy = DuplicatesStrategy.EXCLUDE } @@ -45,11 +45,11 @@ afterEvaluate { project(":platforms:bukkit:common").configureDistribution() forSubProjects(":common:addons") { apply(plugin = "com.github.johnrengelman.shadow") - + tasks.named("build") { finalizedBy(tasks.named("shadowJar")) } - + dependencies { "compileOnly"(project(":common:api")) "testImplementation"(project(":common:api")) diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts index 84d964d5c..eaec594a4 100644 --- a/buildSrc/build.gradle.kts +++ b/buildSrc/build.gradle.kts @@ -17,8 +17,8 @@ repositories { dependencies { //TODO Allow pulling from Versions.kt implementation("com.github.johnrengelman", "shadow", "8.1.1") - implementation("io.papermc.paperweight.userdev", "io.papermc.paperweight.userdev.gradle.plugin","1.5.6") - + implementation("io.papermc.paperweight.userdev", "io.papermc.paperweight.userdev.gradle.plugin", "1.5.6") + implementation("org.ow2.asm", "asm", "9.5") implementation("org.ow2.asm", "asm-tree", "9.5") implementation("com.dfsek.tectonic", "common", "4.2.0") diff --git a/buildSrc/src/main/kotlin/DistributionConfig.kt b/buildSrc/src/main/kotlin/DistributionConfig.kt index 59f16569b..81102bdda 100644 --- a/buildSrc/src/main/kotlin/DistributionConfig.kt +++ b/buildSrc/src/main/kotlin/DistributionConfig.kt @@ -88,7 +88,8 @@ fun Project.configureDistribution() { val jar = getJarTask().archiveFileName.get() resources.computeIfAbsent( if (extra.has("bootstrap") && extra.get("bootstrap") as Boolean) "addons/bootstrap" - else "addons") { ArrayList() }.add(jar) + else "addons" + ) { ArrayList() }.add(jar) } val options = DumperOptions() @@ -109,7 +110,7 @@ fun Project.configureDistribution() { FileWriter(manifest).use { yaml.dump(resources, it) } - + } } diff --git a/buildSrc/src/main/kotlin/Versions.kt b/buildSrc/src/main/kotlin/Versions.kt index 3e45cc7d7..18dbd85fe 100644 --- a/buildSrc/src/main/kotlin/Versions.kt +++ b/buildSrc/src/main/kotlin/Versions.kt @@ -56,7 +56,8 @@ object Versions { const val runPaper = "2.2.0" const val paperWeight = "1.5.6" } -// + + // // object Sponge { // const val sponge = "9.0.0-SNAPSHOT" // const val mixin = "0.8.2" diff --git a/common/addons/biome-provider-extrusion/src/main/resources/terra.addon.yml b/common/addons/biome-provider-extrusion/src/main/resources/terra.addon.yml index 21992a6d1..95fd480c1 100644 --- a/common/addons/biome-provider-extrusion/src/main/resources/terra.addon.yml +++ b/common/addons/biome-provider-extrusion/src/main/resources/terra.addon.yml @@ -1,14 +1,14 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: biome-provider-extrusion version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.extrusion.BiomeExtrusionAddon" + - "com.dfsek.terra.addons.biome.extrusion.BiomeExtrusionAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - biome-query-api: "1.+" \ No newline at end of file + biome-query-api: "1.+" \ No newline at end of file diff --git a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProviderAddon.java b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProviderAddon.java index ba4bce73c..9a49b4d0f 100644 --- a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProviderAddon.java +++ b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProviderAddon.java @@ -58,15 +58,19 @@ public class ImageBiomeProviderAddon implements AddonInitializer { providerRegistry.register(addon.key("IMAGE"), ImageProviderTemplate::new); }) .then(event -> { - CheckedRegistry>>> biomeColorConverterRegistry = event.getPack().getOrCreateRegistry( - BIOME_COLOR_CONVERTER_REGISTRY_KEY); + CheckedRegistry>>> biomeColorConverterRegistry = + event.getPack().getOrCreateRegistry( + BIOME_COLOR_CONVERTER_REGISTRY_KEY); biomeColorConverterRegistry.register(addon.key("EXACT"), ExactBiomeColorConverterTemplate::new); biomeColorConverterRegistry.register(addon.key("CLOSEST"), ClosestBiomeColorConverterTemplate::new); }) .then(event -> { - CheckedRegistry>>> biomeColorMappingRegistry = event.getPack().getOrCreateRegistry( - BIOME_COLOR_MAPPING_REGISTRY_KEY); - biomeColorMappingRegistry.register(addon.key("USE_BIOME_COLORS"), () -> () -> new BiomeDefinedColorMapping<>(event.getPack().getRegistry(Biome.class), b -> b)); + CheckedRegistry>>> biomeColorMappingRegistry = + event.getPack().getOrCreateRegistry( + BIOME_COLOR_MAPPING_REGISTRY_KEY); + biomeColorMappingRegistry.register(addon.key("USE_BIOME_COLORS"), + () -> () -> new BiomeDefinedColorMapping<>(event.getPack().getRegistry(Biome.class), + b -> b)); biomeColorMappingRegistry.register(addon.key("MAP"), DefinedBiomeColorMappingTemplate::new); }) .failThrough(); diff --git a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ClosestBiomeColorConverterTemplate.java b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ClosestBiomeColorConverterTemplate.java index 9c9e15869..2c9973789 100644 --- a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ClosestBiomeColorConverterTemplate.java +++ b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ClosestBiomeColorConverterTemplate.java @@ -8,7 +8,7 @@ import com.dfsek.terra.api.world.biome.Biome; public class ClosestBiomeColorConverterTemplate extends ClosestColorConverterTemplate { - + @Value("match") private ColorMapping match; diff --git a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ExactBiomeColorConverterTemplate.java b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ExactBiomeColorConverterTemplate.java index 3be64aa77..ed32a18e8 100644 --- a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ExactBiomeColorConverterTemplate.java +++ b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ExactBiomeColorConverterTemplate.java @@ -12,19 +12,19 @@ public class ExactBiomeColorConverterTemplate extends ExactColorConverterTemplat @Value("match") private ColorMapping match; - + @Value("else") private Biome fallback; @Value("ignore-alpha") @Default private boolean ignoreAlpha = true; - + @Override protected ColorMapping getMapping() { return match; } - + @Override protected Biome getFallback() { return fallback; diff --git a/common/addons/biome-provider-image-v2/src/main/resources/terra.addon.yml b/common/addons/biome-provider-image-v2/src/main/resources/terra.addon.yml index be3dd2af4..c80bb617a 100644 --- a/common/addons/biome-provider-image-v2/src/main/resources/terra.addon.yml +++ b/common/addons/biome-provider-image-v2/src/main/resources/terra.addon.yml @@ -1,14 +1,14 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: biome-provider-image-v2 version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.image.v2.ImageBiomeProviderAddon" + - "com.dfsek.terra.addons.biome.image.v2.ImageBiomeProviderAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - library-image: "1.+" + library-image: "1.+" diff --git a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java index 27ac28df4..02ff7f446 100644 --- a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java +++ b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java @@ -27,11 +27,9 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class ImageBiomeProviderAddon implements AddonInitializer { - private static final Logger logger = LoggerFactory.getLogger(ImageBiomeProviderAddon.class); - public static final TypeKey>> PROVIDER_REGISTRY_KEY = new TypeKey<>() { }; - + private static final Logger logger = LoggerFactory.getLogger(ImageBiomeProviderAddon.class); @Inject private Platform platform; @@ -51,6 +49,8 @@ public class ImageBiomeProviderAddon implements AddonInitializer { }) .failThrough(); if(platform.getTerraConfig().isDebugLog()) - logger.warn("The biome-provider-image addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the biome-provider-image-v2 addon for future pack development instead."); + logger.warn( + "The biome-provider-image addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the " + + "biome-provider-image-v2 addon for future pack development instead."); } } diff --git a/common/addons/biome-provider-image/src/main/resources/terra.addon.yml b/common/addons/biome-provider-image/src/main/resources/terra.addon.yml index 3fd86ad52..dec87cc26 100644 --- a/common/addons/biome-provider-image/src/main/resources/terra.addon.yml +++ b/common/addons/biome-provider-image/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: biome-provider-image version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.image.ImageBiomeProviderAddon" + - "com.dfsek.terra.addons.biome.image.ImageBiomeProviderAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/biome-provider-pipeline-v2/README.md b/common/addons/biome-provider-pipeline-v2/README.md index d1d216dfd..745ffa241 100644 --- a/common/addons/biome-provider-pipeline-v2/README.md +++ b/common/addons/biome-provider-pipeline-v2/README.md @@ -6,7 +6,7 @@ of "stages" to apply "mutations" to a 2D grid of biomes. Version 2 is a re-implementation of the original addon with the primary goal of providing consistent scaling for noise relative to the world (See https://github.com/PolyhedralDev/Terra/issues/264 for more details), and has been -included as a separate addon to maintain parity with packs utilizing the first version. +included as a separate addon to maintain parity with packs utilizing the first version. This addon registers the `PIPELINE` biome provider type, and all associated configurations. \ No newline at end of file diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/PipelineBiomeProvider.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/PipelineBiomeProvider.java index 08d321abd..02c7376a3 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/PipelineBiomeProvider.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/PipelineBiomeProvider.java @@ -38,7 +38,7 @@ public class PipelineBiomeProvider implements BiomeProvider { this.biomeChunkCache = Caffeine.newBuilder() .maximumSize(64) .build(pipeline::generateChunk); - + Set biomeSet = new HashSet<>(); pipeline.getSource().getBiomes().forEach(biomeSet::add); Iterable result = biomeSet; @@ -49,7 +49,7 @@ public class PipelineBiomeProvider implements BiomeProvider { Iterable finalResult = result; result.forEach(pipelineBiome -> { if(pipelineBiome.isPlaceholder()) { - + StringBuilder biomeList = new StringBuilder("\n"); StreamSupport.stream(finalResult.spliterator(), false) .sorted(Comparator.comparing(StringIdentifiable::getID)) @@ -60,7 +60,8 @@ public class PipelineBiomeProvider implements BiomeProvider { .append(delegate.getClass().getCanonicalName()) .append('\n')); throw new IllegalArgumentException("Biome Pipeline leaks placeholder biome \"" + pipelineBiome.getID() + - "\". Ensure there is a stage to guarantee replacement of the placeholder biome. Biomes: " + + "\". Ensure there is a stage to guarantee replacement of the placeholder biome. " + + "Biomes: " + biomeList); } this.biomes.add(pipelineBiome.getBiome()); @@ -73,7 +74,7 @@ public class PipelineBiomeProvider implements BiomeProvider { } public Biome getBiome(int x, int z, long seed) { - + x += mutator.noise(seed + 1, x, z) * noiseAmp; z += mutator.noise(seed + 2, x, z) * noiseAmp; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/PipelineBiome.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/PipelineBiome.java index ccde84022..aeb99f903 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/PipelineBiome.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/PipelineBiome.java @@ -7,8 +7,6 @@ import com.dfsek.terra.api.world.biome.Biome; public interface PipelineBiome extends StringIdentifiable { - Biome getBiome(); - static PipelineBiome placeholder(String id) { return new PlaceholderPipelineBiome(id); } @@ -21,6 +19,8 @@ public interface PipelineBiome extends StringIdentifiable { return SelfPipelineBiome.INSTANCE; } + Biome getBiome(); + Set getTags(); default boolean isPlaceholder() { diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/SelfPipelineBiome.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/SelfPipelineBiome.java index 80583c1cb..a962dadbe 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/SelfPipelineBiome.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/SelfPipelineBiome.java @@ -10,7 +10,7 @@ final class SelfPipelineBiome implements PipelineBiome { public static final SelfPipelineBiome INSTANCE = new SelfPipelineBiome(); private SelfPipelineBiome() { - + } @Override diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java index f9ea854a5..78e115609 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java @@ -33,24 +33,20 @@ public class BiomePipelineTemplate implements ObjectTemplate { Larger values are quadratically faster, but produce lower quality results. For example, a value of 3 would sample every 3 blocks.""") protected @Meta int resolution = 1; - - @Value("pipeline.source") - @Description("The Biome Source to use for initial population of biomes.") - private @Meta Source source; - - @Value("pipeline.stages") - @Description("A list of pipeline stages to apply to the result of #source") - private @Meta List<@Meta Stage> stages; - @Value("blend.sampler") @Default @Description("A sampler to use for blending the edges of biomes via domain warping.") protected @Meta NoiseSampler blendSampler = NoiseSampler.zero(); - @Value("blend.amplitude") @Default @Description("The amplitude at which to perform blending.") protected @Meta double blendAmplitude = 0d; + @Value("pipeline.source") + @Description("The Biome Source to use for initial population of biomes.") + private @Meta Source source; + @Value("pipeline.stages") + @Description("A list of pipeline stages to apply to the result of #source") + private @Meta List<@Meta Stage> stages; @Override public BiomeProvider get() { diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/BiomeChunkImpl.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/BiomeChunkImpl.java index df843ec4b..5635bd16a 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/BiomeChunkImpl.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/BiomeChunkImpl.java @@ -11,10 +11,10 @@ import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; public class BiomeChunkImpl implements BiomeChunk { - private PipelineBiome[][] biomes; private final SeededVector worldOrigin; private final int chunkOriginArrayIndex; private final int worldCoordinateScale; + private PipelineBiome[][] biomes; public BiomeChunkImpl(SeededVector worldOrigin, PipelineImpl pipeline) { @@ -43,7 +43,8 @@ public class BiomeChunkImpl implements BiomeChunk { for(int gridZ = 0; gridZ < gridSize; gridZ++) { int xIndex = gridOrigin + gridX * gridInterval; int zIndex = gridOrigin + gridZ * gridInterval; - biomes[xIndex][zIndex] = pipeline.getSource().get(worldOrigin.seed(), xIndexToWorldCoordinate(xIndex), zIndexToWorldCoordinate(zIndex)); + biomes[xIndex][zIndex] = pipeline.getSource().get(worldOrigin.seed(), xIndexToWorldCoordinate(xIndex), + zIndexToWorldCoordinate(zIndex)); } } @@ -79,21 +80,6 @@ public class BiomeChunkImpl implements BiomeChunk { } } - @Override - public PipelineBiome get(int xInChunk, int zInChunk) { - int xIndex = xInChunk + chunkOriginArrayIndex; - int zIndex = zInChunk + chunkOriginArrayIndex; - return biomes[xIndex][zIndex]; - } - - private int xIndexToWorldCoordinate(int xIndex) { - return (worldOrigin.x() + xIndex - chunkOriginArrayIndex) * worldCoordinateScale; - } - - private int zIndexToWorldCoordinate(int zIndex) { - return (worldOrigin.z() + zIndex - chunkOriginArrayIndex) * worldCoordinateScale; - } - protected static int initialSizeToArraySize(int expanderCount, int initialSize) { int size = initialSize; for(int i = 0; i < expanderCount; i++) { @@ -117,8 +103,8 @@ public class BiomeChunkImpl implements BiomeChunk { int gridOrigin = 0; int expansionsApplied = 0; int gridInterval = calculateGridInterval(totalExpanderCount, expansionsApplied); - for (Stage stage : stages) { - if (stage instanceof Expander) { + for(Stage stage : stages) { + if(stage instanceof Expander) { expansionsApplied++; gridInterval = calculateGridInterval(totalExpanderCount, expansionsApplied); } @@ -143,6 +129,21 @@ public class BiomeChunkImpl implements BiomeChunk { return 1 << (totalExpansions - expansionsApplied); } + @Override + public PipelineBiome get(int xInChunk, int zInChunk) { + int xIndex = xInChunk + chunkOriginArrayIndex; + int zIndex = zInChunk + chunkOriginArrayIndex; + return biomes[xIndex][zIndex]; + } + + private int xIndexToWorldCoordinate(int xIndex) { + return (worldOrigin.x() + xIndex - chunkOriginArrayIndex) * worldCoordinateScale; + } + + private int zIndexToWorldCoordinate(int zIndex) { + return (worldOrigin.z() + zIndex - chunkOriginArrayIndex) * worldCoordinateScale; + } + private SeededVector getOrigin() { return worldOrigin; } @@ -160,7 +161,8 @@ public class BiomeChunkImpl implements BiomeChunk { private final int zIndex; private final PipelineBiome[][] lookupArray; - private ViewPoint(BiomeChunkImpl chunk, int gridInterval, int gridX, int gridZ, int xIndex, int zIndex, PipelineBiome[][] lookupArray) { + private ViewPoint(BiomeChunkImpl chunk, int gridInterval, int gridX, int gridZ, int xIndex, int zIndex, + PipelineBiome[][] lookupArray) { this.chunk = chunk; this.gridInterval = gridInterval; this.gridX = gridX; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/PipelineImpl.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/PipelineImpl.java index a01091d2e..a9be64bf3 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/PipelineImpl.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/PipelineImpl.java @@ -36,18 +36,18 @@ public class PipelineImpl implements Pipeline { int chunkOriginArrayIndex; int chunkSize; int initialSize = 1; - while (true) { + while(true) { arraySize = BiomeChunkImpl.initialSizeToArraySize(expanderCount, initialSize); chunkOriginArrayIndex = BiomeChunkImpl.calculateChunkOriginArrayIndex(expanderCount, stages); chunkSize = BiomeChunkImpl.calculateChunkSize(arraySize, chunkOriginArrayIndex, expanderCount); - if (chunkSize > 1 && arraySize >= idealChunkArraySize) break; + if(chunkSize > 1 && arraySize >= idealChunkArraySize) break; initialSize++; } this.arraySize = arraySize; this.chunkOriginArrayIndex = chunkOriginArrayIndex; this.chunkSize = chunkSize; - + logger.debug("Initialized a new biome pipeline:"); logger.debug("Array size: {} (Target: {})", arraySize, idealChunkArraySize); logger.debug("Internal array origin: {}", chunkOriginArrayIndex); diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/expander/FractalExpander.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/expander/FractalExpander.java index c82743ba4..c4040d8b4 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/expander/FractalExpander.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/expander/FractalExpander.java @@ -16,21 +16,21 @@ public class FractalExpander implements Expander { @Override public PipelineBiome fillBiome(BiomeChunkImpl.ViewPoint viewPoint) { - + int xMod2 = viewPoint.gridX() % 2; int zMod2 = viewPoint.gridZ() % 2; double roll = sampler.noise(viewPoint.worldSeed(), viewPoint.worldX(), viewPoint.worldZ()); - if (xMod2 == 1 && zMod2 == 0) { // Pick one of 2 neighbors on X axis randomly + if(xMod2 == 1 && zMod2 == 0) { // Pick one of 2 neighbors on X axis randomly return roll > 0 ? viewPoint.getRelativeBiome(-1, 0) : viewPoint.getRelativeBiome(1, 0); - } else if (xMod2 == 0 && zMod2 == 1) { // Pick one of 2 neighbors on Z axis randomly + } else if(xMod2 == 0 && zMod2 == 1) { // Pick one of 2 neighbors on Z axis randomly return roll > 0 ? viewPoint.getRelativeBiome(0, -1) : viewPoint.getRelativeBiome(0, 1); } else { // Pick one of 4 corners randomly return roll > 0 ? - roll > 0.25 ? viewPoint.getRelativeBiome(-1, 1) : viewPoint.getRelativeBiome(1, 1) : + roll > 0.25 ? viewPoint.getRelativeBiome(-1, 1) : viewPoint.getRelativeBiome(1, 1) : roll > -0.25 ? viewPoint.getRelativeBiome(-1, -1) : viewPoint.getRelativeBiome(1, -1); } } diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderListStage.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderListStage.java index 340ff155a..1483816b5 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderListStage.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderListStage.java @@ -38,7 +38,7 @@ public class BorderListStage implements Stage { this.replaceDefault = replaceDefault; this.defaultReplace = defaultReplace; this.replace = replace; - + List points = new ArrayList<>(); for(int x = -1; x <= 1; x++) { for(int z = -1; z <= 1; z++) { @@ -68,10 +68,11 @@ public class BorderListStage implements Stage { if(current != null && current.getTags().contains(border)) { if(replace.containsKey(center)) { PipelineBiome replacement = replace.get(center).get(noiseSampler, viewPoint.worldX(), viewPoint.worldZ(), - viewPoint.worldSeed()); + viewPoint.worldSeed()); return replacement.isSelf() ? center : replacement; } - PipelineBiome replacement = replaceDefault.get(noiseSampler, viewPoint.worldX(), viewPoint.worldZ(), viewPoint.worldSeed()); + PipelineBiome replacement = replaceDefault.get(noiseSampler, viewPoint.worldX(), viewPoint.worldZ(), + viewPoint.worldSeed()); return replacement.isSelf() ? center : replacement; } } diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/SmoothStage.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/SmoothStage.java index 20b664539..fb40f86df 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/SmoothStage.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/SmoothStage.java @@ -34,7 +34,7 @@ public class SmoothStage implements Stage { boolean vert = Objects.equals(top, bottom); boolean horiz = Objects.equals(left, right); - + if(vert && horiz) { return roll > 0 ? roll > 0.25 ? left : right : diff --git a/common/addons/biome-provider-pipeline-v2/src/main/resources/terra.addon.yml b/common/addons/biome-provider-pipeline-v2/src/main/resources/terra.addon.yml index f800574ca..c9b711ce5 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/resources/terra.addon.yml +++ b/common/addons/biome-provider-pipeline-v2/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: biome-provider-pipeline-v2 version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.pipeline.v2.BiomePipelineAddon" + - "com.dfsek.terra.addons.biome.pipeline.v2.BiomePipelineAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java index a4016a51a..ba91c8f9e 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java @@ -41,15 +41,13 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class BiomePipelineAddon implements AddonInitializer { - private static final Logger logger = LoggerFactory.getLogger(BiomePipelineAddon.class); - public static final TypeKey>> SOURCE_REGISTRY_KEY = new TypeKey<>() { }; - public static final TypeKey>> STAGE_REGISTRY_KEY = new TypeKey<>() { }; public static final TypeKey>> PROVIDER_REGISTRY_KEY = new TypeKey<>() { }; + private static final Logger logger = LoggerFactory.getLogger(BiomePipelineAddon.class); @Inject private Platform platform; @@ -91,6 +89,8 @@ public class BiomePipelineAddon implements AddonInitializer { }); if(platform.getTerraConfig().isDebugLog()) - logger.warn("The biome-provider-pipeline addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the biome-provider-pipeline-v2 addon for future pack development instead."); + logger.warn( + "The biome-provider-pipeline addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the" + + " biome-provider-pipeline-v2 addon for future pack development instead."); } } diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java index d4dd96264..7f4287e70 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java @@ -80,11 +80,11 @@ public class BiomePipelineProvider implements BiomeProvider { public Biome getBiome(int x, int z, long seed) { x += mutator.noise(seed + 1, x, z) * noiseAmp; z += mutator.noise(seed + 2, x, z) * noiseAmp; - - + + x /= resolution; z /= resolution; - + int fdX = Math.floorDiv(x, pipeline.getSize()); int fdZ = Math.floorDiv(z, pipeline.getSize()); return holderCache.get(new SeededVector(fdX, fdZ, seed)).getBiome(x - fdX * pipeline.getSize(), @@ -119,7 +119,7 @@ public class BiomePipelineProvider implements BiomeProvider { } return false; } - + @Override public int hashCode() { int code = x; diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/SelfDelegate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/SelfDelegate.java index 60b744059..ad6a4a721 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/SelfDelegate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/SelfDelegate.java @@ -10,7 +10,7 @@ final class SelfDelegate implements BiomeDelegate { public static final SelfDelegate INSTANCE = new SelfDelegate(); private SelfDelegate() { - + } @Override diff --git a/common/addons/biome-provider-pipeline/src/main/resources/terra.addon.yml b/common/addons/biome-provider-pipeline/src/main/resources/terra.addon.yml index abd2555a5..f43908cac 100644 --- a/common/addons/biome-provider-pipeline/src/main/resources/terra.addon.yml +++ b/common/addons/biome-provider-pipeline/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: biome-provider-pipeline version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.pipeline.BiomePipelineAddon" + - "com.dfsek.terra.addons.biome.pipeline.BiomePipelineAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/biome-provider-single/src/main/resources/terra.addon.yml b/common/addons/biome-provider-single/src/main/resources/terra.addon.yml index d986179f3..c7e91131c 100644 --- a/common/addons/biome-provider-single/src/main/resources/terra.addon.yml +++ b/common/addons/biome-provider-single/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: biome-provider-single version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.single.SingleBiomeProviderAddon" + - "com.dfsek.terra.addons.biome.single.SingleBiomeProviderAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/BiomeQueryAPIAddon.java b/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/BiomeQueryAPIAddon.java index 9def4378b..9933ea49e 100644 --- a/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/BiomeQueryAPIAddon.java +++ b/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/BiomeQueryAPIAddon.java @@ -33,12 +33,12 @@ public class BiomeQueryAPIAddon implements AddonInitializer { .getPack() .getRegistry(Biome.class) .entries(); - + BiomeTagFlattener flattener = new BiomeTagFlattener(biomes .stream() .flatMap(biome -> biome.getTags().stream()) .toList()); - + biomes.forEach(biome -> biome.getContext().put(BIOME_TAG_KEY, new BiomeTagHolder(biome, flattener))); }) .global(); diff --git a/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/api/BiomeQueries.java b/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/api/BiomeQueries.java index dbee2752b..6e36b7a45 100644 --- a/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/api/BiomeQueries.java +++ b/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/api/BiomeQueries.java @@ -8,7 +8,7 @@ import com.dfsek.terra.api.world.biome.Biome; public final class BiomeQueries { private BiomeQueries() { - + } public static Predicate has(String tag) { diff --git a/common/addons/biome-query-api/src/main/resources/terra.addon.yml b/common/addons/biome-query-api/src/main/resources/terra.addon.yml index 8a55ce2dc..1030c3e4c 100644 --- a/common/addons/biome-query-api/src/main/resources/terra.addon.yml +++ b/common/addons/biome-query-api/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: biome-query-api version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.query.BiomeQueryAPIAddon" + - "com.dfsek.terra.addons.biome.query.BiomeQueryAPIAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/NoiseChunkGenerator3DAddon.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/NoiseChunkGenerator3DAddon.java index fed22e1c9..69fa4be73 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/NoiseChunkGenerator3DAddon.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/NoiseChunkGenerator3DAddon.java @@ -47,7 +47,7 @@ public class NoiseChunkGenerator3DAddon implements AddonInitializer { event.getPack().applyLoader(SlantHolder.CalculationMethod.class, (type, o, loader, depthTracker) -> SlantHolder.CalculationMethod.valueOf((String) o)); - + NoiseChunkGeneratorPackConfigTemplate config = event.loadTemplate(new NoiseChunkGeneratorPackConfigTemplate()); event.getPack().getContext().put(config); @@ -68,10 +68,13 @@ public class NoiseChunkGenerator3DAddon implements AddonInitializer { .register(addon, ConfigurationLoadEvent.class) .then(event -> { if(event.is(Biome.class)) { - NoiseChunkGeneratorPackConfigTemplate config = event.getPack().getContext().get(NoiseChunkGeneratorPackConfigTemplate.class); + NoiseChunkGeneratorPackConfigTemplate config = event.getPack().getContext().get( + NoiseChunkGeneratorPackConfigTemplate.class); event.getLoadedObject(Biome.class).getContext().put(paletteInfoPropertyKey, - event.load(new BiomePaletteTemplate(platform, config.getSlantCalculationMethod())).get()); + event.load(new BiomePaletteTemplate(platform, + config.getSlantCalculationMethod())) + .get()); event.getLoadedObject(Biome.class).getContext().put(noisePropertiesPropertyKey, event.load(new BiomeNoiseConfigTemplate()).get()); } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/noise/ThreadLocalNoiseHolder.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/noise/ThreadLocalNoiseHolder.java index 454f9492f..fbb9deed8 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/noise/ThreadLocalNoiseHolder.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/noise/ThreadLocalNoiseHolder.java @@ -12,7 +12,7 @@ public class ThreadLocalNoiseHolder { if(holder.init && holder.y == y && holder.z == z && holder.x == x && holder.seed == seed) { return holder.noise; } - + double noise = sampler.noise(seed, x, y, z); holder.noise = noise; holder.x = x; diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java index 0bb19e962..a80311ad1 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java @@ -27,26 +27,22 @@ import com.dfsek.terra.api.world.chunk.generation.util.Palette; public class BiomePaletteTemplate implements ObjectTemplate { private final Platform platform; - + private final SlantHolder.CalculationMethod slantCalculationMethod; @Value("slant") @Default @Description("The slant palettes to use in this biome.") private @Meta List slantLayers = Collections.emptyList(); - @Value("slant-depth") @Default @Description("The maximum depth at which to apply a slant palette.") private @Meta int slantDepth = Integer.MAX_VALUE; - @Value("palette") @Description("The palettes to use in this biome.") private @Meta List<@Meta Map<@Meta Palette, @Meta Integer>> palettes; - @Value("ocean.level") @Description("Sea level in this biome. Defaults to zero") @Default private @Meta int seaLevel = 0; - @Value("ocean.palette") @Description("The palette to use for the ocean in this biome. Defaults to a blank palette.") @Default @@ -56,13 +52,10 @@ public class BiomePaletteTemplate implements ObjectTemplate { return platform.getWorldHandle().air(); } }; - @Value("carving.update-palette") @Default private @Meta boolean updatePalette = false; - private final SlantHolder.CalculationMethod slantCalculationMethod; - public BiomePaletteTemplate(Platform platform, SlantHolder.CalculationMethod slantCalculationMethod) { this.platform = platform; this.slantCalculationMethod = slantCalculationMethod; diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java index d846ac53f..792d16729 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java @@ -145,7 +145,7 @@ public class ChunkInterpolator { */ public double getNoise(double x, double y, double z) { return interpGrid[reRange(((int) x) / 4, 3)][(Math.max(Math.min(((int) y), max), min) - min) / 4][reRange(((int) z) / 4, - 3)].trilerp( + 3)].trilerp( (x % 4) / 4, (y % 4) / 4, (z % 4) / 4); } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java index 327d6fe47..91318b0b4 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java @@ -24,15 +24,6 @@ public class PaletteHolder { this.offset = offset; } - public Palette getPalette(int y) { - int index = y + offset; - return index >= 0 - ? index < palettes.length - ? palettes[index] - : palettes[palettes.length - 1] - : palettes[0]; - } - public static PaletteHolder of(List> palettes) { PaletteHolderBuilder builder = new PaletteHolderBuilder(); for(Map layer : palettes) { @@ -43,6 +34,16 @@ public class PaletteHolder { return builder.build(); } + public Palette getPalette(int y) { + int index = y + offset; + return index >= 0 + ? index < palettes.length + ? palettes[index] + : palettes[palettes.length - 1] + : palettes[0]; + } + + private static class PaletteHolderBuilder { private final TreeMap paletteMap = new TreeMap<>(); diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/MultipleSlantHolder.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/MultipleSlantHolder.java index 6f04a2df7..fec070ea7 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/MultipleSlantHolder.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/MultipleSlantHolder.java @@ -23,7 +23,8 @@ public class MultipleSlantHolder extends SlantHolderImpl { MultipleSlantHolder(List slant, int slantDepth, CalculationMethod calculationMethod) { super(slantDepth, calculationMethod); - NavigableMap layers = new TreeMap<>(slant.stream().collect(Collectors.toMap(SlantHolder.Layer::threshold, SlantHolder.Layer::palette))); + NavigableMap layers = new TreeMap<>( + slant.stream().collect(Collectors.toMap(SlantHolder.Layer::threshold, SlantHolder.Layer::palette))); Stream thresholds = layers.keySet().stream(); double slantThreshold = floorToThreshold ? thresholds.min(Double::compare).orElseThrow() : diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolder.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolder.java index e70670977..7e084d1ff 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolder.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolder.java @@ -9,89 +9,6 @@ import com.dfsek.terra.api.util.vector.Vector3; public interface SlantHolder { - static SlantHolder of(List layers, int slantDepth, CalculationMethod calculationMethod) { - if(layers.isEmpty()) { - return EMPTY; - } else if(layers.size() == 1) { - return new SingleSlantHolder(layers.get(0), slantDepth, calculationMethod); - } - return new MultipleSlantHolder(layers, slantDepth, calculationMethod); - } - - double calculateSlant(Sampler3D sampler, double x, double y, double z); - - boolean isAboveDepth(int depth); - - boolean isInSlantThreshold(double slant); - - PaletteHolder getPalette(double slant); - - record Layer(PaletteHolder palette, double threshold) { - } - - enum CalculationMethod { - DotProduct { - private static final Vector3 DOT_PRODUCT_DIRECTION = Vector3.of(0, 1, 0); - - private static final Vector3[] DOT_PRODUCT_SAMPLE_POINTS = { - Vector3.of(0, 0, -DERIVATIVE_DIST), - Vector3.of(0, 0, DERIVATIVE_DIST), - Vector3.of(0, -DERIVATIVE_DIST, 0), - Vector3.of(0, DERIVATIVE_DIST, 0), - Vector3.of(-DERIVATIVE_DIST, 0, 0), - Vector3.of(DERIVATIVE_DIST, 0, 0) - }; - - @Override - public double slant(Sampler3D sampler, double x, double y, double z) { - Vector3.Mutable normalApproximation = Vector3.Mutable.of(0, 0, 0); - for(Vector3 point : DOT_PRODUCT_SAMPLE_POINTS) { - var scalar = -sampler.sample(x+point.getX(), y+point.getY(), z+point.getZ()); - normalApproximation.add(point.mutable().multiply(scalar)); - } - return DOT_PRODUCT_DIRECTION.dot(normalApproximation.normalize()); - } - - @Override - public boolean floorToThreshold() { - return false; - } - }, - - Derivative { - @Override - public double slant(Sampler3D sampler, double x, double y, double z) { - double baseSample = sampler.sample(x, y, z); - - double xVal1 = (sampler.sample(x + DERIVATIVE_DIST, y, z) - baseSample) / DERIVATIVE_DIST; - double xVal2 = (sampler.sample(x - DERIVATIVE_DIST, y, z) - baseSample) / DERIVATIVE_DIST; - double zVal1 = (sampler.sample(x, y, z + DERIVATIVE_DIST) - baseSample) / DERIVATIVE_DIST; - double zVal2 = (sampler.sample(x, y, z - DERIVATIVE_DIST) - baseSample) / DERIVATIVE_DIST; - double yVal1 = (sampler.sample(x, y + DERIVATIVE_DIST, z) - baseSample) / DERIVATIVE_DIST; - double yVal2 = (sampler.sample(x, y - DERIVATIVE_DIST, z) - baseSample) / DERIVATIVE_DIST; - - return Math.sqrt(((xVal2 - xVal1) * (xVal2 - xVal1)) + ((zVal2 - zVal1) * (zVal2 - zVal1)) + ((yVal2 - yVal1) * (yVal2 - yVal1))); - } - - @Override - public boolean floorToThreshold() { - return true; - } - }; - - private static final double DERIVATIVE_DIST = 0.55; - - public abstract double slant(Sampler3D sampler, double x, double y, double z); - - /* - * Controls whether palettes should be applied before or after their respective thresholds. - * - * If true, slant values will map to the palette of the next floor threshold, otherwise they - * will map to the ceiling. - */ - public abstract boolean floorToThreshold(); - } - SlantHolder EMPTY = new SlantHolder() { @Override public double calculateSlant(Sampler3D sampler, double x, double y, double z) { @@ -113,4 +30,90 @@ public interface SlantHolder { throw new UnsupportedOperationException("Empty holder cannot return a palette"); } }; + + static SlantHolder of(List layers, int slantDepth, CalculationMethod calculationMethod) { + if(layers.isEmpty()) { + return EMPTY; + } else if(layers.size() == 1) { + return new SingleSlantHolder(layers.get(0), slantDepth, calculationMethod); + } + return new MultipleSlantHolder(layers, slantDepth, calculationMethod); + } + + double calculateSlant(Sampler3D sampler, double x, double y, double z); + + boolean isAboveDepth(int depth); + + boolean isInSlantThreshold(double slant); + + PaletteHolder getPalette(double slant); + + + enum CalculationMethod { + DotProduct { + private static final Vector3 DOT_PRODUCT_DIRECTION = Vector3.of(0, 1, 0); + + private static final Vector3[] DOT_PRODUCT_SAMPLE_POINTS = { + Vector3.of(0, 0, -DERIVATIVE_DIST), + Vector3.of(0, 0, DERIVATIVE_DIST), + Vector3.of(0, -DERIVATIVE_DIST, 0), + Vector3.of(0, DERIVATIVE_DIST, 0), + Vector3.of(-DERIVATIVE_DIST, 0, 0), + Vector3.of(DERIVATIVE_DIST, 0, 0) + }; + + @Override + public double slant(Sampler3D sampler, double x, double y, double z) { + Vector3.Mutable normalApproximation = Vector3.Mutable.of(0, 0, 0); + for(Vector3 point : DOT_PRODUCT_SAMPLE_POINTS) { + var scalar = -sampler.sample(x + point.getX(), y + point.getY(), z + point.getZ()); + normalApproximation.add(point.mutable().multiply(scalar)); + } + return DOT_PRODUCT_DIRECTION.dot(normalApproximation.normalize()); + } + + @Override + public boolean floorToThreshold() { + return false; + } + }, + + Derivative { + @Override + public double slant(Sampler3D sampler, double x, double y, double z) { + double baseSample = sampler.sample(x, y, z); + + double xVal1 = (sampler.sample(x + DERIVATIVE_DIST, y, z) - baseSample) / DERIVATIVE_DIST; + double xVal2 = (sampler.sample(x - DERIVATIVE_DIST, y, z) - baseSample) / DERIVATIVE_DIST; + double zVal1 = (sampler.sample(x, y, z + DERIVATIVE_DIST) - baseSample) / DERIVATIVE_DIST; + double zVal2 = (sampler.sample(x, y, z - DERIVATIVE_DIST) - baseSample) / DERIVATIVE_DIST; + double yVal1 = (sampler.sample(x, y + DERIVATIVE_DIST, z) - baseSample) / DERIVATIVE_DIST; + double yVal2 = (sampler.sample(x, y - DERIVATIVE_DIST, z) - baseSample) / DERIVATIVE_DIST; + + return Math.sqrt( + ((xVal2 - xVal1) * (xVal2 - xVal1)) + ((zVal2 - zVal1) * (zVal2 - zVal1)) + ((yVal2 - yVal1) * (yVal2 - yVal1))); + } + + @Override + public boolean floorToThreshold() { + return true; + } + }; + + private static final double DERIVATIVE_DIST = 0.55; + + public abstract double slant(Sampler3D sampler, double x, double y, double z); + + /* + * Controls whether palettes should be applied before or after their respective thresholds. + * + * If true, slant values will map to the palette of the next floor threshold, otherwise they + * will map to the ceiling. + */ + public abstract boolean floorToThreshold(); + } + + + record Layer(PaletteHolder palette, double threshold) { + } } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolderImpl.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolderImpl.java index e7261b88e..73fabd6ae 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolderImpl.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolderImpl.java @@ -4,11 +4,9 @@ import com.dfsek.terra.addons.chunkgenerator.generation.math.samplers.Sampler3D; public abstract class SlantHolderImpl implements SlantHolder { - private final SlantHolder.CalculationMethod calculationMethod; - - private final int slantDepth; - protected final boolean floorToThreshold; + private final SlantHolder.CalculationMethod calculationMethod; + private final int slantDepth; protected SlantHolderImpl(int slantDepth, CalculationMethod calculationMethod) { this.floorToThreshold = calculationMethod.floorToThreshold(); diff --git a/common/addons/chunk-generator-noise-3d/src/main/resources/terra.addon.yml b/common/addons/chunk-generator-noise-3d/src/main/resources/terra.addon.yml index 76eed7bb9..6d32e2bf8 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/resources/terra.addon.yml +++ b/common/addons/chunk-generator-noise-3d/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: chunk-generator-noise-3d version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.chunkgenerator.NoiseChunkGenerator3DAddon" + - "com.dfsek.terra.addons.chunkgenerator.NoiseChunkGenerator3DAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/command-addons/src/main/java/com/dfsek/terra/addons/commands/addons/AddonsCommandAddon.java b/common/addons/command-addons/src/main/java/com/dfsek/terra/addons/commands/addons/AddonsCommandAddon.java index 289ed09e9..2bc66a2d3 100644 --- a/common/addons/command-addons/src/main/java/com/dfsek/terra/addons/commands/addons/AddonsCommandAddon.java +++ b/common/addons/command-addons/src/main/java/com/dfsek/terra/addons/commands/addons/AddonsCommandAddon.java @@ -28,7 +28,7 @@ public class AddonsCommandAddon implements AddonInitializer { .register(addon, CommandRegistrationEvent.class) .then(event -> { CommandManager manager = event.getCommandManager(); - + manager.command( manager.commandBuilder("addons", ArgumentDescription.of("List installed Terra addons")) .permission("terra.addons") @@ -51,9 +51,9 @@ public class AddonsCommandAddon implements AddonInitializer { .handler(context -> { BaseAddon addon = context.get("addon"); StringBuilder addonInfo = new StringBuilder("Addon ").append(addon.getID()).append('\n'); - + addonInfo.append("Version: ").append(addon.getVersion().getFormatted()).append('\n'); - + addonInfo.append("Dependencies:\n"); addon.getDependencies().forEach((id, versions) -> addonInfo .append(" - ") diff --git a/common/addons/command-addons/src/main/resources/terra.addon.yml b/common/addons/command-addons/src/main/resources/terra.addon.yml index 87f5b5454..086ee161d 100644 --- a/common/addons/command-addons/src/main/resources/terra.addon.yml +++ b/common/addons/command-addons/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: command-addons version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.commands.addons.AddonsCommandAddon" + - "com.dfsek.terra.addons.commands.addons.AddonsCommandAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/command-packs/src/main/java/com/dfsek/terra/addons/commands/packs/PacksCommandAddon.java b/common/addons/command-packs/src/main/java/com/dfsek/terra/addons/commands/packs/PacksCommandAddon.java index 7a5326552..2bc9abdeb 100644 --- a/common/addons/command-packs/src/main/java/com/dfsek/terra/addons/commands/packs/PacksCommandAddon.java +++ b/common/addons/command-packs/src/main/java/com/dfsek/terra/addons/commands/packs/PacksCommandAddon.java @@ -33,7 +33,7 @@ public class PacksCommandAddon implements AddonInitializer { .register(addon, CommandRegistrationEvent.class) .then(event -> { CommandManager manager = event.getCommandManager(); - + manager.command( manager.commandBuilder("packs", ArgumentDescription.of("List installed config packs")) .permission("terra.packs") @@ -54,10 +54,10 @@ public class PacksCommandAddon implements AddonInitializer { .handler(context -> { ConfigPack pack = context.get("pack"); StringBuilder packInfo = new StringBuilder("Pack ").append(pack.getID()).append('\n'); - + packInfo.append("Version: ").append(pack.getVersion().getFormatted()).append('\n'); packInfo.append("Author: ").append(pack.getAuthor()).append('\n'); - + packInfo.append("Addon Dependencies:\n"); pack.addons().forEach((id, versions) -> packInfo .append(" - ") diff --git a/common/addons/command-packs/src/main/resources/terra.addon.yml b/common/addons/command-packs/src/main/resources/terra.addon.yml index 4efeb9c99..007e28244 100644 --- a/common/addons/command-packs/src/main/resources/terra.addon.yml +++ b/common/addons/command-packs/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: command-packs version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.commands.packs.PacksCommandAddon" + - "com.dfsek.terra.addons.commands.packs.PacksCommandAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/command-profiler/src/main/resources/terra.addon.yml b/common/addons/command-profiler/src/main/resources/terra.addon.yml index 3ce8d72ab..17f5f4b8a 100644 --- a/common/addons/command-profiler/src/main/resources/terra.addon.yml +++ b/common/addons/command-profiler/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: command-profiler version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.commands.profiler.ProfilerCommandAddon" + - "com.dfsek.terra.addons.commands.profiler.ProfilerCommandAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/command-structures/src/main/java/com/dfsek/terra/addons/commands/structure/StructureCommandAddon.java b/common/addons/command-structures/src/main/java/com/dfsek/terra/addons/commands/structure/StructureCommandAddon.java index ce98abfce..37bab2508 100644 --- a/common/addons/command-structures/src/main/java/com/dfsek/terra/addons/commands/structure/StructureCommandAddon.java +++ b/common/addons/command-structures/src/main/java/com/dfsek/terra/addons/commands/structure/StructureCommandAddon.java @@ -41,7 +41,7 @@ public class StructureCommandAddon implements AddonInitializer { .register(addon, CommandRegistrationEvent.class) .then(event -> { CommandManager manager = event.getCommandManager(); - + manager.command( manager.commandBuilder("structures", ArgumentDescription.of("Manage or generate structures")) .literal("generate") diff --git a/common/addons/command-structures/src/main/resources/terra.addon.yml b/common/addons/command-structures/src/main/resources/terra.addon.yml index c41fc088e..dc4804af9 100644 --- a/common/addons/command-structures/src/main/resources/terra.addon.yml +++ b/common/addons/command-structures/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: command-structures version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.commands.structure.StructureCommandAddon" + - "com.dfsek.terra.addons.commands.structure.StructureCommandAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/config-biome/src/main/resources/terra.addon.yml b/common/addons/config-biome/src/main/resources/terra.addon.yml index f669208b1..dd6eb93bc 100644 --- a/common/addons/config-biome/src/main/resources/terra.addon.yml +++ b/common/addons/config-biome/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-biome version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.BiomeAddon" + - "com.dfsek.terra.addons.biome.BiomeAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/DistributorAddon.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/DistributorAddon.java index 714f44f1a..4b0423d9a 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/DistributorAddon.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/DistributorAddon.java @@ -50,7 +50,7 @@ public class DistributorAddon implements AddonInitializer { CheckedRegistry>> distributorRegistry = event .getPack() .getOrCreateRegistry(DISTRIBUTOR_TOKEN); - + distributorRegistry.register(addon.key("SAMPLER"), SamplerDistributorTemplate::new); distributorRegistry.register(addon.key("POINTS"), PointSetDistributorTemplate::new); distributorRegistry.register(addon.key("PADDED_GRID"), PaddedGridDistributorTemplate::new); @@ -59,7 +59,7 @@ public class DistributorAddon implements AddonInitializer { distributorRegistry.register(addon.key("XOR"), XorDistributorTemplate::new); distributorRegistry.register(addon.key("YES"), YesDistributorTemplate::new); distributorRegistry.register(addon.key("NO"), NoDistributorTemplate::new); - + event.getPack() .applyLoader(Point.class, PointTemplate::new); }) diff --git a/common/addons/config-distributors/src/main/resources/terra.addon.yml b/common/addons/config-distributors/src/main/resources/terra.addon.yml index 6e4c98a4a..4f35aa3ca 100644 --- a/common/addons/config-distributors/src/main/resources/terra.addon.yml +++ b/common/addons/config-distributors/src/main/resources/terra.addon.yml @@ -1,15 +1,15 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-distributors version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.feature.distributor.DistributorAddon" + - "com.dfsek.terra.addons.feature.distributor.DistributorAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - config-feature: "1.+" - generation-stage-feature: "1.+" \ No newline at end of file + config-feature: "1.+" + generation-stage-feature: "1.+" \ No newline at end of file diff --git a/common/addons/config-feature/src/main/resources/terra.addon.yml b/common/addons/config-feature/src/main/resources/terra.addon.yml index cb17b4b76..18656aa8c 100644 --- a/common/addons/config-feature/src/main/resources/terra.addon.yml +++ b/common/addons/config-feature/src/main/resources/terra.addon.yml @@ -1,14 +1,14 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-feature version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.feature.FeatureAddon" + - "com.dfsek.terra.addons.feature.FeatureAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - generation-stage-feature: "1.+" \ No newline at end of file + generation-stage-feature: "1.+" \ No newline at end of file diff --git a/common/addons/config-flora/src/main/resources/terra.addon.yml b/common/addons/config-flora/src/main/resources/terra.addon.yml index b464bed94..0ec6e92f1 100644 --- a/common/addons/config-flora/src/main/resources/terra.addon.yml +++ b/common/addons/config-flora/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-flora version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.flora.FloraAddon" + - "com.dfsek.terra.addons.flora.FloraAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/LocatorAddon.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/LocatorAddon.java index 4157d4027..2a08155cc 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/LocatorAddon.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/LocatorAddon.java @@ -63,16 +63,16 @@ public class LocatorAddon implements AddonInitializer { CheckedRegistry>> locatorRegistry = event.getPack().getOrCreateRegistry(LOCATOR_TOKEN); locatorRegistry.register(addon.key("SURFACE"), SurfaceLocatorTemplate::new); locatorRegistry.register(addon.key("TOP"), TopLocatorTemplate::new); - + locatorRegistry.register(addon.key("RANDOM"), RandomLocatorTemplate::new); locatorRegistry.register(addon.key("GAUSSIAN_RANDOM"), GaussianRandomLocatorTemplate::new); - + locatorRegistry.register(addon.key("PATTERN"), PatternLocatorTemplate::new); locatorRegistry.register(addon.key("ADJACENT_PATTERN"), AdjacentPatternLocatorTemplate::new); - + locatorRegistry.register(addon.key("SAMPLER"), SamplerLocatorTemplate::new); locatorRegistry.register(addon.key("SAMPLER_3D"), Sampler3DLocatorTemplate::new); - + locatorRegistry.register(addon.key("AND"), AndLocatorTemplate::new); locatorRegistry.register(addon.key("OR"), OrLocatorTemplate::new); locatorRegistry.register(addon.key("XOR"), XorLocatorTemplate::new); @@ -83,7 +83,7 @@ public class LocatorAddon implements AddonInitializer { patternRegistry.register(addon.key("MATCH_SOLID"), SolidMatchPatternTemplate::new); patternRegistry.register(addon.key("MATCH"), SingleBlockMatchPatternTemplate::new); patternRegistry.register(addon.key("MATCH_SET"), BlockSetMatchPatternTemplate::new); - + patternRegistry.register(addon.key("AND"), AndPatternTemplate::new); patternRegistry.register(addon.key("OR"), OrPatternTemplate::new); patternRegistry.register(addon.key("XOR"), XorPatternTemplate::new); diff --git a/common/addons/config-locators/src/main/resources/terra.addon.yml b/common/addons/config-locators/src/main/resources/terra.addon.yml index e84bf800d..7e4482e55 100644 --- a/common/addons/config-locators/src/main/resources/terra.addon.yml +++ b/common/addons/config-locators/src/main/resources/terra.addon.yml @@ -1,15 +1,15 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-locators version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.feature.locator.LocatorAddon" + - "com.dfsek.terra.addons.feature.locator.LocatorAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - config-feature: "1.+" - generation-stage-feature: "1.+" \ No newline at end of file + config-feature: "1.+" + generation-stage-feature: "1.+" \ No newline at end of file diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java index ec5b4a675..1b3cb6409 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java @@ -95,7 +95,7 @@ public class NoiseAddon implements AddonInitializer { .applyLoader(DimensionApplicableNoiseSampler.class, DimensionApplicableNoiseSampler::new) .applyLoader(FunctionTemplate.class, FunctionTemplate::new) .applyLoader(CubicSpline.Point.class, CubicSplinePointTemplate::new); - + noiseRegistry.register(addon.key("LINEAR"), LinearNormalizerTemplate::new); noiseRegistry.register(addon.key("NORMAL"), NormalNormalizerTemplate::new); noiseRegistry.register(addon.key("CLAMP"), ClampNormalizerTemplate::new); @@ -103,53 +103,54 @@ public class NoiseAddon implements AddonInitializer { noiseRegistry.register(addon.key("SCALE"), ScaleNormalizerTemplate::new); noiseRegistry.register(addon.key("POSTERIZATION"), PosterizationNormalizerTemplate::new); noiseRegistry.register(addon.key("CUBIC_SPLINE"), CubicSplineNormalizerTemplate::new); - + noiseRegistry.register(addon.key("IMAGE"), ImageSamplerTemplate::new); - + noiseRegistry.register(addon.key("DOMAIN_WARP"), DomainWarpTemplate::new); - + noiseRegistry.register(addon.key("FBM"), BrownianMotionTemplate::new); noiseRegistry.register(addon.key("PING_PONG"), PingPongTemplate::new); noiseRegistry.register(addon.key("RIDGED"), RidgedFractalTemplate::new); - + noiseRegistry.register(addon.key("OPEN_SIMPLEX_2"), () -> new SimpleNoiseTemplate(OpenSimplex2Sampler::new)); noiseRegistry.register(addon.key("OPEN_SIMPLEX_2S"), () -> new SimpleNoiseTemplate(OpenSimplex2SSampler::new)); noiseRegistry.register(addon.key("PERLIN"), () -> new SimpleNoiseTemplate(PerlinSampler::new)); noiseRegistry.register(addon.key("SIMPLEX"), () -> new SimpleNoiseTemplate(SimplexSampler::new)); noiseRegistry.register(addon.key("GABOR"), GaborNoiseTemplate::new); - - + + noiseRegistry.register(addon.key("VALUE"), () -> new SimpleNoiseTemplate(ValueSampler::new)); noiseRegistry.register(addon.key("VALUE_CUBIC"), () -> new SimpleNoiseTemplate(ValueCubicSampler::new)); - + noiseRegistry.register(addon.key("CELLULAR"), CellularNoiseTemplate::new); - + noiseRegistry.register(addon.key("WHITE_NOISE"), () -> new SimpleNoiseTemplate(WhiteNoiseSampler::new)); noiseRegistry.register(addon.key("POSITIVE_WHITE_NOISE"), () -> new SimpleNoiseTemplate(PositiveWhiteNoiseSampler::new)); noiseRegistry.register(addon.key("GAUSSIAN"), () -> new SimpleNoiseTemplate(GaussianNoiseSampler::new)); noiseRegistry.register(addon.key("DISTANCE"), DistanceSamplerTemplate::new); - + noiseRegistry.register(addon.key("CONSTANT"), ConstantNoiseTemplate::new); - + noiseRegistry.register(addon.key("KERNEL"), KernelTemplate::new); - + noiseRegistry.register(addon.key("LINEAR_HEIGHTMAP"), LinearHeightmapSamplerTemplate::new); noiseRegistry.register(addon.key("TRANSLATE"), TranslateSamplerTemplate::new); - + noiseRegistry.register(addon.key("ADD"), () -> new BinaryArithmeticTemplate<>(AdditionSampler::new)); noiseRegistry.register(addon.key("SUB"), () -> new BinaryArithmeticTemplate<>(SubtractionSampler::new)); noiseRegistry.register(addon.key("MUL"), () -> new BinaryArithmeticTemplate<>(MultiplicationSampler::new)); noiseRegistry.register(addon.key("DIV"), () -> new BinaryArithmeticTemplate<>(DivisionSampler::new)); noiseRegistry.register(addon.key("MAX"), () -> new BinaryArithmeticTemplate<>(MaxSampler::new)); noiseRegistry.register(addon.key("MIN"), () -> new BinaryArithmeticTemplate<>(MinSampler::new)); - - + + Map packSamplers = new LinkedHashMap<>(); Map packFunctions = new LinkedHashMap<>(); noiseRegistry.register(addon.key("EXPRESSION"), () -> new ExpressionFunctionTemplate(packSamplers, packFunctions)); - noiseRegistry.register(addon.key("EXPRESSION_NORMALIZER"), () -> new ExpressionNormalizerTemplate(packSamplers, packFunctions)); - + noiseRegistry.register(addon.key("EXPRESSION_NORMALIZER"), + () -> new ExpressionNormalizerTemplate(packSamplers, packFunctions)); + NoiseConfigPackTemplate template = event.loadTemplate(new NoiseConfigPackTemplate()); packSamplers.putAll(template.getSamplers()); packFunctions.putAll(template.getFunctions()); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/TranslateSamplerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/TranslateSamplerTemplate.java index c08a8253f..3e5265ff5 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/TranslateSamplerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/TranslateSamplerTemplate.java @@ -27,6 +27,6 @@ public class TranslateSamplerTemplate extends SamplerTemplate @Override public NoiseSampler get() { - return new TranslateSampler(sampler, x, y ,z); + return new TranslateSampler(sampler, x, y, z); } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java index d062cbaae..425181589 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java @@ -41,15 +41,18 @@ public class ExpressionFunctionTemplate extends SamplerTemplate functions = new LinkedHashMap<>(); - public ExpressionFunctionTemplate(Map globalSamplers, Map globalFunctions) { + public ExpressionFunctionTemplate(Map globalSamplers, + Map globalFunctions) { this.globalSamplers = globalSamplers; this.globalFunctions = globalFunctions; } @Override public NoiseSampler get() { - var mergedFunctions = new HashMap<>(globalFunctions); mergedFunctions.putAll(functions); - var mergedSamplers = new HashMap<>(globalSamplers); mergedSamplers.putAll(samplers); + var mergedFunctions = new HashMap<>(globalFunctions); + mergedFunctions.putAll(functions); + var mergedSamplers = new HashMap<>(globalSamplers); + mergedSamplers.putAll(samplers); try { return new ExpressionFunction(convertFunctionsAndSamplers(mergedFunctions, mergedSamplers), expression, vars); } catch(ParseException e) { diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java index e0b40b69f..f0a2e9db1 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java @@ -45,15 +45,18 @@ public class ExpressionNormalizerTemplate extends NormalizerTemplate functions = new LinkedHashMap<>(); - public ExpressionNormalizerTemplate(Map globalSamplers, Map globalFunctions) { + public ExpressionNormalizerTemplate(Map globalSamplers, + Map globalFunctions) { this.globalSamplers = globalSamplers; this.globalFunctions = globalFunctions; } @Override public NoiseSampler get() { - var mergedFunctions = new HashMap<>(globalFunctions); mergedFunctions.putAll(functions); - var mergedSamplers = new HashMap<>(globalSamplers); mergedSamplers.putAll(samplers); + var mergedFunctions = new HashMap<>(globalFunctions); + mergedFunctions.putAll(functions); + var mergedSamplers = new HashMap<>(globalSamplers); + mergedSamplers.putAll(samplers); try { return new ExpressionNormalizer(function, convertFunctionsAndSamplers(mergedFunctions, mergedSamplers), expression, vars); } catch(ParseException e) { diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java index a1ab99d28..49070ea79 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java @@ -28,18 +28,14 @@ public class CubicSpline { } } - public double apply(double in) { - return calculate(in, fromValues, toValues, gradients); - } - public static double calculate(double in, double[] fromValues, double[] toValues, double[] gradients) { int pointIdx = floorBinarySearch(in, fromValues) - 1; int pointIdxLast = fromValues.length - 1; - if (pointIdx < 0) { // If to left of first point return linear function intersecting said point using point's gradient + if(pointIdx < 0) { // If to left of first point return linear function intersecting said point using point's gradient return gradients[0] * (in - fromValues[0]) + toValues[0]; - } else if (pointIdx == pointIdxLast) { // Do same if to right of last point + } else if(pointIdx == pointIdxLast) { // Do same if to right of last point return gradients[pointIdxLast] * (in - fromValues[pointIdxLast]) + toValues[pointIdxLast]; } else { double fromLeft = fromValues[pointIdx]; @@ -48,7 +44,7 @@ public class CubicSpline { double toLeft = toValues[pointIdx]; double toRight = toValues[pointIdx + 1]; - double gradientLeft = gradients[pointIdx]; + double gradientLeft = gradients[pointIdx]; double gradientRight = gradients[pointIdx + 1]; double fromDelta = fromRight - fromLeft; @@ -56,7 +52,8 @@ public class CubicSpline { double t = (in - fromLeft) / fromDelta; - return lerp(t, toLeft, toRight) + t * (1.0F - t) * lerp(t, gradientLeft * fromDelta - toDelta, -gradientRight * fromDelta + toDelta); + return lerp(t, toLeft, toRight) + t * (1.0F - t) * lerp(t, gradientLeft * fromDelta - toDelta, + -gradientRight * fromDelta + toDelta); } } @@ -64,10 +61,10 @@ public class CubicSpline { int left = 0; int right = values.length; int idx = right - left; - while (idx > 0) { + while(idx > 0) { int halfDelta = idx / 2; int mid = left + halfDelta; - if (targetValue < values[mid]) { + if(targetValue < values[mid]) { idx = halfDelta; } else { left = mid + 1; @@ -76,6 +73,11 @@ public class CubicSpline { } return left; } + + public double apply(double in) { + return calculate(in, fromValues, toValues, gradients); + } + public record Point(double from, double to, double gradient) implements Comparable { diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java index 9bee3e2c0..55f7ef2c6 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java @@ -14,10 +14,11 @@ import com.dfsek.terra.addons.noise.paralithic.noise.NoiseFunction3; public class FunctionUtil { - private FunctionUtil() {} + private FunctionUtil() { } public static Map convertFunctionsAndSamplers(Map functions, - Map samplers) throws ParseException { + Map samplers) + throws ParseException { Map functionMap = new HashMap<>(); for(Map.Entry entry : functions.entrySet()) { functionMap.put(entry.getKey(), UserDefinedFunction.newInstance(entry.getValue())); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java index 246c7bab1..72fbbed9a 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java @@ -20,14 +20,30 @@ public class DistanceSampler extends NoiseFunction { this.radius = radius; this.distanceAtRadius = distance2d(distanceFunction, radius, 0); // distance2d and distance3d should return the same value } - + + private static double distance2d(DistanceFunction distanceFunction, double x, double z) { + return switch(distanceFunction) { + case Euclidean -> Math.sqrt(x * x + z * z); + case EuclideanSq -> x * x + z * z; + case Manhattan -> Math.abs(x) + Math.abs(z); + }; + } + + private static double distance3d(DistanceFunction distanceFunction, double x, double y, double z) { + return switch(distanceFunction) { + case Euclidean -> Math.sqrt(x * x + y * y + z * z); + case EuclideanSq -> x * x + y * y + z * z; + case Manhattan -> Math.abs(x) + Math.abs(y) + Math.abs(z); + }; + } + @Override public double getNoiseRaw(long seed, double x, double y) { double dx = x - ox; double dy = y - oz; - if (normalize && (Math.abs(dx) > radius || Math.abs(dy) > radius)) return 1; + if(normalize && (Math.abs(dx) > radius || Math.abs(dy) > radius)) return 1; double dist = distance2d(distanceFunction, dx, dy); - if (normalize) return Math.min(((2*dist)/distanceAtRadius)-1, 1); + if(normalize) return Math.min(((2 * dist) / distanceAtRadius) - 1, 1); return dist; } @@ -38,26 +54,10 @@ public class DistanceSampler extends NoiseFunction { double dz = z - oz; if(normalize && (Math.abs(dx) > radius || Math.abs(dy) > radius || Math.abs(dz) > radius)) return 1; double dist = distance3d(distanceFunction, dx, dy, dz); - if (normalize) return Math.min(((2*dist)/distanceAtRadius)-1, 1); + if(normalize) return Math.min(((2 * dist) / distanceAtRadius) - 1, 1); return dist; } - private static double distance2d(DistanceFunction distanceFunction, double x, double z) { - return switch(distanceFunction) { - case Euclidean -> Math.sqrt(x*x + z*z); - case EuclideanSq -> x*x + z*z; - case Manhattan -> Math.abs(x) + Math.abs(z); - }; - } - - private static double distance3d(DistanceFunction distanceFunction, double x, double y, double z) { - return switch(distanceFunction) { - case Euclidean -> Math.sqrt(x*x + y*y + z*z); - case EuclideanSq -> x*x + y*y + z*z; - case Manhattan -> Math.abs(x) + Math.abs(y) + Math.abs(z); - }; - } - public enum DistanceFunction { Euclidean, EuclideanSq, diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java index c9a729a39..1b74295a8 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java @@ -17,11 +17,10 @@ public class GaborNoiseSampler extends NoiseFunction { private double a = 0.1; private double f0 = 0.625; private double kernelRadius = (Math.sqrt(-Math.log(0.05) / Math.PI) / a); - private double impulsesPerKernel = 64d; private double impulseDensity = (impulsesPerKernel / (Math.PI * kernelRadius * kernelRadius)); private double impulsesPerCell = impulseDensity * kernelRadius * kernelRadius; private double g = Math.exp(-impulsesPerCell); - + private double impulsesPerKernel = 64d; private double omega0 = Math.PI * 0.25; private boolean isotropic = true; @@ -72,8 +71,9 @@ public class GaborNoiseSampler extends NoiseFunction { } private double gabor(double omega_0, double x, double y) { - return k * (Math.exp(-Math.PI * (a * a) * (x * x + y * y)) * MathUtil.cos(2 * Math.PI * f0 * (x * MathUtil.cos(omega_0) + y * MathUtil.sin( - omega_0)))); + return k * (Math.exp(-Math.PI * (a * a) * (x * x + y * y)) * MathUtil.cos(2 * Math.PI * f0 * (x * MathUtil.cos(omega_0) + + y * MathUtil.sin( + omega_0)))); } public void setA(double a) { diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java index 890714272..a996ded2a 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java @@ -15,7 +15,7 @@ public abstract class NoiseFunction implements NoiseSampler { protected static final int PRIME_X = 501125321; protected static final int PRIME_Y = 1136930381; protected static final int PRIME_Z = 1720413743; - + protected double frequency = 0.02d; protected long salt; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java index 0c2e8b335..8b14d9d2f 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java @@ -33,11 +33,11 @@ public class ValueCubicSampler extends ValueStyleNoise { MathUtil.cubicLerp(valCoord(seed, x0, y0), valCoord(seed, x1, y0), valCoord(seed, x2, y0), valCoord(seed, x3, y0), xs), MathUtil.cubicLerp(valCoord(seed, x0, y1), valCoord(seed, x1, y1), valCoord(seed, x2, y1), valCoord(seed, x3, y1), - xs), + xs), MathUtil.cubicLerp(valCoord(seed, x0, y2), valCoord(seed, x1, y2), valCoord(seed, x2, y2), valCoord(seed, x3, y2), - xs), + xs), MathUtil.cubicLerp(valCoord(seed, x0, y3), valCoord(seed, x1, y3), valCoord(seed, x2, y3), valCoord(seed, x3, y3), - xs), + xs), ys) * (1 / (1.5 * 1.5)); } @@ -69,43 +69,43 @@ public class ValueCubicSampler extends ValueStyleNoise { return MathUtil.cubicLerp( MathUtil.cubicLerp( MathUtil.cubicLerp(valCoord(seed, x0, y0, z0), valCoord(seed, x1, y0, z0), valCoord(seed, x2, y0, z0), - valCoord(seed, x3, y0, z0), xs), + valCoord(seed, x3, y0, z0), xs), MathUtil.cubicLerp(valCoord(seed, x0, y1, z0), valCoord(seed, x1, y1, z0), valCoord(seed, x2, y1, z0), - valCoord(seed, x3, y1, z0), xs), + valCoord(seed, x3, y1, z0), xs), MathUtil.cubicLerp(valCoord(seed, x0, y2, z0), valCoord(seed, x1, y2, z0), valCoord(seed, x2, y2, z0), - valCoord(seed, x3, y2, z0), xs), + valCoord(seed, x3, y2, z0), xs), MathUtil.cubicLerp(valCoord(seed, x0, y3, z0), valCoord(seed, x1, y3, z0), valCoord(seed, x2, y3, z0), - valCoord(seed, x3, y3, z0), xs), + valCoord(seed, x3, y3, z0), xs), ys), MathUtil.cubicLerp( MathUtil.cubicLerp(valCoord(seed, x0, y0, z1), valCoord(seed, x1, y0, z1), valCoord(seed, x2, y0, z1), - valCoord(seed, x3, y0, z1), xs), + valCoord(seed, x3, y0, z1), xs), MathUtil.cubicLerp(valCoord(seed, x0, y1, z1), valCoord(seed, x1, y1, z1), valCoord(seed, x2, y1, z1), - valCoord(seed, x3, y1, z1), xs), + valCoord(seed, x3, y1, z1), xs), MathUtil.cubicLerp(valCoord(seed, x0, y2, z1), valCoord(seed, x1, y2, z1), valCoord(seed, x2, y2, z1), - valCoord(seed, x3, y2, z1), xs), + valCoord(seed, x3, y2, z1), xs), MathUtil.cubicLerp(valCoord(seed, x0, y3, z1), valCoord(seed, x1, y3, z1), valCoord(seed, x2, y3, z1), - valCoord(seed, x3, y3, z1), xs), + valCoord(seed, x3, y3, z1), xs), ys), MathUtil.cubicLerp( MathUtil.cubicLerp(valCoord(seed, x0, y0, z2), valCoord(seed, x1, y0, z2), valCoord(seed, x2, y0, z2), - valCoord(seed, x3, y0, z2), xs), + valCoord(seed, x3, y0, z2), xs), MathUtil.cubicLerp(valCoord(seed, x0, y1, z2), valCoord(seed, x1, y1, z2), valCoord(seed, x2, y1, z2), - valCoord(seed, x3, y1, z2), xs), + valCoord(seed, x3, y1, z2), xs), MathUtil.cubicLerp(valCoord(seed, x0, y2, z2), valCoord(seed, x1, y2, z2), valCoord(seed, x2, y2, z2), - valCoord(seed, x3, y2, z2), xs), + valCoord(seed, x3, y2, z2), xs), MathUtil.cubicLerp(valCoord(seed, x0, y3, z2), valCoord(seed, x1, y3, z2), valCoord(seed, x2, y3, z2), - valCoord(seed, x3, y3, z2), xs), + valCoord(seed, x3, y3, z2), xs), ys), MathUtil.cubicLerp( MathUtil.cubicLerp(valCoord(seed, x0, y0, z3), valCoord(seed, x1, y0, z3), valCoord(seed, x2, y0, z3), - valCoord(seed, x3, y0, z3), xs), + valCoord(seed, x3, y0, z3), xs), MathUtil.cubicLerp(valCoord(seed, x0, y1, z3), valCoord(seed, x1, y1, z3), valCoord(seed, x2, y1, z3), - valCoord(seed, x3, y1, z3), xs), + valCoord(seed, x3, y1, z3), xs), MathUtil.cubicLerp(valCoord(seed, x0, y2, z3), valCoord(seed, x1, y2, z3), valCoord(seed, x2, y2, z3), - valCoord(seed, x3, y2, z3), xs), + valCoord(seed, x3, y2, z3), xs), MathUtil.cubicLerp(valCoord(seed, x0, y3, z3), valCoord(seed, x1, y3, z3), valCoord(seed, x2, y3, z3), - valCoord(seed, x3, y3, z3), xs), + valCoord(seed, x3, y3, z3), xs), ys), zs) * (1 / (1.5 * 1.5 * 1.5)); } diff --git a/common/addons/config-noise-function/src/main/resources/terra.addon.yml b/common/addons/config-noise-function/src/main/resources/terra.addon.yml index b22b0f781..c1320f289 100644 --- a/common/addons/config-noise-function/src/main/resources/terra.addon.yml +++ b/common/addons/config-noise-function/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-noise-function version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.noise.NoiseAddon" + - "com.dfsek.terra.addons.noise.NoiseAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/DoublePredicateLoader.java b/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/DoublePredicateLoader.java index 4b9bf789e..a9528d31b 100644 --- a/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/DoublePredicateLoader.java +++ b/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/DoublePredicateLoader.java @@ -18,7 +18,7 @@ public class DoublePredicateLoader implements TypeLoader { @Override public DoublePredicate load(@NotNull AnnotatedType annotatedType, @NotNull Object o, @NotNull ConfigLoader configLoader, DepthTracker depthTracker) throws LoadException { - if (o instanceof String expressionString) { + if(o instanceof String expressionString) { Scope scope = new Scope(); scope.addInvocationVariable("value"); try { diff --git a/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java b/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java index 75e2e6faa..60ddc8b8c 100644 --- a/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java +++ b/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java @@ -16,6 +16,7 @@ import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent; import com.dfsek.terra.api.event.functional.FunctionalEventHandler; import com.dfsek.terra.api.inject.annotations.Inject; + public class NumberPredicateAddon implements AddonInitializer { @Inject diff --git a/common/addons/config-number-predicate/src/main/resources/terra.addon.yml b/common/addons/config-number-predicate/src/main/resources/terra.addon.yml index e4014b3a3..838742309 100644 --- a/common/addons/config-number-predicate/src/main/resources/terra.addon.yml +++ b/common/addons/config-number-predicate/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-number-predicate version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.numberpredicate.NumberPredicateAddon" + - "com.dfsek.terra.addons.numberpredicate.NumberPredicateAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java index f2485c2c0..529983f7b 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java @@ -167,6 +167,7 @@ public class VanillaOre implements Structure { return blockCount > 0; } + public BlockState getMaterial(BlockType replace) { return materials.getOrDefault(replace, material); } diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java index 12dcda3ce..6a1ce728f 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java @@ -15,6 +15,7 @@ import static com.dfsek.terra.addons.ore.utils.VanillaOreUtils.shouldPlace; public class VanillaScatteredOre extends VanillaOre { protected final int spread; + public VanillaScatteredOre(BlockState material, double size, MaterialSet replaceable, boolean applyGravity, double exposed, Map materials, int spread) { super(material, size, replaceable, applyGravity, exposed, materials); @@ -30,9 +31,9 @@ public class VanillaScatteredOre extends VanillaOre { for(int j = 0; j < i; ++j) { this.setPos(mutable, random, location, Math.min(j, spread)); BlockType block = world.getBlockState(mutable).getBlockType(); - if (shouldPlace(getReplaceable(), block, exposed, random, world, mutable.getX(), mutable.getY(), mutable.getZ())) { - world.setBlockState(mutable, getMaterial(block), isApplyGravity()); - } + if(shouldPlace(getReplaceable(), block, exposed, random, world, mutable.getX(), mutable.getY(), mutable.getZ())) { + world.setBlockState(mutable, getMaterial(block), isApplyGravity()); + } } return true; @@ -48,6 +49,6 @@ public class VanillaScatteredOre extends VanillaOre { } private int getSpread(Random random, int spread) { - return Math.round((random.nextFloat() - random.nextFloat()) * (float)spread); + return Math.round((random.nextFloat() - random.nextFloat()) * (float) spread); } } diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java index aa8f0132d..48bf3a712 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java @@ -18,7 +18,8 @@ public class VanillaOreUtils { } } - public static boolean shouldPlace(MaterialSet replaceable, BlockType type, Double exposed, Random random, WritableWorld world, int x, int y, int z) { + public static boolean shouldPlace(MaterialSet replaceable, BlockType type, Double exposed, Random random, WritableWorld world, int x, + int y, int z) { if(!replaceable.contains(type)) { return false; } else if(shouldNotDiscard(random, exposed)) { diff --git a/common/addons/config-ore/src/main/resources/terra.addon.yml b/common/addons/config-ore/src/main/resources/terra.addon.yml index 60ea05e60..bab302e4f 100644 --- a/common/addons/config-ore/src/main/resources/terra.addon.yml +++ b/common/addons/config-ore/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-ore version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.ore.OreAddon" + - "com.dfsek.terra.addons.ore.OreAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/config-palette/src/main/resources/terra.addon.yml b/common/addons/config-palette/src/main/resources/terra.addon.yml index 255a58048..67db4259c 100644 --- a/common/addons/config-palette/src/main/resources/terra.addon.yml +++ b/common/addons/config-palette/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-palette version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.palette.PaletteAddon" + - "com.dfsek.terra.addons.palette.PaletteAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/config-structure/src/main/resources/terra.addon.yml b/common/addons/config-structure/src/main/resources/terra.addon.yml index ad31e3641..3143b5830 100644 --- a/common/addons/config-structure/src/main/resources/terra.addon.yml +++ b/common/addons/config-structure/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-structure version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.structure.StructureAddon" + - "com.dfsek.terra.addons.structure.StructureAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationAddon.java b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationAddon.java index f58dfd692..1e6adbdbe 100644 --- a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationAddon.java +++ b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationAddon.java @@ -66,7 +66,7 @@ public class FeatureGenerationAddon implements AddonInitializer { .then(event -> { if(event.is(Biome.class)) { DynamicTemplate.Builder templateBuilder = DynamicTemplate.builder(); - + List featureGenerationStages = new ArrayList<>(); event.getPack().getStages().forEach(stage -> { if(stage instanceof FeatureGenerationStage featureGenerationStage) { @@ -80,13 +80,13 @@ public class FeatureGenerationAddon implements AddonInitializer { .build()); } }); - + DynamicTemplate template = event.load(templateBuilder.build()); - + Map> features = new HashMap<>(); - + featureGenerationStages.forEach(stage -> features.put(stage, template.get(stage.getID(), List.class))); - + event.getLoadedObject(Biome.class).getContext().put(biomeFeaturesKey, new BiomeFeatures(features)); } }) diff --git a/common/addons/generation-stage-feature/src/main/resources/terra.addon.yml b/common/addons/generation-stage-feature/src/main/resources/terra.addon.yml index 640aa8aa3..0f0447864 100644 --- a/common/addons/generation-stage-feature/src/main/resources/terra.addon.yml +++ b/common/addons/generation-stage-feature/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: generation-stage-feature version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.generation.feature.FeatureGenerationAddon" + - "com.dfsek.terra.addons.generation.feature.FeatureGenerationAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/generation-stage-structure/src/main/resources/terra.addon.yml b/common/addons/generation-stage-structure/src/main/resources/terra.addon.yml index 2d361cf3d..9aa1ac530 100644 --- a/common/addons/generation-stage-structure/src/main/resources/terra.addon.yml +++ b/common/addons/generation-stage-structure/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: generation-stage-structure version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.generation.structure.StructureGenerationAddon" + - "com.dfsek.terra.addons.generation.structure.StructureGenerationAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/language-yaml/src/main/resources/terra.addon.yml b/common/addons/language-yaml/src/main/resources/terra.addon.yml index 2b3d1d50b..541c7f693 100644 --- a/common/addons/language-yaml/src/main/resources/terra.addon.yml +++ b/common/addons/language-yaml/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: language-yaml version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.yaml.YamlAddon" + - "com.dfsek.terra.addons.yaml.YamlAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/library-image/build.gradle.kts b/common/addons/library-image/build.gradle.kts index 703657471..e01ce95f8 100644 --- a/common/addons/library-image/build.gradle.kts +++ b/common/addons/library-image/build.gradle.kts @@ -2,7 +2,6 @@ version = version("1.0.1") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) - } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java index 638056f7f..811164b01 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java @@ -84,6 +84,6 @@ public class ImageLibraryAddon implements AddonInitializer { colorSamplerRegistry.register(addon.key("COLOR"), ConstantColorSamplerTemplate::new); colorSamplerRegistry.register(addon.key("ROTATE"), RotateColorSamplerTemplate::new); colorSamplerRegistry.register(addon.key("TRANSLATE"), TranslateColorSamplerTemplate::new); - }); + }); } } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/ColorSampler.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/ColorSampler.java index 9cf226302..6c0baa7f7 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/ColorSampler.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/ColorSampler.java @@ -6,6 +6,7 @@ public interface ColorSampler { /** * @param x World x coordinate * @param z World z coordinate + * * @return Integer representing a web color */ int apply(int x, int z); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/transform/Alignment.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/transform/Alignment.java index 834428c5c..87285171c 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/transform/Alignment.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/transform/Alignment.java @@ -10,7 +10,7 @@ public enum Alignment implements ImageTransformation { public int transformX(Image image, int x) { return x; } - + @Override public int transformZ(Image image, int z) { return z; @@ -21,7 +21,7 @@ public enum Alignment implements ImageTransformation { public int transformX(Image image, int x) { return x + image.getWidth() / 2; } - + @Override public int transformZ(Image image, int z) { return z + image.getHeight() / 2; diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/RotateColorSampler.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/RotateColorSampler.java index 8ace7a3ef..aa348b350 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/RotateColorSampler.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/RotateColorSampler.java @@ -3,6 +3,7 @@ package com.dfsek.terra.addons.image.colorsampler.mutate; import com.dfsek.terra.addons.image.colorsampler.ColorSampler; import com.dfsek.terra.api.util.MathUtil; + public class RotateColorSampler implements ColorSampler { private final ColorSampler sampler; @@ -15,15 +16,15 @@ public class RotateColorSampler implements ColorSampler { this.sampler = sampler; double normalizedDegrees = degrees % 360.0; - if (normalizedDegrees < 0) normalizedDegrees += 360.0; + if(normalizedDegrees < 0) normalizedDegrees += 360.0; - if (normalizedDegrees == 0.0) + if(normalizedDegrees == 0.0) rotationMethod = RotationMethod.DEG_0; - else if (normalizedDegrees == 90.0) + else if(normalizedDegrees == 90.0) rotationMethod = RotationMethod.DEG_90; - else if (normalizedDegrees == 180.0) + else if(normalizedDegrees == 180.0) rotationMethod = RotationMethod.DEG_180; - else if (normalizedDegrees == 270.0) + else if(normalizedDegrees == 270.0) rotationMethod = RotationMethod.DEG_270; else rotationMethod = RotationMethod.RAD_ANY; diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ColorLoader.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ColorLoader.java index 03316d87b..61115f3b6 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ColorLoader.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ColorLoader.java @@ -28,28 +28,24 @@ public class ColorLoader implements TypeLoader { this.argb = parse(string); } - public int getColor() { - return argb; - } - private static int parse(String string) throws IllegalArgumentException { - if (string.length() == 0) + if(string.length() == 0) throw new IllegalArgumentException("Empty string cannot be parsed as a valid color"); String[] split = string.split(","); - if (split.length == 1) + if(split.length == 1) return parseHex(string); - else if (split.length == 3) + else if(split.length == 3) return parseChannels("255", split[0], split[1], split[2]); - else if (split.length == 4) + else if(split.length == 4) return parseChannels(split[0], split[1], split[2], split[3]); else throw new IllegalArgumentException("Invalid channels provided, required format RED,GREEN,BLUE or ALPHA,RED,GREEN,BLUE"); } private static int parseHex(String hex) throws IllegalArgumentException { - if (hex.startsWith("#")) + if(hex.startsWith("#")) hex = hex.substring(1); int alpha = 255; @@ -71,7 +67,7 @@ public class ColorLoader implements TypeLoader { blue = Integer.parseInt(hex.substring(4, 6), 16); return ColorUtil.argbValidated(alpha, red, green, blue); - } catch (NumberFormatException e) { + } catch(NumberFormatException e) { throw new IllegalArgumentException("Failed to parse hex color", e); } } @@ -84,9 +80,13 @@ public class ColorLoader implements TypeLoader { int b = Integer.decode(blue); return ColorUtil.argbValidated(a, r, g, b); - } catch (NumberFormatException e) { + } catch(NumberFormatException e) { throw new IllegalArgumentException("Invalid channel value", e); } } + + public int getColor() { + return argb; + } } } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java index 60d58cddd..1d823f06c 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java @@ -7,6 +7,7 @@ import com.dfsek.tectonic.api.config.template.annotations.Value; import com.dfsek.terra.api.properties.Properties; + public class ImageLibraryPackConfigTemplate implements ConfigTemplate, Properties { // TODO - These would be better as plugin wide config parameters in config.yml @@ -17,8 +18,10 @@ public class ImageLibraryPackConfigTemplate implements ConfigTemplate, Propertie @Value("images.cache.timeout") @Description("How many seconds to keep images loaded in the image cache for. " + - "If set to a number greater than 0, images will be removed from memory if not used after the timeout, otherwise images will stay loaded in memory. " + - "Setting the timeout to greater than 0 will trade decreased memory consumption when not performing any image reads for a period of time for extra processing time required to perform cache lookups.") + "If set to a number greater than 0, images will be removed from memory if not used after the timeout, otherwise images " + + "will stay loaded in memory. " + + "Setting the timeout to greater than 0 will trade decreased memory consumption when not performing any image reads for a" + + " period of time for extra processing time required to perform cache lookups.") @Default private int cacheTimeout = 0; diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/SingleImageColorSamplerTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/SingleImageColorSamplerTemplate.java index dd31a3d67..20d8f161f 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/SingleImageColorSamplerTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/SingleImageColorSamplerTemplate.java @@ -9,7 +9,7 @@ import com.dfsek.terra.addons.image.colorsampler.image.SingleImageColorSampler; public class SingleImageColorSamplerTemplate extends ImageColorSamplerTemplate { @Value("outside-sampler") private ColorSampler fallback; - + @Override public ColorSampler get() { return new SingleImageColorSampler(image, fallback, alignment); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/TileImageColorSamplerTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/TileImageColorSamplerTemplate.java index 72421cb58..5fa89676e 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/TileImageColorSamplerTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/TileImageColorSamplerTemplate.java @@ -5,7 +5,7 @@ import com.dfsek.terra.addons.image.colorsampler.image.TileImageColorSampler; public class TileImageColorSamplerTemplate extends ImageColorSamplerTemplate { - + @Override public ColorSampler get() { return new TileImageColorSampler(image, alignment); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/TranslateColorSamplerTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/TranslateColorSamplerTemplate.java index e8e18c447..fa310c378 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/TranslateColorSamplerTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/TranslateColorSamplerTemplate.java @@ -16,6 +16,6 @@ public class TranslateColorSamplerTemplate extends MutateColorSamplerTemplate { @Override public ColorSampler get() { - return new TranslateColorSampler(sampler, translateX, translateZ); + return new TranslateColorSampler(sampler, translateX, translateZ); } } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java index 54551504c..ac3ea4800 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java @@ -27,12 +27,12 @@ record ImageCache(LoadingCache cache) implements Properties { ImageCache images; if(!pack.getContext().has(ImageCache.class)) { var cacheBuilder = Caffeine.newBuilder(); - if (config.unloadOnTimeout()) cacheBuilder.expireAfterAccess(config.getCacheTimeout(), TimeUnit.SECONDS); + if(config.unloadOnTimeout()) cacheBuilder.expireAfterAccess(config.getCacheTimeout(), TimeUnit.SECONDS); images = new ImageCache(cacheBuilder.build(s -> loadImage(s, files))); pack.getContext().put(images); } else images = pack.getContext().get(ImageCache.class); - if (config.loadOnUse()) { + if(config.loadOnUse()) { if(config.unloadOnTimeout()) { // Grab directly from cache if images are to unload on timeout return new SuppliedImage(() -> images.cache.get(path)); } else { diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageTemplate.java index 7590ca1b4..b94096871 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageTemplate.java @@ -12,13 +12,11 @@ import com.dfsek.terra.api.config.Loader; public class ImageTemplate implements ObjectTemplate { + private final Loader files; + private final ConfigPack pack; @Value("path") private String path; - private final Loader files; - - private final ConfigPack pack; - public ImageTemplate(Loader files, ConfigPack pack) { this.files = files; this.pack = pack; diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/StitchedImageTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/StitchedImageTemplate.java index 509bbeb22..e85537d09 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/StitchedImageTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/StitchedImageTemplate.java @@ -15,24 +15,19 @@ import com.dfsek.terra.api.config.Loader; public class StitchedImageTemplate implements ObjectTemplate, ValidatedConfigTemplate { - + + private final Loader files; + private final ConfigPack pack; @Value("path-format") private String path; - @Value("rows") private int rows; - @Value("columns") private int cols; - @Value("zero-indexed") @Default private boolean zeroIndexed = false; - - private final Loader files; - - private final ConfigPack pack; - + public StitchedImageTemplate(Loader files, ConfigPack pack) { this.files = files; this.pack = pack; @@ -54,13 +49,13 @@ public class StitchedImageTemplate implements ObjectTemplate, ValidatedCo } private String getFormattedPath(int row, int column) { - if (!zeroIndexed) { + if(!zeroIndexed) { row++; column++; } return path.replaceFirst("\\{row}", String.valueOf(row)).replaceFirst("\\{column}", String.valueOf(column)); } - + @Override public boolean validate() throws ValidationException { if(!path.contains("{row}")) diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/noisesampler/DistanceTransformNoiseSamplerTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/noisesampler/DistanceTransformNoiseSamplerTemplate.java index 32c523d3c..012b5b8bb 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/noisesampler/DistanceTransformNoiseSamplerTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/noisesampler/DistanceTransformNoiseSamplerTemplate.java @@ -69,6 +69,7 @@ public class DistanceTransformNoiseSamplerTemplate implements ObjectTemplate implements ColorConverter { - + private final Map map; - + private final Integer[] colors; - + public ClosestMatchColorConverter(Map map) { this.map = map; this.colors = map.keySet().toArray(new Integer[0]); } - + @Override public T apply(int color) { int closest = 0; @@ -32,7 +33,7 @@ public class ClosestMatchColorConverter implements ColorConverter { } return map.get(closest); } - + @Override public Iterable getEntries() { return map.values(); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/ExactColorConverter.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/ExactColorConverter.java index 8f6f55d4c..054e9397f 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/ExactColorConverter.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/ExactColorConverter.java @@ -16,7 +16,7 @@ public class ExactColorConverter implements ColorConverter { private final boolean ignoreAlpha; public ExactColorConverter(Map map, T fallback, boolean ignoreAlpha) { - if (ignoreAlpha) { + if(ignoreAlpha) { map = MapUtil.mapKeys(map, ColorUtil::zeroAlpha); } this.map = map; @@ -26,7 +26,7 @@ public class ExactColorConverter implements ColorConverter { @Override public T apply(int color) { - if (ignoreAlpha) { + if(ignoreAlpha) { color = ColorUtil.zeroAlpha(color); } T lookup = map.get(color); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/mapping/BiomeDefinedColorMapping.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/mapping/BiomeDefinedColorMapping.java index 469596577..f12d9782c 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/mapping/BiomeDefinedColorMapping.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/mapping/BiomeDefinedColorMapping.java @@ -30,7 +30,8 @@ public class BiomeDefinedColorMapping implements ColorMapping { if(!output.containsKey(color)) { output.put(color, biome); } else { - throw new IllegalArgumentException(String.format("Biome %s has same color as %s: %x", biome.getID(), output.get(color).getID(), color)); + throw new IllegalArgumentException( + String.format("Biome %s has same color as %s: %x", biome.getID(), output.get(color).getID(), color)); } })); return output.entrySet().stream().collect(Collectors.toMap(Entry::getKey, e -> converter.apply(e.getValue()))); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/StitchedImage.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/StitchedImage.java index c2d131b46..1507cf432 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/StitchedImage.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/StitchedImage.java @@ -40,7 +40,7 @@ public class StitchedImage implements Image { } private int getColumn(int x) { - for(int i = columnOffsets.length-1; i > 0; i--) { + for(int i = columnOffsets.length - 1; i > 0; i--) { if(x >= columnOffsets[i]) return i; } @@ -48,7 +48,7 @@ public class StitchedImage implements Image { } private int getRow(int y) { - for(int i = rowOffsets.length-1; i > 0; i--) { + for(int i = rowOffsets.length - 1; i > 0; i--) { if(y >= rowOffsets[i]) return i; } @@ -59,7 +59,7 @@ public class StitchedImage implements Image { public int getRGB(int x, int y) { int row = getRow(y); int column = getColumn(x); - return images[row][column].getRGB(x-columnOffsets[column], y-rowOffsets[row]); + return images[row][column].getRGB(x - columnOffsets[column], y - rowOffsets[row]); } @Override diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/SuppliedImage.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/SuppliedImage.java index 99fcbfcd3..f3e398c50 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/SuppliedImage.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/SuppliedImage.java @@ -2,6 +2,7 @@ package com.dfsek.terra.addons.image.image; import java.util.function.Supplier; + public class SuppliedImage implements Image { private final Supplier imageSupplier; diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java index a7fbe1194..b5fa3458b 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java @@ -16,21 +16,20 @@ import static com.dfsek.terra.addons.image.util.MathUtil.lerp; */ public class DistanceTransform { + private static final double MAX_DISTANCE_CAP = 10_000_000; // Arbitrarily large value, doubtful someone would private final double[][] distances; - /** * Size bounds matching the provided image. */ private final int width, height; - /** * Min and max distances of the distance computation. These may change after {@link #normalize(Normalization)} calls. */ private double minDistance, maxDistance; - private static final double MAX_DISTANCE_CAP = 10_000_000; // Arbitrarily large value, doubtful someone would - // ever use an image large enough to exceed this. - public DistanceTransform(Image image, Channel channel, int threshold, boolean clampToMaxEdgeDistance, CostFunction costFunction, boolean invertThreshold) { + // ever use an image large enough to exceed this. + public DistanceTransform(Image image, Channel channel, int threshold, boolean clampToMaxEdgeDistance, CostFunction costFunction, + boolean invertThreshold) { // Construct binary image based on threshold value boolean[][] binaryImage = new boolean[image.getWidth()][image.getHeight()]; for(int x = 0; x < image.getWidth(); x++) { @@ -47,17 +46,17 @@ public class DistanceTransform { binaryImageEdge[x][y] = false; else // If cell borders any false cell - binaryImageEdge[x][y] = x > 0 && !binaryImage[x-1][y] || - y > 0 && !binaryImage[x][y-1] || - x < image.getWidth ()-1 && !binaryImage[x+1][y] || - y < image.getHeight()-1 && !binaryImage[x][y+1]; + binaryImageEdge[x][y] = x > 0 && !binaryImage[x - 1][y] || + y > 0 && !binaryImage[x][y - 1] || + x < image.getWidth() - 1 && !binaryImage[x + 1][y] || + y < image.getHeight() - 1 && !binaryImage[x][y + 1]; } } double[][] function = new double[image.getWidth()][image.getHeight()]; for(int x = 0; x < image.getWidth(); x++) { for(int y = 0; y < image.getHeight(); y++) { - function[x][y] = switch (costFunction) { + function[x][y] = switch(costFunction) { case Channel -> ColorUtil.getChannel(image.getRGB(x, y), channel); case Threshold -> binaryImage[x][y] ? MAX_DISTANCE_CAP : 0; case ThresholdEdge, ThresholdEdgeSigned -> binaryImageEdge[x][y] ? 0 : MAX_DISTANCE_CAP; @@ -80,11 +79,11 @@ public class DistanceTransform { double max = Double.NEGATIVE_INFINITY; for(int x = 0; x < image.getWidth(); x++) { max = Math.max(max, distances[x][0]); - max = Math.max(max, distances[x][image.getHeight()-1]); + max = Math.max(max, distances[x][image.getHeight() - 1]); } for(int y = 0; y < image.getHeight(); y++) { max = Math.max(max, distances[0][y]); - max = Math.max(max, distances[image.getWidth()-1][y]); + max = Math.max(max, distances[image.getWidth() - 1][y]); } // Clamp to that largest value for(int x = 0; x < image.getWidth(); x++) { @@ -93,7 +92,7 @@ public class DistanceTransform { } } } - + this.width = image.getWidth(); this.height = image.getHeight(); @@ -122,28 +121,28 @@ public class DistanceTransform { private double[] calculateDistance1D(double[] f) { double[] d = new double[f.length]; int[] v = new int[f.length]; - double[] z = new double[f.length+1]; + double[] z = new double[f.length + 1]; int k = 0; v[0] = 0; z[0] = Integer.MIN_VALUE; z[1] = Integer.MAX_VALUE; - for(int q = 1; q <= f.length-1; q++) { - double s = ((f[q]+Math.pow(q, 2))-(f[v[k]]+Math.pow(v[k], 2)))/(2*q-2*v[k]); - while (s <= z[k]) { + for(int q = 1; q <= f.length - 1; q++) { + double s = ((f[q] + Math.pow(q, 2)) - (f[v[k]] + Math.pow(v[k], 2))) / (2 * q - 2 * v[k]); + while(s <= z[k]) { k--; - s = ((f[q]+Math.pow(q, 2))-(f[v[k]]+Math.pow(v[k], 2)))/(2*q-2*v[k]); + s = ((f[q] + Math.pow(q, 2)) - (f[v[k]] + Math.pow(v[k], 2))) / (2 * q - 2 * v[k]); } k++; v[k] = q; z[k] = s; - z[k+1] = Integer.MAX_VALUE; + z[k + 1] = Integer.MAX_VALUE; } k = 0; - for(int q = 0; q <= f.length-1; q++) { - while(z[k+1] < q) + for(int q = 0; q <= f.length - 1; q++) { + while(z[k + 1] < q) k++; - d[q] = Math.pow(q-v[k], 2) + f[v[k]]; + d[q] = Math.pow(q - v[k], 2) + f[v[k]]; } return d; } @@ -164,9 +163,9 @@ public class DistanceTransform { yield lerp(distances[x][y], minDistance, -1, maxDistance, 1); } else { if(d > 0) { - yield Math.pow(d/maxDistance, 2); + yield Math.pow(d / maxDistance, 2); } else if(d < 0) { - yield -Math.pow(d/minDistance, 2); + yield -Math.pow(d / minDistance, 2); } else { yield 0; } @@ -198,6 +197,7 @@ public class DistanceTransform { ThresholdEdgeSigned, } + public enum Normalization { /** * Return the raw calculated distances. @@ -217,21 +217,22 @@ public class DistanceTransform { SmoothPreserveZero, } + public static class Noise implements NoiseSampler { - + private final DistanceTransform transform; - + public Noise(DistanceTransform transform, Normalization normalization) { this.transform = transform; transform.normalize(normalization); } - + @Override public double noise(long seed, double x, double y) { - if(x<0 || y<0 || x>=transform.width || y>=transform.height) return transform.minDistance; + if(x < 0 || y < 0 || x >= transform.width || y >= transform.height) return transform.minDistance; return transform.distances[(int) Math.floor(x)][(int) Math.floor(y)]; } - + @Override public double noise(long seed, double x, double y, double z) { return noise(seed, x, z); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/ColorUtil.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/ColorUtil.java index 6e76cd72e..dc7316d8c 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/ColorUtil.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/ColorUtil.java @@ -5,7 +5,7 @@ package com.dfsek.terra.addons.image.util; */ public class ColorUtil { - private ColorUtil() {} + private ColorUtil() { } public static int distance(int a, int b) { return Math.abs(getRed(a) - getRed(b)) + @@ -17,6 +17,7 @@ public class ColorUtil { * Returns the red channel value of a given ARGB color value. * * @param argb the ARGB color value to extract the red channel value from + * * @return the red channel value of the given ARGB color value, in the range 0-255 */ public static int getRed(int argb) { @@ -27,6 +28,7 @@ public class ColorUtil { * Returns the green channel value of a given ARGB color value. * * @param argb the ARGB color value to extract the green channel value from + * * @return the green channel value of the given ARGB color value, in the range 0-255 */ public static int getGreen(int argb) { @@ -37,6 +39,7 @@ public class ColorUtil { * Returns the blue channel value of a given ARGB color value. * * @param argb the ARGB color value to extract the blue channel value from + * * @return the blue channel value of the given ARGB color value, in the range 0-255 */ public static int getBlue(int argb) { @@ -47,6 +50,7 @@ public class ColorUtil { * Returns the alpha channel value of a given ARGB color value. * * @param argb the ARGB color value to extract the blue channel value from + * * @return the alpha channel value of the given ARGB color value, in the range 0-255 */ public static int getAlpha(int argb) { @@ -57,6 +61,7 @@ public class ColorUtil { * Returns the grayscale value of a given ARGB color value. * * @param argb the ARGB color value to convert to grayscale + * * @return the grayscale value of the given ARGB color value, in the range 0-255 */ public static int getGrayscale(int argb) { @@ -66,8 +71,9 @@ public class ColorUtil { /** * Returns the value of the specified channel for a given ARGB color value. * - * @param argb the ARGB color value to extract the channel value from + * @param argb the ARGB color value to extract the channel value from * @param channel the channel to extract the value from + * * @return the value of the specified channel for the given ARGB color value, in the range 0-255 */ public static int getChannel(int argb, Channel channel) { @@ -78,6 +84,7 @@ public class ColorUtil { * Sets the red channel value of a given ARGB color value to zero. * * @param argb the ARGB color value to zero the red channel of + * * @return the resulting ARGB color value with the red channel set to zero */ public static int zeroRed(int argb) { @@ -88,6 +95,7 @@ public class ColorUtil { * Sets the green channel value of a given ARGB color value to zero. * * @param argb the ARGB color value to zero the green channel of + * * @return the resulting ARGB color value with the green channel set to zero */ public static int zeroGreen(int argb) { @@ -98,6 +106,7 @@ public class ColorUtil { * Sets the blue channel value of a given ARGB color value to zero. * * @param argb the ARGB color value to zero the blue channel of + * * @return the resulting ARGB color value with the blue channel set to zero */ public static int zeroBlue(int argb) { @@ -109,6 +118,7 @@ public class ColorUtil { * This is the same as setting the color to fully transparent. * * @param argb the ARGB color value to zero the alpha channel of + * * @return the resulting ARGB color value with the alpha channel set to zero */ public static int zeroAlpha(int argb) { @@ -120,6 +130,7 @@ public class ColorUtil { * This is the same as setting the color to black, while preserving the alpha. * * @param argb the ARGB color value to zero the color channel of + * * @return the resulting ARGB color value with the color channels set to zero */ public static int zeroGrayscale(int argb) { @@ -129,8 +140,9 @@ public class ColorUtil { /** * Sets the specified channel value of a given ARGB color value to zero. * - * @param argb the ARGB color value to zero the specified channel of + * @param argb the ARGB color value to zero the specified channel of * @param channel the channel to zero the value of + * * @return the resulting ARGB color value with the specified channel value set to zero */ public static int zeroChannel(int argb, Channel channel) { @@ -141,6 +153,7 @@ public class ColorUtil { * Multiply the RGB channels of a given ARGB color value by its alpha channel value. * * @param argb the ARGB color value to premultiply the RGB channels of + * * @return the resulting premultiplied ARGB color value */ public static int premultiply(int argb) { @@ -155,9 +168,10 @@ public class ColorUtil { * Returns an ARGB color value with the specified values for alpha, red, green, and blue channels. * * @param alpha the alpha value, between 0 and 255, to set in the ARGB color value - * @param red the red value, between 0 and 255, to set in the ARGB color value + * @param red the red value, between 0 and 255, to set in the ARGB color value * @param green the green value, between 0 and 255, to set in the ARGB color value - * @param blue the blue value, between 0 and 255, to set in the ARGB color value + * @param blue the blue value, between 0 and 255, to set in the ARGB color value + * * @return the resulting ARGB color value with the specified values for alpha, red, green, and blue channels */ public static int argb(int alpha, int red, int green, int blue) { @@ -169,17 +183,19 @@ public class ColorUtil { * after validating that each channel value is in the range 0-255. * * @param alpha the alpha value, between 0 and 255, to set in the ARGB color value - * @param red the red value, between 0 and 255, to set in the ARGB color value + * @param red the red value, between 0 and 255, to set in the ARGB color value * @param green the green value, between 0 and 255, to set in the ARGB color value - * @param blue the blue value, between 0 and 255, to set in the ARGB color value + * @param blue the blue value, between 0 and 255, to set in the ARGB color value + * * @return the resulting ARGB color value with the specified values for alpha, red, green, and blue channels + * * @throws IllegalArgumentException if any channel value is outside the range 0-255 */ public static int argbValidated(int alpha, int red, int green, int blue) throws IllegalArgumentException { - if (alpha < 0 || alpha > 255 || - red < 0 || red > 255 || - green < 0 || green > 255 || - blue < 0 || blue > 255 + if(alpha < 0 || alpha > 255 || + red < 0 || red > 255 || + green < 0 || green > 255 || + blue < 0 || blue > 255 ) throw new IllegalArgumentException("Channel values must be in range 0-255"); return argb(alpha, red, green, blue); } @@ -189,6 +205,7 @@ public class ColorUtil { * for the red, green, and blue channels. * * @param alpha the alpha channel value to set in the ARGB color value + * * @return the resulting ARGB color value */ public static int argbAlpha(int alpha) { return alpha << 24; } @@ -198,6 +215,7 @@ public class ColorUtil { * for the alpha, green, and blue channels. * * @param red the red channel value to set in the ARGB color value + * * @return the resulting ARGB color value */ public static int argbRed(int red) { return red << 16; } @@ -207,6 +225,7 @@ public class ColorUtil { * for the alpha, red, and blue channels. * * @param green the green channel value to set in the ARGB color value + * * @return the resulting ARGB color value */ public static int argbGreen(int green) { return green << 8; } @@ -216,6 +235,7 @@ public class ColorUtil { * for the alpha, red, and green channels. * * @param blue the blue channel value to set in the ARGB color value + * * @return the resulting ARGB color value */ public static int argbBlue(int blue) { return blue; } @@ -224,6 +244,7 @@ public class ColorUtil { * Returns an ARGB color value with the specified grayscale value for all four channels. * * @param value the grayscale value to set in all four channels of the ARGB color value + * * @return the resulting ARGB color value with the specified grayscale value for all four channels */ public static int argbGrayscale(int value) { return argb(value, value, value, value); } @@ -234,7 +255,7 @@ public class ColorUtil { public int from(int argb) { return getRed(argb); } - + @Override public int zero(int argb) { return zeroRed(argb); @@ -250,7 +271,7 @@ public class ColorUtil { public int from(int argb) { return getGreen(argb); } - + @Override public int zero(int argb) { return zeroGreen(argb); @@ -266,7 +287,7 @@ public class ColorUtil { public int from(int argb) { return getBlue(argb); } - + @Override public int zero(int argb) { return zeroBlue(argb); @@ -282,7 +303,7 @@ public class ColorUtil { public int from(int argb) { return getGrayscale(argb); } - + @Override public int zero(int argb) { return zeroGrayscale(argb); @@ -298,7 +319,7 @@ public class ColorUtil { public int from(int argb) { return getAlpha(argb); } - + @Override public int zero(int argb) { return zeroAlpha(argb); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MapUtil.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MapUtil.java index 7fa1040ce..01b730895 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MapUtil.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MapUtil.java @@ -7,8 +7,8 @@ import java.util.stream.Collectors; public class MapUtil { - - private MapUtil() {} + + private MapUtil() { } /** * Utility method for applying transformations on a map's keys. @@ -20,6 +20,6 @@ public class MapUtil { .collect(Collectors.toMap( e -> mappingFunction.apply(e.getKey()), Entry::getValue - )); + )); } } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MathUtil.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MathUtil.java index 40e52e5d1..ea677eac8 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MathUtil.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MathUtil.java @@ -1,9 +1,9 @@ package com.dfsek.terra.addons.image.util; public class MathUtil { - private MathUtil() {} + private MathUtil() { } public static double lerp(double x, double x1, double y1, double x2, double y2) { - return (((y1-y2)*(x-x1))/(x1-x2))+y1; + return (((y1 - y2) * (x - x1)) / (x1 - x2)) + y1; } } diff --git a/common/addons/library-image/src/main/resources/terra.addon.yml b/common/addons/library-image/src/main/resources/terra.addon.yml index c664c3df4..4e9cbb54c 100644 --- a/common/addons/library-image/src/main/resources/terra.addon.yml +++ b/common/addons/library-image/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: library-image version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.image.ImageLibraryAddon" + - "com.dfsek.terra.addons.image.ImageLibraryAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License diff --git a/common/addons/locator-slant-noise-3d/src/main/resources/terra.addon.yml b/common/addons/locator-slant-noise-3d/src/main/resources/terra.addon.yml index 8a7ef4ad9..0189030b6 100644 --- a/common/addons/locator-slant-noise-3d/src/main/resources/terra.addon.yml +++ b/common/addons/locator-slant-noise-3d/src/main/resources/terra.addon.yml @@ -1,14 +1,14 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: locator-slant-noise-3d version: @VERSION@ entrypoints: - - "com.dfsek.terra.addon.feature.locator.slant.SlantLocatorAddon" + - "com.dfsek.terra.addon.feature.locator.slant.SlantLocatorAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - chunk-generator-noise-3d: "[1.2.0,2.0.0)" \ No newline at end of file + chunk-generator-noise-3d: "[1.2.0,2.0.0)" \ No newline at end of file diff --git a/common/addons/palette-block-shortcut/src/main/resources/terra.addon.yml b/common/addons/palette-block-shortcut/src/main/resources/terra.addon.yml index 6b643a053..263fefa83 100644 --- a/common/addons/palette-block-shortcut/src/main/resources/terra.addon.yml +++ b/common/addons/palette-block-shortcut/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: palette-block-shortcut version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.palette.shortcut.block.PaletteBlockShortcutAddon" + - "com.dfsek.terra.addons.palette.shortcut.block.PaletteBlockShortcutAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/PipelineImageAddon.java b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/PipelineImageAddon.java index eb62a79b2..df69d9662 100644 --- a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/PipelineImageAddon.java +++ b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/PipelineImageAddon.java @@ -28,11 +28,13 @@ import com.dfsek.terra.api.world.biome.Biome; public class PipelineImageAddon implements AddonInitializer { - public static final TypeKey>>> PIPELINE_BIOME_COLOR_CONVERTER_REGISTRY_KEY = new TypeKey<>() { - }; + public static final TypeKey>>> PIPELINE_BIOME_COLOR_CONVERTER_REGISTRY_KEY = + new TypeKey<>() { + }; - public static final TypeKey>>> PIPELINE_BIOME_COLOR_MAPPING_REGISTRY_KEY = new TypeKey<>() { - }; + public static final TypeKey>>> PIPELINE_BIOME_COLOR_MAPPING_REGISTRY_KEY = + new TypeKey<>() { + }; @Inject private Platform platform; @@ -48,19 +50,24 @@ public class PipelineImageAddon implements AddonInitializer { .register(addon, ConfigPackPreLoadEvent.class) .priority(500) .then(event -> { - CheckedRegistry>>> biomeColorConverterRegistry = event.getPack().getOrCreateRegistry( - PIPELINE_BIOME_COLOR_CONVERTER_REGISTRY_KEY); + CheckedRegistry>>> biomeColorConverterRegistry = + event.getPack().getOrCreateRegistry( + PIPELINE_BIOME_COLOR_CONVERTER_REGISTRY_KEY); biomeColorConverterRegistry.register(addon.key("EXACT"), ExactPipelineBiomeColorConverterTemplate::new); biomeColorConverterRegistry.register(addon.key("CLOSEST"), ClosestPipelineBiomeColorConverterTemplate::new); }) .then(event -> { - CheckedRegistry>> sourceRegistry = event.getPack().getOrCreateRegistry(BiomePipelineAddon.SOURCE_REGISTRY_KEY); + CheckedRegistry>> sourceRegistry = event.getPack().getOrCreateRegistry( + BiomePipelineAddon.SOURCE_REGISTRY_KEY); sourceRegistry.register(addon.key("IMAGE"), ImageSourceTemplate::new); }) .then(event -> { - CheckedRegistry>>> biomeColorMappingRegistry = event.getPack().getOrCreateRegistry( - PIPELINE_BIOME_COLOR_MAPPING_REGISTRY_KEY); - biomeColorMappingRegistry.register(addon.key("USE_BIOME_COLORS"), () -> () -> new BiomeDefinedColorMapping<>(event.getPack().getRegistry(Biome.class), DelegatedPipelineBiome::new)); + CheckedRegistry>>> biomeColorMappingRegistry = + event.getPack().getOrCreateRegistry( + PIPELINE_BIOME_COLOR_MAPPING_REGISTRY_KEY); + biomeColorMappingRegistry.register(addon.key("USE_BIOME_COLORS"), + () -> () -> new BiomeDefinedColorMapping<>(event.getPack().getRegistry(Biome.class), + DelegatedPipelineBiome::new)); biomeColorMappingRegistry.register(addon.key("MAP"), DefinedPipelineBiomeColorMappingTemplate::new); }) .failThrough(); diff --git a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ClosestPipelineBiomeColorConverterTemplate.java b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ClosestPipelineBiomeColorConverterTemplate.java index a695398dc..df5fb3471 100644 --- a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ClosestPipelineBiomeColorConverterTemplate.java +++ b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ClosestPipelineBiomeColorConverterTemplate.java @@ -8,7 +8,7 @@ import com.dfsek.terra.addons.image.converter.mapping.ColorMapping; public class ClosestPipelineBiomeColorConverterTemplate extends ClosestColorConverterTemplate { - + @Value("match") private ColorMapping match; diff --git a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ExactPipelineBiomeColorConverterTemplate.java b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ExactPipelineBiomeColorConverterTemplate.java index 305a03e31..ac94d2bd9 100644 --- a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ExactPipelineBiomeColorConverterTemplate.java +++ b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ExactPipelineBiomeColorConverterTemplate.java @@ -12,19 +12,19 @@ public class ExactPipelineBiomeColorConverterTemplate extends ExactColorConverte @Value("match") private ColorMapping match; - + @Value("else") private PipelineBiome fallback; @Value("ignore-alpha") @Default private boolean ignoreAlpha = true; - + @Override protected ColorMapping getMapping() { return match; } - + @Override protected PipelineBiome getFallback() { return fallback; diff --git a/common/addons/pipeline-image/src/main/resources/terra.addon.yml b/common/addons/pipeline-image/src/main/resources/terra.addon.yml index 09adeb933..0da6c930c 100644 --- a/common/addons/pipeline-image/src/main/resources/terra.addon.yml +++ b/common/addons/pipeline-image/src/main/resources/terra.addon.yml @@ -1,14 +1,14 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: pipeline-image version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.pipeline.image.PipelineImageAddon" + - "com.dfsek.terra.addons.biome.pipeline.image.PipelineImageAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: library-image: "1.+" diff --git a/common/addons/structure-block-shortcut/src/main/resources/terra.addon.yml b/common/addons/structure-block-shortcut/src/main/resources/terra.addon.yml index d653e2d9c..62a2e875d 100644 --- a/common/addons/structure-block-shortcut/src/main/resources/terra.addon.yml +++ b/common/addons/structure-block-shortcut/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: structure-block-shortcut version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.palette.shortcut.block.StructureBlockShortcutAddon" + - "com.dfsek.terra.addons.palette.shortcut.block.StructureBlockShortcutAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/structure-mutator/src/main/resources/terra.addon.yml b/common/addons/structure-mutator/src/main/resources/terra.addon.yml index 29df5332d..328b8d54d 100644 --- a/common/addons/structure-mutator/src/main/resources/terra.addon.yml +++ b/common/addons/structure-mutator/src/main/resources/terra.addon.yml @@ -1,11 +1,11 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: structure-mutator version: @VERSION@ entrypoints: [ ] website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeSchematicAddon.java b/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeSchematicAddon.java index ce5a02453..4ed00cf8e 100644 --- a/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeSchematicAddon.java +++ b/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeSchematicAddon.java @@ -76,7 +76,7 @@ public class SpongeSchematicAddon implements AddonInitializer { int wid = baseTag.getShort("Width"); int len = baseTag.getShort("Length"); int hei = baseTag.getShort("Height"); - + CompoundTag metadata = baseTag.getCompoundTag("Metadata"); Vector3Int offset = switch(ver) { diff --git a/common/addons/structure-sponge-loader/src/main/resources/terra.addon.yml b/common/addons/structure-sponge-loader/src/main/resources/terra.addon.yml index d5635f09b..a3c6a8ecf 100644 --- a/common/addons/structure-sponge-loader/src/main/resources/terra.addon.yml +++ b/common/addons/structure-sponge-loader/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: structure-sponge-loader version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.sponge.SpongeSchematicAddon" + - "com.dfsek.terra.addons.sponge.SpongeSchematicAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/Parser.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/Parser.java index 7c4a47639..82da454dd 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/Parser.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/Parser.java @@ -338,9 +338,9 @@ public class Parser { Returnable value = parseExpression(tokens, true, scopeBuilder); ParserUtil.checkReturnType(value, returnType); - + String id = identifier.getContent(); - + return switch(value.returnType()) { case NUMBER -> new NumAssignmentNode((Returnable) value, identifier.getPosition(), scopeBuilder.num(id)); case STRING -> new StrAssignmentNode((Returnable) value, identifier.getPosition(), scopeBuilder.str(id)); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Executable.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Executable.java index 6f9c026a0..09c11f2dc 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Executable.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Executable.java @@ -7,12 +7,12 @@ import com.dfsek.terra.addons.terrascript.parser.lang.Scope.ScopeBuilder; public class Executable { private final Block script; private final ThreadLocal scope; - + public Executable(Block script, ScopeBuilder scopeBuilder) { this.script = script; this.scope = ThreadLocal.withInitial(scopeBuilder::build); } - + public boolean execute(ImplementationArguments arguments) { return script.apply(arguments, scope.get()).getLevel() != Block.ReturnLevel.FAIL; } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Scope.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Scope.java index 951bb261c..cd2de2393 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Scope.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Scope.java @@ -74,7 +74,7 @@ public class Scope { } return id; } - + public int num(String id) { int num = numSize; indices.put(check(id), Pair.of(num, ReturnType.NUMBER)); @@ -105,14 +105,14 @@ public class Scope { parent.updateBoolSize(size); } } - + private void updateNumSize(int size) { this.numSize = Math.max(numSize, size); if(parent != null) { parent.updateNumSize(size); } } - + private void updateStrSize(int size) { this.strSize = Math.max(strSize, size); if(parent != null) { diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/BooleanConstant.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/BooleanConstant.java index c51bf5870..cdf1bcb1c 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/BooleanConstant.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/BooleanConstant.java @@ -14,7 +14,7 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class BooleanConstant extends ConstantExpression { private final boolean constant; - + public BooleanConstant(Boolean constant, Position position) { super(constant, position); this.constant = constant; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/NumericConstant.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/NumericConstant.java index 721ecd560..ad1cb1ad1 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/NumericConstant.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/NumericConstant.java @@ -15,7 +15,7 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class NumericConstant extends ConstantExpression { private final double constant; - + public NumericConstant(Number constant, Position position) { super(constant, position); this.constant = constant.doubleValue(); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/Function.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/Function.java index 004c66f1b..87c16e700 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/Function.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/Function.java @@ -19,12 +19,12 @@ public interface Function extends Returnable { public ReturnType returnType() { return null; } - + @Override public Object apply(ImplementationArguments implementationArguments, Scope scope) { return null; } - + @Override public Position getPosition() { return null; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanOrOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanOrOperation.java index 85fecf29f..fa7231221 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanOrOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanOrOperation.java @@ -27,7 +27,7 @@ public class BooleanOrOperation extends BinaryOperation { public boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { return left.applyBoolean(implementationArguments, scope) || right.applyBoolean(implementationArguments, scope); } - + @Override public ReturnType returnType() { return ReturnType.BOOLEAN; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ModuloOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ModuloOperation.java index 71225b1e4..fcc5023fa 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ModuloOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ModuloOperation.java @@ -27,7 +27,7 @@ public class ModuloOperation extends BinaryOperation { public double applyDouble(ImplementationArguments implementationArguments, Scope scope) { return left.applyDouble(implementationArguments, scope) % right.applyDouble(implementationArguments, scope); } - + @Override public ReturnType returnType() { return ReturnType.NUMBER; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/MultiplicationOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/MultiplicationOperation.java index 40480d113..bd0acd8c5 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/MultiplicationOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/MultiplicationOperation.java @@ -27,7 +27,7 @@ public class MultiplicationOperation extends BinaryOperation { public double applyDouble(ImplementationArguments implementationArguments, Scope scope) { return left.applyDouble(implementationArguments, scope) * right.applyDouble(implementationArguments, scope); } - + @Override public ReturnType returnType() { return ReturnType.NUMBER; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NumberAdditionOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NumberAdditionOperation.java index fb4af8020..32c649247 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NumberAdditionOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NumberAdditionOperation.java @@ -27,7 +27,7 @@ public class NumberAdditionOperation extends BinaryOperation { public double applyDouble(ImplementationArguments implementationArguments, Scope scope) { return left.applyDouble(implementationArguments, scope) + right.applyDouble(implementationArguments, scope); } - + @Override public ReturnType returnType() { return ReturnType.NUMBER; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/SubtractionOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/SubtractionOperation.java index f2905ae88..427756171 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/SubtractionOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/SubtractionOperation.java @@ -27,7 +27,7 @@ public class SubtractionOperation extends BinaryOperation { public double applyDouble(ImplementationArguments implementationArguments, Scope scope) { return left.applyDouble(implementationArguments, scope) - right.applyDouble(implementationArguments, scope); } - + @Override public ReturnType returnType() { return ReturnType.NUMBER; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java index 61d96d36a..746fbd14e 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java @@ -40,7 +40,7 @@ public class EqualsStatement extends BinaryOperation { if(leftValue instanceof Number l && rightValue instanceof Number r) { return Math.abs(l.doubleValue() - r.doubleValue()) <= EPSILON; } - + return leftValue.equals(rightValue); } } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanOrEqualsStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanOrEqualsStatement.java index ad03a9793..6453e8d62 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanOrEqualsStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanOrEqualsStatement.java @@ -29,7 +29,7 @@ public class LessThanOrEqualsStatement extends BinaryOperation public boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { return left.applyDouble(implementationArguments, scope) <= right.applyDouble(implementationArguments, scope); } - + @Override public Returnable.ReturnType returnType() { return Returnable.ReturnType.BOOLEAN; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanStatement.java index 39941c6c4..f710e3630 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanStatement.java @@ -29,7 +29,7 @@ public class LessThanStatement extends BinaryOperation { public boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { return left.applyDouble(implementationArguments, scope) < right.applyDouble(implementationArguments, scope); } - + @Override public Returnable.ReturnType returnType() { return Returnable.ReturnType.BOOLEAN; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java index 032108784..d06152ec0 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java @@ -7,36 +7,11 @@ package com.dfsek.terra.addons.terrascript.script; -import org.apache.commons.io.IOUtils; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import java.io.IOException; -import java.io.InputStream; -import java.nio.charset.Charset; -import java.util.Random; - import com.dfsek.terra.addons.terrascript.parser.Parser; import com.dfsek.terra.addons.terrascript.parser.lang.Executable; import com.dfsek.terra.addons.terrascript.parser.lang.Returnable; import com.dfsek.terra.addons.terrascript.parser.lang.functions.FunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.BinaryNumberFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.BiomeFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.BlockFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.CheckBlockFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.EntityFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.GetMarkFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.LootFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.PullFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.RandomFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.RecursionsFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.SetMarkFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.StateFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.StructureFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.UnaryBooleanFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.UnaryNumberFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.UnaryStringFunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.ZeroArgFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.*; import com.dfsek.terra.api.Platform; import com.dfsek.terra.api.registry.Registry; import com.dfsek.terra.api.registry.key.Keyed; @@ -48,6 +23,15 @@ import com.dfsek.terra.api.util.Rotation; import com.dfsek.terra.api.util.vector.Vector3Int; import com.dfsek.terra.api.world.WritableWorld; +import org.apache.commons.io.IOUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.Charset; +import java.util.Random; + public class StructureScript implements Structure, Keyed { private static final Logger LOGGER = LoggerFactory.getLogger(StructureScript.class); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java index 446466c8e..aa9f7c21e 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java @@ -69,7 +69,7 @@ public class LootFunction implements Function { y.apply(implementationArguments, scope) .intValue(), (int) Math.round(xz.getZ())).mutable().add(arguments.getOrigin()).immutable(); - + try { BlockEntity data = arguments.getWorld().getBlockEntity(apply); if(!(data instanceof Container container)) { @@ -77,12 +77,12 @@ public class LootFunction implements Function { apply, data); return; } - + LootPopulateEvent event = new LootPopulateEvent(container, table, arguments.getWorld().getPack(), script); platform.getEventManager().callEvent(event); if(event.isCancelled()) return; - + event.getTable().fillInventory(container.getInventory(), new Random(apply.hashCode())); data.update(false); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java index 640d52ecc..516c5fd07 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java @@ -7,9 +7,6 @@ package com.dfsek.terra.addons.terrascript.script.functions; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - import com.dfsek.terra.addons.terrascript.parser.lang.ImplementationArguments; import com.dfsek.terra.addons.terrascript.parser.lang.Returnable; import com.dfsek.terra.addons.terrascript.parser.lang.Scope; @@ -21,6 +18,9 @@ import com.dfsek.terra.api.util.RotationUtil; import com.dfsek.terra.api.util.vector.Vector2; import com.dfsek.terra.api.util.vector.Vector3; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + public class StateFunction implements Function { private static final Logger LOGGER = LoggerFactory.getLogger(StateFunction.class); diff --git a/common/addons/structure-terrascript-loader/src/main/resources/terra.addon.yml b/common/addons/structure-terrascript-loader/src/main/resources/terra.addon.yml index 0850687c9..20352eb7e 100644 --- a/common/addons/structure-terrascript-loader/src/main/resources/terra.addon.yml +++ b/common/addons/structure-terrascript-loader/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: structure-terrascript-loader version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.terrascript.TerraScriptAddon" + - "com.dfsek.terra.addons.terrascript.TerraScriptAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/terrascript-function-check-noise-3d/src/main/resources/terra.addon.yml b/common/addons/terrascript-function-check-noise-3d/src/main/resources/terra.addon.yml index 028db2274..1ab94f379 100644 --- a/common/addons/terrascript-function-check-noise-3d/src/main/resources/terra.addon.yml +++ b/common/addons/terrascript-function-check-noise-3d/src/main/resources/terra.addon.yml @@ -1,15 +1,15 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: structure-function-check-noise-3d version: @VERSION@ entrypoints: - - "com.dfsek.terra.addon.terrascript.check.TerraScriptCheckFunctionAddon" + - "com.dfsek.terra.addon.terrascript.check.TerraScriptCheckFunctionAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - structure-terrascript-loader: "1.+" - chunk-generator-noise-3d: "1.+" \ No newline at end of file + structure-terrascript-loader: "1.+" + chunk-generator-noise-3d: "1.+" \ No newline at end of file diff --git a/common/addons/terrascript-function-sampler/src/main/resources/terra.addon.yml b/common/addons/terrascript-function-sampler/src/main/resources/terra.addon.yml index 635814c2c..31bb39127 100644 --- a/common/addons/terrascript-function-sampler/src/main/resources/terra.addon.yml +++ b/common/addons/terrascript-function-sampler/src/main/resources/terra.addon.yml @@ -1,15 +1,15 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: terrascript-function-sampler version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.terrascript.sampler.TerraScriptSamplerFunctionAddon" + - "com.dfsek.terra.addons.terrascript.sampler.TerraScriptSamplerFunctionAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - structure-terrascript-loader: "1.+" - config-noise-function: "1.+" \ No newline at end of file + structure-terrascript-loader: "1.+" + config-noise-function: "1.+" \ No newline at end of file diff --git a/common/api/build.gradle.kts b/common/api/build.gradle.kts index bdcdd3901..68a2f0d75 100644 --- a/common/api/build.gradle.kts +++ b/common/api/build.gradle.kts @@ -3,9 +3,9 @@ dependencies { compileOnlyApi("org.slf4j", "slf4j-api", Versions.Libraries.slf4j) testImplementation("org.slf4j", "slf4j-api", Versions.Libraries.slf4j) api("cloud.commandframework", "cloud-core", Versions.Libraries.cloud) - + api("com.dfsek.tectonic", "common", Versions.Libraries.tectonic) - + api("com.github.ben-manes.caffeine:caffeine:3.1.0") } \ No newline at end of file diff --git a/common/api/src/main/java/com/dfsek/terra/api/Platform.java b/common/api/src/main/java/com/dfsek/terra/api/Platform.java index a6ed29a54..744d7f716 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/Platform.java +++ b/common/api/src/main/java/com/dfsek/terra/api/Platform.java @@ -7,11 +7,6 @@ package com.dfsek.terra.api; -import org.jetbrains.annotations.Contract; -import org.jetbrains.annotations.NotNull; - -import java.io.File; - import com.dfsek.terra.api.addon.BaseAddon; import com.dfsek.terra.api.config.ConfigPack; import com.dfsek.terra.api.config.PluginConfig; @@ -23,6 +18,11 @@ import com.dfsek.terra.api.registry.CheckedRegistry; import com.dfsek.terra.api.registry.Registry; import com.dfsek.terra.api.tectonic.LoaderRegistrar; +import org.jetbrains.annotations.Contract; +import org.jetbrains.annotations.NotNull; + +import java.io.File; + /** * Represents a Terra mod/plugin instance. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/GeometryUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/GeometryUtil.java index 25984257f..6bb21b3df 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/GeometryUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/GeometryUtil.java @@ -7,7 +7,7 @@ import com.dfsek.terra.api.util.vector.Vector3Int; public final class GeometryUtil { private GeometryUtil() { - + } public static void sphere(Vector3Int origin, int radius, Consumer action) { diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java index 36bf0472e..716b879af 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java @@ -14,11 +14,14 @@ import java.util.List; * Utility class for mathematical functions. */ public final class MathUtil { + /** + * Epsilon for fuzzy floating point comparisons. + */ + public static final double EPSILON = 1.0E-5; private static final int SIN_BITS, SIN_MASK, SIN_COUNT; private static final double radFull, radToIndex; private static final double degFull, degToIndex; private static final double[] sin, cos; - static { SIN_BITS = 12; SIN_MASK = ~(-1 << SIN_BITS); @@ -32,23 +35,18 @@ public final class MathUtil { sin = new double[SIN_COUNT]; cos = new double[SIN_COUNT]; - for (int i = 0; i < SIN_COUNT; i++) { + for(int i = 0; i < SIN_COUNT; i++) { sin[i] = Math.sin((i + 0.5f) / SIN_COUNT * radFull); cos[i] = Math.cos((i + 0.5f) / SIN_COUNT * radFull); } // Four cardinal directions (credits: Nate) - for (int i = 0; i < 360; i += 90) { + for(int i = 0; i < 360; i += 90) { sin[(int) (i * degToIndex) & SIN_MASK] = Math.sin(i * Math.PI / 180.0); cos[(int) (i * degToIndex) & SIN_MASK] = Math.cos(i * Math.PI / 180.0); } } - /** - * Epsilon for fuzzy floating point comparisons. - */ - public static final double EPSILON = 1.0E-5; - public static double sin(double rad) { return sin[(int) (rad * radToIndex) & SIN_MASK]; } @@ -114,7 +112,7 @@ public final class MathUtil { } public static int normalizeIndex(double val, int size) { - return Math.max(Math.min((int)Math.floor(((val + 1D) / 2D) * size), size - 1), 0); + return Math.max(Math.min((int) Math.floor(((val + 1D) / 2D) * size), size - 1), 0); } public static long squash(int first, int last) { diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java b/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java index dd202560d..84c9041e5 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java @@ -57,13 +57,15 @@ public class ProbabilityCollection implements Collection { @SuppressWarnings("unchecked") public E get(NoiseSampler n, Vector3Int vector3Int, long seed) { if(array.length == 0) return null; - return (E) array[(int) MathUtil.normalizeIndex(n.noise(seed, vector3Int.getX(), vector3Int.getY(), vector3Int.getZ()), array.length)]; + return (E) array[(int) MathUtil.normalizeIndex(n.noise(seed, vector3Int.getX(), vector3Int.getY(), vector3Int.getZ()), + array.length)]; } @SuppressWarnings("unchecked") public E get(NoiseSampler n, Vector3 vector3Int, long seed) { if(array.length == 0) return null; - return (E) array[(int) MathUtil.normalizeIndex(n.noise(seed, vector3Int.getX(), vector3Int.getY(), vector3Int.getZ()), array.length)]; + return (E) array[(int) MathUtil.normalizeIndex(n.noise(seed, vector3Int.getX(), vector3Int.getY(), vector3Int.getZ()), + array.length)]; } @SuppressWarnings("unchecked") diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/generic/either/Either.java b/common/api/src/main/java/com/dfsek/terra/api/util/generic/either/Either.java index 25022cf18..56fdec9d7 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/generic/either/Either.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/generic/either/Either.java @@ -80,7 +80,7 @@ public final class Either { @Override public boolean equals(Object obj) { if(!(obj instanceof Either that)) return false; - + return (this.leftPresent && that.leftPresent && Objects.equals(this.left, that.left)) || (!this.leftPresent && !that.leftPresent && Objects.equals(this.right, that.right)); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/generic/pair/Pair.java b/common/api/src/main/java/com/dfsek/terra/api/util/generic/pair/Pair.java index 51e72ab80..1eef92360 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/generic/pair/Pair.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/generic/pair/Pair.java @@ -106,52 +106,52 @@ public final class Pair { return String.format("{%s,%s}", left, right); } - + public static class Mutable { private L left; private R right; - + private Mutable(L left, R right) { this.left = left; this.right = right; } - + @NotNull @Contract("_, _ -> new") public static Pair.Mutable of(L1 left, R1 right) { return new Mutable<>(left, right); } - + @Contract("-> new") public Pair immutable() { return Pair.of(left, right); } - + public L getLeft() { return left; } - + public void setLeft(L left) { this.left = left; } - + public R getRight() { return right; } - + public void setRight(R right) { this.right = right; } - + @Override public int hashCode() { return Objects.hash(left, right); } - + @Override public boolean equals(Object obj) { if(!(obj instanceof Mutable that)) return false; - + return Objects.equals(this.left, that.left) && Objects.equals(this.right, that.right); } } diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/reflection/ReflectionUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/reflection/ReflectionUtil.java index a79a4cefa..795ba8936 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/reflection/ReflectionUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/reflection/ReflectionUtil.java @@ -73,7 +73,7 @@ public final class ReflectionUtil { public static String typeToString(Type type) { return type instanceof Class ? ((Class) type).getName() : type.toString(); } - + public static boolean equals(Type a, Type b) { if(a == b) { return true; diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java index 0a139478a..7d8e45665 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java @@ -28,6 +28,7 @@ public class Vector2 { this.x = x; this.z = z; } + public static Vector2 zero() { return ZERO; } diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2Int.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2Int.java index 1a64414c8..48e71562b 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2Int.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2Int.java @@ -66,29 +66,29 @@ public class Vector2Int { return false; } - + public static class Mutable extends Vector2Int { - + protected Mutable(int x, int z) { super(x, z); } - + public int getZ() { return z; } - + public void setZ(int z) { this.z = z; } - + public int getX() { return x; } - + public void setX(int x) { this.x = x; } - + public Vector2Int immutable() { return new Vector2Int(x, z); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java index f346fb433..2f649b3d6 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java @@ -22,6 +22,7 @@ public class Vector3 { this.y = y; this.z = z; } + public static Vector3 zero() { return ZERO; } diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/CachingBiomeProvider.java b/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/CachingBiomeProvider.java index fff67f75a..37aeed63b 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/CachingBiomeProvider.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/CachingBiomeProvider.java @@ -30,12 +30,12 @@ public class CachingBiomeProvider implements BiomeProvider, Handle { .initialCapacity(98304) .maximumSize(98304) // 1 full chunk (high res) .build(vec -> delegate.getBiome(vec.x * res, vec.y * res, vec.z * res, vec.seed)); - + this.baseCache = Caffeine .newBuilder() .maximumSize(256) // 1 full chunk (high res) .build(vec -> delegate.getBaseBiome(vec.x * res, vec.z * res, vec.seed)); - + } @Override @@ -80,8 +80,8 @@ public class CachingBiomeProvider implements BiomeProvider, Handle { return 31 * code + ((int) (seed ^ (seed >>> 32))); } } - - + + private record SeededVector2(int x, int z, long seed) { @Override public boolean equals(Object obj) { diff --git a/common/api/src/test/java/util/ColumnTest.java b/common/api/src/test/java/util/ColumnTest.java index 06f4a03e4..c6bff5035 100644 --- a/common/api/src/test/java/util/ColumnTest.java +++ b/common/api/src/test/java/util/ColumnTest.java @@ -86,17 +86,17 @@ public class ColumnTest { public int getMaxY() { return max; } - + @Override public int getX() { return 0; } - + @Override public int getZ() { return 0; } - + @Override public T get(int y) { return p.apply(y); diff --git a/common/implementation/base/build.gradle.kts b/common/implementation/base/build.gradle.kts index 75ebf671e..aa7626f3f 100644 --- a/common/implementation/base/build.gradle.kts +++ b/common/implementation/base/build.gradle.kts @@ -1,15 +1,15 @@ dependencies { api(project(":common:api")) api(project(":common:implementation:bootstrap-addon-loader")) - + testImplementation("org.slf4j", "slf4j-api", Versions.Libraries.slf4j) - + implementation("commons-io", "commons-io", Versions.Libraries.Internal.apacheIO) - + implementation("org.apache.commons", "commons-text", Versions.Libraries.Internal.apacheText) implementation("com.dfsek.tectonic", "yaml", Versions.Libraries.tectonic) - - + + implementation("com.dfsek", "paralithic", Versions.Libraries.paralithic) } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/AbstractPlatform.java b/common/implementation/base/src/main/java/com/dfsek/terra/AbstractPlatform.java index 4ea9466ec..84ef39437 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/AbstractPlatform.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/AbstractPlatform.java @@ -180,7 +180,7 @@ public abstract class AbstractPlatform implements Platform { bootstrapAddonLoader.loadAddons(addonsFolder, bootstrapAddonClassLoader) .forEach(bootstrapAddon -> { platformInjector.inject(bootstrapAddon); - + bootstrapAddon.loadAddons(addonsFolder, bootstrapAddonClassLoader) .forEach(addonList::add); }); diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/config/BufferedImageLoader.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/config/BufferedImageLoader.java index b6f50dd78..057eba98e 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/config/BufferedImageLoader.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/config/BufferedImageLoader.java @@ -33,6 +33,7 @@ import com.dfsek.terra.api.config.ConfigPack; import com.dfsek.terra.api.config.Loader; import com.dfsek.terra.api.properties.Properties; + /* * @deprecated Use the Image and ImageLoader class provided by the library-image addon instead. This is subject to removal in v7. */ @@ -45,7 +46,7 @@ public class BufferedImageLoader implements TypeLoader { public BufferedImageLoader(Loader files, ConfigPack pack) { this.files = files; this.pack = pack; - if (!pack.getContext().has(ImageCache.class)) + if(!pack.getContext().has(ImageCache.class)) pack.getContext().put(new ImageCache(new ConcurrentHashMap<>())); } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaListLikePreprocessor.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaListLikePreprocessor.java index 59e335ab4..db868690b 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaListLikePreprocessor.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaListLikePreprocessor.java @@ -68,7 +68,8 @@ public class MetaListLikePreprocessor extends MetaPreprocessor { if(!(metaValue instanceof List)) { throw new LoadException( - "Meta list / set injection (via <<) must point to a list. '" + meta + "' points to type " + metaValue.getClass().getCanonicalName(), + "Meta list / set injection (via <<) must point to a list. '" + meta + "' points to type " + + metaValue.getClass().getCanonicalName(), depthTracker); } diff --git a/common/implementation/base/src/main/resources/config.yml b/common/implementation/base/src/main/resources/config.yml index 72dd67061..6d120ef58 100644 --- a/common/implementation/base/src/main/resources/config.yml +++ b/common/implementation/base/src/main/resources/config.yml @@ -6,15 +6,15 @@ # wiki for information regarding config pack development. debug: - commands: false - log: false - profiler: false - script: false + commands: false + log: false + profiler: false + script: false dump-default: true biome-search-resolution: 4 cache: - structure: 32 - sampler: 128 - biome-provider: 32 + structure: 32 + sampler: 128 + biome-provider: 32 script: - max-recursion: 1000 \ No newline at end of file + max-recursion: 1000 \ No newline at end of file diff --git a/common/implementation/base/src/test/java/registry/RegistryTest.java b/common/implementation/base/src/test/java/registry/RegistryTest.java index 3f17a1776..b11e123b6 100644 --- a/common/implementation/base/src/test/java/registry/RegistryTest.java +++ b/common/implementation/base/src/test/java/registry/RegistryTest.java @@ -50,7 +50,7 @@ public class RegistryTest { test.registerChecked(RegistryKey.parse("test:test"), "bazinga2"); fail("Shouldn't be able to re-register with #registerChecked!"); } catch(DuplicateEntryException ignore) { - + } } @@ -66,7 +66,7 @@ public class RegistryTest { test.register(RegistryKey.parse("test:test"), "bazinga2"); fail("Shouldn't be able to re-register in CheckedRegistry!"); } catch(DuplicateEntryException ignore) { - + } } @@ -90,7 +90,7 @@ public class RegistryTest { test.getByID("test"); fail("Shouldn't be able to get with ambiguous ID!"); } catch(IllegalArgumentException ignore) { - + } } } diff --git a/common/implementation/base/src/test/resources/config.yml b/common/implementation/base/src/test/resources/config.yml index d2a7fb934..49f6def92 100644 --- a/common/implementation/base/src/test/resources/config.yml +++ b/common/implementation/base/src/test/resources/config.yml @@ -2,9 +2,9 @@ dimensions: 2 type: Cellular frequency: 0.01 cellular: - return: Distance3Div + return: Distance3Div normalize: - type: LINEAR - linear: - min: -1 - max: 0 \ No newline at end of file + type: LINEAR + linear: + min: -1 + max: 0 \ No newline at end of file diff --git a/common/implementation/base/src/test/resources/meta.yml b/common/implementation/base/src/test/resources/meta.yml index 116b32b89..5762716a6 100644 --- a/common/implementation/base/src/test/resources/meta.yml +++ b/common/implementation/base/src/test/resources/meta.yml @@ -1,18 +1,18 @@ list: - - ONE - - "<< metaTarget.yml:list" - - FOUR - - FIVE - - SIX - - "<< metaTarget.yml:list2" - - NINE - - TEN + - ONE + - "<< metaTarget.yml:list" + - FOUR + - FIVE + - SIX + - "<< metaTarget.yml:list2" + - NINE + - TEN map: - "<<": - - metaTarget.yml:map1 - - metaTarget.yml:map2 - one: ONE - two: TWO + "<<": + - metaTarget.yml:map1 + - metaTarget.yml:map2 + one: ONE + two: TWO string: "one-${metaTarget.yml:string.two}-${metaTarget.yml:string.three}-four-five-${metaTarget.yml:string.six}" int: 2 + 4 double: ${metaTarget.yml:double} + 5.6 \ No newline at end of file diff --git a/common/implementation/base/src/test/resources/metaTarget.yml b/common/implementation/base/src/test/resources/metaTarget.yml index 338930b52..17e3c41d0 100644 --- a/common/implementation/base/src/test/resources/metaTarget.yml +++ b/common/implementation/base/src/test/resources/metaTarget.yml @@ -1,17 +1,17 @@ list: - - TWO - - THREE + - TWO + - THREE list2: - - SEVEN - - EIGHT + - SEVEN + - EIGHT map1: - three: THREE - four: FOUR - five: FIVE + three: THREE + four: FOUR + five: FIVE map2: - six: SIX + six: SIX string: - two: two - three: three - six: six + two: two + three: three + six: six double: 1 \ No newline at end of file diff --git a/common/implementation/bootstrap-addon-loader/src/main/java/com/dfsek/terra/addon/BootstrapAddonLoader.java b/common/implementation/bootstrap-addon-loader/src/main/java/com/dfsek/terra/addon/BootstrapAddonLoader.java index 301f276fa..874e8047c 100644 --- a/common/implementation/bootstrap-addon-loader/src/main/java/com/dfsek/terra/addon/BootstrapAddonLoader.java +++ b/common/implementation/bootstrap-addon-loader/src/main/java/com/dfsek/terra/addon/BootstrapAddonLoader.java @@ -84,7 +84,7 @@ public class BootstrapAddonLoader implements BootstrapBaseAddon bootstrapAddons = Files.walk(bootstrapFolder, 1, FileVisitOption.FOLLOW_LINKS)) { return bootstrapAddons.filter(path -> path.toFile().isFile()) .filter(path -> path.toFile().canRead()) @@ -96,7 +96,7 @@ public class BootstrapAddonLoader implements BootstrapBaseAddon event.getPack().getContext().put(event.loadTemplate(new PreLoadCompatibilityOptions()))) - .global(); + .getHandler(FunctionalEventHandler.class) + .register(this, ConfigPackPreLoadEvent.class) + .then(event -> event.getPack().getContext().put(event.loadTemplate(new PreLoadCompatibilityOptions()))) + .global(); terraBukkitPlugin.getEventManager() .getHandler(FunctionalEventHandler.class) diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java index 1ab9731ac..a33393cfd 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java @@ -94,7 +94,7 @@ public class TerraBukkitPlugin extends JavaPlugin { Bukkit.getPluginManager().registerEvents(new CommonListener(), this); // Register master event listener PaperUtil.checkPaper(this); - + Initializer.init(platform); } diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitBlockPopulator.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitBlockPopulator.java index 1a1cb3b13..51dc63300 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitBlockPopulator.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitBlockPopulator.java @@ -13,8 +13,8 @@ import com.dfsek.terra.bukkit.world.BukkitProtoWorld; public class BukkitBlockPopulator extends BlockPopulator { - private ConfigPack pack; private final BlockState air; + private ConfigPack pack; public BukkitBlockPopulator(ConfigPack pack, BlockState air) { this.pack = pack; @@ -28,6 +28,7 @@ public class BukkitBlockPopulator extends BlockPopulator { @Override public void populate(@NotNull WorldInfo worldInfo, @NotNull Random random, int chunkX, int chunkZ, @NotNull LimitedRegion limitedRegion) { - pack.getStages().forEach(generationStage -> generationStage.populate(new BukkitProtoWorld(limitedRegion, air, pack.getBiomeProvider()))); + pack.getStages().forEach( + generationStage -> generationStage.populate(new BukkitProtoWorld(limitedRegion, air, pack.getBiomeProvider()))); } } diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGeneratorWrapper.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGeneratorWrapper.java index f3235d65a..171b9e9eb 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGeneratorWrapper.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGeneratorWrapper.java @@ -40,11 +40,11 @@ import com.dfsek.terra.bukkit.world.BukkitWorldProperties; public class BukkitChunkGeneratorWrapper extends org.bukkit.generator.ChunkGenerator implements GeneratorWrapper { private static final Logger LOGGER = LoggerFactory.getLogger(BukkitChunkGeneratorWrapper.class); private final BlockState air; + private final BukkitBlockPopulator blockPopulator; private ChunkGenerator delegate; private ConfigPack pack; - private final BukkitBlockPopulator blockPopulator; - + public BukkitChunkGeneratorWrapper(ChunkGenerator delegate, ConfigPack pack, BlockState air) { this.delegate = delegate; this.pack = pack; @@ -87,7 +87,7 @@ public class BukkitChunkGeneratorWrapper extends org.bukkit.generator.ChunkGener public boolean shouldGenerateMobs() { return true; } - + @Override public boolean shouldGenerateStructures() { return true; @@ -107,7 +107,7 @@ public class BukkitChunkGeneratorWrapper extends org.bukkit.generator.ChunkGener return delegate; } - + private record SeededVector(int x, int z, WorldProperties worldProperties) { @Override public boolean equals(Object obj) { @@ -116,7 +116,7 @@ public class BukkitChunkGeneratorWrapper extends org.bukkit.generator.ChunkGener } return false; } - + @Override public int hashCode() { int code = x; diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/handles/BukkitWorldHandle.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/handles/BukkitWorldHandle.java index 563a3b66e..e292fb0f2 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/handles/BukkitWorldHandle.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/handles/BukkitWorldHandle.java @@ -56,7 +56,8 @@ public class BukkitWorldHandle implements WorldHandle { return new BukkitEntityType(switch(entityID) { case "END_CRYSTAL" -> org.bukkit.entity.EntityType.ENDER_CRYSTAL; - case "ENDER_CRYSTAL" -> throw new IllegalArgumentException("Invalid entity identifier " + id); // make sure this issue can't happen the other way around. + case "ENDER_CRYSTAL" -> throw new IllegalArgumentException( + "Invalid entity identifier " + id); // make sure this issue can't happen the other way around. default -> org.bukkit.entity.EntityType.valueOf(entityID); }); } diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java index d634eedba..dfe81ca06 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java @@ -52,7 +52,7 @@ public class BukkitProtoWorld implements ProtoWorld { BlockData bukkitData = BukkitAdapter.adapt(data); delegate.setBlockData(x, y, z, bukkitData); if(physics) { - if (BukkitUtils.isLiquid(bukkitData)) { + if(BukkitUtils.isLiquid(bukkitData)) { delegate.scheduleFluidUpdate(x, y, z); } else { delegate.scheduleBlockUpdate(x, y, z); diff --git a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/AwfulBukkitHacks.java b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/AwfulBukkitHacks.java index e125ffb68..02ac1b5c8 100644 --- a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/AwfulBukkitHacks.java +++ b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/AwfulBukkitHacks.java @@ -91,7 +91,7 @@ public class AwfulBukkitHacks { ": " + vanilla.tags() .toList()); - + vanilla.tags() .forEach( tag -> collect diff --git a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSBiomeInjector.java index 6271e4632..1e8245b4c 100644 --- a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSBiomeInjector.java @@ -33,28 +33,28 @@ public class NMSBiomeInjector { .generationSettings(vanilla.getGenerationSettings()) .temperature(vanilla.getBaseTemperature()) .downfall(vanilla.getDownfall()); - + BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder(); - + effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier()); - + VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); - + effects.fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor())) - + .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) - + .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) - + .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); - + if(vanillaBiomeProperties.getFoliageColor() == null) { vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride); } else { effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor()); } - + if(vanillaBiomeProperties.getGrassColor() == null) { vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride); } else { @@ -66,7 +66,7 @@ public class NMSBiomeInjector { vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound); vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic); vanilla.getAmbientParticle().ifPresent(effects::ambientParticle); - + builder.specialEffects(effects.build()); return builder.build(); // build() diff --git a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/Reflection.java b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/Reflection.java index 9e226cb8d..793637395 100644 --- a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/Reflection.java +++ b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/Reflection.java @@ -22,14 +22,14 @@ public class Reflection { BIOME = reflectionProxyFactory.reflectionProxy(BiomeProxy.class); } - + @Proxies(MappedRegistry.class) public interface MappedRegistryProxy { @FieldSetter("frozen") void setFrozen(MappedRegistry instance, boolean frozen); } - + @Proxies(Biome.class) public interface BiomeProxy { @FieldGetter("biomeCategory") diff --git a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/AwfulBukkitHacks.java b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/AwfulBukkitHacks.java index 3bce51cdd..d4f934f36 100644 --- a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/AwfulBukkitHacks.java +++ b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/AwfulBukkitHacks.java @@ -92,7 +92,7 @@ public class AwfulBukkitHacks { ": " + vanilla.tags() .toList()); - + vanilla.tags() .forEach( tag -> collect diff --git a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeInjector.java index 8a5d56c35..61acffc74 100644 --- a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeInjector.java @@ -15,7 +15,7 @@ import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; public class NMSBiomeInjector { - + public static Optional> getEntry(Registry registry, ResourceLocation identifier) { return registry.getOptional(identifier) .flatMap(registry::getResourceKey) @@ -41,11 +41,11 @@ public class NMSBiomeInjector { VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); effects.fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor())) - + .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) - + .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) - + .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); if(vanillaBiomeProperties.getFoliageColor() == null) { diff --git a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSChunkGeneratorDelegate.java index ea8b2267d..5eecb9325 100644 --- a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSChunkGeneratorDelegate.java +++ b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSChunkGeneratorDelegate.java @@ -112,15 +112,16 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { @NotNull RandomState noiseConfig, @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) { return vanilla.fillFromNoise(executor, blender, noiseConfig, structureAccessor, chunk) - .thenApply(c -> { - LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); - BiomeProvider biomeProvider = pack.getBiomeProvider(); - PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); - if(compatibilityOptions.isBeard()) { - beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), biomeProvider, compatibilityOptions); - } - return c; - }); + .thenApply(c -> { + LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); + BiomeProvider biomeProvider = pack.getBiomeProvider(); + PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); + if(compatibilityOptions.isBeard()) { + beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), + biomeProvider, compatibilityOptions); + } + return c; + }); } private void beard(StructureManager structureAccessor, ChunkAccess chunk, WorldProperties world, BiomeProvider biomeProvider, @@ -187,10 +188,10 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { */ return vanilla.getBaseColumn(x, z, world, noiseConfig); } - + @Override public void addDebugScreenInfo(@NotNull List text, @NotNull RandomState noiseConfig, @NotNull BlockPos pos) { - + } @Override @@ -231,7 +232,7 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { } }); } - + private List generateRingPositions(StructureSet holder, RandomState randomstate, ConcentricRingsStructurePlacement concentricringsstructureplacement) { // Spigot if(concentricringsstructureplacement.count() == 0) { diff --git a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/Reflection.java b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/Reflection.java index b704952d5..58062c5a5 100644 --- a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/Reflection.java +++ b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/Reflection.java @@ -30,6 +30,7 @@ public class Reflection { void setFrozen(MappedRegistry instance, boolean frozen); } + @Proxies(StructureManager.class) public interface StructureManagerProxy { @FieldGetter("level") diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeInjector.java index efcdf004a..7067437dd 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeInjector.java @@ -15,7 +15,7 @@ import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; public class NMSBiomeInjector { - + public static Optional> getEntry(Registry registry, ResourceLocation identifier) { return registry.getOptional(identifier) .flatMap(registry::getResourceKey) @@ -41,11 +41,11 @@ public class NMSBiomeInjector { VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); effects.fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor())) - + .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) - + .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) - + .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); if(vanillaBiomeProperties.getFoliageColor() == null) { diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeProvider.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeProvider.java index e7b09426d..7c3820aad 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeProvider.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeProvider.java @@ -21,8 +21,8 @@ public class NMSBiomeProvider extends BiomeSource { super(delegate.stream() .map(biome -> RegistryFetcher.biomeRegistry() .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() - .get(NMSBiomeInfo.class) - .biomeKey()))); + .get(NMSBiomeInfo.class) + .biomeKey()))); this.delegate = delegate; this.seed = seed; } diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSChunkGeneratorDelegate.java index 5faa4ba4b..b057b808a 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSChunkGeneratorDelegate.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSChunkGeneratorDelegate.java @@ -90,15 +90,16 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { @NotNull RandomState noiseConfig, @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) { return vanilla.fillFromNoise(executor, blender, noiseConfig, structureAccessor, chunk) - .thenApply(c -> { - LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); - BiomeProvider biomeProvider = pack.getBiomeProvider(); - PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); - if(compatibilityOptions.isBeard()) { - beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), biomeProvider, compatibilityOptions); - } - return c; - }); + .thenApply(c -> { + LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); + BiomeProvider biomeProvider = pack.getBiomeProvider(); + PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); + if(compatibilityOptions.isBeard()) { + beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), + biomeProvider, compatibilityOptions); + } + return c; + }); } private void beard(StructureManager structureAccessor, ChunkAccess chunk, WorldProperties world, BiomeProvider biomeProvider, @@ -165,9 +166,9 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { */ return vanilla.getBaseColumn(x, z, world, noiseConfig); } - + @Override public void addDebugScreenInfo(@NotNull List text, @NotNull RandomState noiseConfig, @NotNull BlockPos pos) { - + } } diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSInjectListener.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSInjectListener.java index 015de732e..b805bfd61 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSInjectListener.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSInjectListener.java @@ -37,7 +37,7 @@ public class NMSInjectListener implements Listener { ChunkGenerator vanilla = serverWorld.getChunkSource().getGenerator(); NMSBiomeProvider provider = new NMSBiomeProvider(pack.getBiomeProvider(), craftWorld.getSeed()); - + serverWorld.getChunkSource().chunkMap.generator = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed()); LOGGER.info("Successfully injected into world."); diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/Reflection.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/Reflection.java index 11236d132..fd602468e 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/Reflection.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/Reflection.java @@ -36,12 +36,14 @@ public class Reflection { void setFrozen(MappedRegistry instance, boolean frozen); } + @Proxies(StructureManager.class) public interface StructureManagerProxy { @FieldGetter("level") LevelAccessor getLevel(StructureManager instance); } + @Proxies(Holder.Reference.class) public interface ReferenceProxy { @MethodName("bindValue") diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeInjector.java index 2c328f26d..71c81d511 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeInjector.java @@ -13,63 +13,64 @@ import java.util.Optional; import com.dfsek.terra.api.config.ConfigPack; import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; -public class NMSBiomeInjector { +public class NMSBiomeInjector { + public static Optional> getEntry(Registry registry, ResourceLocation identifier) { return registry.getOptional(identifier) .flatMap(registry::getResourceKey) .flatMap(registry::getHolder); } - + public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { Biome.BiomeBuilder builder = new Biome.BiomeBuilder(); - + builder .downfall(vanilla.climateSettings.downfall()) .temperature(vanilla.getBaseTemperature()) .mobSpawnSettings(vanilla.getMobSettings()) .generationSettings(vanilla.getGenerationSettings()); - - + + BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder(); - + effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier()); - + VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); - + effects.fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor())) - + .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) - + .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) - + .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); - + if(vanillaBiomeProperties.getFoliageColor() == null) { vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride); } else { effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor()); } - + if(vanillaBiomeProperties.getGrassColor() == null) { vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride); } else { // grass effects.grassColorOverride(vanillaBiomeProperties.getGrassColor()); } - + vanilla.getAmbientLoop().ifPresent(effects::ambientLoopSound); vanilla.getAmbientAdditions().ifPresent(effects::ambientAdditionsSound); vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound); vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic); vanilla.getAmbientParticle().ifPresent(effects::ambientParticle); - + builder.specialEffects(effects.build()); - + return builder.build(); } - + public static String createBiomeID(ConfigPack pack, com.dfsek.terra.api.registry.key.RegistryKey biomeID) { return pack.getID() .toLowerCase() + "/" + biomeID.getNamespace().toLowerCase(Locale.ROOT) + "/" + biomeID.getID().toLowerCase(Locale.ROOT); diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeProvider.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeProvider.java index 3040d1956..60a82f58e 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeProvider.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeProvider.java @@ -18,26 +18,27 @@ public class NMSBiomeProvider extends BiomeSource { private final BiomeProvider delegate; private final long seed; private final Registry biomeRegistry = RegistryFetcher.biomeRegistry(); - + public NMSBiomeProvider(BiomeProvider delegate, long seed) { super(); this.delegate = delegate; this.seed = seed; } + @Override protected Stream> collectPossibleBiomes() { - return delegate.stream() - .map(biome -> RegistryFetcher.biomeRegistry() - .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() - .get(NMSBiomeInfo.class) - .biomeKey())); + return delegate.stream() + .map(biome -> RegistryFetcher.biomeRegistry() + .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey())); } - + @Override protected @NotNull Codec codec() { return BiomeSource.CODEC; } - + @Override public @NotNull Holder getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) { return biomeRegistry.getHolderOrThrow(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed) diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSChunkGeneratorDelegate.java index e977a2855..97eba7114 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSChunkGeneratorDelegate.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSChunkGeneratorDelegate.java @@ -91,15 +91,16 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { @NotNull RandomState noiseConfig, @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) { return vanilla.fillFromNoise(executor, blender, noiseConfig, structureAccessor, chunk) - .thenApply(c -> { - LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); - BiomeProvider biomeProvider = pack.getBiomeProvider(); - PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); - if(compatibilityOptions.isBeard()) { - beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), biomeProvider, compatibilityOptions); - } - return c; - }); + .thenApply(c -> { + LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); + BiomeProvider biomeProvider = pack.getBiomeProvider(); + PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); + if(compatibilityOptions.isBeard()) { + beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), + biomeProvider, compatibilityOptions); + } + return c; + }); } private void beard(StructureManager structureAccessor, ChunkAccess chunk, WorldProperties world, BiomeProvider biomeProvider, @@ -162,9 +163,9 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { } return new NoiseColumn(getMinY(), array); } - + @Override public void addDebugScreenInfo(@NotNull List text, @NotNull RandomState noiseConfig, @NotNull BlockPos pos) { - + } } diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInjectListener.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInjectListener.java index 46b479860..2b8383b3d 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInjectListener.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInjectListener.java @@ -37,7 +37,7 @@ public class NMSInjectListener implements Listener { ChunkGenerator vanilla = serverWorld.getChunkSource().getGenerator(); NMSBiomeProvider provider = new NMSBiomeProvider(pack.getBiomeProvider(), craftWorld.getSeed()); - + serverWorld.getChunkSource().chunkMap.generator = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed()); LOGGER.info("Successfully injected into world."); diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/Reflection.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/Reflection.java index beb2c1e75..c0c9136ae 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/Reflection.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/Reflection.java @@ -36,12 +36,14 @@ public class Reflection { void setFrozen(MappedRegistry instance, boolean frozen); } + @Proxies(StructureManager.class) public interface StructureManagerProxy { @FieldGetter("level") LevelAccessor getLevel(StructureManager instance); } + @Proxies(Holder.Reference.class) public interface ReferenceProxy { @MethodName("bindValue") diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java index 36d43b0ec..a0245f021 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java @@ -13,63 +13,64 @@ import java.util.Optional; import com.dfsek.terra.api.config.ConfigPack; import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; -public class NMSBiomeInjector { +public class NMSBiomeInjector { + public static Optional> getEntry(Registry registry, ResourceLocation identifier) { return registry.getOptional(identifier) .flatMap(registry::getResourceKey) .flatMap(registry::getHolder); } - + public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { Biome.BiomeBuilder builder = new Biome.BiomeBuilder(); - + builder .downfall(vanilla.climateSettings.downfall()) .temperature(vanilla.getBaseTemperature()) .mobSpawnSettings(vanilla.getMobSettings()) .generationSettings(vanilla.getGenerationSettings()); - - + + BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder(); - + effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier()); - + VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); - + effects.fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor())) - + .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) - + .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) - + .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); - + if(vanillaBiomeProperties.getFoliageColor() == null) { vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride); } else { effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor()); } - + if(vanillaBiomeProperties.getGrassColor() == null) { vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride); } else { // grass effects.grassColorOverride(vanillaBiomeProperties.getGrassColor()); } - + vanilla.getAmbientLoop().ifPresent(effects::ambientLoopSound); vanilla.getAmbientAdditions().ifPresent(effects::ambientAdditionsSound); vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound); vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic); vanilla.getAmbientParticle().ifPresent(effects::ambientParticle); - + builder.specialEffects(effects.build()); - + return builder.build(); } - + public static String createBiomeID(ConfigPack pack, com.dfsek.terra.api.registry.key.RegistryKey biomeID) { return pack.getID() .toLowerCase() + "/" + biomeID.getNamespace().toLowerCase(Locale.ROOT) + "/" + biomeID.getID().toLowerCase(Locale.ROOT); diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java index 4f0cbea1a..17902f30c 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java @@ -18,26 +18,27 @@ public class NMSBiomeProvider extends BiomeSource { private final BiomeProvider delegate; private final long seed; private final Registry biomeRegistry = RegistryFetcher.biomeRegistry(); - + public NMSBiomeProvider(BiomeProvider delegate, long seed) { super(); this.delegate = delegate; this.seed = seed; } + @Override protected Stream> collectPossibleBiomes() { - return delegate.stream() - .map(biome -> RegistryFetcher.biomeRegistry() - .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() - .get(NMSBiomeInfo.class) - .biomeKey())); + return delegate.stream() + .map(biome -> RegistryFetcher.biomeRegistry() + .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey())); } - + @Override protected @NotNull Codec codec() { return BiomeSource.CODEC; } - + @Override public @NotNull Holder getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) { return biomeRegistry.getHolderOrThrow(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed) diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java index f0e929a5b..f140e2528 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java @@ -91,15 +91,16 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { @NotNull RandomState noiseConfig, @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) { return vanilla.fillFromNoise(executor, blender, noiseConfig, structureAccessor, chunk) - .thenApply(c -> { - LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); - BiomeProvider biomeProvider = pack.getBiomeProvider(); - PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); - if(compatibilityOptions.isBeard()) { - beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), biomeProvider, compatibilityOptions); - } - return c; - }); + .thenApply(c -> { + LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); + BiomeProvider biomeProvider = pack.getBiomeProvider(); + PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); + if(compatibilityOptions.isBeard()) { + beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), + biomeProvider, compatibilityOptions); + } + return c; + }); } private void beard(StructureManager structureAccessor, ChunkAccess chunk, WorldProperties world, BiomeProvider biomeProvider, @@ -162,9 +163,9 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { } return new NoiseColumn(getMinY(), array); } - + @Override public void addDebugScreenInfo(@NotNull List text, @NotNull RandomState noiseConfig, @NotNull BlockPos pos) { - + } } diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInjectListener.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInjectListener.java index 3b2fbb0f8..2d83d6c1b 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInjectListener.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInjectListener.java @@ -37,7 +37,7 @@ public class NMSInjectListener implements Listener { ChunkGenerator vanilla = serverWorld.getChunkSource().getGenerator(); NMSBiomeProvider provider = new NMSBiomeProvider(pack.getBiomeProvider(), craftWorld.getSeed()); - + serverWorld.getChunkSource().chunkMap.generator = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed()); LOGGER.info("Successfully injected into world."); diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/Reflection.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/Reflection.java index 6197e6e01..f3f17b085 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/Reflection.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/Reflection.java @@ -36,12 +36,14 @@ public class Reflection { void setFrozen(MappedRegistry instance, boolean frozen); } + @Proxies(StructureManager.class) public interface StructureManagerProxy { @FieldGetter("level") LevelAccessor getLevel(StructureManager instance); } + @Proxies(Holder.Reference.class) public interface ReferenceProxy { @MethodName("bindValue") diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeInjector.java index 3db3fcd25..a4972ce3f 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeInjector.java @@ -15,62 +15,62 @@ import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; public class NMSBiomeInjector { - + public static Optional> getEntry(Registry registry, ResourceLocation identifier) { return registry.getOptional(identifier) .flatMap(registry::getResourceKey) .flatMap(registry::getHolder); } - + public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { Biome.BiomeBuilder builder = new Biome.BiomeBuilder(); - + builder .downfall(vanilla.climateSettings.downfall()) .temperature(vanilla.getBaseTemperature()) .mobSpawnSettings(vanilla.getMobSettings()) .generationSettings(vanilla.getGenerationSettings()); - - + + BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder(); - + effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier()); - + VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); - + effects.fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor())) - + .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) - + .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) - + .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); - + if(vanillaBiomeProperties.getFoliageColor() == null) { vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride); } else { effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor()); } - + if(vanillaBiomeProperties.getGrassColor() == null) { vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride); } else { // grass effects.grassColorOverride(vanillaBiomeProperties.getGrassColor()); } - + vanilla.getAmbientLoop().ifPresent(effects::ambientLoopSound); vanilla.getAmbientAdditions().ifPresent(effects::ambientAdditionsSound); vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound); vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic); vanilla.getAmbientParticle().ifPresent(effects::ambientParticle); - + builder.specialEffects(effects.build()); - + return builder.build(); } - + public static String createBiomeID(ConfigPack pack, com.dfsek.terra.api.registry.key.RegistryKey biomeID) { return pack.getID() .toLowerCase() + "/" + biomeID.getNamespace().toLowerCase(Locale.ROOT) + "/" + biomeID.getID().toLowerCase(Locale.ROOT); diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeProvider.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeProvider.java index bba17a5f8..baac766e4 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeProvider.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeProvider.java @@ -18,26 +18,27 @@ public class NMSBiomeProvider extends BiomeSource { private final BiomeProvider delegate; private final long seed; private final Registry biomeRegistry = RegistryFetcher.biomeRegistry(); - + public NMSBiomeProvider(BiomeProvider delegate, long seed) { super(); this.delegate = delegate; this.seed = seed; } + @Override protected Stream> collectPossibleBiomes() { - return delegate.stream() - .map(biome -> RegistryFetcher.biomeRegistry() - .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() - .get(NMSBiomeInfo.class) - .biomeKey())); + return delegate.stream() + .map(biome -> RegistryFetcher.biomeRegistry() + .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey())); } - + @Override protected @NotNull Codec codec() { return BiomeSource.CODEC; } - + @Override public @NotNull Holder getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) { return biomeRegistry.getHolderOrThrow(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed) diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSChunkGeneratorDelegate.java index 7b10e9418..a10376900 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSChunkGeneratorDelegate.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSChunkGeneratorDelegate.java @@ -91,15 +91,16 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { @NotNull RandomState noiseConfig, @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) { return vanilla.fillFromNoise(executor, blender, noiseConfig, structureAccessor, chunk) - .thenApply(c -> { - LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); - BiomeProvider biomeProvider = pack.getBiomeProvider(); - PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); - if(compatibilityOptions.isBeard()) { - beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), biomeProvider, compatibilityOptions); - } - return c; - }); + .thenApply(c -> { + LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); + BiomeProvider biomeProvider = pack.getBiomeProvider(); + PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); + if(compatibilityOptions.isBeard()) { + beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), + biomeProvider, compatibilityOptions); + } + return c; + }); } private void beard(StructureManager structureAccessor, ChunkAccess chunk, WorldProperties world, BiomeProvider biomeProvider, @@ -162,9 +163,9 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { } return new NoiseColumn(getMinY(), array); } - + @Override public void addDebugScreenInfo(@NotNull List text, @NotNull RandomState noiseConfig, @NotNull BlockPos pos) { - + } } diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSInjectListener.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSInjectListener.java index 7fd566251..b3dd2c7d4 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSInjectListener.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSInjectListener.java @@ -37,7 +37,7 @@ public class NMSInjectListener implements Listener { ChunkGenerator vanilla = serverWorld.getChunkSource().getGenerator(); NMSBiomeProvider provider = new NMSBiomeProvider(pack.getBiomeProvider(), craftWorld.getSeed()); - + serverWorld.getChunkSource().chunkMap.generator = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed()); LOGGER.info("Successfully injected into world."); diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/Reflection.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/Reflection.java index 15511b989..3432482d5 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/Reflection.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/Reflection.java @@ -36,12 +36,14 @@ public class Reflection { void setFrozen(MappedRegistry instance, boolean frozen); } + @Proxies(StructureManager.class) public interface StructureManagerProxy { @FieldGetter("level") LevelAccessor getLevel(StructureManager instance); } + @Proxies(Holder.Reference.class) public interface ReferenceProxy { @MethodName("bindValue") diff --git a/platforms/cli/build.gradle.kts b/platforms/cli/build.gradle.kts index 7e35aa714..9edd40c66 100644 --- a/platforms/cli/build.gradle.kts +++ b/platforms/cli/build.gradle.kts @@ -6,14 +6,14 @@ val javaMainClass = "com.dfsek.terra.cli.TerraCLI" dependencies { shadedApi(project(":common:implementation:base")) - + shadedApi("commons-io:commons-io:${Versions.Libraries.Internal.apacheIO}") shadedApi("com.github.Querz:NBT:${Versions.CLI.nbt}") - + shadedImplementation("com.google.guava:guava:${Versions.Libraries.Internal.guava}") - + shadedImplementation("ch.qos.logback:logback-classic:${Versions.CLI.logback}") - + } @@ -22,7 +22,7 @@ tasks.withType { manifest { attributes( "Main-Class" to javaMainClass, - ) + ) } } diff --git a/platforms/cli/src/main/java/com/dfsek/terra/cli/block/CLIBlockState.java b/platforms/cli/src/main/java/com/dfsek/terra/cli/block/CLIBlockState.java index 026f3dfc5..53cbc5e90 100644 --- a/platforms/cli/src/main/java/com/dfsek/terra/cli/block/CLIBlockState.java +++ b/platforms/cli/src/main/java/com/dfsek/terra/cli/block/CLIBlockState.java @@ -16,9 +16,9 @@ public class CLIBlockState implements BlockState { public CLIBlockState(String value) { this.value = value; if(value.contains("[")) { - + } else { - + } this.isAir = value.startsWith("minecraft:air"); this.nbt = new CompoundTag(); diff --git a/platforms/fabric/build.gradle.kts b/platforms/fabric/build.gradle.kts index ef49ab714..b10031f49 100644 --- a/platforms/fabric/build.gradle.kts +++ b/platforms/fabric/build.gradle.kts @@ -11,39 +11,39 @@ architectury { dependencies { shadedApi(project(":common:implementation:base")) - + implementation(project(path = ":platforms:mixin-common", configuration = "namedElements")) { isTransitive = false } "developmentFabric"(project(path = ":platforms:mixin-common", configuration = "namedElements")) { isTransitive = false } shaded(project(path = ":platforms:mixin-common", configuration = "transformProductionFabric")) { isTransitive = false } implementation(project(path = ":platforms:mixin-lifecycle", configuration = "namedElements")) { isTransitive = false } "developmentFabric"(project(path = ":platforms:mixin-lifecycle", configuration = "namedElements")) { isTransitive = false } shaded(project(path = ":platforms:mixin-lifecycle", configuration = "transformProductionFabric")) { isTransitive = false } - - + + minecraft("com.mojang:minecraft:${Versions.Mod.minecraft}") mappings("net.fabricmc:yarn:${Versions.Mod.yarn}:v2") - + modImplementation("net.fabricmc:fabric-loader:${Versions.Mod.fabricLoader}") - + setOf( "fabric-lifecycle-events-v1", "fabric-resource-loader-v0", "fabric-api-base", "fabric-command-api-v2", "fabric-networking-api-v1" - ).forEach { apiModule -> + ).forEach { apiModule -> val module = fabricApi.module(apiModule, Versions.Fabric.fabricAPI) modImplementation(module) include(module) } - + modImplementation("cloud.commandframework", "cloud-fabric", Versions.Libraries.cloud) include("cloud.commandframework", "cloud-fabric", Versions.Libraries.cloud) } loom { accessWidenerPath.set(project(":platforms:mixin-common").file("src/main/resources/terra.accesswidener")) - + mixin { defaultRefmapName.set("terra.fabric.refmap.json") } @@ -57,7 +57,7 @@ tasks { compileJava { options.release.set(17) } - + remapJar { injectAccessWidener.set(true) inputFile.set(shadowJar.get().archiveFile) diff --git a/platforms/forge/build.gradle.kts b/platforms/forge/build.gradle.kts index 947879bb1..09d2dd73f 100644 --- a/platforms/forge/build.gradle.kts +++ b/platforms/forge/build.gradle.kts @@ -12,19 +12,19 @@ architectury { dependencies { annotationProcessor("net.fabricmc:sponge-mixin:${Versions.Mod.mixin}") annotationProcessor("dev.architectury:architectury-loom:${Versions.Mod.architecuryLoom}") - + shadedApi(project(":common:implementation:base")) "forgeRuntimeLibrary"(project(":common:implementation:base")) - + implementation(project(path = ":platforms:mixin-common", configuration = "namedElements")) { isTransitive = false } "developmentForge"(project(path = ":platforms:mixin-common", configuration = "namedElements")) { isTransitive = false } shaded(project(path = ":platforms:mixin-common", configuration = "transformProductionForge")) { isTransitive = false } - + forge(group = "net.minecraftforge", name = "forge", version = Versions.Forge.forge) - + minecraft("com.mojang:minecraft:${Versions.Mod.minecraft}") mappings("net.fabricmc:yarn:${Versions.Mod.yarn}:v2") - + //forge is not ok. compileOnly("org.burningwave:core:${Versions.Forge.burningwave}") "forgeRuntimeLibrary"("org.burningwave:core:${Versions.Forge.burningwave}") @@ -32,11 +32,11 @@ dependencies { loom { accessWidenerPath.set(project(":platforms:mixin-common").file("src/main/resources/terra.accesswidener")) - + mixin { defaultRefmapName.set("terra.forge.refmap.json") } - + // launches { // named("client") { // property("fabric.log.level", "info") @@ -47,7 +47,7 @@ loom { // property("mixin.env.disableRefMap", "true") // } // } - + forge { convertAccessWideners.set(true) mixinConfig("terra.common.mixins.json") @@ -66,11 +66,11 @@ tasks { mapOf( "Implementation-Title" to rootProject.name, "Implementation-Version" to project.version, - ) - ) + ) + ) } } - + remapJar { inputFile.set(shadowJar.get().archiveFile) archiveFileName.set("${rootProject.name.capitalize()}-forge-${project.version}.jar") diff --git a/platforms/forge/src/main/java/com/dfsek/terra/forge/AwfulForgeHacks.java b/platforms/forge/src/main/java/com/dfsek/terra/forge/AwfulForgeHacks.java index 07f4dafc9..f37e5b1ee 100644 --- a/platforms/forge/src/main/java/com/dfsek/terra/forge/AwfulForgeHacks.java +++ b/platforms/forge/src/main/java/com/dfsek/terra/forge/AwfulForgeHacks.java @@ -122,14 +122,14 @@ public final class AwfulForgeHacks { .getLocation() .toURI() .getPath(); - + cl.addURL(new URL("jar:file:" + pathToJar + "!/")); Class newClassLoad = Class.forName(name, true, cl); omegaCL.loadOrDefine(newClassLoad, AbstractPlatform.class.getClassLoader()); } catch(ClassNotFoundException | URISyntaxException | IOException ex) { throw new RuntimeException(ex); } - + } }); } catch(IOException e) { diff --git a/platforms/forge/src/main/java/com/dfsek/terra/forge/mixin/lifecycle/NoiseConfigMixin.java b/platforms/forge/src/main/java/com/dfsek/terra/forge/mixin/lifecycle/NoiseConfigMixin.java index 8fe83f721..c18791cb8 100644 --- a/platforms/forge/src/main/java/com/dfsek/terra/forge/mixin/lifecycle/NoiseConfigMixin.java +++ b/platforms/forge/src/main/java/com/dfsek/terra/forge/mixin/lifecycle/NoiseConfigMixin.java @@ -26,7 +26,8 @@ public class NoiseConfigMixin { @Inject(method = "(Lnet/minecraft/world/gen/chunk/ChunkGeneratorSettings;Lnet/minecraft/registry/RegistryEntryLookup;J)V", at = @At("TAIL")) - private void mapMultiNoise(ChunkGeneratorSettings chunkGeneratorSettings, RegistryEntryLookup noiseParametersLookup, long seed, + private void mapMultiNoise(ChunkGeneratorSettings chunkGeneratorSettings, RegistryEntryLookup noiseParametersLookup, + long seed, CallbackInfo ci) { SeedHack.register(multiNoiseSampler, seed); } diff --git a/platforms/forge/src/main/java/com/dfsek/terra/forge/util/BiomeUtil.java b/platforms/forge/src/main/java/com/dfsek/terra/forge/util/BiomeUtil.java index 9c14f7d1a..6114714b9 100644 --- a/platforms/forge/src/main/java/com/dfsek/terra/forge/util/BiomeUtil.java +++ b/platforms/forge/src/main/java/com/dfsek/terra/forge/util/BiomeUtil.java @@ -61,7 +61,8 @@ public final class BiomeUtil { VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); net.minecraft.world.biome.Biome minecraftBiome = MinecraftUtil.createBiome(biome, - ForgeRegistries.BIOMES.getDelegateOrThrow(vanilla.getKey().orElseThrow()) + ForgeRegistries.BIOMES.getDelegateOrThrow( + vanilla.getKey().orElseThrow()) .value(), vanillaBiomeProperties); @@ -82,7 +83,8 @@ public final class BiomeUtil { Objects.requireNonNullElse(vanillaBiomeProperties.getVillagerType(), villagerMap.getOrDefault(vanilla.getKey().orElseThrow(), VillagerType.PLAINS))); - MinecraftUtil.TERRA_BIOME_MAP.computeIfAbsent(vanilla.getKey().orElseThrow().getValue(), i -> new ArrayList<>()).add(identifier); + MinecraftUtil.TERRA_BIOME_MAP.computeIfAbsent(vanilla.getKey().orElseThrow().getValue(), i -> new ArrayList<>()).add( + identifier); } } } diff --git a/platforms/merged/build.gradle.kts b/platforms/merged/build.gradle.kts index 2683bd74d..ec9e56f87 100644 --- a/platforms/merged/build.gradle.kts +++ b/platforms/merged/build.gradle.kts @@ -1,6 +1,6 @@ val platformOverrides = mapOf( "fabric" to "remapJar" - ) +) dependencies { api(project(":common:implementation:base")) @@ -24,7 +24,7 @@ tasks["processResources"].dependsOn(dump) afterEvaluate { project(":platforms").subprojects.forEach { if (it == this@afterEvaluate) return@forEach - + val taskName = platformOverrides.getOrDefault(it.name, "jar") val task = it.tasks.named(taskName).get() if (task !is AbstractArchiveTask) { diff --git a/platforms/mixin-common/build.gradle.kts b/platforms/mixin-common/build.gradle.kts index fb73717b1..e8ff5dc7f 100644 --- a/platforms/mixin-common/build.gradle.kts +++ b/platforms/mixin-common/build.gradle.kts @@ -6,7 +6,7 @@ plugins { loom { accessWidenerPath.set(file("src/main/resources/terra.accesswidener")) - + mixin { defaultRefmapName.set("terra.common.refmap.json") } @@ -14,11 +14,11 @@ loom { dependencies { shadedApi(project(":common:implementation:base")) - + compileOnly("net.fabricmc:sponge-mixin:${Versions.Mod.mixin}") annotationProcessor("net.fabricmc:sponge-mixin:${Versions.Mod.mixin}") annotationProcessor("dev.architectury:architectury-loom:${Versions.Mod.architecuryLoom}") - + minecraft("com.mojang:minecraft:${Versions.Mod.minecraft}") mappings("net.fabricmc:yarn:${Versions.Mod.yarn}:v2") } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/ModPlatform.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/ModPlatform.java index 760277606..29cc8fed6 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/ModPlatform.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/ModPlatform.java @@ -56,7 +56,7 @@ import com.dfsek.terra.mod.util.PresetUtil; public abstract class ModPlatform extends AbstractPlatform { private final ItemHandle itemHandle = new MinecraftItemHandle(); private final WorldHandle worldHandle = new MinecraftWorldHandle(); - + public abstract MinecraftServer getServer(); public void registerWorldTypes(BiConsumer registerFunction) { @@ -110,8 +110,11 @@ public abstract class ModPlatform extends AbstractPlatform { protected abstract BaseAddon getPlatformAddon(); public abstract Registry dimensionTypeRegistry(); + public abstract Registry biomeRegistry(); + public abstract Registry chunkGeneratorSettingsRegistry(); + public abstract Registry multiNoiseBiomeSourceParameterListRegistry(); @Override diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/BiomeParticleConfigTemplate.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/BiomeParticleConfigTemplate.java index a48ec5c54..7139031d2 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/BiomeParticleConfigTemplate.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/BiomeParticleConfigTemplate.java @@ -26,7 +26,9 @@ public class BiomeParticleConfigTemplate implements ObjectTemplate TERRA_BIOME_SOURCE = RecordCodecBuilder .create(instance -> instance.group( - CONFIG_PACK.fieldOf("pack") - .stable() - .forGetter(TerraBiomeSource::getPack)) + CONFIG_PACK.fieldOf("pack") + .stable() + .forGetter(TerraBiomeSource::getPack)) .apply(instance, instance.stable(TerraBiomeSource::new))); public static final Codec MINECRAFT_CHUNK_GENERATOR_WRAPPER = RecordCodecBuilder diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/MinecraftChunkGeneratorWrapper.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/MinecraftChunkGeneratorWrapper.java index fd1ee7cf9..fc1e0f54c 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/MinecraftChunkGeneratorWrapper.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/MinecraftChunkGeneratorWrapper.java @@ -129,7 +129,8 @@ public class MinecraftChunkGeneratorWrapper extends net.minecraft.world.gen.chun private void beard(StructureAccessor structureAccessor, Chunk chunk, WorldProperties world, BiomeProvider biomeProvider, PreLoadCompatibilityOptions compatibilityOptions) { - StructureWeightSampler structureWeightSampler = StructureWeightSampler.createStructureWeightSampler(structureAccessor, chunk.getPos()); + StructureWeightSampler structureWeightSampler = StructureWeightSampler.createStructureWeightSampler(structureAccessor, + chunk.getPos()); double threshold = compatibilityOptions.getBeardThreshold(); double airThreshold = compatibilityOptions.getAirThreshold(); int xi = chunk.getPos().x << 4; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/TerraBiomeSource.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/TerraBiomeSource.java index 4bd2866ae..3e5404776 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/TerraBiomeSource.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/TerraBiomeSource.java @@ -63,9 +63,9 @@ public class TerraBiomeSource extends BiomeSource { @Override public RegistryEntry getBiome(int biomeX, int biomeY, int biomeZ, MultiNoiseSampler noiseSampler) { return ((ProtoPlatformBiome) pack - .getBiomeProvider() - .getBiome(biomeX << 2, biomeY << 2, biomeZ << 2, SeedHack.getSeed(noiseSampler)) - .getPlatformBiome()).getDelegate(); + .getBiomeProvider() + .getBiome(biomeX << 2, biomeY << 2, biomeZ << 2, SeedHack.getSeed(noiseSampler)) + .getPlatformBiome()).getDelegate(); } public BiomeProvider getProvider() { diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftWorldHandle.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftWorldHandle.java index ba84f3129..c48ab6244 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftWorldHandle.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftWorldHandle.java @@ -36,7 +36,8 @@ public class MinecraftWorldHandle implements WorldHandle { @Override public @NotNull BlockState createBlockState(@NotNull String data) { try { - net.minecraft.block.BlockState state = BlockArgumentParser.block(Registries.BLOCK.getReadOnlyWrapper(), data, true).blockState(); + net.minecraft.block.BlockState state = BlockArgumentParser.block(Registries.BLOCK.getReadOnlyWrapper(), data, true) + .blockState(); if(state == null) throw new IllegalArgumentException("Invalid data: " + data); return (BlockState) state; } catch(CommandSyntaxException e) { diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/MobSpawnerBlockEntityMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/MobSpawnerBlockEntityMixin.java index 7f8a6850b..43a0d8a39 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/MobSpawnerBlockEntityMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/MobSpawnerBlockEntityMixin.java @@ -66,7 +66,7 @@ public abstract class MobSpawnerBlockEntityMixin extends BlockEntity { } public void terra$setDelay(int delay) { - + } public int terra$getMinSpawnDelay() { @@ -74,7 +74,7 @@ public abstract class MobSpawnerBlockEntityMixin extends BlockEntity { } public void terra$setMinSpawnDelay(int delay) { - + } public int terra$getMaxSpawnDelay() { @@ -82,7 +82,7 @@ public abstract class MobSpawnerBlockEntityMixin extends BlockEntity { } public void terra$setMaxSpawnDelay(int delay) { - + } public int terra$getSpawnCount() { @@ -90,7 +90,7 @@ public abstract class MobSpawnerBlockEntityMixin extends BlockEntity { } public void terra$setSpawnCount(int spawnCount) { - + } public int terra$getMaxNearbyEntities() { @@ -98,7 +98,7 @@ public abstract class MobSpawnerBlockEntityMixin extends BlockEntity { } public void terra$setMaxNearbyEntities(int maxNearbyEntities) { - + } public int terra$getRequiredPlayerRange() { @@ -106,7 +106,7 @@ public abstract class MobSpawnerBlockEntityMixin extends BlockEntity { } public void terra$setRequiredPlayerRange(int requiredPlayerRange) { - + } public int terra$getSpawnRange() { @@ -114,7 +114,7 @@ public abstract class MobSpawnerBlockEntityMixin extends BlockEntity { } public void terra$setSpawnRange(int spawnRange) { - + } public void terra$applyState(String state) { diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java index 0cc130471..54c89c1ec 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java @@ -55,9 +55,9 @@ public abstract class WorldChunkMixin { public void terra$setBlock(int x, int y, int z, BlockState data, boolean physics) { BlockPos blockPos = new BlockPos(x, y, z); setBlockState(blockPos, (net.minecraft.block.BlockState) data, false); - if (physics) { + if(physics) { net.minecraft.block.BlockState state = ((net.minecraft.block.BlockState) data); - if (state.isLiquid()) { + if(state.isLiquid()) { world.getFluidTickScheduler().scheduleTick(OrderedTick.create(state.getFluidState().getFluid(), blockPos)); } else { world.getBlockTickScheduler().scheduleTick(OrderedTick.create(state.getBlock(), blockPos)); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftUtil.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftUtil.java index 2470f139f..de0b9b841 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftUtil.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftUtil.java @@ -158,7 +158,8 @@ public final class MinecraftUtil { builder.temperature(Objects.requireNonNullElse(vanillaBiomeProperties.getTemperature(), vanilla.getTemperature())); - builder.downfall(Objects.requireNonNullElse(vanillaBiomeProperties.getDownfall(), ((BiomeAccessor) ((Object) vanilla)).getWeather().downfall())); + builder.downfall(Objects.requireNonNullElse(vanillaBiomeProperties.getDownfall(), + ((BiomeAccessor) ((Object) vanilla)).getWeather().downfall())); builder.temperatureModifier(Objects.requireNonNullElse(vanillaBiomeProperties.getTemperatureModifier(), ((BiomeAccessor) ((Object) vanilla)).getWeather().temperatureModifier())); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/PresetUtil.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/PresetUtil.java index fb061b67d..006fbc004 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/PresetUtil.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/PresetUtil.java @@ -51,27 +51,35 @@ public class PresetUtil { PRESETS.add(generatorID); RegistryEntry registryEntry = dimensionTypeRegistry.getEntry(DimensionTypes.THE_NETHER).orElseThrow(); - RegistryEntry.Reference reference = multiNoiseBiomeSourceParameterLists.getEntry(MultiNoiseBiomeSourceParameterLists.NETHER).orElseThrow(); - RegistryEntry registryEntry2 = chunkGeneratorSettingsRegistry.getEntry(ChunkGeneratorSettings.NETHER).orElseThrow(); + RegistryEntry.Reference reference = multiNoiseBiomeSourceParameterLists.getEntry( + MultiNoiseBiomeSourceParameterLists.NETHER).orElseThrow(); + RegistryEntry registryEntry2 = chunkGeneratorSettingsRegistry.getEntry(ChunkGeneratorSettings.NETHER) + .orElseThrow(); RegistryEntry registryEntry3 = dimensionTypeRegistry.getEntry(DimensionTypes.THE_END).orElseThrow(); - RegistryEntry registryEntry4 = chunkGeneratorSettingsRegistry.getEntry(ChunkGeneratorSettings.END).orElseThrow(); + RegistryEntry registryEntry4 = chunkGeneratorSettingsRegistry.getEntry(ChunkGeneratorSettings.END) + .orElseThrow(); TerraBiomeSource biomeSource = new TerraBiomeSource(pack); ChunkGenerator generator = new MinecraftChunkGeneratorWrapper(biomeSource, pack, overworld); DimensionOptions dimensionOptions = new DimensionOptions(overworldDimensionType, generator); - DimensionOptions netherDimensionOptions = new DimensionOptions(registryEntry, new NoiseChunkGenerator(MultiNoiseBiomeSource.create(reference), registryEntry2)); - DimensionOptions endDimensionOptions = new DimensionOptions(registryEntry3, new NoiseChunkGenerator(TheEndBiomeSource.createVanilla(platform.biomeRegistry().getReadOnlyWrapper()), registryEntry4)); + DimensionOptions netherDimensionOptions = new DimensionOptions(registryEntry, + new NoiseChunkGenerator(MultiNoiseBiomeSource.create(reference), + registryEntry2)); + DimensionOptions endDimensionOptions = new DimensionOptions(registryEntry3, new NoiseChunkGenerator( + TheEndBiomeSource.createVanilla(platform.biomeRegistry().getReadOnlyWrapper()), registryEntry4)); WorldPreset preset = createPreset(dimensionOptions, netherDimensionOptions, endDimensionOptions); LOGGER.info("Created world type \"{}\"", generatorID); return Pair.of(generatorID, preset); } - private static WorldPreset createPreset(DimensionOptions dimensionOptions, DimensionOptions netherDimensionOptions, DimensionOptions endDimensionOptions) { + private static WorldPreset createPreset(DimensionOptions dimensionOptions, DimensionOptions netherDimensionOptions, + DimensionOptions endDimensionOptions) { return new WorldPreset( - Map.of(DimensionOptions.OVERWORLD, dimensionOptions, DimensionOptions.NETHER, netherDimensionOptions, DimensionOptions.END, endDimensionOptions) + Map.of(DimensionOptions.OVERWORLD, dimensionOptions, DimensionOptions.NETHER, netherDimensionOptions, DimensionOptions.END, + endDimensionOptions) ); } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/TagUtil.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/TagUtil.java index feb3826f1..3520c4718 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/TagUtil.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/TagUtil.java @@ -76,7 +76,7 @@ public final class TagUtil { ": " + vanilla.streamTags() .toList()); - + vanilla.streamTags() .forEach( tag -> collect diff --git a/platforms/mixin-lifecycle/build.gradle.kts b/platforms/mixin-lifecycle/build.gradle.kts index 142d6868b..a4568c2e3 100644 --- a/platforms/mixin-lifecycle/build.gradle.kts +++ b/platforms/mixin-lifecycle/build.gradle.kts @@ -6,16 +6,16 @@ plugins { dependencies { shadedApi(project(":common:implementation:base")) - + compileOnly("net.fabricmc:sponge-mixin:${Versions.Mod.mixin}") annotationProcessor("net.fabricmc:sponge-mixin:${Versions.Mod.mixin}") annotationProcessor("dev.architectury:architectury-loom:${Versions.Mod.architecuryLoom}") - + implementation(project(path = ":platforms:mixin-common", configuration = "namedElements")) { isTransitive = false } - + minecraft("com.mojang:minecraft:${Versions.Mod.minecraft}") mappings("net.fabricmc:yarn:${Versions.Mod.yarn}:v2") - + modImplementation("cloud.commandframework", "cloud-fabric", Versions.Libraries.cloud) { exclude("net.fabricmc") exclude("net.fabricmc.fabric-api") @@ -24,7 +24,7 @@ dependencies { loom { accessWidenerPath.set(project(":platforms:mixin-common").file("src/main/resources/terra.accesswidener")) - + mixin { defaultRefmapName.set("terra.lifecycle.refmap.json") } @@ -34,7 +34,7 @@ tasks { compileJava { options.release.set(17) } - + remapJar { inputFile.set(shadowJar.get().archiveFile) } diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java index bc481f560..3f53bfdfb 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java @@ -15,16 +15,16 @@ public class LifecycleEntryPoint { protected static void initialize(String modName, LifecyclePlatform platform) { logger.info("Initializing Terra {} mod...", modName); - + FabricServerCommandManager manager = new FabricServerCommandManager<>( CommandExecutionCoordinator.simpleCoordinator(), serverCommandSource -> (CommandSender) serverCommandSource, commandSender -> (ServerCommandSource) commandSender ); - - + + manager.brigadierManager().setNativeNumberSuggestions(false); - + platform.getEventManager().callEvent(new CommandRegistrationEvent(manager)); } } diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java index 4bf538144..2008b1266 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java @@ -30,18 +30,27 @@ import com.dfsek.terra.mod.generation.MinecraftChunkGeneratorWrapper; public abstract class LifecyclePlatform extends ModPlatform { private static final Logger LOGGER = LoggerFactory.getLogger(LifecyclePlatform.class); - private static MinecraftServer server; - private static final AtomicReference> BIOMES = new AtomicReference<>(); private static final AtomicReference> DIMENSIONS = new AtomicReference<>(); private static final AtomicReference> SETTINGS = new AtomicReference<>(); private static final AtomicReference> NOISE = new AtomicReference<>(); + private static MinecraftServer server; public LifecyclePlatform() { CommonPlatform.initialize(this); load(); } + public static void setRegistries(Registry biomeRegistry, + Registry dimensionTypeRegistry, + Registry chunkGeneratorSettingsRegistry, + Registry multiNoiseBiomeSourceParameterListRegistry) { + BIOMES.set(biomeRegistry); + DIMENSIONS.set(dimensionTypeRegistry); + SETTINGS.set(chunkGeneratorSettingsRegistry); + NOISE.set(multiNoiseBiomeSourceParameterListRegistry); + } + @Override public MinecraftServer getServer() { return server; @@ -76,16 +85,6 @@ public abstract class LifecyclePlatform extends ModPlatform { return succeed; } - public static void setRegistries(Registry biomeRegistry, - Registry dimensionTypeRegistry, - Registry chunkGeneratorSettingsRegistry, - Registry multiNoiseBiomeSourceParameterListRegistry) { - BIOMES.set(biomeRegistry); - DIMENSIONS.set(dimensionTypeRegistry); - SETTINGS.set(chunkGeneratorSettingsRegistry); - NOISE.set(multiNoiseBiomeSourceParameterListRegistry); - } - @Override protected Iterable platformAddon() { List addons = new ArrayList<>(); @@ -102,9 +101,9 @@ public abstract class LifecyclePlatform extends ModPlatform { LOGGER.warn("Failed to parse Minecraft version", e); } } - + addons.addAll(getPlatformMods()); - + return addons; } diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/NoiseConfigMixin.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/NoiseConfigMixin.java index 714fa7246..8363e4c00 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/NoiseConfigMixin.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/NoiseConfigMixin.java @@ -26,7 +26,8 @@ public class NoiseConfigMixin { @Inject(method = "(Lnet/minecraft/world/gen/chunk/ChunkGeneratorSettings;Lnet/minecraft/registry/RegistryEntryLookup;J)V", at = @At("TAIL")) - private void mapMultiNoise(ChunkGeneratorSettings chunkGeneratorSettings, RegistryEntryLookup noiseParametersLookup, long seed, + private void mapMultiNoise(ChunkGeneratorSettings chunkGeneratorSettings, + RegistryEntryLookup noiseParametersLookup, long seed, CallbackInfo ci) { SeedHack.register(multiNoiseSampler, seed); } diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/RegistryLoaderMixin.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/RegistryLoaderMixin.java index 8193a3224..6e4cfefc4 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/RegistryLoaderMixin.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/RegistryLoaderMixin.java @@ -52,7 +52,8 @@ public class RegistryLoaderMixin { MutableRegistry worldPresets = extractRegistry(instance, RegistryKeys.WORLD_PRESET).orElseThrow(); MutableRegistry chunkGeneratorSettings = extractRegistry(instance, RegistryKeys.CHUNK_GENERATOR_SETTINGS).orElseThrow(); - MutableRegistry multiNoiseBiomeSourceParameterLists = extractRegistry(instance, RegistryKeys.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST).orElseThrow(); + MutableRegistry multiNoiseBiomeSourceParameterLists = extractRegistry(instance, + RegistryKeys.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST).orElseThrow(); LifecyclePlatform.setRegistries(biomes, dimensionTypes, chunkGeneratorSettings, multiNoiseBiomeSourceParameterLists); LifecycleUtil.initialize(biomes, worldPresets); diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/BiomeUtil.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/BiomeUtil.java index 20ad6a17d..d3078b71a 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/BiomeUtil.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/BiomeUtil.java @@ -65,9 +65,9 @@ public final class BiomeUtil { .orElseThrow()); } else { ((ProtoPlatformBiome) biome.getPlatformBiome()).setDelegate(Registry.registerReference(registry, - MinecraftUtil.registerKey(identifier) - .getValue(), - minecraftBiome)); + MinecraftUtil.registerKey(identifier) + .getValue(), + minecraftBiome)); } Map, VillagerType> villagerMap = VillagerTypeAccessor.getBiomeTypeToIdMap(); diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/LifecycleUtil.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/LifecycleUtil.java index 6b4516c5f..6b4f36eeb 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/LifecycleUtil.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/LifecycleUtil.java @@ -13,12 +13,13 @@ import com.dfsek.terra.mod.CommonPlatform; public final class LifecycleUtil { private LifecycleUtil() { - + } public static void initialize(MutableRegistry biomeMutableRegistry, MutableRegistry worldPresetMutableRegistry) { CommonPlatform.get().getEventManager().callEvent(new PlatformInitializationEvent()); BiomeUtil.registerBiomes(biomeMutableRegistry); - CommonPlatform.get().registerWorldTypes((id, preset) -> Registry.register(worldPresetMutableRegistry, RegistryKey.of(RegistryKeys.WORLD_PRESET, id), preset)); + CommonPlatform.get().registerWorldTypes( + (id, preset) -> Registry.register(worldPresetMutableRegistry, RegistryKey.of(RegistryKeys.WORLD_PRESET, id), preset)); } } diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/RegistryUtil.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/RegistryUtil.java index a22e449b5..aeffe254e 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/RegistryUtil.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/RegistryUtil.java @@ -9,7 +9,7 @@ import com.dfsek.terra.mod.data.Codecs; public final class RegistryUtil { private RegistryUtil() { - + } public static void register() { diff --git a/platforms/mixin-lifecycle/src/main/resources/terra.lifecycle.mixins.json b/platforms/mixin-lifecycle/src/main/resources/terra.lifecycle.mixins.json index bf42757a4..33695db0e 100644 --- a/platforms/mixin-lifecycle/src/main/resources/terra.lifecycle.mixins.json +++ b/platforms/mixin-lifecycle/src/main/resources/terra.lifecycle.mixins.json @@ -1,23 +1,23 @@ { - "required": true, - "minVersion": "0.8", - "package": "com.dfsek.terra.lifecycle.mixin", - "compatibilityLevel": "JAVA_17", - "mixins": [ - "NoiseConfigMixin", - "RegistryEntryReferenceInvoker", - "RegistryMixin", - "SimpleRegistryMixin", - "lifecycle.MinecraftServerMixin", - "lifecycle.RegistryLoaderMixin", - "lifecycle.SaveLoadingMixin" - ], - "client": [ - ], - "server": [ - ], - "injectors": { - "defaultRequire": 1 - }, - "refmap": "terra.lifecycle.refmap.json" + "required": true, + "minVersion": "0.8", + "package": "com.dfsek.terra.lifecycle.mixin", + "compatibilityLevel": "JAVA_17", + "mixins": [ + "NoiseConfigMixin", + "RegistryEntryReferenceInvoker", + "RegistryMixin", + "SimpleRegistryMixin", + "lifecycle.MinecraftServerMixin", + "lifecycle.RegistryLoaderMixin", + "lifecycle.SaveLoadingMixin" + ], + "client": [ + ], + "server": [ + ], + "injectors": { + "defaultRequire": 1 + }, + "refmap": "terra.lifecycle.refmap.json" } \ No newline at end of file diff --git a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/AwfulQuiltHacks.java b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/AwfulQuiltHacks.java index 6dbcbaff4..e702a5e4c 100644 --- a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/AwfulQuiltHacks.java +++ b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/AwfulQuiltHacks.java @@ -23,12 +23,12 @@ public final class AwfulQuiltHacks { } catch(ReflectiveOperationException e) { throw new RuntimeException("Failed to load Classloader fields", e); } - + ADD_URL_METHOD = tempAddUrlMethod; } - + private AwfulQuiltHacks() { } - + /** * Hackily load the package which a mixin may exist within. *

diff --git a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltAddon.java b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltAddon.java index f0767fdcf..6c3419a26 100644 --- a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltAddon.java +++ b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltAddon.java @@ -5,11 +5,11 @@ import com.dfsek.terra.mod.ModPlatform; public class QuiltAddon extends MinecraftAddon { - + public QuiltAddon(ModPlatform modPlatform) { super(modPlatform); } - + @Override public String getID() { return "terra-quilt"; diff --git a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java index 32772b349..021f7b2ce 100644 --- a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java +++ b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java @@ -32,8 +32,11 @@ public class QuiltPlatform extends LifecyclePlatform { @Override protected Collection getPlatformMods() { - return QuiltLoader.getAllMods().stream().flatMap(mod -> parseModData(mod.metadata().id(), mod.metadata().version().raw(), "quilt")).collect( - Collectors.toList()); + return QuiltLoader.getAllMods() + .stream() + .flatMap(mod -> parseModData(mod.metadata().id(), mod.metadata().version().raw(), "quilt")) + .collect( + Collectors.toList()); } @Override From ad9bc7f67c160b3e9c14facba541226ebdd8362c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Thu, 2 Nov 2023 18:47:45 -0600 Subject: [PATCH 59/83] fix format error --- .../terra/addons/noise/samplers/noise/GaborNoiseSampler.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java index 1b74295a8..acc853035 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java @@ -17,10 +17,10 @@ public class GaborNoiseSampler extends NoiseFunction { private double a = 0.1; private double f0 = 0.625; private double kernelRadius = (Math.sqrt(-Math.log(0.05) / Math.PI) / a); + private double impulsesPerKernel = 64d; private double impulseDensity = (impulsesPerKernel / (Math.PI * kernelRadius * kernelRadius)); private double impulsesPerCell = impulseDensity * kernelRadius * kernelRadius; private double g = Math.exp(-impulsesPerCell); - private double impulsesPerKernel = 64d; private double omega0 = Math.PI * 0.25; private boolean isotropic = true; From 77812545df6304ccc04dd129b8ea953deaac40b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Sun, 5 Nov 2023 20:07:13 -0700 Subject: [PATCH 60/83] Fix stupid build error and a couple gradle warnings thank you gradle .replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() } is clearly better than .capitalize() --- buildSrc/src/main/kotlin/DistributionConfig.kt | 11 ++++++++++- platforms/fabric/build.gradle.kts | 4 +++- platforms/forge/build.gradle.kts | 4 +++- platforms/quilt/build.gradle.kts.disabled | 2 +- 4 files changed, 17 insertions(+), 4 deletions(-) diff --git a/buildSrc/src/main/kotlin/DistributionConfig.kt b/buildSrc/src/main/kotlin/DistributionConfig.kt index 81102bdda..875fe2a68 100644 --- a/buildSrc/src/main/kotlin/DistributionConfig.kt +++ b/buildSrc/src/main/kotlin/DistributionConfig.kt @@ -5,7 +5,9 @@ import java.net.URI import java.net.URL import java.nio.file.FileSystems import java.nio.file.Files +import java.nio.file.ProviderNotFoundException import java.nio.file.StandardCopyOption +import java.nio.file.spi.FileSystemProvider import org.gradle.api.DefaultTask import org.gradle.api.Project import org.gradle.api.plugins.BasePluginExtension @@ -46,7 +48,14 @@ fun Project.configureDistribution() { // https://github.com/johnrengelman/shadow/issues/111 val dest = URI.create("jar:" + tasks.named("shadowJar").get().archiveFile.get().asFile.toURI()) - FileSystems.newFileSystem(dest, mapOf("create" to "false"), null).use { fs -> + val preExistingProvider = try { + FileSystems.getFileSystem(dest) + } catch (e: Exception) { + null + }; + val provider = if (preExistingProvider == null) { preExistingProvider } else { FileSystems.newFileSystem(dest, mapOf("create" to "false"), null) + }; + provider?.use { fs -> forSubProjects(":common:addons") { val jar = getJarTask() diff --git a/platforms/fabric/build.gradle.kts b/platforms/fabric/build.gradle.kts index b10031f49..4337a75ae 100644 --- a/platforms/fabric/build.gradle.kts +++ b/platforms/fabric/build.gradle.kts @@ -1,3 +1,5 @@ +import java.util.* + plugins { id("dev.architectury.loom") version Versions.Mod.architecuryLoom id("architectury-plugin") version Versions.Mod.architecturyPlugin @@ -61,6 +63,6 @@ tasks { remapJar { injectAccessWidener.set(true) inputFile.set(shadowJar.get().archiveFile) - archiveFileName.set("${rootProject.name.capitalize()}-fabric-${project.version}.jar") + archiveFileName.set("${rootProject.name.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() }}-fabric-${project.version}.jar") } } diff --git a/platforms/forge/build.gradle.kts b/platforms/forge/build.gradle.kts index 09d2dd73f..2c3e1988a 100644 --- a/platforms/forge/build.gradle.kts +++ b/platforms/forge/build.gradle.kts @@ -1,3 +1,5 @@ +import java.util.* + plugins { id("dev.architectury.loom") version Versions.Mod.architecuryLoom id("architectury-plugin") version Versions.Mod.architecturyPlugin @@ -73,6 +75,6 @@ tasks { remapJar { inputFile.set(shadowJar.get().archiveFile) - archiveFileName.set("${rootProject.name.capitalize()}-forge-${project.version}.jar") + archiveFileName.set("${rootProject.name.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() }}-forge-${project.version}.jar") } } \ No newline at end of file diff --git a/platforms/quilt/build.gradle.kts.disabled b/platforms/quilt/build.gradle.kts.disabled index 31b4589d2..1a5d5630f 100644 --- a/platforms/quilt/build.gradle.kts.disabled +++ b/platforms/quilt/build.gradle.kts.disabled @@ -60,6 +60,6 @@ tasks { remapJar { injectAccessWidener.set(true) inputFile.set(shadowJar.get().archiveFile) - archiveFileName.set("${rootProject.name.capitalize()}-quilt-${project.version}.jar") + archiveFileName.set("${rootProject.name.replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString() })}-quilt-${project.version}.jar") } } From c00753b0fc91a6e97344281da930a3144e7c66d9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Sun, 5 Nov 2023 20:12:57 -0700 Subject: [PATCH 61/83] let reformat have another go at it --- .../src/main/kotlin/DistributionConfig.kt | 7 ++-- .../biome/extrusion/BiomeExtrusionAddon.java | 4 +-- .../api/delegate/EphemeralBiomeDelegate.java | 4 +-- .../config/palette/BiomePaletteTemplate.java | 8 ++--- .../chunkgenerator/palette/PaletteHolder.java | 2 +- .../terra/addons/noise/math/CubicSpline.java | 2 +- .../samplers/noise/ExpressionFunction.java | 4 +-- .../samplers/noise/GaborNoiseSampler.java | 2 +- .../terrascript/script/StructureScript.java | 36 +++++++++++++------ .../script/functions/StateFunction.java | 6 ++-- .../java/com/dfsek/terra/api/Platform.java | 10 +++--- .../dfsek/terra/api/util/GeometryUtil.java | 2 +- .../dfsek/terra/api/util/PopulationUtil.java | 4 +-- .../dfsek/terra/api/world/biome/Biome.java | 4 +-- .../com/dfsek/terra/addon/InternalAddon.java | 2 +- .../preprocessor/MetaMapPreprocessor.java | 9 ++--- .../dfsek/terra/registry/ShortcutHolder.java | 7 ++-- .../com/dfsek/terra/bukkit/BukkitEntity.java | 6 ++-- .../bukkit/nms/v1_19_R3/NMSInitializer.java | 4 +-- .../bukkit/nms/v1_20_R1/NMSBiomeInfo.java | 4 +-- .../v1_20_R1/NMSChunkGeneratorDelegate.java | 20 +++++------ .../dfsek/terra/cli/handle/CLIItemHandle.java | 4 +-- .../dfsek/terra/fabric/FabricEntryPoint.java | 4 +-- 23 files changed, 85 insertions(+), 70 deletions(-) diff --git a/buildSrc/src/main/kotlin/DistributionConfig.kt b/buildSrc/src/main/kotlin/DistributionConfig.kt index 875fe2a68..16276f500 100644 --- a/buildSrc/src/main/kotlin/DistributionConfig.kt +++ b/buildSrc/src/main/kotlin/DistributionConfig.kt @@ -5,9 +5,7 @@ import java.net.URI import java.net.URL import java.nio.file.FileSystems import java.nio.file.Files -import java.nio.file.ProviderNotFoundException import java.nio.file.StandardCopyOption -import java.nio.file.spi.FileSystemProvider import org.gradle.api.DefaultTask import org.gradle.api.Project import org.gradle.api.plugins.BasePluginExtension @@ -53,7 +51,10 @@ fun Project.configureDistribution() { } catch (e: Exception) { null }; - val provider = if (preExistingProvider == null) { preExistingProvider } else { FileSystems.newFileSystem(dest, mapOf("create" to "false"), null) + val provider = if (preExistingProvider == null) { + preExistingProvider + } else { + FileSystems.newFileSystem(dest, mapOf("create" to "false"), null) }; provider?.use { fs -> forSubProjects(":common:addons") { diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BiomeExtrusionAddon.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BiomeExtrusionAddon.java index cd4b1c9a4..1e3d0ff0e 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BiomeExtrusionAddon.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BiomeExtrusionAddon.java @@ -2,8 +2,6 @@ package com.dfsek.terra.addons.biome.extrusion; import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; -import java.util.function.Supplier; - import com.dfsek.terra.addons.biome.extrusion.api.Extrusion; import com.dfsek.terra.addons.biome.extrusion.api.ReplaceableBiome; import com.dfsek.terra.addons.biome.extrusion.config.BiomeExtrusionTemplate; @@ -23,6 +21,8 @@ import com.dfsek.terra.api.util.reflection.TypeKey; import com.dfsek.terra.api.world.biome.Biome; import com.dfsek.terra.api.world.biome.generation.BiomeProvider; +import java.util.function.Supplier; + public class BiomeExtrusionAddon implements AddonInitializer { public static final TypeKey>> EXTRUSION_REGISTRY_KEY = new TypeKey<>() { diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/EphemeralBiomeDelegate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/EphemeralBiomeDelegate.java index d02221f1b..aed7d584f 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/EphemeralBiomeDelegate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/EphemeralBiomeDelegate.java @@ -1,10 +1,10 @@ package com.dfsek.terra.addons.biome.pipeline.api.delegate; +import com.dfsek.terra.api.world.biome.Biome; + import java.util.HashSet; import java.util.Set; -import com.dfsek.terra.api.world.biome.Biome; - final class EphemeralBiomeDelegate implements BiomeDelegate { private final Set tags; diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java index a80311ad1..b473a82f3 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java @@ -12,10 +12,6 @@ import com.dfsek.tectonic.api.config.template.annotations.Description; import com.dfsek.tectonic.api.config.template.annotations.Value; import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; -import java.util.Collections; -import java.util.List; -import java.util.Map; - import com.dfsek.terra.addons.chunkgenerator.palette.BiomePaletteInfo; import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolder; import com.dfsek.terra.addons.chunkgenerator.palette.slant.SlantHolder; @@ -24,6 +20,10 @@ import com.dfsek.terra.api.block.state.BlockState; import com.dfsek.terra.api.config.meta.Meta; import com.dfsek.terra.api.world.chunk.generation.util.Palette; +import java.util.Collections; +import java.util.List; +import java.util.Map; + public class BiomePaletteTemplate implements ObjectTemplate { private final Platform platform; diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java index 91318b0b4..1f89ce1f9 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java @@ -43,7 +43,7 @@ public class PaletteHolder { : palettes[0]; } - + private static class PaletteHolderBuilder { private final TreeMap paletteMap = new TreeMap<>(); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java index 49070ea79..fa595b879 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java @@ -78,7 +78,7 @@ public class CubicSpline { return calculate(in, fromValues, toValues, gradients); } - + public record Point(double from, double to, double gradient) implements Comparable { @Override diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ExpressionFunction.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ExpressionFunction.java index eed78c01e..e3d43c7b9 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ExpressionFunction.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ExpressionFunction.java @@ -13,10 +13,10 @@ import com.dfsek.paralithic.eval.parser.Scope; import com.dfsek.paralithic.eval.tokenizer.ParseException; import com.dfsek.paralithic.functions.Function; -import java.util.Map; - import com.dfsek.terra.addons.noise.paralithic.noise.SeedContext; +import java.util.Map; + /** * NoiseSampler implementation using a Paralithic expression. diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java index acc853035..1b74295a8 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java @@ -17,10 +17,10 @@ public class GaborNoiseSampler extends NoiseFunction { private double a = 0.1; private double f0 = 0.625; private double kernelRadius = (Math.sqrt(-Math.log(0.05) / Math.PI) / a); - private double impulsesPerKernel = 64d; private double impulseDensity = (impulsesPerKernel / (Math.PI * kernelRadius * kernelRadius)); private double impulsesPerCell = impulseDensity * kernelRadius * kernelRadius; private double g = Math.exp(-impulsesPerCell); + private double impulsesPerKernel = 64d; private double omega0 = Math.PI * 0.25; private boolean isotropic = true; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java index d06152ec0..032108784 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java @@ -7,11 +7,36 @@ package com.dfsek.terra.addons.terrascript.script; +import org.apache.commons.io.IOUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.Charset; +import java.util.Random; + import com.dfsek.terra.addons.terrascript.parser.Parser; import com.dfsek.terra.addons.terrascript.parser.lang.Executable; import com.dfsek.terra.addons.terrascript.parser.lang.Returnable; import com.dfsek.terra.addons.terrascript.parser.lang.functions.FunctionBuilder; -import com.dfsek.terra.addons.terrascript.script.builders.*; +import com.dfsek.terra.addons.terrascript.script.builders.BinaryNumberFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.BiomeFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.BlockFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.CheckBlockFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.EntityFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.GetMarkFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.LootFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.PullFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.RandomFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.RecursionsFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.SetMarkFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.StateFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.StructureFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.UnaryBooleanFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.UnaryNumberFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.UnaryStringFunctionBuilder; +import com.dfsek.terra.addons.terrascript.script.builders.ZeroArgFunctionBuilder; import com.dfsek.terra.api.Platform; import com.dfsek.terra.api.registry.Registry; import com.dfsek.terra.api.registry.key.Keyed; @@ -23,15 +48,6 @@ import com.dfsek.terra.api.util.Rotation; import com.dfsek.terra.api.util.vector.Vector3Int; import com.dfsek.terra.api.world.WritableWorld; -import org.apache.commons.io.IOUtils; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import java.io.IOException; -import java.io.InputStream; -import java.nio.charset.Charset; -import java.util.Random; - public class StructureScript implements Structure, Keyed { private static final Logger LOGGER = LoggerFactory.getLogger(StructureScript.class); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java index 516c5fd07..640d52ecc 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java @@ -7,6 +7,9 @@ package com.dfsek.terra.addons.terrascript.script.functions; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + import com.dfsek.terra.addons.terrascript.parser.lang.ImplementationArguments; import com.dfsek.terra.addons.terrascript.parser.lang.Returnable; import com.dfsek.terra.addons.terrascript.parser.lang.Scope; @@ -18,9 +21,6 @@ import com.dfsek.terra.api.util.RotationUtil; import com.dfsek.terra.api.util.vector.Vector2; import com.dfsek.terra.api.util.vector.Vector3; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - public class StateFunction implements Function { private static final Logger LOGGER = LoggerFactory.getLogger(StateFunction.class); diff --git a/common/api/src/main/java/com/dfsek/terra/api/Platform.java b/common/api/src/main/java/com/dfsek/terra/api/Platform.java index 744d7f716..a6ed29a54 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/Platform.java +++ b/common/api/src/main/java/com/dfsek/terra/api/Platform.java @@ -7,6 +7,11 @@ package com.dfsek.terra.api; +import org.jetbrains.annotations.Contract; +import org.jetbrains.annotations.NotNull; + +import java.io.File; + import com.dfsek.terra.api.addon.BaseAddon; import com.dfsek.terra.api.config.ConfigPack; import com.dfsek.terra.api.config.PluginConfig; @@ -18,11 +23,6 @@ import com.dfsek.terra.api.registry.CheckedRegistry; import com.dfsek.terra.api.registry.Registry; import com.dfsek.terra.api.tectonic.LoaderRegistrar; -import org.jetbrains.annotations.Contract; -import org.jetbrains.annotations.NotNull; - -import java.io.File; - /** * Represents a Terra mod/plugin instance. diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/GeometryUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/GeometryUtil.java index 6bb21b3df..25984257f 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/GeometryUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/GeometryUtil.java @@ -7,7 +7,7 @@ import com.dfsek.terra.api.util.vector.Vector3Int; public final class GeometryUtil { private GeometryUtil() { - + } public static void sphere(Vector3Int origin, int radius, Consumer action) { diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/PopulationUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/PopulationUtil.java index 5a6016da8..f16b45629 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/PopulationUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/PopulationUtil.java @@ -7,10 +7,10 @@ package com.dfsek.terra.api.util; -import java.util.Random; - import com.dfsek.terra.api.world.chunk.Chunk; +import java.util.Random; + public final class PopulationUtil { public static Random getRandom(Chunk c) { diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/biome/Biome.java b/common/api/src/main/java/com/dfsek/terra/api/world/biome/Biome.java index 027c715f7..417dea9cd 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/biome/Biome.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/biome/Biome.java @@ -8,11 +8,11 @@ package com.dfsek.terra.api.world.biome; -import java.util.Set; - import com.dfsek.terra.api.properties.PropertyHolder; import com.dfsek.terra.api.registry.key.StringIdentifiable; +import java.util.Set; + /** * Represents a Terra biome diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/addon/InternalAddon.java b/common/implementation/base/src/main/java/com/dfsek/terra/addon/InternalAddon.java index cdd9ac5f2..0a63af2db 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/addon/InternalAddon.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/addon/InternalAddon.java @@ -27,7 +27,7 @@ public class InternalAddon implements BaseAddon { private static final Version VERSION = Versions.getVersion(1, 0, 0); public InternalAddon() { - + } @Override diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaMapPreprocessor.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaMapPreprocessor.java index f4953ca6e..f90544e9c 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaMapPreprocessor.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaMapPreprocessor.java @@ -23,6 +23,11 @@ import com.dfsek.tectonic.api.depth.EntryLevel; import com.dfsek.tectonic.api.exception.LoadException; import com.dfsek.tectonic.api.loader.ConfigLoader; import com.dfsek.tectonic.api.preprocessor.Result; + +import com.dfsek.terra.api.config.meta.Meta; +import com.dfsek.terra.api.util.generic.pair.Pair; +import com.dfsek.terra.api.util.reflection.TypeKey; + import org.jetbrains.annotations.NotNull; import java.lang.reflect.AnnotatedType; @@ -32,10 +37,6 @@ import java.util.List; import java.util.Map; import java.util.Optional; -import com.dfsek.terra.api.config.meta.Meta; -import com.dfsek.terra.api.util.generic.pair.Pair; -import com.dfsek.terra.api.util.reflection.TypeKey; - public class MetaMapPreprocessor extends MetaPreprocessor { private static final TypeKey> STRING_LIST = new TypeKey<>() { diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/registry/ShortcutHolder.java b/common/implementation/base/src/main/java/com/dfsek/terra/registry/ShortcutHolder.java index 8330a959b..5261ce76b 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/registry/ShortcutHolder.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/registry/ShortcutHolder.java @@ -4,15 +4,16 @@ import com.dfsek.tectonic.api.depth.DepthTracker; import com.dfsek.tectonic.api.exception.LoadException; import com.dfsek.tectonic.api.loader.ConfigLoader; import com.dfsek.tectonic.api.loader.type.TypeLoader; + +import com.dfsek.terra.api.registry.Registry; +import com.dfsek.terra.api.tectonic.ShortcutLoader; + import org.jetbrains.annotations.NotNull; import java.lang.reflect.AnnotatedType; import java.util.HashMap; import java.util.Map; -import com.dfsek.terra.api.registry.Registry; -import com.dfsek.terra.api.tectonic.ShortcutLoader; - public class ShortcutHolder implements TypeLoader { private final Map> shortcuts = new HashMap<>(); diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitEntity.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitEntity.java index 7ea9d2294..aa404ff67 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitEntity.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitEntity.java @@ -17,14 +17,14 @@ package com.dfsek.terra.bukkit; -import io.papermc.lib.PaperLib; -import org.bukkit.Location; - import com.dfsek.terra.api.entity.Entity; import com.dfsek.terra.api.util.vector.Vector3; import com.dfsek.terra.api.world.ServerWorld; import com.dfsek.terra.bukkit.world.BukkitAdapter; +import io.papermc.lib.PaperLib; +import org.bukkit.Location; + public class BukkitEntity implements Entity { private final org.bukkit.entity.Entity entity; diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInitializer.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInitializer.java index 99797e8ab..a5e286f00 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInitializer.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInitializer.java @@ -1,10 +1,10 @@ package com.dfsek.terra.bukkit.nms.v1_19_R3; -import org.bukkit.Bukkit; - import com.dfsek.terra.bukkit.PlatformImpl; import com.dfsek.terra.bukkit.nms.Initializer; +import org.bukkit.Bukkit; + public class NMSInitializer implements Initializer { @Override diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInfo.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInfo.java index 7d8203ce3..5978f935f 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInfo.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInfo.java @@ -1,10 +1,10 @@ package com.dfsek.terra.bukkit.nms.v1_20_R1; +import com.dfsek.terra.api.properties.Properties; + import net.minecraft.resources.ResourceKey; import net.minecraft.world.level.biome.Biome; -import com.dfsek.terra.api.properties.Properties; - public record NMSBiomeInfo(ResourceKey biomeKey) implements Properties { } diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java index f140e2528..fcdd63753 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java @@ -1,13 +1,16 @@ package com.dfsek.terra.bukkit.nms.v1_20_R1; +import com.dfsek.terra.api.config.ConfigPack; +import com.dfsek.terra.api.world.biome.generation.BiomeProvider; +import com.dfsek.terra.api.world.info.WorldProperties; +import com.dfsek.terra.bukkit.config.PreLoadCompatibilityOptions; +import com.dfsek.terra.bukkit.world.BukkitWorldProperties; +import com.dfsek.terra.bukkit.world.block.data.BukkitBlockState; + import com.mojang.serialization.Codec; import net.minecraft.core.BlockPos; import net.minecraft.server.level.WorldGenRegion; -import net.minecraft.world.level.LevelAccessor; -import net.minecraft.world.level.LevelHeightAccessor; -import net.minecraft.world.level.NoiseColumn; -import net.minecraft.world.level.StructureManager; -import net.minecraft.world.level.WorldGenLevel; +import net.minecraft.world.level.*; import net.minecraft.world.level.biome.BiomeManager; import net.minecraft.world.level.block.Blocks; import net.minecraft.world.level.block.state.BlockState; @@ -28,13 +31,6 @@ import java.util.List; import java.util.concurrent.CompletableFuture; import java.util.concurrent.Executor; -import com.dfsek.terra.api.config.ConfigPack; -import com.dfsek.terra.api.world.biome.generation.BiomeProvider; -import com.dfsek.terra.api.world.info.WorldProperties; -import com.dfsek.terra.bukkit.config.PreLoadCompatibilityOptions; -import com.dfsek.terra.bukkit.world.BukkitWorldProperties; -import com.dfsek.terra.bukkit.world.block.data.BukkitBlockState; - public class NMSChunkGeneratorDelegate extends ChunkGenerator { private static final Logger LOGGER = LoggerFactory.getLogger(NMSChunkGeneratorDelegate.class); diff --git a/platforms/cli/src/main/java/com/dfsek/terra/cli/handle/CLIItemHandle.java b/platforms/cli/src/main/java/com/dfsek/terra/cli/handle/CLIItemHandle.java index 719729138..3a183d006 100644 --- a/platforms/cli/src/main/java/com/dfsek/terra/cli/handle/CLIItemHandle.java +++ b/platforms/cli/src/main/java/com/dfsek/terra/cli/handle/CLIItemHandle.java @@ -1,11 +1,11 @@ package com.dfsek.terra.cli.handle; -import java.util.Set; - import com.dfsek.terra.api.handle.ItemHandle; import com.dfsek.terra.api.inventory.Item; import com.dfsek.terra.api.inventory.item.Enchantment; +import java.util.Set; + public class CLIItemHandle implements ItemHandle { @Override diff --git a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java index d316b1a3a..95f3cf68e 100644 --- a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java +++ b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java @@ -17,10 +17,10 @@ package com.dfsek.terra.fabric; -import net.fabricmc.api.ModInitializer; - import com.dfsek.terra.lifecycle.LifecycleEntryPoint; +import net.fabricmc.api.ModInitializer; + public class FabricEntryPoint extends LifecycleEntryPoint implements ModInitializer { private static final FabricPlatform TERRA_PLUGIN = new FabricPlatform(); From c4f665ffc5def6c0b756b2f1c251c30893443b05 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Thu, 2 Nov 2023 18:47:45 -0600 Subject: [PATCH 62/83] fix format error --- .../terra/addons/noise/samplers/noise/GaborNoiseSampler.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java index 1b74295a8..acc853035 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java @@ -17,10 +17,10 @@ public class GaborNoiseSampler extends NoiseFunction { private double a = 0.1; private double f0 = 0.625; private double kernelRadius = (Math.sqrt(-Math.log(0.05) / Math.PI) / a); + private double impulsesPerKernel = 64d; private double impulseDensity = (impulsesPerKernel / (Math.PI * kernelRadius * kernelRadius)); private double impulsesPerCell = impulseDensity * kernelRadius * kernelRadius; private double g = Math.exp(-impulsesPerCell); - private double impulsesPerKernel = 64d; private double omega0 = Math.PI * 0.25; private boolean isotropic = true; From 0b1d67b53354fdb0a8fdd89dc4f7f90e9f9388dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Sun, 5 Nov 2023 20:51:28 -0700 Subject: [PATCH 63/83] Actually fix issue --- .../src/main/kotlin/DistributionConfig.kt | 38 +++++++++---------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/buildSrc/src/main/kotlin/DistributionConfig.kt b/buildSrc/src/main/kotlin/DistributionConfig.kt index 16276f500..f871b1cbb 100644 --- a/buildSrc/src/main/kotlin/DistributionConfig.kt +++ b/buildSrc/src/main/kotlin/DistributionConfig.kt @@ -3,6 +3,7 @@ import java.io.File import java.io.FileWriter import java.net.URI import java.net.URL +import java.nio.file.FileSystemNotFoundException import java.nio.file.FileSystems import java.nio.file.Files import java.nio.file.StandardCopyOption @@ -46,29 +47,28 @@ fun Project.configureDistribution() { // https://github.com/johnrengelman/shadow/issues/111 val dest = URI.create("jar:" + tasks.named("shadowJar").get().archiveFile.get().asFile.toURI()) - val preExistingProvider = try { + val provider = try { FileSystems.getFileSystem(dest) - } catch (e: Exception) { + } catch (e: FileSystemNotFoundException) { null - }; - val provider = if (preExistingProvider == null) { - preExistingProvider - } else { - FileSystems.newFileSystem(dest, mapOf("create" to "false"), null) - }; + } ?: FileSystems.newFileSystem(dest, mapOf("create" to "false"), null); provider?.use { fs -> forSubProjects(":common:addons") { - val jar = getJarTask() - - println("Packaging addon ${jar.archiveFileName.get()} to $dest. size: ${jar.archiveFile.get().asFile.length() / 1024}KB") - - val boot = if (extra.has("bootstrap") && extra.get("bootstrap") as Boolean) "bootstrap/" else "" - val addonPath = fs.getPath("/addons/$boot${jar.archiveFileName.get()}") - - if (!Files.exists(addonPath)) { - Files.createDirectories(addonPath.parent) - Files.createFile(addonPath) - Files.copy(jar.archiveFile.get().asFile.toPath(), addonPath, StandardCopyOption.REPLACE_EXISTING) + if (fs.isOpen) { + val jar = getJarTask() + + if (jar.archiveFile.get().asFile.exists()) { + println("Packaging addon ${jar.archiveFileName.get()} to $dest. size: ${jar.archiveFile.get().asFile.length() / 1024}KB") + + val boot = if (extra.has("bootstrap") && extra.get("bootstrap") as Boolean) "bootstrap/" else "" + val addonPath = fs.getPath("/addons/$boot${jar.archiveFileName.get()}") + + if (!Files.exists(addonPath)) { + Files.createDirectories(addonPath.parent) + Files.createFile(addonPath) + Files.copy(jar.archiveFile.get().asFile.toPath(), addonPath, StandardCopyOption.REPLACE_EXISTING) + } + } } } From 0ab463f34f27630c2c4b1a8c365d2c6c4d0d0035 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Sun, 5 Nov 2023 21:07:25 -0700 Subject: [PATCH 64/83] bukkit clean up --- .../dfsek/terra/bukkit/TerraBukkitPlugin.java | 38 +++++++++++-------- 1 file changed, 22 insertions(+), 16 deletions(-) diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java index a33393cfd..2d3c2e0ee 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java @@ -63,21 +63,7 @@ public class TerraBukkitPlugin extends JavaPlugin { try { - PaperCommandManager commandManager = new PaperCommandManager<>(this, - CommandExecutionCoordinator.simpleCoordinator(), - BukkitAdapter::adapt, - BukkitAdapter::adapt); - if(commandManager.queryCapability(CloudBukkitCapabilities.NATIVE_BRIGADIER)) { - commandManager.registerBrigadier(); - final CloudBrigadierManager brigManager = commandManager.brigadierManager(); - if(brigManager != null) { - brigManager.setNativeNumberSuggestions(false); - } - } - - if(commandManager.queryCapability(CloudBukkitCapabilities.ASYNCHRONOUS_COMPLETION)) { - commandManager.registerAsynchronousCompletions(); - } + PaperCommandManager commandManager = getCommandSenderPaperCommandManager(); platform.getEventManager().callEvent(new CommandRegistrationEvent(commandManager)); @@ -98,6 +84,26 @@ public class TerraBukkitPlugin extends JavaPlugin { Initializer.init(platform); } + @NotNull + private PaperCommandManager getCommandSenderPaperCommandManager() throws Exception { + PaperCommandManager commandManager = new PaperCommandManager<>(this, + CommandExecutionCoordinator.simpleCoordinator(), + BukkitAdapter::adapt, + BukkitAdapter::adapt); + if(commandManager.hasCapability(CloudBukkitCapabilities.NATIVE_BRIGADIER)) { + commandManager.registerBrigadier(); + final CloudBrigadierManager brigManager = commandManager.brigadierManager(); + if(brigManager != null) { + brigManager.setNativeNumberSuggestions(false); + } + } + + if(commandManager.hasCapability(CloudBukkitCapabilities.ASYNCHRONOUS_COMPLETION)) { + commandManager.registerAsynchronousCompletions(); + } + return commandManager; + } + public PlatformImpl getPlatform() { return platform; } @@ -153,7 +159,7 @@ public class TerraBukkitPlugin extends JavaPlugin { """.strip()); }; runnable.run(); - getFoliaLib().getImpl().runLaterAsync(runnable, 200L); + foliaLib.getImpl().runLaterAsync(runnable, 200L); // Bukkit.shutdown(); // we're not *that* evil Bukkit.getPluginManager().disablePlugin(this); return false; From 3f9f2bdce46b7956d94bf027194446db5cc95b7b Mon Sep 17 00:00:00 2001 From: solonovamax Date: Wed, 8 Nov 2023 20:38:25 -0500 Subject: [PATCH 65/83] Use kotlin's Path extensions rather than Files.whatever Signed-off-by: solonovamax --- buildSrc/src/main/kotlin/DistributionConfig.kt | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/buildSrc/src/main/kotlin/DistributionConfig.kt b/buildSrc/src/main/kotlin/DistributionConfig.kt index f871b1cbb..b492e90de 100644 --- a/buildSrc/src/main/kotlin/DistributionConfig.kt +++ b/buildSrc/src/main/kotlin/DistributionConfig.kt @@ -5,8 +5,6 @@ import java.net.URI import java.net.URL import java.nio.file.FileSystemNotFoundException import java.nio.file.FileSystems -import java.nio.file.Files -import java.nio.file.StandardCopyOption import org.gradle.api.DefaultTask import org.gradle.api.Project import org.gradle.api.plugins.BasePluginExtension @@ -17,6 +15,10 @@ import org.gradle.kotlin.dsl.get import org.gradle.kotlin.dsl.named import org.yaml.snakeyaml.DumperOptions import org.yaml.snakeyaml.Yaml +import kotlin.io.path.copyTo +import kotlin.io.path.createDirectories +import kotlin.io.path.createFile +import kotlin.io.path.exists fun Project.configureDistribution() { @@ -51,7 +53,7 @@ fun Project.configureDistribution() { FileSystems.getFileSystem(dest) } catch (e: FileSystemNotFoundException) { null - } ?: FileSystems.newFileSystem(dest, mapOf("create" to "false"), null); + } ?: FileSystems.newFileSystem(dest, mapOf("create" to "false"), null) provider?.use { fs -> forSubProjects(":common:addons") { if (fs.isOpen) { @@ -63,10 +65,10 @@ fun Project.configureDistribution() { val boot = if (extra.has("bootstrap") && extra.get("bootstrap") as Boolean) "bootstrap/" else "" val addonPath = fs.getPath("/addons/$boot${jar.archiveFileName.get()}") - if (!Files.exists(addonPath)) { - Files.createDirectories(addonPath.parent) - Files.createFile(addonPath) - Files.copy(jar.archiveFile.get().asFile.toPath(), addonPath, StandardCopyOption.REPLACE_EXISTING) + if (!addonPath.exists()) { + addonPath.parent.createDirectories() + addonPath.createFile() + jar.archiveFile.get().asFile.toPath().copyTo(addonPath, overwrite = true) } } } @@ -136,7 +138,7 @@ fun Project.configureDistribution() { dependsOn(downloadDefaultPacks) configurations = listOf(project.configurations["shaded"]) archiveClassifier.set("shaded") - setVersion(project.version) + version = project.version relocate("org.apache.commons", "com.dfsek.terra.lib.commons") relocate("org.objectweb.asm", "com.dfsek.terra.lib.asm") relocate("com.dfsek.paralithic", "com.dfsek.terra.lib.paralithic") From b3ef4ac79c6e87b4ebf28437008dd33c13c09b41 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Wed, 8 Nov 2023 19:52:05 -0700 Subject: [PATCH 66/83] optimized tan --- .../terra/addons/terrascript/script/StructureScript.java | 2 +- .../api/src/main/java/com/dfsek/terra/api/util/MathUtil.java | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java index 032108784..0657a4281 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java @@ -111,7 +111,7 @@ public class StructureScript implements Structure, Keyed { .registerFunction("round", new UnaryNumberFunctionBuilder(number -> Math.round(number.doubleValue()))) .registerFunction("sin", new UnaryNumberFunctionBuilder(number -> MathUtil.sin(number.doubleValue()))) .registerFunction("cos", new UnaryNumberFunctionBuilder(number -> MathUtil.cos(number.doubleValue()))) - .registerFunction("tan", new UnaryNumberFunctionBuilder(number -> Math.tan(number.doubleValue()))) + .registerFunction("tan", new UnaryNumberFunctionBuilder(number -> MathUtil.tan(number.doubleValue()))) .registerFunction("asin", new UnaryNumberFunctionBuilder(number -> Math.asin(number.doubleValue()))) .registerFunction("acos", new UnaryNumberFunctionBuilder(number -> Math.acos(number.doubleValue()))) .registerFunction("atan", new UnaryNumberFunctionBuilder(number -> Math.atan(number.doubleValue()))) diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java index 716b879af..7227d9c0e 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java @@ -55,6 +55,10 @@ public final class MathUtil { return cos[(int) (rad * radToIndex) & SIN_MASK]; } + public static double tan(double rad) { + return sin(rad)/cos(rad); + } + public static double invSqrt(double x) { double xhalf = 0.5d * x; long i = Double.doubleToLongBits(x); From 020033f8390454d638459f9ea4bbb36eb03d2ad2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Wed, 8 Nov 2023 19:53:36 -0700 Subject: [PATCH 67/83] add rsqrt ts function --- .../dfsek/terra/addons/terrascript/script/StructureScript.java | 1 + 1 file changed, 1 insertion(+) diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java index 0657a4281..bbf9394b7 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java @@ -105,6 +105,7 @@ public class StructureScript implements Structure, Keyed { .registerFunction("pow", new BinaryNumberFunctionBuilder( (number, number2) -> Math.pow(number.doubleValue(), number2.doubleValue()))) .registerFunction("sqrt", new UnaryNumberFunctionBuilder(number -> Math.sqrt(number.doubleValue()))) + .registerFunction("rsqrt", new UnaryNumberFunctionBuilder(number -> MathUtil.invSqrt(number.doubleValue()))) .registerFunction("floor", new UnaryNumberFunctionBuilder(number -> Math.floor(number.doubleValue()))) .registerFunction("ceil", new UnaryNumberFunctionBuilder(number -> Math.ceil(number.doubleValue()))) .registerFunction("log", new UnaryNumberFunctionBuilder(number -> Math.log(number.doubleValue()))) From 7cf87de463a1e40f5c475f3c6660b976e33e45ef Mon Sep 17 00:00:00 2001 From: solonovamax Date: Wed, 8 Nov 2023 22:42:14 -0500 Subject: [PATCH 68/83] Add TODO to replace FoliaLib when we drop support for 1.18 and 1.19 Signed-off-by: solonovamax --- platforms/bukkit/common/build.gradle.kts | 2 ++ 1 file changed, 2 insertions(+) diff --git a/platforms/bukkit/common/build.gradle.kts b/platforms/bukkit/common/build.gradle.kts index ccea91901..1324e038d 100644 --- a/platforms/bukkit/common/build.gradle.kts +++ b/platforms/bukkit/common/build.gradle.kts @@ -8,6 +8,8 @@ dependencies { compileOnly("io.papermc.paper", "paper-api", Versions.Bukkit.paper) shadedApi("io.papermc", "paperlib", Versions.Bukkit.paperLib) + // TODO: 2023-11-08 When we drop support for 1.18 and 1.19, we can remove FoliaLib and instead use `RegionScheduler`, + // AsyncScheduler, or GlobalRegionScheduler. shadedApi("com.tcoded", "FoliaLib", Versions.Bukkit.foliaLib) shadedApi("com.google.guava", "guava", Versions.Libraries.Internal.guava) From dd7bebb27f4bcc0280286d251051ee9702f4b5c2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Wed, 8 Nov 2023 21:18:35 -0700 Subject: [PATCH 69/83] Update lerp usage and docs --- .../math/interpolation/Interpolator.java | 22 +++++-------------- .../math/interpolation/Interpolator3.java | 5 ++++- .../LazilyEvaluatedInterpolator.java | 18 +++++++-------- .../terra/addons/ore/ores/VanillaOre.java | 10 +++------ .../com/dfsek/terra/api/util/MathUtil.java | 13 +++++++++-- 5 files changed, 32 insertions(+), 36 deletions(-) diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator.java index 7fd8bb54b..15bef7056 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator.java @@ -7,6 +7,9 @@ package com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation; +import com.dfsek.terra.api.util.MathUtil; + + /** * Class for bilinear interpolation of values arranged on a unit square. */ @@ -28,19 +31,6 @@ public class Interpolator { this.v3 = v3; } - /** - * 1D Linear interpolation between 2 points 1 unit apart. - * - * @param t - Distance from v0. Total distance between v0 and v1 is 1 unit. - * @param v0 - Value at v0. - * @param v1 - Value at v1. - * - * @return double - The interpolated value. - */ - public static double lerp(double t, double v0, double v1) { - return v0 + t * (v1 - v0); - } - /** * 2D Bilinear interpolation between 4 points on a unit square. * @@ -50,8 +40,8 @@ public class Interpolator { * @return double - The interpolated value. */ public double bilerp(double s, double t) { - double v01 = lerp(s, v0, v1); - double v23 = lerp(s, v2, v3); - return lerp(t, v01, v23); + double v01 = MathUtil.lerp(s, v0, v1); + double v23 = MathUtil.lerp(s, v2, v3); + return MathUtil.lerp(t, v01, v23); } } \ No newline at end of file diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator3.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator3.java index 3650ca592..0a6bf7263 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator3.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator3.java @@ -7,6 +7,9 @@ package com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation; +import com.dfsek.terra.api.util.MathUtil; + + /** * Class for bilinear interpolation of values arranged on a unit square. */ @@ -34,6 +37,6 @@ public class Interpolator3 { } public double trilerp(double x, double y, double z) { - return Interpolator.lerp(x, top.bilerp(y, z), bottom.bilerp(y, z)); + return MathUtil.lerp(x, top.bilerp(y, z), bottom.bilerp(y, z)); } } \ No newline at end of file diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/LazilyEvaluatedInterpolator.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/LazilyEvaluatedInterpolator.java index d2aa6d13d..e31d77f52 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/LazilyEvaluatedInterpolator.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/LazilyEvaluatedInterpolator.java @@ -2,11 +2,9 @@ package com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation; import com.dfsek.terra.addons.chunkgenerator.config.noise.BiomeNoiseProperties; import com.dfsek.terra.api.properties.PropertyKey; +import com.dfsek.terra.api.util.MathUtil; import com.dfsek.terra.api.world.biome.generation.BiomeProvider; -import static com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation.Interpolator.lerp; - - public class LazilyEvaluatedInterpolator { private final Double[] samples; // @@ -82,10 +80,10 @@ public class LazilyEvaluatedInterpolator { double xFrac = (double) (x % horizontalRes) / horizontalRes; double zFrac = (double) (z % horizontalRes) / horizontalRes; - double lerp_bottom_0 = lerp(zFrac, sample_0_0_0, sample_0_0_1); - double lerp_bottom_1 = lerp(zFrac, sample_1_0_0, sample_1_0_1); + double lerp_bottom_0 = MathUtil.lerp(zFrac, sample_0_0_0, sample_0_0_1); + double lerp_bottom_1 = MathUtil.lerp(zFrac, sample_1_0_0, sample_1_0_1); - double lerp_bottom = lerp(xFrac, lerp_bottom_0, lerp_bottom_1); + double lerp_bottom = MathUtil.lerp(xFrac, lerp_bottom_0, lerp_bottom_1); if(yRange) { // we can do bilerp return lerp_bottom; @@ -101,11 +99,11 @@ public class LazilyEvaluatedInterpolator { double sample_1_1_0 = sample(xIndex + 1, yIndex + 1, zIndex, x + horizontalRes, y + verticalRes, z); double sample_1_1_1 = sample(xIndex + 1, yIndex + 1, zIndex + 1, x + horizontalRes, y + verticalRes, z + horizontalRes); - double lerp_top_0 = lerp(zFrac, sample_0_1_0, sample_0_1_1); - double lerp_top_1 = lerp(zFrac, sample_1_1_0, sample_1_1_1); + double lerp_top_0 = MathUtil.lerp(zFrac, sample_0_1_0, sample_0_1_1); + double lerp_top_1 = MathUtil.lerp(zFrac, sample_1_1_0, sample_1_1_1); - double lerp_top = lerp(xFrac, lerp_top_0, lerp_top_1); + double lerp_top = MathUtil.lerp(xFrac, lerp_top_0, lerp_top_1); - return lerp(yFrac, lerp_bottom, lerp_top); + return MathUtil.lerp(yFrac, lerp_bottom, lerp_top); } } diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java index 529983f7b..46b49d49b 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaOre.java @@ -43,10 +43,6 @@ public class VanillaOre implements Structure { this.materials = materials; } - public static double lerp(double t, double v0, double v1) { - return v0 + t * (v1 - v0); - } - @Override public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation) { float randomRadian = random.nextFloat() * (float) Math.PI; @@ -68,9 +64,9 @@ public class VanillaOre implements Structure { // Compute initial point positions and radius for(int i = 0; i < sizeInt; ++i) { float t = (float) i / (float) sizeInt; - double xt = lerp(t, startX, endX); - double yt = lerp(t, startY, endY); - double zt = lerp(t, startZ, endZ); + double xt = MathUtil.lerp(t, startX, endX); + double yt = MathUtil.lerp(t, startY, endY); + double zt = MathUtil.lerp(t, startZ, endZ); double roll = random.nextDouble() * size / 16.0; // Taper radius closer to line ends double radius = ((MathUtil.sin((float) Math.PI * t) + 1.0F) * roll + 1.0) / 2.0; diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java index 7227d9c0e..b46c6e543 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java @@ -237,8 +237,17 @@ public final class MathUtil { return h; } - public static double lerp(double a, double b, double t) { - return a + t * (b - a); + /** + * 1D Linear interpolation between 2 points 1 unit apart. + * + * @param t - Distance from v0. Total distance between v0 and v1 is 1 unit. + * @param v0 - Value at v0. + * @param v1 - Value at v1. + * + * @return double - The interpolated value. + */ + public static double lerp(double t, double v0, double v1) { + return v0 + t * (v1 - v0); } public static double cubicLerp(double a, double b, double c, double d, double t) { From 0df940d6885533f7379e83efecb9dd35244e758c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Wed, 8 Nov 2023 21:20:01 -0700 Subject: [PATCH 70/83] improve invSqrt formatting Co-authored-by: solonovamax what the fuck? --- .../java/com/dfsek/terra/api/util/MathUtil.java | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java index b46c6e543..d745f35e2 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java @@ -60,12 +60,14 @@ public final class MathUtil { } public static double invSqrt(double x) { - double xhalf = 0.5d * x; - long i = Double.doubleToLongBits(x); - i = 0x5fe6ec85e7de30daL - (i >> 1); - x = Double.longBitsToDouble(i); - x *= (1.5d - xhalf * x * x); - return x; + double halfX = 0.5d * x; + long i = Double.doubleToLongBits(x); // evil floating point bit level hacking + i = 0x5FE6EC85E7DE30DAL - (i >> 1); // what the fuck? + double y = Double.longBitsToDouble(i); + y *= (1.5d - halfX * y * y); // 1st newtonian iteration + // y *= (1.5d - halfX * y * y); // 2nd newtonian iteration, this can be removed + + return y; } /** From 89d497d500bf0957c6e489efcd8501489bb4303e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Wed, 8 Nov 2023 21:58:57 -0700 Subject: [PATCH 71/83] Some requested changes --- common/addons/biome-provider-image-v2/build.gradle.kts | 2 +- common/addons/biome-provider-image/build.gradle.kts | 2 +- common/addons/biome-provider-pipeline-v2/build.gradle.kts | 2 +- common/addons/biome-provider-pipeline/build.gradle.kts | 2 +- common/addons/chunk-generator-noise-3d/build.gradle.kts | 2 +- common/addons/config-distributors/build.gradle.kts | 2 +- common/addons/config-flora/build.gradle.kts | 2 +- common/addons/config-locators/build.gradle.kts | 2 +- common/addons/config-ore/build.gradle.kts | 2 +- common/addons/config-structure/build.gradle.kts | 2 +- common/addons/library-image/build.gradle.kts | 2 +- .../terra/addons/image/operator/DistanceTransform.java | 6 ++++-- .../addons/structure-terrascript-loader/build.gradle.kts | 8 +++++++- .../terrascript-function-check-noise-3d/build.gradle.kts | 2 +- platforms/cli/build.gradle.kts | 8 ++++---- platforms/mixin-common/README.md | 2 +- platforms/mixin-lifecycle/README.md | 2 +- 17 files changed, 29 insertions(+), 21 deletions(-) diff --git a/common/addons/biome-provider-image-v2/build.gradle.kts b/common/addons/biome-provider-image-v2/build.gradle.kts index 38f4801d2..989c8567c 100644 --- a/common/addons/biome-provider-image-v2/build.gradle.kts +++ b/common/addons/biome-provider-image-v2/build.gradle.kts @@ -1,4 +1,4 @@ -version = version("1.0.0") +version = version("1.0.1") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) diff --git a/common/addons/biome-provider-image/build.gradle.kts b/common/addons/biome-provider-image/build.gradle.kts index f1755a0f0..e01ce95f8 100644 --- a/common/addons/biome-provider-image/build.gradle.kts +++ b/common/addons/biome-provider-image/build.gradle.kts @@ -1,4 +1,4 @@ -version = version("1.0.0") +version = version("1.0.1") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) diff --git a/common/addons/biome-provider-pipeline-v2/build.gradle.kts b/common/addons/biome-provider-pipeline-v2/build.gradle.kts index d3eaff9fe..f0b8af23a 100644 --- a/common/addons/biome-provider-pipeline-v2/build.gradle.kts +++ b/common/addons/biome-provider-pipeline-v2/build.gradle.kts @@ -1,4 +1,4 @@ -version = version("1.0.0") +version = version("1.0.1") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) diff --git a/common/addons/biome-provider-pipeline/build.gradle.kts b/common/addons/biome-provider-pipeline/build.gradle.kts index 35e4d7076..2e19b7c85 100644 --- a/common/addons/biome-provider-pipeline/build.gradle.kts +++ b/common/addons/biome-provider-pipeline/build.gradle.kts @@ -1,4 +1,4 @@ -version = version("1.0.1") +version = version("1.0.2") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) diff --git a/common/addons/chunk-generator-noise-3d/build.gradle.kts b/common/addons/chunk-generator-noise-3d/build.gradle.kts index b4888dea4..3640ad054 100644 --- a/common/addons/chunk-generator-noise-3d/build.gradle.kts +++ b/common/addons/chunk-generator-noise-3d/build.gradle.kts @@ -1,4 +1,4 @@ -version = version("1.2.0") +version = version("1.2.1") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) diff --git a/common/addons/config-distributors/build.gradle.kts b/common/addons/config-distributors/build.gradle.kts index 9d0aac37f..35e4d7076 100644 --- a/common/addons/config-distributors/build.gradle.kts +++ b/common/addons/config-distributors/build.gradle.kts @@ -1,4 +1,4 @@ -version = version("1.0.0") +version = version("1.0.1") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) diff --git a/common/addons/config-flora/build.gradle.kts b/common/addons/config-flora/build.gradle.kts index 9d0aac37f..35e4d7076 100644 --- a/common/addons/config-flora/build.gradle.kts +++ b/common/addons/config-flora/build.gradle.kts @@ -1,4 +1,4 @@ -version = version("1.0.0") +version = version("1.0.1") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) diff --git a/common/addons/config-locators/build.gradle.kts b/common/addons/config-locators/build.gradle.kts index 47ace7fcc..9360372c2 100644 --- a/common/addons/config-locators/build.gradle.kts +++ b/common/addons/config-locators/build.gradle.kts @@ -1,4 +1,4 @@ -version = version("1.1.0") +version = version("1.1.1") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) diff --git a/common/addons/config-ore/build.gradle.kts b/common/addons/config-ore/build.gradle.kts index 8cbbf63e6..469635ee6 100644 --- a/common/addons/config-ore/build.gradle.kts +++ b/common/addons/config-ore/build.gradle.kts @@ -1,4 +1,4 @@ -version = version("1.0.0") +version = version("1.1.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) diff --git a/common/addons/config-structure/build.gradle.kts b/common/addons/config-structure/build.gradle.kts index aab2399ea..a40803d2b 100644 --- a/common/addons/config-structure/build.gradle.kts +++ b/common/addons/config-structure/build.gradle.kts @@ -1,4 +1,4 @@ -version = version("1.0.0") +version = version("1.0.1") dependencies { api("com.googlecode.json-simple:json-simple:1.1.1") diff --git a/common/addons/library-image/build.gradle.kts b/common/addons/library-image/build.gradle.kts index e01ce95f8..b8682c80b 100644 --- a/common/addons/library-image/build.gradle.kts +++ b/common/addons/library-image/build.gradle.kts @@ -1,4 +1,4 @@ -version = version("1.0.1") +version = version("1.1.0") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java index b5fa3458b..4f74ca592 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java @@ -127,10 +127,12 @@ public class DistanceTransform { z[0] = Integer.MIN_VALUE; z[1] = Integer.MAX_VALUE; for(int q = 1; q <= f.length - 1; q++) { - double s = ((f[q] + Math.pow(q, 2)) - (f[v[k]] + Math.pow(v[k], 2))) / (2 * q - 2 * v[k]); + double fqPlusQ2 = (f[q] + Math.pow(q, 2)); + double twoQ = 2*q; + double s = (fqPlusQ2 - (f[v[k]] + Math.pow(v[k], 2))) / (twoQ - 2 * v[k]); while(s <= z[k]) { k--; - s = ((f[q] + Math.pow(q, 2)) - (f[v[k]] + Math.pow(v[k], 2))) / (2 * q - 2 * v[k]); + s = (fqPlusQ2 - (f[v[k]] + Math.pow(v[k], 2))) / (twoQ - 2 * v[k]); } k++; v[k] = q; diff --git a/common/addons/structure-terrascript-loader/build.gradle.kts b/common/addons/structure-terrascript-loader/build.gradle.kts index 93e35b659..a042ee13c 100644 --- a/common/addons/structure-terrascript-loader/build.gradle.kts +++ b/common/addons/structure-terrascript-loader/build.gradle.kts @@ -1,6 +1,12 @@ -version = version("1.1.0") +import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar + +version = version("1.2.0") dependencies { api("commons-io:commons-io:2.7") compileOnlyApi(project(":common:addons:manifest-addon-loader")) } + +tasks.named("shadowJar") { + relocate("org.apache.commons", "com.dfsek.terra.addons.terrascript.lib.commons") +} diff --git a/common/addons/terrascript-function-check-noise-3d/build.gradle.kts b/common/addons/terrascript-function-check-noise-3d/build.gradle.kts index bb694d2c6..75dbafba5 100644 --- a/common/addons/terrascript-function-check-noise-3d/build.gradle.kts +++ b/common/addons/terrascript-function-check-noise-3d/build.gradle.kts @@ -1,4 +1,4 @@ -version = version("1.0.0") +version = version("1.0.1") dependencies { compileOnlyApi(project(":common:addons:manifest-addon-loader")) diff --git a/platforms/cli/build.gradle.kts b/platforms/cli/build.gradle.kts index 9edd40c66..12c452419 100644 --- a/platforms/cli/build.gradle.kts +++ b/platforms/cli/build.gradle.kts @@ -7,12 +7,12 @@ val javaMainClass = "com.dfsek.terra.cli.TerraCLI" dependencies { shadedApi(project(":common:implementation:base")) - shadedApi("commons-io:commons-io:${Versions.Libraries.Internal.apacheIO}") - shadedApi("com.github.Querz:NBT:${Versions.CLI.nbt}") + shadedApi("commons-io", "commons-io", Versions.Libraries.Internal.apacheIO) + shadedApi("com.github.Querz", "NBT", "Versions.CLI.nbt") - shadedImplementation("com.google.guava:guava:${Versions.Libraries.Internal.guava}") + shadedImplementation("com.google.guava", "guava", "Versions.Libraries.Internal.guava") - shadedImplementation("ch.qos.logback:logback-classic:${Versions.CLI.logback}") + shadedImplementation("ch.qos.logback", "logback-classic", "Versions.CLI.logback") } diff --git a/platforms/mixin-common/README.md b/platforms/mixin-common/README.md index f252941a2..abc4b885e 100644 --- a/platforms/mixin-common/README.md +++ b/platforms/mixin-common/README.md @@ -1,4 +1,4 @@ # mixin-common -This project contains mixins shared between Forge, Fabric and formerly Quilt, as +This project contains mixins shared between Forge, Fabric, and formerly Quilt, as well as glue code. \ No newline at end of file diff --git a/platforms/mixin-lifecycle/README.md b/platforms/mixin-lifecycle/README.md index 95d7e8c1c..d0f9f2bc3 100644 --- a/platforms/mixin-lifecycle/README.md +++ b/platforms/mixin-lifecycle/README.md @@ -1,3 +1,3 @@ # mixin-lifecycle -This project contains lifecycle mixins shared between Fabric and formerly Quilt. \ No newline at end of file +This project contains lifecycle mixins shared between Fabric, and formerly Quilt. \ No newline at end of file From 839bc23a5a2ee5919b7c99620b1d14bdd61923c1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Thu, 9 Nov 2023 11:29:09 -0700 Subject: [PATCH 72/83] add stub for not physics --- .../script/functions/BlockFunction.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java index 6fab3af63..c5ca7eb7e 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java @@ -7,6 +7,8 @@ package com.dfsek.terra.addons.terrascript.script.functions; +import com.dfsek.terra.addons.terrascript.parser.lang.constants.BooleanConstant; + import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -37,6 +39,18 @@ public class BlockFunction implements Function { private final Returnable physics; private final Position position; + public BlockFunction(Returnable x, Returnable y, Returnable z, Returnable blockData, + Returnable overwrite, Platform platform, Position position) { + this.x = x; + this.y = y; + this.z = z; + this.blockData = blockData; + this.overwrite = overwrite; + this.platform = platform; + this.position = position; + this.physics = new BooleanConstant(false, position);; + } + public BlockFunction(Returnable x, Returnable y, Returnable z, Returnable blockData, Returnable overwrite, Returnable physics, Platform platform, Position position) { this.x = x; From acf79f5c53ce39b00866292a78a9c9e5c7c5a150 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Thu, 9 Nov 2023 11:37:01 -0700 Subject: [PATCH 73/83] change class structure of LifecycleEntryPoint --- .../main/java/com/dfsek/terra/fabric/FabricEntryPoint.java | 4 ++-- .../java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java index 95f3cf68e..b4d9fb851 100644 --- a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java +++ b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java @@ -22,11 +22,11 @@ import com.dfsek.terra.lifecycle.LifecycleEntryPoint; import net.fabricmc.api.ModInitializer; -public class FabricEntryPoint extends LifecycleEntryPoint implements ModInitializer { +public class FabricEntryPoint implements ModInitializer { private static final FabricPlatform TERRA_PLUGIN = new FabricPlatform(); @Override public void onInitialize() { - initialize("Fabric", TERRA_PLUGIN); + LifecycleEntryPoint.initialize("Fabric", TERRA_PLUGIN); } } diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java index 3f53bfdfb..8530b57ad 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java @@ -10,10 +10,10 @@ import com.dfsek.terra.api.command.CommandSender; import com.dfsek.terra.api.event.events.platform.CommandRegistrationEvent; -public class LifecycleEntryPoint { +public final class LifecycleEntryPoint { private static final Logger logger = LoggerFactory.getLogger(LifecycleEntryPoint.class); - protected static void initialize(String modName, LifecyclePlatform platform) { + public static void initialize(String modName, LifecyclePlatform platform) { logger.info("Initializing Terra {} mod...", modName); FabricServerCommandManager manager = new FabricServerCommandManager<>( From d8938c5519b092d590da023b4403db91cd7e41a1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Thu, 9 Nov 2023 11:37:46 -0700 Subject: [PATCH 74/83] remove comments --- platforms/mixin-common/build.gradle.kts | 1 - platforms/mixin-lifecycle/build.gradle.kts | 1 - 2 files changed, 2 deletions(-) diff --git a/platforms/mixin-common/build.gradle.kts b/platforms/mixin-common/build.gradle.kts index e8ff5dc7f..a6b4e7231 100644 --- a/platforms/mixin-common/build.gradle.kts +++ b/platforms/mixin-common/build.gradle.kts @@ -24,7 +24,6 @@ dependencies { } architectury { -// common("fabric", "forge", "quilt") common("fabric", "forge") minecraft = Versions.Mod.minecraft } diff --git a/platforms/mixin-lifecycle/build.gradle.kts b/platforms/mixin-lifecycle/build.gradle.kts index a4568c2e3..490cdf687 100644 --- a/platforms/mixin-lifecycle/build.gradle.kts +++ b/platforms/mixin-lifecycle/build.gradle.kts @@ -41,7 +41,6 @@ tasks { } architectury { -// common("fabric", "quilt") common("fabric") minecraft = Versions.Mod.minecraft } \ No newline at end of file From 72e0974cc5ea819cd188e5c29d53243563bbf3dd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Thu, 9 Nov 2023 11:40:19 -0700 Subject: [PATCH 75/83] fix cli build --- platforms/cli/build.gradle.kts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/platforms/cli/build.gradle.kts b/platforms/cli/build.gradle.kts index 12c452419..5070c047f 100644 --- a/platforms/cli/build.gradle.kts +++ b/platforms/cli/build.gradle.kts @@ -8,11 +8,11 @@ dependencies { shadedApi(project(":common:implementation:base")) shadedApi("commons-io", "commons-io", Versions.Libraries.Internal.apacheIO) - shadedApi("com.github.Querz", "NBT", "Versions.CLI.nbt") + shadedApi("com.github.Querz", "NBT", Versions.CLI.nbt) - shadedImplementation("com.google.guava", "guava", "Versions.Libraries.Internal.guava") + shadedImplementation("com.google.guava", "guava", Versions.Libraries.Internal.guava) - shadedImplementation("ch.qos.logback", "logback-classic", "Versions.CLI.logback") + shadedImplementation("ch.qos.logback", "logback-classic", Versions.CLI.logback) } From a117db40be9f8d495435fe4c9f47cbc1c6868b63 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Thu, 9 Nov 2023 12:47:48 -0700 Subject: [PATCH 76/83] change formatting --- .../src/main/java/com/dfsek/terra/fabric/FabricPlatform.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricPlatform.java b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricPlatform.java index da44b168e..a4d023523 100644 --- a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricPlatform.java +++ b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricPlatform.java @@ -33,8 +33,8 @@ public class FabricPlatform extends LifecyclePlatform { @Override protected Collection getPlatformMods() { return FabricLoader.getInstance().getAllMods().stream().flatMap( - mod -> parseModData(mod.getMetadata().getId(), mod.getMetadata().getVersion().getFriendlyString(), "fabric")).collect( - Collectors.toList()); + mod -> parseModData(mod.getMetadata().getId(), mod.getMetadata().getVersion().getFriendlyString(), "fabric") + ).collect(Collectors.toList()); } @Override From 4065cfea532d8d15b8633d2e59857e74ded8dd1d Mon Sep 17 00:00:00 2001 From: Astrashh Date: Fri, 10 Nov 2023 11:47:12 +1100 Subject: [PATCH 77/83] Fix YAML formatting (#426) * Remove trailing whitespace in YAML formatting * Reformat YAML files --- .editorconfig | 4 +-- .github/ISSUE_TEMPLATE/config.yml | 18 ++++++------- .../src/main/resources/terra.addon.yml | 12 ++++----- .../src/main/resources/terra.addon.yml | 12 ++++----- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 14 +++++----- .../src/main/resources/terra.addon.yml | 12 ++++----- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 14 +++++----- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 12 ++++----- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 14 +++++----- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 8 +++--- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 10 +++---- .../src/main/resources/terra.addon.yml | 14 +++++----- .../src/main/resources/terra.addon.yml | 14 +++++----- .../base/src/main/resources/config.yml | 16 ++++++------ .../base/src/test/resources/config.yml | 10 +++---- .../base/src/test/resources/meta.yml | 26 +++++++++---------- .../base/src/test/resources/metaTarget.yml | 22 ++++++++-------- 41 files changed, 236 insertions(+), 236 deletions(-) diff --git a/.editorconfig b/.editorconfig index 30cfb5ef7..9ab244cf7 100644 --- a/.editorconfig +++ b/.editorconfig @@ -577,14 +577,14 @@ ij_properties_keep_blank_lines = false ij_properties_key_value_delimiter = equals ij_properties_spaces_around_key_value_delimiter = false -[{*.yaml, *.yml}] +[{*.yml, *.yaml}] indent_size = 2 ij_visual_guides = none ij_yaml_align_values_properties = do_not_align ij_yaml_autoinsert_sequence_marker = true ij_yaml_block_mapping_on_new_line = false ij_yaml_indent_sequence_value = true -ij_yaml_keep_indents_on_empty_lines = true +ij_yaml_keep_indents_on_empty_lines = false ij_yaml_keep_line_breaks = true ij_yaml_sequence_on_new_line = false ij_yaml_space_before_colon = false diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml index 329a48021..4611034c8 100644 --- a/.github/ISSUE_TEMPLATE/config.yml +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -1,11 +1,11 @@ blank_issues_enabled: false contact_links: - - name: Which Issue Template do I Choose? - url: https://github.com/PolyhedralDev/Terra/wiki/How-To-Choose-An-Issue-Template - about: Click this if you don't know which issue template to select. This will help you make sure you choose the right one and provide enough information for us to help you. - - name: Terra Wiki - url: https://github.com/PolyhedralDev/Terra/wiki - about: Documentation for all things Terra. - - name: Join the Support Discord - url: https://discord.dfsek.com - about: If you have a basic support question, join the Discord instead. \ No newline at end of file + - name: Which Issue Template do I Choose? + url: https://github.com/PolyhedralDev/Terra/wiki/How-To-Choose-An-Issue-Template + about: Click this if you don't know which issue template to select. This will help you make sure you choose the right one and provide enough information for us to help you. + - name: Terra Wiki + url: https://github.com/PolyhedralDev/Terra/wiki + about: Documentation for all things Terra. + - name: Join the Support Discord + url: https://discord.dfsek.com + about: If you have a basic support question, join the Discord instead. \ No newline at end of file diff --git a/common/addons/biome-provider-extrusion/src/main/resources/terra.addon.yml b/common/addons/biome-provider-extrusion/src/main/resources/terra.addon.yml index 95fd480c1..21992a6d1 100644 --- a/common/addons/biome-provider-extrusion/src/main/resources/terra.addon.yml +++ b/common/addons/biome-provider-extrusion/src/main/resources/terra.addon.yml @@ -1,14 +1,14 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: biome-provider-extrusion version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.extrusion.BiomeExtrusionAddon" + - "com.dfsek.terra.addons.biome.extrusion.BiomeExtrusionAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - biome-query-api: "1.+" \ No newline at end of file + biome-query-api: "1.+" \ No newline at end of file diff --git a/common/addons/biome-provider-image-v2/src/main/resources/terra.addon.yml b/common/addons/biome-provider-image-v2/src/main/resources/terra.addon.yml index c80bb617a..be3dd2af4 100644 --- a/common/addons/biome-provider-image-v2/src/main/resources/terra.addon.yml +++ b/common/addons/biome-provider-image-v2/src/main/resources/terra.addon.yml @@ -1,14 +1,14 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: biome-provider-image-v2 version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.image.v2.ImageBiomeProviderAddon" + - "com.dfsek.terra.addons.biome.image.v2.ImageBiomeProviderAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - library-image: "1.+" + library-image: "1.+" diff --git a/common/addons/biome-provider-image/src/main/resources/terra.addon.yml b/common/addons/biome-provider-image/src/main/resources/terra.addon.yml index dec87cc26..3fd86ad52 100644 --- a/common/addons/biome-provider-image/src/main/resources/terra.addon.yml +++ b/common/addons/biome-provider-image/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: biome-provider-image version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.image.ImageBiomeProviderAddon" + - "com.dfsek.terra.addons.biome.image.ImageBiomeProviderAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/biome-provider-pipeline-v2/src/main/resources/terra.addon.yml b/common/addons/biome-provider-pipeline-v2/src/main/resources/terra.addon.yml index c9b711ce5..f800574ca 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/resources/terra.addon.yml +++ b/common/addons/biome-provider-pipeline-v2/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: biome-provider-pipeline-v2 version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.pipeline.v2.BiomePipelineAddon" + - "com.dfsek.terra.addons.biome.pipeline.v2.BiomePipelineAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/biome-provider-pipeline/src/main/resources/terra.addon.yml b/common/addons/biome-provider-pipeline/src/main/resources/terra.addon.yml index f43908cac..abd2555a5 100644 --- a/common/addons/biome-provider-pipeline/src/main/resources/terra.addon.yml +++ b/common/addons/biome-provider-pipeline/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: biome-provider-pipeline version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.pipeline.BiomePipelineAddon" + - "com.dfsek.terra.addons.biome.pipeline.BiomePipelineAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/biome-provider-single/src/main/resources/terra.addon.yml b/common/addons/biome-provider-single/src/main/resources/terra.addon.yml index c7e91131c..d986179f3 100644 --- a/common/addons/biome-provider-single/src/main/resources/terra.addon.yml +++ b/common/addons/biome-provider-single/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: biome-provider-single version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.single.SingleBiomeProviderAddon" + - "com.dfsek.terra.addons.biome.single.SingleBiomeProviderAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/biome-query-api/src/main/resources/terra.addon.yml b/common/addons/biome-query-api/src/main/resources/terra.addon.yml index 1030c3e4c..8a55ce2dc 100644 --- a/common/addons/biome-query-api/src/main/resources/terra.addon.yml +++ b/common/addons/biome-query-api/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: biome-query-api version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.query.BiomeQueryAPIAddon" + - "com.dfsek.terra.addons.biome.query.BiomeQueryAPIAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/chunk-generator-noise-3d/src/main/resources/terra.addon.yml b/common/addons/chunk-generator-noise-3d/src/main/resources/terra.addon.yml index 6d32e2bf8..76eed7bb9 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/resources/terra.addon.yml +++ b/common/addons/chunk-generator-noise-3d/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: chunk-generator-noise-3d version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.chunkgenerator.NoiseChunkGenerator3DAddon" + - "com.dfsek.terra.addons.chunkgenerator.NoiseChunkGenerator3DAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/command-addons/src/main/resources/terra.addon.yml b/common/addons/command-addons/src/main/resources/terra.addon.yml index 086ee161d..87f5b5454 100644 --- a/common/addons/command-addons/src/main/resources/terra.addon.yml +++ b/common/addons/command-addons/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: command-addons version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.commands.addons.AddonsCommandAddon" + - "com.dfsek.terra.addons.commands.addons.AddonsCommandAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/command-packs/src/main/resources/terra.addon.yml b/common/addons/command-packs/src/main/resources/terra.addon.yml index 007e28244..4efeb9c99 100644 --- a/common/addons/command-packs/src/main/resources/terra.addon.yml +++ b/common/addons/command-packs/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: command-packs version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.commands.packs.PacksCommandAddon" + - "com.dfsek.terra.addons.commands.packs.PacksCommandAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/command-profiler/src/main/resources/terra.addon.yml b/common/addons/command-profiler/src/main/resources/terra.addon.yml index 17f5f4b8a..3ce8d72ab 100644 --- a/common/addons/command-profiler/src/main/resources/terra.addon.yml +++ b/common/addons/command-profiler/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: command-profiler version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.commands.profiler.ProfilerCommandAddon" + - "com.dfsek.terra.addons.commands.profiler.ProfilerCommandAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/command-structures/src/main/resources/terra.addon.yml b/common/addons/command-structures/src/main/resources/terra.addon.yml index dc4804af9..c41fc088e 100644 --- a/common/addons/command-structures/src/main/resources/terra.addon.yml +++ b/common/addons/command-structures/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: command-structures version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.commands.structure.StructureCommandAddon" + - "com.dfsek.terra.addons.commands.structure.StructureCommandAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/config-biome/src/main/resources/terra.addon.yml b/common/addons/config-biome/src/main/resources/terra.addon.yml index dd6eb93bc..f669208b1 100644 --- a/common/addons/config-biome/src/main/resources/terra.addon.yml +++ b/common/addons/config-biome/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-biome version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.BiomeAddon" + - "com.dfsek.terra.addons.biome.BiomeAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/config-distributors/src/main/resources/terra.addon.yml b/common/addons/config-distributors/src/main/resources/terra.addon.yml index 4f35aa3ca..6e4c98a4a 100644 --- a/common/addons/config-distributors/src/main/resources/terra.addon.yml +++ b/common/addons/config-distributors/src/main/resources/terra.addon.yml @@ -1,15 +1,15 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-distributors version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.feature.distributor.DistributorAddon" + - "com.dfsek.terra.addons.feature.distributor.DistributorAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - config-feature: "1.+" - generation-stage-feature: "1.+" \ No newline at end of file + config-feature: "1.+" + generation-stage-feature: "1.+" \ No newline at end of file diff --git a/common/addons/config-feature/src/main/resources/terra.addon.yml b/common/addons/config-feature/src/main/resources/terra.addon.yml index 18656aa8c..cb17b4b76 100644 --- a/common/addons/config-feature/src/main/resources/terra.addon.yml +++ b/common/addons/config-feature/src/main/resources/terra.addon.yml @@ -1,14 +1,14 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-feature version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.feature.FeatureAddon" + - "com.dfsek.terra.addons.feature.FeatureAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - generation-stage-feature: "1.+" \ No newline at end of file + generation-stage-feature: "1.+" \ No newline at end of file diff --git a/common/addons/config-flora/src/main/resources/terra.addon.yml b/common/addons/config-flora/src/main/resources/terra.addon.yml index 0ec6e92f1..b464bed94 100644 --- a/common/addons/config-flora/src/main/resources/terra.addon.yml +++ b/common/addons/config-flora/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-flora version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.flora.FloraAddon" + - "com.dfsek.terra.addons.flora.FloraAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/config-locators/src/main/resources/terra.addon.yml b/common/addons/config-locators/src/main/resources/terra.addon.yml index 7e4482e55..e84bf800d 100644 --- a/common/addons/config-locators/src/main/resources/terra.addon.yml +++ b/common/addons/config-locators/src/main/resources/terra.addon.yml @@ -1,15 +1,15 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-locators version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.feature.locator.LocatorAddon" + - "com.dfsek.terra.addons.feature.locator.LocatorAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - config-feature: "1.+" - generation-stage-feature: "1.+" \ No newline at end of file + config-feature: "1.+" + generation-stage-feature: "1.+" \ No newline at end of file diff --git a/common/addons/config-noise-function/src/main/resources/terra.addon.yml b/common/addons/config-noise-function/src/main/resources/terra.addon.yml index c1320f289..b22b0f781 100644 --- a/common/addons/config-noise-function/src/main/resources/terra.addon.yml +++ b/common/addons/config-noise-function/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-noise-function version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.noise.NoiseAddon" + - "com.dfsek.terra.addons.noise.NoiseAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/config-number-predicate/src/main/resources/terra.addon.yml b/common/addons/config-number-predicate/src/main/resources/terra.addon.yml index 838742309..e4014b3a3 100644 --- a/common/addons/config-number-predicate/src/main/resources/terra.addon.yml +++ b/common/addons/config-number-predicate/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-number-predicate version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.numberpredicate.NumberPredicateAddon" + - "com.dfsek.terra.addons.numberpredicate.NumberPredicateAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/config-ore/src/main/resources/terra.addon.yml b/common/addons/config-ore/src/main/resources/terra.addon.yml index bab302e4f..60ea05e60 100644 --- a/common/addons/config-ore/src/main/resources/terra.addon.yml +++ b/common/addons/config-ore/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-ore version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.ore.OreAddon" + - "com.dfsek.terra.addons.ore.OreAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/config-palette/src/main/resources/terra.addon.yml b/common/addons/config-palette/src/main/resources/terra.addon.yml index 67db4259c..255a58048 100644 --- a/common/addons/config-palette/src/main/resources/terra.addon.yml +++ b/common/addons/config-palette/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-palette version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.palette.PaletteAddon" + - "com.dfsek.terra.addons.palette.PaletteAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/config-structure/src/main/resources/terra.addon.yml b/common/addons/config-structure/src/main/resources/terra.addon.yml index 3143b5830..ad31e3641 100644 --- a/common/addons/config-structure/src/main/resources/terra.addon.yml +++ b/common/addons/config-structure/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: config-structure version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.structure.StructureAddon" + - "com.dfsek.terra.addons.structure.StructureAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/generation-stage-feature/src/main/resources/terra.addon.yml b/common/addons/generation-stage-feature/src/main/resources/terra.addon.yml index 0f0447864..640aa8aa3 100644 --- a/common/addons/generation-stage-feature/src/main/resources/terra.addon.yml +++ b/common/addons/generation-stage-feature/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: generation-stage-feature version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.generation.feature.FeatureGenerationAddon" + - "com.dfsek.terra.addons.generation.feature.FeatureGenerationAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/generation-stage-structure/src/main/resources/terra.addon.yml b/common/addons/generation-stage-structure/src/main/resources/terra.addon.yml index 9aa1ac530..2d361cf3d 100644 --- a/common/addons/generation-stage-structure/src/main/resources/terra.addon.yml +++ b/common/addons/generation-stage-structure/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: generation-stage-structure version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.generation.structure.StructureGenerationAddon" + - "com.dfsek.terra.addons.generation.structure.StructureGenerationAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/language-yaml/src/main/resources/terra.addon.yml b/common/addons/language-yaml/src/main/resources/terra.addon.yml index 541c7f693..2b3d1d50b 100644 --- a/common/addons/language-yaml/src/main/resources/terra.addon.yml +++ b/common/addons/language-yaml/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: language-yaml version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.yaml.YamlAddon" + - "com.dfsek.terra.addons.yaml.YamlAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/library-image/src/main/resources/terra.addon.yml b/common/addons/library-image/src/main/resources/terra.addon.yml index 4e9cbb54c..c664c3df4 100644 --- a/common/addons/library-image/src/main/resources/terra.addon.yml +++ b/common/addons/library-image/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: library-image version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.image.ImageLibraryAddon" + - "com.dfsek.terra.addons.image.ImageLibraryAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License diff --git a/common/addons/locator-slant-noise-3d/src/main/resources/terra.addon.yml b/common/addons/locator-slant-noise-3d/src/main/resources/terra.addon.yml index 0189030b6..8a7ef4ad9 100644 --- a/common/addons/locator-slant-noise-3d/src/main/resources/terra.addon.yml +++ b/common/addons/locator-slant-noise-3d/src/main/resources/terra.addon.yml @@ -1,14 +1,14 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: locator-slant-noise-3d version: @VERSION@ entrypoints: - - "com.dfsek.terra.addon.feature.locator.slant.SlantLocatorAddon" + - "com.dfsek.terra.addon.feature.locator.slant.SlantLocatorAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - chunk-generator-noise-3d: "[1.2.0,2.0.0)" \ No newline at end of file + chunk-generator-noise-3d: "[1.2.0,2.0.0)" \ No newline at end of file diff --git a/common/addons/palette-block-shortcut/src/main/resources/terra.addon.yml b/common/addons/palette-block-shortcut/src/main/resources/terra.addon.yml index 263fefa83..6b643a053 100644 --- a/common/addons/palette-block-shortcut/src/main/resources/terra.addon.yml +++ b/common/addons/palette-block-shortcut/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: palette-block-shortcut version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.palette.shortcut.block.PaletteBlockShortcutAddon" + - "com.dfsek.terra.addons.palette.shortcut.block.PaletteBlockShortcutAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/pipeline-image/src/main/resources/terra.addon.yml b/common/addons/pipeline-image/src/main/resources/terra.addon.yml index 0da6c930c..2ae877a14 100644 --- a/common/addons/pipeline-image/src/main/resources/terra.addon.yml +++ b/common/addons/pipeline-image/src/main/resources/terra.addon.yml @@ -1,15 +1,15 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: pipeline-image version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.biome.pipeline.image.PipelineImageAddon" + - "com.dfsek.terra.addons.biome.pipeline.image.PipelineImageAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - library-image: "1.+" - biome-provider-pipeline-v2: "1.+" + library-image: "1.+" + biome-provider-pipeline-v2: "1.+" diff --git a/common/addons/structure-block-shortcut/src/main/resources/terra.addon.yml b/common/addons/structure-block-shortcut/src/main/resources/terra.addon.yml index 62a2e875d..d653e2d9c 100644 --- a/common/addons/structure-block-shortcut/src/main/resources/terra.addon.yml +++ b/common/addons/structure-block-shortcut/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: structure-block-shortcut version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.palette.shortcut.block.StructureBlockShortcutAddon" + - "com.dfsek.terra.addons.palette.shortcut.block.StructureBlockShortcutAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/structure-mutator/src/main/resources/terra.addon.yml b/common/addons/structure-mutator/src/main/resources/terra.addon.yml index 328b8d54d..29df5332d 100644 --- a/common/addons/structure-mutator/src/main/resources/terra.addon.yml +++ b/common/addons/structure-mutator/src/main/resources/terra.addon.yml @@ -1,11 +1,11 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: structure-mutator version: @VERSION@ entrypoints: [ ] website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/structure-sponge-loader/src/main/resources/terra.addon.yml b/common/addons/structure-sponge-loader/src/main/resources/terra.addon.yml index a3c6a8ecf..d5635f09b 100644 --- a/common/addons/structure-sponge-loader/src/main/resources/terra.addon.yml +++ b/common/addons/structure-sponge-loader/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: structure-sponge-loader version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.sponge.SpongeSchematicAddon" + - "com.dfsek.terra.addons.sponge.SpongeSchematicAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/structure-terrascript-loader/src/main/resources/terra.addon.yml b/common/addons/structure-terrascript-loader/src/main/resources/terra.addon.yml index 20352eb7e..0850687c9 100644 --- a/common/addons/structure-terrascript-loader/src/main/resources/terra.addon.yml +++ b/common/addons/structure-terrascript-loader/src/main/resources/terra.addon.yml @@ -1,12 +1,12 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: structure-terrascript-loader version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.terrascript.TerraScriptAddon" + - "com.dfsek.terra.addons.terrascript.TerraScriptAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License \ No newline at end of file diff --git a/common/addons/terrascript-function-check-noise-3d/src/main/resources/terra.addon.yml b/common/addons/terrascript-function-check-noise-3d/src/main/resources/terra.addon.yml index 1ab94f379..028db2274 100644 --- a/common/addons/terrascript-function-check-noise-3d/src/main/resources/terra.addon.yml +++ b/common/addons/terrascript-function-check-noise-3d/src/main/resources/terra.addon.yml @@ -1,15 +1,15 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: structure-function-check-noise-3d version: @VERSION@ entrypoints: - - "com.dfsek.terra.addon.terrascript.check.TerraScriptCheckFunctionAddon" + - "com.dfsek.terra.addon.terrascript.check.TerraScriptCheckFunctionAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - structure-terrascript-loader: "1.+" - chunk-generator-noise-3d: "1.+" \ No newline at end of file + structure-terrascript-loader: "1.+" + chunk-generator-noise-3d: "1.+" \ No newline at end of file diff --git a/common/addons/terrascript-function-sampler/src/main/resources/terra.addon.yml b/common/addons/terrascript-function-sampler/src/main/resources/terra.addon.yml index 31bb39127..635814c2c 100644 --- a/common/addons/terrascript-function-sampler/src/main/resources/terra.addon.yml +++ b/common/addons/terrascript-function-sampler/src/main/resources/terra.addon.yml @@ -1,15 +1,15 @@ schema-version: 1 contributors: - - Terra contributors + - Terra contributors id: terrascript-function-sampler version: @VERSION@ entrypoints: - - "com.dfsek.terra.addons.terrascript.sampler.TerraScriptSamplerFunctionAddon" + - "com.dfsek.terra.addons.terrascript.sampler.TerraScriptSamplerFunctionAddon" website: - issues: https://github.com/PolyhedralDev/Terra/issues - source: https://github.com/PolyhedralDev/Terra - docs: https://terra.polydev.org + issues: https://github.com/PolyhedralDev/Terra/issues + source: https://github.com/PolyhedralDev/Terra + docs: https://terra.polydev.org license: MIT License depends: - structure-terrascript-loader: "1.+" - config-noise-function: "1.+" \ No newline at end of file + structure-terrascript-loader: "1.+" + config-noise-function: "1.+" \ No newline at end of file diff --git a/common/implementation/base/src/main/resources/config.yml b/common/implementation/base/src/main/resources/config.yml index 6d120ef58..72dd67061 100644 --- a/common/implementation/base/src/main/resources/config.yml +++ b/common/implementation/base/src/main/resources/config.yml @@ -6,15 +6,15 @@ # wiki for information regarding config pack development. debug: - commands: false - log: false - profiler: false - script: false + commands: false + log: false + profiler: false + script: false dump-default: true biome-search-resolution: 4 cache: - structure: 32 - sampler: 128 - biome-provider: 32 + structure: 32 + sampler: 128 + biome-provider: 32 script: - max-recursion: 1000 \ No newline at end of file + max-recursion: 1000 \ No newline at end of file diff --git a/common/implementation/base/src/test/resources/config.yml b/common/implementation/base/src/test/resources/config.yml index 49f6def92..d2a7fb934 100644 --- a/common/implementation/base/src/test/resources/config.yml +++ b/common/implementation/base/src/test/resources/config.yml @@ -2,9 +2,9 @@ dimensions: 2 type: Cellular frequency: 0.01 cellular: - return: Distance3Div + return: Distance3Div normalize: - type: LINEAR - linear: - min: -1 - max: 0 \ No newline at end of file + type: LINEAR + linear: + min: -1 + max: 0 \ No newline at end of file diff --git a/common/implementation/base/src/test/resources/meta.yml b/common/implementation/base/src/test/resources/meta.yml index 5762716a6..116b32b89 100644 --- a/common/implementation/base/src/test/resources/meta.yml +++ b/common/implementation/base/src/test/resources/meta.yml @@ -1,18 +1,18 @@ list: - - ONE - - "<< metaTarget.yml:list" - - FOUR - - FIVE - - SIX - - "<< metaTarget.yml:list2" - - NINE - - TEN + - ONE + - "<< metaTarget.yml:list" + - FOUR + - FIVE + - SIX + - "<< metaTarget.yml:list2" + - NINE + - TEN map: - "<<": - - metaTarget.yml:map1 - - metaTarget.yml:map2 - one: ONE - two: TWO + "<<": + - metaTarget.yml:map1 + - metaTarget.yml:map2 + one: ONE + two: TWO string: "one-${metaTarget.yml:string.two}-${metaTarget.yml:string.three}-four-five-${metaTarget.yml:string.six}" int: 2 + 4 double: ${metaTarget.yml:double} + 5.6 \ No newline at end of file diff --git a/common/implementation/base/src/test/resources/metaTarget.yml b/common/implementation/base/src/test/resources/metaTarget.yml index 17e3c41d0..338930b52 100644 --- a/common/implementation/base/src/test/resources/metaTarget.yml +++ b/common/implementation/base/src/test/resources/metaTarget.yml @@ -1,17 +1,17 @@ list: - - TWO - - THREE + - TWO + - THREE list2: - - SEVEN - - EIGHT + - SEVEN + - EIGHT map1: - three: THREE - four: FOUR - five: FIVE + three: THREE + four: FOUR + five: FIVE map2: - six: SIX + six: SIX string: - two: two - three: three - six: six + two: two + three: three + six: six double: 1 \ No newline at end of file From b8586135b85f54cff7fc0919fb78c71f820b55c7 Mon Sep 17 00:00:00 2001 From: Astrash Date: Fri, 10 Nov 2023 13:33:34 +1100 Subject: [PATCH 78/83] Make RangeLoader inner class private Also removes redundant suppression --- .../main/java/com/dfsek/terra/config/loaders/RangeLoader.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java index 5093a0263..04876c0e3 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/RangeLoader.java @@ -34,7 +34,6 @@ import com.dfsek.terra.api.util.ConstantRange; import com.dfsek.terra.api.util.Range; -@SuppressWarnings("unchecked") public class RangeLoader implements TypeLoader { @Override public Range load(@NotNull AnnotatedType type, @NotNull Object o, @NotNull ConfigLoader configLoader, DepthTracker depthTracker) @@ -50,7 +49,7 @@ public class RangeLoader implements TypeLoader { /* * Template needed so keys can be meta annotated, otherwise the loader could just grab keys directly from the object */ - public static class RangeMapTemplate implements ObjectTemplate { + private static class RangeMapTemplate implements ObjectTemplate { @Value("min") private @Meta int min; From a73fda7d04a868792dfc6a51185378d858062b90 Mon Sep 17 00:00:00 2001 From: Astrash Date: Mon, 13 Nov 2023 11:48:06 +1100 Subject: [PATCH 79/83] Forgot @Meta --- .../addon/feature/locator/slant/SlantLocatorTemplate.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java index e79cef042..bcfb8e330 100644 --- a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java +++ b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java @@ -5,13 +5,14 @@ import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; import java.util.function.DoublePredicate; +import com.dfsek.terra.api.config.meta.Meta; import com.dfsek.terra.api.structure.feature.Locator; public class SlantLocatorTemplate implements ObjectTemplate { @Value("condition") - private DoublePredicate predicate; + private @Meta DoublePredicate predicate; @Override public Locator get() { From defd775f13f20064f818990837273adca4f9b391 Mon Sep 17 00:00:00 2001 From: Astrashh Date: Mon, 13 Nov 2023 11:57:01 +1100 Subject: [PATCH 80/83] Change Java whitespace handling in .editorconfig (#425) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Change whitespace handling in .editorconfig * Reformat code * fix format error * Reformat code --------- Co-authored-by: Zoë Gidiere --- .editorconfig | 10 +- .../dfsek/terra/addon/loader/ApiAddon.java | 6 +- .../addon/loader/ApiAddonClassLoader.java | 2 +- .../terra/addon/loader/ApiAddonLoader.java | 8 +- .../biome/extrusion/BaseBiomeColumn.java | 14 +- .../biome/extrusion/BiomeExtrusionAddon.java | 56 +-- .../extrusion/BiomeExtrusionProvider.java | 22 +- .../addons/biome/extrusion/api/Extrusion.java | 2 +- .../biome/extrusion/api/PresentBiome.java | 6 +- .../biome/extrusion/api/ReplaceableBiome.java | 8 +- .../addons/biome/extrusion/api/SelfBiome.java | 4 +- .../config/BiomeExtrusionTemplate.java | 6 +- .../config/ReplaceableBiomeLoader.java | 10 +- .../extrusions/ReplaceExtrusionTemplate.java | 4 +- .../extrusions/SamplerExtrusionTemplate.java | 2 +- .../extrusions/SetExtrusionTemplate.java | 2 +- .../extrusions/ReplaceExtrusion.java | 22 +- .../extrusion/extrusions/SetExtrusion.java | 20 +- .../biome/image/v2/ImageBiomeProvider.java | 14 +- .../image/v2/ImageBiomeProviderAddon.java | 60 +-- .../v2/config/ImageProviderTemplate.java | 8 +- .../ClosestBiomeColorConverterTemplate.java | 4 +- .../ExactBiomeColorConverterTemplate.java | 12 +- .../DefinedBiomeColorMappingTemplate.java | 4 +- .../biome/image/ImageBiomeProvider.java | 32 +- .../biome/image/ImageBiomeProviderAddon.java | 28 +- .../biome/image/ImageProviderTemplate.java | 4 +- .../biome/pipeline/v2/BiomePipelineAddon.java | 66 +-- .../pipeline/v2/BiomePipelineColumn.java | 20 +- .../pipeline/v2/PipelineBiomeProvider.java | 50 +-- .../biome/pipeline/v2/api/BiomeChunk.java | 2 +- .../biome/pipeline/v2/api/Expander.java | 6 +- .../biome/pipeline/v2/api/Pipeline.java | 6 +- .../biome/pipeline/v2/api/SeededVector.java | 4 +- .../addons/biome/pipeline/v2/api/Source.java | 2 +- .../addons/biome/pipeline/v2/api/Stage.java | 4 +- .../v2/api/biome/DelegatedPipelineBiome.java | 12 +- .../pipeline/v2/api/biome/PipelineBiome.java | 16 +- .../api/biome/PlaceholderPipelineBiome.java | 16 +- .../v2/api/biome/SelfPipelineBiome.java | 14 +- .../v2/config/BiomePipelineTemplate.java | 4 +- .../v2/config/PipelineBiomeLoader.java | 10 +- .../config/source/SamplerSourceTemplate.java | 4 +- .../mutator/BorderListStageTemplate.java | 10 +- .../stage/mutator/BorderStageTemplate.java | 6 +- .../mutator/ReplaceListStageTemplate.java | 6 +- .../stage/mutator/ReplaceStageTemplate.java | 4 +- .../pipeline/v2/pipeline/BiomeChunkImpl.java | 68 +-- .../pipeline/v2/pipeline/PipelineImpl.java | 28 +- .../pipeline/v2/source/SamplerSource.java | 6 +- .../pipeline/v2/source/SingleSource.java | 8 +- .../v2/stage/expander/FractalExpander.java | 16 +- .../v2/stage/mutators/BorderListStage.java | 18 +- .../v2/stage/mutators/BorderStage.java | 24 +- .../v2/stage/mutators/ReplaceListStage.java | 12 +- .../v2/stage/mutators/ReplaceStage.java | 8 +- .../v2/stage/mutators/SmoothStage.java | 14 +- .../biome/pipeline/BiomeHolderImpl.java | 24 +- .../addons/biome/pipeline/BiomePipeline.java | 20 +- .../biome/pipeline/BiomePipelineAddon.java | 70 +-- .../biome/pipeline/BiomePipelineColumn.java | 20 +- .../biome/pipeline/BiomePipelineProvider.java | 50 +-- .../biome/pipeline/api/BiomeHolder.java | 8 +- .../pipeline/api/delegate/BiomeDelegate.java | 16 +- .../pipeline/api/delegate/DelegatedBiome.java | 12 +- .../api/delegate/EphemeralBiomeDelegate.java | 20 +- .../pipeline/api/delegate/SelfDelegate.java | 14 +- .../biome/pipeline/api/stage/Stage.java | 4 +- .../pipeline/api/stage/type/BiomeMutator.java | 10 +- .../pipeline/config/BiomeDelegateLoader.java | 10 +- .../config/BiomePipelineTemplate.java | 6 +- .../config/SamplerSourceTemplate.java | 4 +- .../mutator/BorderListMutatorTemplate.java | 10 +- .../stage/mutator/BorderMutatorTemplate.java | 6 +- .../mutator/ReplaceListMutatorTemplate.java | 6 +- .../stage/mutator/ReplaceMutatorTemplate.java | 4 +- .../pipeline/expand/FractalExpander.java | 4 +- .../pipeline/mutator/BorderListMutator.java | 6 +- .../biome/pipeline/mutator/BorderMutator.java | 22 +- .../pipeline/mutator/ReplaceListMutator.java | 10 +- .../pipeline/mutator/ReplaceMutator.java | 6 +- .../biome/pipeline/mutator/SmoothMutator.java | 16 +- .../biome/pipeline/source/BiomeSource.java | 2 +- .../biome/pipeline/source/SamplerSource.java | 6 +- .../biome/pipeline/stages/ExpanderStage.java | 8 +- .../biome/pipeline/stages/MutatorStage.java | 10 +- .../biome/single/SingleBiomeProvider.java | 8 +- .../single/SingleBiomeProviderAddon.java | 22 +- .../single/SingleBiomeProviderTemplate.java | 2 +- .../biome/query/BiomeQueryAPIAddon.java | 36 +- .../addons/biome/query/api/BiomeQueries.java | 4 +- .../biome/query/impl/BiomeTagFlattener.java | 6 +- .../biome/query/impl/BiomeTagHolder.java | 6 +- .../biome/query/impl/SingleTagQuery.java | 18 +- .../NoiseChunkGenerator3DAddon.java | 82 ++-- ...NoiseChunkGeneratorPackConfigTemplate.java | 14 +- .../noise/BiomeNoiseConfigTemplate.java | 16 +- .../config/noise/ThreadLocalNoiseHolder.java | 8 +- .../config/palette/BiomePaletteTemplate.java | 14 +- .../palette/slant/SlantLayerTemplate.java | 6 +- .../generation/NoiseChunkGenerator3D.java | 82 ++-- .../generation/math/PaletteUtil.java | 4 +- .../math/interpolation/ChunkInterpolator.java | 88 ++-- .../interpolation/ElevationInterpolator.java | 26 +- .../math/interpolation/Interpolator.java | 4 +- .../math/interpolation/Interpolator3.java | 4 +- .../LazilyEvaluatedInterpolator.java | 61 +-- .../generation/math/samplers/Sampler3D.java | 8 +- .../math/samplers/SamplerProvider.java | 16 +- .../chunkgenerator/palette/PaletteHolder.java | 18 +- .../palette/slant/MultipleSlantHolder.java | 8 +- .../palette/slant/SingleSlantHolder.java | 8 +- .../palette/slant/SlantHolder.java | 60 +-- .../palette/slant/SlantHolderImpl.java | 10 +- .../commands/addons/AddonsCommandAddon.java | 88 ++-- .../commands/packs/PacksCommandAddon.java | 118 ++--- .../profiler/ProfilerCommandAddon.java | 94 ++-- .../structure/StructureCommandAddon.java | 58 +-- .../dfsek/terra/addons/biome/BiomeAddon.java | 18 +- .../terra/addons/biome/BiomeConfigType.java | 8 +- .../terra/addons/biome/BiomeFactory.java | 4 +- .../terra/addons/biome/BiomeTemplate.java | 24 +- .../addons/biome/PaletteSettingsImpl.java | 4 +- .../terra/addons/biome/UserDefinedBiome.java | 18 +- .../addons/biome/holder/PaletteHolder.java | 4 +- .../biome/holder/PaletteHolderBuilder.java | 8 +- .../feature/distributor/DistributorAddon.java | 44 +- .../config/AndDistributorTemplate.java | 6 +- .../config/OrDistributorTemplate.java | 6 +- .../config/PaddedGridDistributorTemplate.java | 6 +- .../config/PointSetDistributorTemplate.java | 2 +- .../config/SamplerDistributorTemplate.java | 2 +- .../config/XorDistributorTemplate.java | 6 +- .../distributors/PaddedGridDistributor.java | 14 +- .../distributors/PointSetDistributor.java | 4 +- .../distributors/SamplerDistributor.java | 6 +- .../feature/distributor/util/Point.java | 12 +- .../distributor/util/PointTemplate.java | 4 +- .../addons/feature/ConfiguredFeature.java | 14 +- .../terra/addons/feature/FeatureAddon.java | 12 +- .../addons/feature/FeatureConfigType.java | 8 +- .../terra/addons/feature/FeatureFactory.java | 2 +- .../terra/addons/feature/FeatureTemplate.java | 18 +- .../dfsek/terra/addons/flora/FloraAddon.java | 18 +- .../terra/addons/flora/FloraConfigType.java | 6 +- .../terra/addons/flora/FloraFactory.java | 4 +- .../terra/addons/flora/FloraTemplate.java | 20 +- .../flora/config/BlockLayerTemplate.java | 4 +- .../addons/flora/flora/gen/BlockLayer.java | 6 +- .../addons/flora/flora/gen/TerraFlora.java | 30 +- .../addons/feature/locator/LocatorAddon.java | 72 +-- .../AdjacentPatternLocatorTemplate.java | 6 +- .../locator/config/AndLocatorTemplate.java | 4 +- .../config/GaussianRandomLocatorTemplate.java | 8 +- .../locator/config/OrLocatorTemplate.java | 4 +- .../config/PatternLocatorTemplate.java | 4 +- .../locator/config/RandomLocatorTemplate.java | 6 +- .../config/Sampler3DLocatorTemplate.java | 2 +- .../config/SamplerLocatorTemplate.java | 2 +- .../config/SurfaceLocatorTemplate.java | 2 +- .../locator/config/TopLocatorTemplate.java | 4 +- .../locator/config/XorLocatorTemplate.java | 4 +- .../pattern/AirMatchPatternTemplate.java | 4 +- .../config/pattern/AndPatternTemplate.java | 4 +- .../pattern/BlockSetMatchPatternTemplate.java | 4 +- .../config/pattern/NotPatternTemplate.java | 2 +- .../config/pattern/OrPatternTemplate.java | 4 +- .../SingleBlockMatchPatternTemplate.java | 6 +- .../pattern/SolidMatchPatternTemplate.java | 2 +- .../config/pattern/XorPatternTemplate.java | 4 +- .../locators/AdjacentPatternLocator.java | 6 +- .../locators/GaussianRandomLocator.java | 22 +- .../locator/locators/PatternLocator.java | 4 +- .../locator/locators/RandomLocator.java | 16 +- .../locator/locators/Sampler3DLocator.java | 4 +- .../locator/locators/SamplerLocator.java | 10 +- .../locator/locators/SurfaceLocator.java | 4 +- .../feature/locator/locators/TopLocator.java | 4 +- .../locator/patterns/MatchPattern.java | 6 +- .../feature/locator/patterns/Pattern.java | 12 +- .../dfsek/terra/addons/noise/NoiseAddon.java | 160 +++---- .../addons/noise/NoiseConfigPackTemplate.java | 6 +- .../config/CubicSplinePointTemplate.java | 8 +- .../DimensionApplicableNoiseSampler.java | 8 +- .../templates/BinaryArithmeticTemplate.java | 4 +- .../config/templates/DomainWarpTemplate.java | 6 +- .../config/templates/FunctionTemplate.java | 16 +- .../templates/ImageSamplerTemplate.java | 12 +- .../config/templates/KernelTemplate.java | 26 +- .../LinearHeightmapSamplerTemplate.java | 6 +- .../config/templates/SamplerTemplate.java | 4 +- .../templates/TranslateSamplerTemplate.java | 10 +- .../noise/CellularNoiseTemplate.java | 10 +- .../noise/ConstantNoiseTemplate.java | 2 +- .../noise/DistanceSamplerTemplate.java | 14 +- .../noise/ExpressionFunctionTemplate.java | 4 +- .../templates/noise/GaborNoiseTemplate.java | 10 +- .../config/templates/noise/NoiseTemplate.java | 2 +- .../templates/noise/SimpleNoiseTemplate.java | 4 +- .../noise/fractal/FractalTemplate.java | 8 +- .../noise/fractal/PingPongTemplate.java | 2 +- .../normalizer/ClampNormalizerTemplate.java | 4 +- .../CubicSplineNormalizerTemplate.java | 4 +- .../ExpressionNormalizerTemplate.java | 14 +- .../normalizer/LinearNormalizerTemplate.java | 4 +- .../normalizer/NormalNormalizerTemplate.java | 6 +- .../PosterizationNormalizerTemplate.java | 2 +- .../normalizer/ScaleNormalizerTemplate.java | 2 +- .../terra/addons/noise/math/CubicSpline.java | 36 +- .../noise/normalizer/ClampNormalizer.java | 4 +- .../normalizer/CubicSplineNoiseSampler.java | 6 +- .../normalizer/ExpressionNormalizer.java | 6 +- .../noise/normalizer/LinearNormalizer.java | 4 +- .../noise/normalizer/NormalNormalizer.java | 12 +- .../addons/noise/normalizer/Normalizer.java | 8 +- .../normalizer/PosterizationNormalizer.java | 4 +- .../normalizer/ProbabilityNormalizer.java | 2 +- .../noise/normalizer/ScaleNormalizer.java | 4 +- .../addons/noise/paralithic/FunctionUtil.java | 8 +- .../defined/UserDefinedFunction.java | 20 +- .../paralithic/noise/NoiseFunction2.java | 10 +- .../paralithic/noise/NoiseFunction3.java | 10 +- .../noise/paralithic/noise/SeedContext.java | 4 +- .../noise/samplers/DomainWarpedSampler.java | 20 +- .../addons/noise/samplers/ImageSampler.java | 14 +- .../addons/noise/samplers/KernelSampler.java | 16 +- .../samplers/LinearHeightmapSampler.java | 8 +- .../noise/samplers/TranslateSampler.java | 8 +- .../samplers/arithmetic/AdditionSampler.java | 2 +- .../arithmetic/BinaryArithmeticSampler.java | 8 +- .../samplers/arithmetic/DivisionSampler.java | 2 +- .../noise/samplers/arithmetic/MaxSampler.java | 2 +- .../noise/samplers/arithmetic/MinSampler.java | 2 +- .../arithmetic/MultiplicationSampler.java | 2 +- .../arithmetic/SubtractionSampler.java | 2 +- .../noise/samplers/noise/CellularSampler.java | 418 +++++++++--------- .../noise/samplers/noise/ConstantSampler.java | 6 +- .../noise/samplers/noise/DistanceSampler.java | 16 +- .../samplers/noise/ExpressionFunction.java | 18 +- .../samplers/noise/GaborNoiseSampler.java | 36 +- .../noise/samplers/noise/NoiseFunction.java | 26 +- .../noise/fractal/BrownianMotionSampler.java | 16 +- .../noise/fractal/FractalNoiseFunction.java | 12 +- .../noise/fractal/PingPongSampler.java | 24 +- .../noise/fractal/RidgedFractalSampler.java | 18 +- .../noise/random/GaussianNoiseSampler.java | 6 +- .../random/PositiveWhiteNoiseSampler.java | 6 +- .../noise/random/WhiteNoiseSampler.java | 16 +- .../noise/simplex/OpenSimplex2SSampler.java | 96 ++-- .../noise/simplex/OpenSimplex2Sampler.java | 56 +-- .../samplers/noise/simplex/PerlinSampler.java | 24 +- .../noise/simplex/SimplexSampler.java | 90 ++-- .../noise/simplex/SimplexStyleSampler.java | 134 +++--- .../noise/value/ValueCubicSampler.java | 116 ++--- .../samplers/noise/value/ValueSampler.java | 20 +- .../samplers/noise/value/ValueStyleNoise.java | 8 +- .../numberpredicate/NumberPredicateAddon.java | 16 +- .../com/dfsek/terra/addons/ore/OreAddon.java | 14 +- .../dfsek/terra/addons/ore/OreConfigType.java | 6 +- .../dfsek/terra/addons/ore/OreFactory.java | 2 +- .../dfsek/terra/addons/ore/OreTemplate.java | 26 +- .../addons/ore/ScatteredOreConfigType.java | 6 +- .../terra/addons/ore/ScatteredOreFactory.java | 2 +- .../addons/ore/ScatteredOreTemplate.java | 4 +- .../terra/addons/ore/ores/VanillaOre.java | 50 +-- .../addons/ore/ores/VanillaScatteredOre.java | 14 +- .../addons/ore/utils/VanillaOreUtils.java | 4 +- .../terra/addons/palette/PaletteAddon.java | 18 +- .../addons/palette/PaletteConfigType.java | 8 +- .../terra/addons/palette/PaletteTemplate.java | 10 +- .../addons/palette/palette/PaletteImpl.java | 22 +- .../palette/palette/PaletteLayerHolder.java | 8 +- .../palette/palette/PaletteLayerLoader.java | 6 +- .../addons/structure/BiomeStructures.java | 4 +- .../structure/BiomeStructuresTemplate.java | 2 +- .../addons/structure/StructureAddon.java | 12 +- .../addons/structure/StructureConfigType.java | 6 +- .../addons/structure/StructureTemplate.java | 14 +- .../addons/structure/TerraStructure.java | 12 +- .../structure/structures/loot/Entry.java | 12 +- .../structures/loot/LootTableImpl.java | 6 +- .../structure/structures/loot/Pool.java | 8 +- .../loot/functions/AmountFunction.java | 4 +- .../loot/functions/DamageFunction.java | 4 +- .../loot/functions/EnchantFunction.java | 14 +- .../feature/FeatureGenerationAddon.java | 80 ++-- .../feature/FeatureGenerationStage.java | 70 +-- .../feature/config/BiomeFeatures.java | 4 +- .../feature/config/FeatureStageTemplate.java | 12 +- .../structure/StructureGenerationAddon.java | 36 +- .../structure/StructureGenerationStage.java | 6 +- .../structure/config/BiomeStructures.java | 4 +- .../config/BiomeStructuresTemplate.java | 2 +- .../dfsek/terra/addons/yaml/YamlAddon.java | 20 +- .../terra/addons/image/ImageLibraryAddon.java | 80 ++-- .../image/colorsampler/ColorSampler.java | 2 +- .../image/SingleImageColorSampler.java | 10 +- .../image/TileImageColorSampler.java | 8 +- .../image/transform/Alignment.java | 6 +- .../image/transform/ImageTransformation.java | 4 +- .../mutate/RotateColorSampler.java | 18 +- .../mutate/TranslateColorSampler.java | 6 +- .../addons/image/config/ColorLoader.java | 32 +- .../ImageLibraryPackConfigTemplate.java | 10 +- .../ConstantColorSamplerTemplate.java | 4 +- .../image/ImageColorSamplerTemplate.java | 6 +- .../SingleImageColorSamplerTemplate.java | 2 +- .../image/TileImageColorSamplerTemplate.java | 2 +- .../mutate/MutateColorSamplerTemplate.java | 2 +- .../mutate/RotateColorSamplerTemplate.java | 4 +- .../mutate/TranslateColorSamplerTemplate.java | 6 +- .../ClosestColorConverterTemplate.java | 4 +- .../ExactColorConverterTemplate.java | 8 +- .../addons/image/config/image/ImageCache.java | 6 +- .../image/config/image/ImageTemplate.java | 6 +- .../config/image/StitchedImageTemplate.java | 10 +- .../ChannelNoiseSamplerTemplate.java | 10 +- ...DistanceTransformNoiseSamplerTemplate.java | 18 +- .../converter/ClosestMatchColorConverter.java | 10 +- .../image/converter/ColorConverter.java | 4 +- .../image/converter/ExactColorConverter.java | 10 +- .../mapping/BiomeDefinedColorMapping.java | 10 +- .../image/image/BufferedImageWrapper.java | 10 +- .../dfsek/terra/addons/image/image/Image.java | 4 +- .../addons/image/image/StitchedImage.java | 20 +- .../addons/image/image/SuppliedImage.java | 10 +- .../noisesampler/ChannelNoiseSampler.java | 14 +- .../image/operator/DistanceTransform.java | 54 +-- .../terra/addons/image/util/ColorUtil.java | 72 +-- .../terra/addons/image/util/MapUtil.java | 16 +- .../terra/addons/image/util/MathUtil.java | 2 +- .../feature/locator/slant/SlantLocator.java | 6 +- .../locator/slant/SlantLocatorAddon.java | 18 +- .../locator/slant/SlantLocatorTemplate.java | 4 +- .../addons/manifest/impl/ManifestAddon.java | 20 +- .../impl/ManifestAddonClassLoader.java | 2 +- .../manifest/impl/ManifestAddonLoader.java | 56 +-- .../manifest/impl/config/AddonManifest.java | 30 +- .../manifest/impl/config/WebsiteConfig.java | 12 +- .../impl/exception/AddonException.java | 4 +- .../impl/exception/ManifestException.java | 4 +- .../ManifestNotPresentException.java | 4 +- .../block/PaletteBlockShortcutAddon.java | 16 +- .../shortcut/block/SingletonPalette.java | 4 +- .../biome/pipeline/image/ImageSource.java | 10 +- .../pipeline/image/PipelineImageAddon.java | 70 +-- .../image/config/ImageSourceTemplate.java | 6 +- ...stPipelineBiomeColorConverterTemplate.java | 4 +- ...ctPipelineBiomeColorConverterTemplate.java | 12 +- ...inedPipelineBiomeColorMappingTemplate.java | 4 +- .../shortcut/block/SingletonStructure.java | 4 +- .../block/StructureBlockShortcutAddon.java | 18 +- .../structure/mutator/MutatedStructure.java | 18 +- .../mutator/MutatedStructureConfigType.java | 8 +- .../mutator/MutatedStructureFactory.java | 10 +- .../mutator/StructureMutatorAddon.java | 18 +- .../config/MutatedStructureTemplate.java | 14 +- .../addons/sponge/SpongeSchematicAddon.java | 50 +-- .../terra/addons/sponge/SpongeStructure.java | 12 +- .../addons/terrascript/TerraScriptAddon.java | 60 +-- .../addons/terrascript/parser/Parser.java | 160 +++---- .../addons/terrascript/parser/ParserUtil.java | 54 +-- .../parser/exceptions/ParseException.java | 8 +- .../addons/terrascript/parser/lang/Block.java | 24 +- .../terrascript/parser/lang/Executable.java | 4 +- .../addons/terrascript/parser/lang/Item.java | 6 +- .../terrascript/parser/lang/Returnable.java | 8 +- .../addons/terrascript/parser/lang/Scope.java | 46 +- .../lang/constants/BooleanConstant.java | 6 +- .../lang/constants/ConstantExpression.java | 8 +- .../lang/constants/NumericConstant.java | 6 +- .../parser/lang/constants/StringConstant.java | 2 +- .../parser/lang/functions/Function.java | 8 +- .../lang/functions/FunctionBuilder.java | 4 +- .../lang/keywords/flow/BreakKeyword.java | 8 +- .../lang/keywords/flow/ContinueKeyword.java | 8 +- .../lang/keywords/flow/FailKeyword.java | 8 +- .../lang/keywords/flow/ReturnKeyword.java | 8 +- .../lang/keywords/looplike/ForKeyword.java | 8 +- .../lang/keywords/looplike/IfKeyword.java | 8 +- .../lang/keywords/looplike/WhileKeyword.java | 8 +- .../lang/operations/BinaryOperation.java | 4 +- .../lang/operations/BooleanAndOperation.java | 6 +- .../lang/operations/BooleanNotOperation.java | 6 +- .../lang/operations/BooleanOrOperation.java | 6 +- .../operations/ConcatenationOperation.java | 6 +- .../lang/operations/DivisionOperation.java | 6 +- .../lang/operations/ModuloOperation.java | 6 +- .../operations/MultiplicationOperation.java | 6 +- .../lang/operations/NegationOperation.java | 6 +- .../operations/NumberAdditionOperation.java | 6 +- .../lang/operations/SubtractionOperation.java | 6 +- .../lang/operations/UnaryOperation.java | 4 +- .../statements/EqualsStatement.java | 12 +- .../GreaterOrEqualsThanStatement.java | 6 +- .../statements/GreaterThanStatement.java | 8 +- .../statements/LessThanOrEqualsStatement.java | 8 +- .../statements/LessThanStatement.java | 8 +- .../statements/NotEqualsStatement.java | 8 +- .../lang/variables/BooleanVariable.java | 10 +- .../parser/lang/variables/NumberVariable.java | 10 +- .../parser/lang/variables/StringVariable.java | 10 +- .../parser/lang/variables/Variable.java | 6 +- .../variables/assign/BoolAssignmentNode.java | 4 +- .../variables/assign/NumAssignmentNode.java | 4 +- .../variables/assign/StrAssignmentNode.java | 4 +- .../assign/VariableAssignmentNode.java | 6 +- .../reference/BoolVariableReferenceNode.java | 4 +- .../reference/NumVariableReferenceNode.java | 4 +- .../reference/StrVariableReferenceNode.java | 2 +- .../reference/VariableReferenceNode.java | 6 +- .../terrascript/script/StructureScript.java | 112 ++--- .../script/TerraImplementationArguments.java | 20 +- .../builders/BinaryNumberFunctionBuilder.java | 16 +- .../script/builders/BiomeFunctionBuilder.java | 10 +- .../script/builders/BlockFunctionBuilder.java | 16 +- .../builders/CheckBlockFunctionBuilder.java | 6 +- .../builders/EntityFunctionBuilder.java | 10 +- .../builders/GetMarkFunctionBuilder.java | 10 +- .../script/builders/LootFunctionBuilder.java | 12 +- .../script/builders/PullFunctionBuilder.java | 10 +- .../builders/RandomFunctionBuilder.java | 4 +- .../builders/RecursionsFunctionBuilder.java | 4 +- .../builders/SetMarkFunctionBuilder.java | 10 +- .../script/builders/StateFunctionBuilder.java | 10 +- .../builders/StructureFunctionBuilder.java | 16 +- .../builders/UnaryBooleanFunctionBuilder.java | 16 +- .../builders/UnaryNumberFunctionBuilder.java | 14 +- .../builders/UnaryStringFunctionBuilder.java | 14 +- .../builders/ZeroArgFunctionBuilder.java | 12 +- .../script/functions/BiomeFunction.java | 34 +- .../script/functions/BlockFunction.java | 33 +- .../script/functions/CheckBlockFunction.java | 34 +- .../script/functions/EntityFunction.java | 24 +- .../script/functions/GetMarkFunction.java | 22 +- .../script/functions/LootFunction.java | 76 ++-- .../script/functions/PullFunction.java | 16 +- .../script/functions/RandomFunction.java | 12 +- .../script/functions/RecursionsFunction.java | 8 +- .../script/functions/SetMarkFunction.java | 22 +- .../script/functions/StateFunction.java | 16 +- .../script/functions/StructureFunction.java | 44 +- .../addons/terrascript/tokenizer/Char.java | 22 +- .../terrascript/tokenizer/Lookahead.java | 28 +- .../terrascript/tokenizer/Position.java | 4 +- .../addons/terrascript/tokenizer/Token.java | 28 +- .../terrascript/tokenizer/Tokenizer.java | 68 +-- .../tokenizer/exceptions/EOFException.java | 6 +- .../tokenizer/exceptions/FormatException.java | 6 +- .../exceptions/TokenizerException.java | 6 +- .../test/java/structure/LookaheadTest.java | 2 +- .../src/test/java/structure/ParserTest.java | 26 +- .../terrascript/check/CheckFunction.java | 40 +- .../check/CheckFunctionBuilder.java | 10 +- .../check/TerraScriptCheckFunctionAddon.java | 20 +- .../sampler/ConstantSamplerFunction.java | 16 +- .../terrascript/sampler/SamplerFunction.java | 16 +- .../sampler/SamplerFunctionBuilder.java | 70 +-- .../TerraScriptSamplerFunctionAddon.java | 24 +- .../java/com/dfsek/terra/api/Platform.java | 22 +- .../com/dfsek/terra/api/addon/BaseAddon.java | 6 +- .../bootstrap/BootstrapAddonClassLoader.java | 10 +- .../com/dfsek/terra/api/block/BlockType.java | 4 +- .../terra/api/block/entity/BlockEntity.java | 12 +- .../terra/api/block/entity/MobSpawner.java | 30 +- .../terra/api/block/entity/SerialState.java | 32 +- .../dfsek/terra/api/block/entity/Sign.java | 4 +- .../terra/api/block/state/BlockState.java | 20 +- .../api/block/state/properties/Property.java | 2 +- .../properties/base/BooleanProperty.java | 6 +- .../state/properties/base/EnumProperty.java | 6 +- .../state/properties/base/IntProperty.java | 6 +- .../state/properties/enums/Direction.java | 18 +- .../block/state/properties/enums/Half.java | 2 +- .../terra/api/command/CommandSender.java | 4 +- .../command/arguments/RegistryArgument.java | 86 ++-- .../dfsek/terra/api/config/ConfigPack.java | 20 +- .../dfsek/terra/api/config/ConfigType.java | 4 +- .../com/dfsek/terra/api/config/Loader.java | 10 +- .../dfsek/terra/api/config/PluginConfig.java | 20 +- .../com/dfsek/terra/api/entity/Entity.java | 6 +- .../dfsek/terra/api/event/EventManager.java | 4 +- .../api/event/events/AbstractCancellable.java | 4 +- .../terra/api/event/events/Cancellable.java | 2 +- .../config/ConfigurationDiscoveryEvent.java | 10 +- .../events/config/ConfigurationLoadEvent.java | 22 +- .../config/pack/ConfigPackLoadEvent.java | 8 +- .../config/type/ConfigTypeLoadEvent.java | 14 +- .../platform/CommandRegistrationEvent.java | 4 +- .../world/generation/EntitySpawnEvent.java | 6 +- .../world/generation/LootPopulateEvent.java | 14 +- .../api/event/functional/EventContext.java | 6 +- .../functional/FunctionalEventHandler.java | 2 +- .../dfsek/terra/api/handle/ItemHandle.java | 6 +- .../dfsek/terra/api/handle/WorldHandle.java | 4 +- .../com/dfsek/terra/api/inject/Injector.java | 4 +- .../inject/exception/InjectionException.java | 4 +- .../terra/api/inject/impl/InjectorImpl.java | 10 +- .../dfsek/terra/api/inventory/Inventory.java | 4 +- .../com/dfsek/terra/api/inventory/Item.java | 2 +- .../dfsek/terra/api/inventory/ItemStack.java | 10 +- .../terra/api/inventory/item/Damageable.java | 4 +- .../terra/api/inventory/item/Enchantment.java | 6 +- .../terra/api/inventory/item/ItemMeta.java | 2 +- .../dfsek/terra/api/noise/NoiseSampler.java | 20 +- .../dfsek/terra/api/profiler/Profiler.java | 10 +- .../com/dfsek/terra/api/profiler/Timings.java | 30 +- .../dfsek/terra/api/properties/Context.java | 14 +- .../terra/api/properties/PropertyKey.java | 4 +- .../terra/api/registry/CheckedRegistry.java | 2 +- .../terra/api/registry/OpenRegistry.java | 8 +- .../dfsek/terra/api/registry/Registry.java | 30 +- .../exception/DuplicateEntryException.java | 4 +- .../exception/NoSuchEntryException.java | 2 +- .../dfsek/terra/api/registry/key/Keyed.java | 4 +- .../terra/api/registry/key/Namespaced.java | 2 +- .../terra/api/registry/key/RegistryKey.java | 30 +- .../registry/meta/CheckedRegistryHolder.java | 4 +- .../api/registry/meta/RegistryHolder.java | 4 +- .../api/registry/meta/RegistryProvider.java | 2 +- .../dfsek/terra/api/structure/LootTable.java | 2 +- .../configured/ConfiguredStructure.java | 4 +- .../api/structure/feature/BinaryColumn.java | 32 +- .../api/structure/feature/Distributor.java | 10 +- .../terra/api/structure/feature/Feature.java | 4 +- .../terra/api/structure/feature/Locator.java | 6 +- .../api/tectonic/ConfigLoadingDelegate.java | 6 +- .../dfsek/terra/api/transform/Validator.java | 2 +- .../exception/AttemptsFailedException.java | 4 +- .../exception/TransformException.java | 8 +- .../java/com/dfsek/terra/api/util/Column.java | 28 +- .../dfsek/terra/api/util/ConstantRange.java | 44 +- .../dfsek/terra/api/util/GeometryUtil.java | 4 +- .../com/dfsek/terra/api/util/MathUtil.java | 84 ++-- .../dfsek/terra/api/util/PopulationUtil.java | 8 +- .../java/com/dfsek/terra/api/util/Range.java | 32 +- .../com/dfsek/terra/api/util/Rotation.java | 14 +- .../dfsek/terra/api/util/RotationUtil.java | 4 +- .../api/util/collection/MaterialSet.java | 48 +- .../collection/ProbabilityCollection.java | 78 ++-- .../dfsek/terra/api/util/generic/Lazy.java | 6 +- .../terra/api/util/generic/either/Either.java | 24 +- .../terra/api/util/generic/pair/Pair.java | 62 +-- .../api/util/mutable/MutableBoolean.java | 12 +- .../terra/api/util/mutable/MutableDouble.java | 16 +- .../api/util/mutable/MutableInteger.java | 18 +- .../terra/api/util/mutable/MutableNumber.java | 28 +- .../api/util/mutable/MutablePrimitive.java | 2 +- .../api/util/reflection/ReflectionUtil.java | 16 +- .../terra/api/util/reflection/TypeKey.java | 24 +- .../dfsek/terra/api/util/vector/Vector2.java | 72 +-- .../terra/api/util/vector/Vector2Int.java | 38 +- .../dfsek/terra/api/util/vector/Vector3.java | 128 +++--- .../terra/api/util/vector/Vector3Int.java | 42 +- .../dfsek/terra/api/world/BufferedWorld.java | 64 +-- .../dfsek/terra/api/world/ReadableWorld.java | 10 +- .../dfsek/terra/api/world/ServerWorld.java | 2 +- .../java/com/dfsek/terra/api/world/World.java | 4 +- .../dfsek/terra/api/world/WritableWorld.java | 40 +- .../dfsek/terra/api/world/biome/Biome.java | 10 +- .../world/biome/generation/BiomeColumn.java | 14 +- .../world/biome/generation/BiomeProvider.java | 22 +- .../generation/CachingBiomeProvider.java | 42 +- .../dfsek/terra/api/world/chunk/Chunk.java | 10 +- .../terra/api/world/chunk/ChunkAccess.java | 2 +- .../chunk/generation/ChunkGenerator.java | 8 +- .../world/chunk/generation/ProtoWorld.java | 4 +- .../world/chunk/generation/util/Column.java | 38 +- .../terra/api/world/info/WorldProperties.java | 4 +- .../terra/api/world/util/Interceptors.java | 10 +- .../api/world/util/WriteInterceptor.java | 2 +- common/api/src/test/java/util/ColumnTest.java | 48 +- .../com/dfsek/terra/AbstractPlatform.java | 222 +++++----- .../dfsek/terra/addon/DependencySorter.java | 38 +- .../com/dfsek/terra/addon/EphemeralAddon.java | 6 +- .../com/dfsek/terra/addon/InternalAddon.java | 6 +- .../CircularDependencyException.java | 4 +- .../addon/dependency/DependencyException.java | 4 +- .../DependencyVersionException.java | 4 +- .../dfsek/terra/config/GenericLoaders.java | 24 +- .../dfsek/terra/config/PluginConfigImpl.java | 44 +- .../config/fileloaders/FolderLoader.java | 8 +- .../terra/config/fileloaders/LoaderImpl.java | 12 +- .../terra/config/fileloaders/ZIPLoader.java | 8 +- .../GenericTemplateSupplierLoader.java | 12 +- .../config/loaders/LinkedHashMapLoader.java | 4 +- .../config/loaders/MaterialSetLoader.java | 8 +- .../loaders/ProbabilityCollectionLoader.java | 14 +- .../terra/config/loaders/RangeLoader.java | 6 +- .../loaders/config/BufferedImageLoader.java | 8 +- .../config/pack/ConfigPackAddonsTemplate.java | 4 +- .../terra/config/pack/ConfigPackImpl.java | 184 ++++---- .../config/pack/ConfigPackPostTemplate.java | 2 +- .../terra/config/pack/ConfigPackTemplate.java | 78 ++-- .../MetaListLikePreprocessor.java | 30 +- .../preprocessor/MetaMapPreprocessor.java | 29 +- .../preprocessor/MetaNumberPreprocessor.java | 6 +- .../config/preprocessor/MetaPreprocessor.java | 12 +- .../preprocessor/MetaStringPreprocessor.java | 6 +- .../preprocessor/MetaValuePreprocessor.java | 8 +- .../terra/config/prototype/ProtoConfig.java | 8 +- .../dfsek/terra/event/EventContextImpl.java | 24 +- .../dfsek/terra/event/EventManagerImpl.java | 8 +- .../event/FunctionalEventHandlerImpl.java | 12 +- .../java/com/dfsek/terra/profiler/Frame.java | 8 +- .../dfsek/terra/profiler/ProfilerImpl.java | 26 +- .../exception/MalformedStackException.java | 6 +- .../profiler/exception/ProfilerException.java | 6 +- .../terra/registry/CheckedRegistryImpl.java | 24 +- .../terra/registry/LockedRegistryImpl.java | 20 +- .../terra/registry/OpenRegistryImpl.java | 62 +-- .../dfsek/terra/registry/ShortcutHolder.java | 21 +- .../terra/registry/master/ConfigRegistry.java | 10 +- .../dfsek/terra/transform/MapTransform.java | 10 +- .../terra/transform/TransformerImpl.java | 10 +- .../base/src/test/java/MetaTest.java | 66 +-- .../src/test/java/profiler/ProfilerTest.java | 16 +- .../src/test/java/registry/RegistryTest.java | 36 +- .../terra/addon/BootstrapAddonLoader.java | 34 +- .../addon/exception/AddonLoadException.java | 4 +- .../com/dfsek/terra/bukkit/BukkitAddon.java | 36 +- .../terra/bukkit/BukkitCommandSender.java | 10 +- .../com/dfsek/terra/bukkit/BukkitEntity.java | 18 +- .../com/dfsek/terra/bukkit/BukkitPlayer.java | 12 +- .../com/dfsek/terra/bukkit/PlatformImpl.java | 38 +- .../dfsek/terra/bukkit/TerraBukkitPlugin.java | 46 +- .../config/PreLoadCompatibilityOptions.java | 14 +- .../bukkit/config/VanillaBiomeProperties.java | 22 +- .../bukkit/generator/BukkitBiomeProvider.java | 12 +- .../generator/BukkitBlockPopulator.java | 8 +- .../BukkitChunkGeneratorWrapper.java | 32 +- .../bukkit/generator/BukkitProtoChunk.java | 16 +- .../bukkit/handles/BukkitItemHandle.java | 8 +- .../bukkit/handles/BukkitWorldHandle.java | 14 +- .../bukkit/listeners/SpigotListener.java | 8 +- .../dfsek/terra/bukkit/nms/Initializer.java | 4 +- .../dfsek/terra/bukkit/util/VersionUtil.java | 54 +-- .../terra/bukkit/world/BukkitAdapter.java | 84 ++-- .../dfsek/terra/bukkit/world/BukkitChunk.java | 16 +- .../bukkit/world/BukkitPlatformBiome.java | 6 +- .../terra/bukkit/world/BukkitProtoWorld.java | 48 +- .../terra/bukkit/world/BukkitServerWorld.java | 34 +- .../bukkit/world/BukkitWorldProperties.java | 14 +- .../world/block/BukkitBlockTypeAndItem.java | 18 +- .../world/block/data/BukkitBlockState.java | 22 +- .../world/block/state/BukkitBlockEntity.java | 18 +- .../world/block/state/BukkitContainer.java | 6 +- .../world/block/state/BukkitMobSpawner.java | 34 +- .../bukkit/world/block/state/BukkitSign.java | 8 +- .../bukkit/world/entity/BukkitEntityType.java | 4 +- .../world/inventory/BukkitInventory.java | 10 +- .../world/inventory/BukkitItemMeta.java | 10 +- .../world/inventory/BukkitItemStack.java | 14 +- .../inventory/meta/BukkitDamageable.java | 6 +- .../inventory/meta/BukkitEnchantment.java | 12 +- .../bukkit/nms/v1_18_R2/AwfulBukkitHacks.java | 108 ++--- .../bukkit/nms/v1_18_R2/NMSBiomeInjector.java | 56 +-- .../bukkit/nms/v1_18_R2/NMSBiomeProvider.java | 22 +- .../v1_18_R2/NMSChunkGeneratorDelegate.java | 70 +-- .../nms/v1_18_R2/NMSInjectListener.java | 16 +- .../nms/v1_18_R2/NMSWorldProperties.java | 10 +- .../terra/bukkit/nms/v1_18_R2/Reflection.java | 14 +- .../terra/bukkit/nms/v1_18_R2/Registries.java | 12 +- .../bukkit/nms/v1_19_R1/AwfulBukkitHacks.java | 108 ++--- .../bukkit/nms/v1_19_R1/NMSBiomeInjector.java | 54 +-- .../bukkit/nms/v1_19_R1/NMSBiomeProvider.java | 20 +- .../v1_19_R1/NMSChunkGeneratorDelegate.java | 92 ++-- .../nms/v1_19_R1/NMSInjectListener.java | 14 +- .../nms/v1_19_R1/NMSWorldProperties.java | 10 +- .../terra/bukkit/nms/v1_19_R1/Reflection.java | 14 +- .../terra/bukkit/nms/v1_19_R1/Registries.java | 12 +- .../bukkit/nms/v1_19_R2/AwfulBukkitHacks.java | 76 ++-- .../bukkit/nms/v1_19_R2/NMSBiomeInjector.java | 54 +-- .../bukkit/nms/v1_19_R2/NMSBiomeProvider.java | 20 +- .../v1_19_R2/NMSChunkGeneratorDelegate.java | 60 +-- .../nms/v1_19_R2/NMSInjectListener.java | 12 +- .../nms/v1_19_R2/NMSWorldProperties.java | 10 +- .../terra/bukkit/nms/v1_19_R2/Reflection.java | 20 +- .../bukkit/nms/v1_19_R2/RegistryFetcher.java | 6 +- .../bukkit/nms/v1_19_R3/AwfulBukkitHacks.java | 76 ++-- .../bukkit/nms/v1_19_R3/NMSBiomeInjector.java | 52 +-- .../bukkit/nms/v1_19_R3/NMSBiomeProvider.java | 22 +- .../v1_19_R3/NMSChunkGeneratorDelegate.java | 62 +-- .../bukkit/nms/v1_19_R3/NMSInitializer.java | 4 +- .../nms/v1_19_R3/NMSInjectListener.java | 12 +- .../nms/v1_19_R3/NMSWorldProperties.java | 10 +- .../terra/bukkit/nms/v1_19_R3/Reflection.java | 20 +- .../bukkit/nms/v1_19_R3/RegistryFetcher.java | 6 +- .../bukkit/nms/v1_20_R1/AwfulBukkitHacks.java | 76 ++-- .../bukkit/nms/v1_20_R1/NMSBiomeInfo.java | 4 +- .../bukkit/nms/v1_20_R1/NMSBiomeInjector.java | 52 +-- .../bukkit/nms/v1_20_R1/NMSBiomeProvider.java | 22 +- .../v1_20_R1/NMSChunkGeneratorDelegate.java | 82 ++-- .../nms/v1_20_R1/NMSInjectListener.java | 12 +- .../nms/v1_20_R1/NMSWorldProperties.java | 10 +- .../terra/bukkit/nms/v1_20_R1/Reflection.java | 20 +- .../bukkit/nms/v1_20_R1/RegistryFetcher.java | 6 +- .../bukkit/nms/v1_20_R2/AwfulBukkitHacks.java | 76 ++-- .../bukkit/nms/v1_20_R2/NMSBiomeInjector.java | 52 +-- .../bukkit/nms/v1_20_R2/NMSBiomeProvider.java | 22 +- .../v1_20_R2/NMSChunkGeneratorDelegate.java | 62 +-- .../nms/v1_20_R2/NMSInjectListener.java | 12 +- .../nms/v1_20_R2/NMSWorldProperties.java | 10 +- .../terra/bukkit/nms/v1_20_R2/Reflection.java | 20 +- .../bukkit/nms/v1_20_R2/RegistryFetcher.java | 6 +- .../java/com/dfsek/terra/cli/CLIPlatform.java | 16 +- .../java/com/dfsek/terra/cli/TerraCLI.java | 14 +- .../dfsek/terra/cli/block/CLIBlockState.java | 26 +- .../dfsek/terra/cli/block/CLIBlockType.java | 10 +- .../dfsek/terra/cli/handle/CLIItemHandle.java | 8 +- .../terra/cli/handle/CLIWorldHandle.java | 8 +- .../com/dfsek/terra/cli/world/CLIWorld.java | 94 ++-- .../com/dfsek/terra/cli/world/Region.java | 10 +- .../dfsek/terra/cli/world/chunk/CLIChunk.java | 18 +- .../com/dfsek/terra/fabric/FabricAddon.java | 4 +- .../dfsek/terra/fabric/FabricEntryPoint.java | 6 +- .../dfsek/terra/fabric/FabricPlatform.java | 12 +- .../dfsek/terra/forge/AwfulForgeHacks.java | 142 +++--- .../com/dfsek/terra/forge/ForgeAddon.java | 4 +- .../dfsek/terra/forge/ForgeEntryPoint.java | 18 +- .../com/dfsek/terra/forge/ForgePlatform.java | 36 +- .../mixin/lifecycle/NoiseConfigMixin.java | 2 +- .../com/dfsek/terra/forge/util/BiomeUtil.java | 48 +- .../com/dfsek/terra/mod/CommonPlatform.java | 8 +- .../com/dfsek/terra/mod/MinecraftAddon.java | 44 +- .../java/com/dfsek/terra/mod/ModPlatform.java | 78 ++-- .../config/BiomeAdditionsSoundTemplate.java | 4 +- .../mod/config/BiomeMoodSoundTemplate.java | 8 +- .../config/BiomeParticleConfigTemplate.java | 10 +- .../terra/mod/config/EntityTypeTemplate.java | 2 +- .../terra/mod/config/MusicSoundTemplate.java | 8 +- .../config/PreLoadCompatibilityOptions.java | 14 +- .../terra/mod/config/ProtoPlatformBiome.java | 12 +- .../terra/mod/config/SoundEventTemplate.java | 4 +- .../terra/mod/config/SpawnCostConfig.java | 12 +- .../terra/mod/config/SpawnEntryTemplate.java | 8 +- .../terra/mod/config/SpawnGroupTemplate.java | 2 +- .../mod/config/SpawnSettingsTemplate.java | 8 +- .../terra/mod/config/SpawnTypeConfig.java | 8 +- .../mod/config/VanillaBiomeProperties.java | 70 +-- .../mod/config/VillagerTypeTemplate.java | 2 +- .../java/com/dfsek/terra/mod/data/Codecs.java | 76 ++-- .../MinecraftChunkGeneratorWrapper.java | 62 +-- .../mod/generation/TerraBiomeSource.java | 32 +- .../terra/mod/handle/MinecraftItemHandle.java | 6 +- .../mod/handle/MinecraftWorldHandle.java | 10 +- ...oveGoalsUnsynchronizedRandomAccessFix.java | 4 +- .../GenerationSettingsFloraFeaturesMixin.java | 4 +- .../terra/HandleImplementationMixin.java | 46 +- .../terra/block/BlockMixin.java | 4 +- .../terra/block/entity/BlockEntityMixin.java | 12 +- .../entity/MobSpawnerBlockEntityMixin.java | 54 +-- .../block/entity/SignBlockEntityMixin.java | 10 +- .../terra/block/state/BlockStateMixin.java | 20 +- .../terra/block/state/PropertyMixin.java | 8 +- .../terra/chunk/ChunkRegionMixin.java | 14 +- .../terra/chunk/WorldChunkMixin.java | 22 +- .../terra/chunk/data/ProtoChunkMixin.java | 10 +- .../terra/entity/EntityMixin.java | 10 +- .../entity/ServerCommandSourceMixin.java | 10 +- .../LockableContainerBlockEntityMixin.java | 4 +- .../terra/inventory/item/ItemMixin.java | 4 +- .../terra/inventory/item/ItemStackMixin.java | 20 +- .../inventory/meta/EnchantmentMixin.java | 8 +- .../meta/ItemStackDamageableMixin.java | 10 +- .../inventory/meta/ItemStackMetaMixin.java | 10 +- .../terra/world/ChunkRegionMixin.java | 44 +- .../terra/world/ServerWorldMixin.java | 30 +- .../lifecycle/DataPackContentsMixin.java | 2 +- .../terra/mod/util/MinecraftAdapter.java | 10 +- .../dfsek/terra/mod/util/MinecraftUtil.java | 118 ++--- .../com/dfsek/terra/mod/util/PresetUtil.java | 48 +- .../com/dfsek/terra/mod/util/SeedHack.java | 6 +- .../com/dfsek/terra/mod/util/TagUtil.java | 120 ++--- .../terra/lifecycle/LifecycleEntryPoint.java | 16 +- .../terra/lifecycle/LifecyclePlatform.java | 42 +- .../lifecycle/mixin/NoiseConfigMixin.java | 2 +- .../lifecycle/mixin/SimpleRegistryMixin.java | 2 +- .../mixin/lifecycle/RegistryLoaderMixin.java | 54 +-- .../mixin/lifecycle/SaveLoadingMixin.java | 18 +- .../dfsek/terra/lifecycle/util/BiomeUtil.java | 40 +- .../terra/lifecycle/util/LifecycleUtil.java | 6 +- .../terra/lifecycle/util/RegistryUtil.java | 4 +- .../dfsek/terra/quilt/AwfulQuiltHacks.java | 6 +- .../com/dfsek/terra/quilt/QuiltAddon.java | 4 +- .../dfsek/terra/quilt/QuiltEntryPoint.java | 2 +- .../com/dfsek/terra/quilt/QuiltPlatform.java | 16 +- .../com/dfsek/terra/sponge/PlatformImpl.java | 12 +- .../dfsek/terra/sponge/SpongeListener.java | 4 +- .../dfsek/terra/sponge/TerraSpongePlugin.java | 6 +- .../terra/sponge/block/SpongeBlockState.java | 20 +- .../terra/sponge/block/SpongeBlockType.java | 10 +- .../sponge/handle/SpongeWorldHandle.java | 8 +- 793 files changed, 7579 insertions(+), 7577 deletions(-) diff --git a/.editorconfig b/.editorconfig index 9ab244cf7..e1d947c25 100644 --- a/.editorconfig +++ b/.editorconfig @@ -8,7 +8,7 @@ indent_style = space insert_final_newline = false max_line_length = 140 tab_width = 4 -ij_continuation_indent_size = 8 +ij_continuation_indent_size = 4 ij_formatter_off_tag = @formatter:off ij_formatter_on_tag = @formatter:on ij_formatter_tags_enabled = false @@ -25,12 +25,12 @@ ij_java_align_multiline_annotation_parameters = true ij_java_align_multiline_array_initializer_expression = true ij_java_align_multiline_assignment = true ij_java_align_multiline_binary_operation = true -ij_java_align_multiline_chained_methods = true +ij_java_align_multiline_chained_methods = false ij_java_align_multiline_extends_list = true ij_java_align_multiline_for = true -ij_java_align_multiline_method_parentheses = true +ij_java_align_multiline_method_parentheses = false ij_java_align_multiline_parameters = true -ij_java_align_multiline_parameters_in_calls = true +ij_java_align_multiline_parameters_in_calls = false ij_java_align_multiline_parenthesized_expression = true ij_java_align_multiline_records = true ij_java_align_multiline_resources = true @@ -127,7 +127,7 @@ ij_java_keep_blank_lines_in_declarations = 2 ij_java_keep_builder_methods_indents = true ij_java_keep_control_statement_in_one_line = true ij_java_keep_first_column_comment = false -ij_java_keep_indents_on_empty_lines = true +ij_java_keep_indents_on_empty_lines = false ij_java_keep_line_breaks = true ij_java_keep_multiple_expressions_in_one_line = false ij_java_keep_simple_blocks_in_one_line = true diff --git a/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddon.java b/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddon.java index ba68e0434..6fb965850 100644 --- a/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddon.java +++ b/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddon.java @@ -8,17 +8,17 @@ import com.dfsek.terra.api.addon.BaseAddon; public class ApiAddon implements BaseAddon { private final Version version; private final String id; - + public ApiAddon(Version version, String id) { this.version = version; this.id = id; } - + @Override public Version getVersion() { return version; } - + @Override public String getID() { return id; diff --git a/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonClassLoader.java b/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonClassLoader.java index b6fc722fe..31c1eda90 100644 --- a/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonClassLoader.java +++ b/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonClassLoader.java @@ -15,7 +15,7 @@ public class ApiAddonClassLoader extends URLClassLoader { static { ClassLoader.registerAsParallelCapable(); } - + public ApiAddonClassLoader(URL[] urls, ClassLoader parent) { super(urls, parent); } diff --git a/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonLoader.java b/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonLoader.java index 9af4d9ab8..3d2c977f5 100644 --- a/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonLoader.java +++ b/common/addons/api-addon-loader/src/main/java/com/dfsek/terra/addon/loader/ApiAddonLoader.java @@ -20,18 +20,18 @@ import com.dfsek.terra.api.addon.bootstrap.BootstrapBaseAddon; public class ApiAddonLoader implements BootstrapBaseAddon { private static final Version VERSION = Versions.getVersion(1, 0, 0); - + @Override public Iterable loadAddons(Path addonsFolder, BootstrapAddonClassLoader parent) { - + return Collections.emptySet(); } - + @Override public String getID() { return "API"; } - + @Override public Version getVersion() { return VERSION; diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BaseBiomeColumn.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BaseBiomeColumn.java index 6dcad812f..4af6cc838 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BaseBiomeColumn.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BaseBiomeColumn.java @@ -9,11 +9,11 @@ class BaseBiomeColumn implements Column { private final Biome base; private final int min; private final int max; - + private final int x; private final int z; private final long seed; - + protected BaseBiomeColumn(BiomeExtrusionProvider biomeProvider, Biome base, int min, int max, int x, int z, long seed) { this.biomeProvider = biomeProvider; this.base = base; @@ -23,27 +23,27 @@ class BaseBiomeColumn implements Column { this.z = z; this.seed = seed; } - + @Override public int getMinY() { return min; } - + @Override public int getMaxY() { return max; } - + @Override public int getX() { return x; } - + @Override public int getZ() { return z; } - + @Override public Biome get(int y) { return biomeProvider.extrude(base, x, y, z, seed); diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BiomeExtrusionAddon.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BiomeExtrusionAddon.java index 1e3d0ff0e..633ef5704 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BiomeExtrusionAddon.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BiomeExtrusionAddon.java @@ -2,6 +2,8 @@ package com.dfsek.terra.addons.biome.extrusion; import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; +import java.util.function.Supplier; + import com.dfsek.terra.addons.biome.extrusion.api.Extrusion; import com.dfsek.terra.addons.biome.extrusion.api.ReplaceableBiome; import com.dfsek.terra.addons.biome.extrusion.config.BiomeExtrusionTemplate; @@ -21,47 +23,45 @@ import com.dfsek.terra.api.util.reflection.TypeKey; import com.dfsek.terra.api.world.biome.Biome; import com.dfsek.terra.api.world.biome.generation.BiomeProvider; -import java.util.function.Supplier; - public class BiomeExtrusionAddon implements AddonInitializer { public static final TypeKey>> EXTRUSION_REGISTRY_KEY = new TypeKey<>() { }; - + public static final TypeKey>> PROVIDER_REGISTRY_KEY = new TypeKey<>() { }; - + @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> { - CheckedRegistry>> providerRegistry = - event.getPack() - .getOrCreateRegistry(PROVIDER_REGISTRY_KEY); - providerRegistry.register(addon.key("EXTRUSION"), BiomeExtrusionTemplate::new); - }) - .then(event -> { - CheckedRegistry>> extrusionRegistry = event.getPack().getOrCreateRegistry( - EXTRUSION_REGISTRY_KEY); - extrusionRegistry.register(addon.key("SET"), SetExtrusionTemplate::new); - extrusionRegistry.register(addon.key("REPLACE"), ReplaceExtrusionTemplate::new); - }) - .failThrough(); - + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> { + CheckedRegistry>> providerRegistry = + event.getPack() + .getOrCreateRegistry(PROVIDER_REGISTRY_KEY); + providerRegistry.register(addon.key("EXTRUSION"), BiomeExtrusionTemplate::new); + }) + .then(event -> { + CheckedRegistry>> extrusionRegistry = event.getPack().getOrCreateRegistry( + EXTRUSION_REGISTRY_KEY); + extrusionRegistry.register(addon.key("SET"), SetExtrusionTemplate::new); + extrusionRegistry.register(addon.key("REPLACE"), ReplaceExtrusionTemplate::new); + }) + .failThrough(); + platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPostLoadEvent.class) - .then(event -> { - Registry biomeRegistry = event.getPack().getRegistry(Biome.class); - event.getPack().applyLoader(ReplaceableBiome.class, new ReplaceableBiomeLoader(biomeRegistry)); - }); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPostLoadEvent.class) + .then(event -> { + Registry biomeRegistry = event.getPack().getRegistry(Biome.class); + event.getPack().applyLoader(ReplaceableBiome.class, new ReplaceableBiomeLoader(biomeRegistry)); + }); } } diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BiomeExtrusionProvider.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BiomeExtrusionProvider.java index c9f1f8129..621c2d37a 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BiomeExtrusionProvider.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/BiomeExtrusionProvider.java @@ -16,7 +16,7 @@ public class BiomeExtrusionProvider implements BiomeProvider { private final Set biomes; private final List extrusions; private final int resolution; - + public BiomeExtrusionProvider(BiomeProvider delegate, List extrusions, int resolution) { this.delegate = delegate; this.biomes = delegate.stream().collect(Collectors.toSet()); @@ -24,43 +24,43 @@ public class BiomeExtrusionProvider implements BiomeProvider { this.extrusions = extrusions; this.resolution = resolution; } - + @Override public Biome getBiome(int x, int y, int z, long seed) { Biome delegated = delegate.getBiome(x, y, z, seed); - + return extrude(delegated, x, y, z, seed); } - + public Biome extrude(Biome original, int x, int y, int z, long seed) { for(Extrusion extrusion : extrusions) { original = extrusion.extrude(original, x, y, z, seed); } return original; } - + @Override public Column getColumn(int x, int z, long seed, int min, int max) { return delegate.getBaseBiome(x, z, seed) - .map(base -> (Column) new BaseBiomeColumn(this, base, min, max, x, z, seed)) - .orElseGet(() -> BiomeProvider.super.getColumn(x, z, seed, min, max)); + .map(base -> (Column) new BaseBiomeColumn(this, base, min, max, x, z, seed)) + .orElseGet(() -> BiomeProvider.super.getColumn(x, z, seed, min, max)); } - + @Override public Optional getBaseBiome(int x, int z, long seed) { return delegate.getBaseBiome(x, z, seed); } - + @Override public Iterable getBiomes() { return biomes; } - + @Override public int resolution() { return resolution; } - + public BiomeProvider getDelegate() { return delegate; } diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/Extrusion.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/Extrusion.java index 8a7154fa9..4c4ca972a 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/Extrusion.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/Extrusion.java @@ -7,6 +7,6 @@ import com.dfsek.terra.api.world.biome.Biome; public interface Extrusion { Biome extrude(Biome original, int x, int y, int z, long seed); - + Collection getBiomes(); } diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/PresentBiome.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/PresentBiome.java index 385b01e0b..23ea5116b 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/PresentBiome.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/PresentBiome.java @@ -6,16 +6,16 @@ import com.dfsek.terra.api.world.biome.Biome; final class PresentBiome implements ReplaceableBiome { private final Biome biome; - + PresentBiome(Biome biome) { this.biome = biome; } - + @Override public Biome get(Biome existing) { return biome; } - + @Override public boolean isSelf() { return false; diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/ReplaceableBiome.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/ReplaceableBiome.java index d79ec409a..a2a02e2f5 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/ReplaceableBiome.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/ReplaceableBiome.java @@ -13,19 +13,19 @@ public sealed interface ReplaceableBiome permits PresentBiome, SelfBiome { static ReplaceableBiome of(Biome biome) { return new PresentBiome(biome); } - + static ReplaceableBiome self() { return SelfBiome.INSTANCE; } - + Biome get(Biome existing); - + default Biome get() { if(isSelf()) { throw new IllegalStateException("Cannot get() self biome!"); } return get(null); } - + boolean isSelf(); } diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/SelfBiome.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/SelfBiome.java index 42e775ccc..ef1d3225d 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/SelfBiome.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/SelfBiome.java @@ -8,12 +8,12 @@ import com.dfsek.terra.api.world.biome.Biome; final class SelfBiome implements ReplaceableBiome { public static final SelfBiome INSTANCE = new SelfBiome(); - + @Override public Biome get(Biome existing) { return Objects.requireNonNull(existing); } - + @Override public boolean isSelf() { return true; diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/BiomeExtrusionTemplate.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/BiomeExtrusionTemplate.java index 810246d65..87e5d1f8b 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/BiomeExtrusionTemplate.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/BiomeExtrusionTemplate.java @@ -15,14 +15,14 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class BiomeExtrusionTemplate implements ObjectTemplate { @Value("provider") private @Meta BiomeProvider provider; - + @Value("resolution") @Default private @Meta int resolution = 4; - + @Value("extrusions") private @Meta List<@Meta Extrusion> extrusions; - + @Override public BiomeProvider get() { return new BiomeExtrusionProvider(provider, extrusions, resolution); diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/ReplaceableBiomeLoader.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/ReplaceableBiomeLoader.java index 9ef2573ab..79bd46e21 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/ReplaceableBiomeLoader.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/ReplaceableBiomeLoader.java @@ -15,18 +15,18 @@ import com.dfsek.terra.api.world.biome.Biome; public class ReplaceableBiomeLoader implements TypeLoader { private final Registry biomeRegistry; - + public ReplaceableBiomeLoader(Registry biomeRegistry) { this.biomeRegistry = biomeRegistry; } - + @Override public ReplaceableBiome load(@NotNull AnnotatedType t, @NotNull Object c, @NotNull ConfigLoader loader, DepthTracker depthTracker) throws LoadException { if(c.equals("SELF")) return ReplaceableBiome.self(); return biomeRegistry - .getByID((String) c) - .map(ReplaceableBiome::of) - .orElseThrow(() -> new LoadException("No such biome: " + c, depthTracker)); + .getByID((String) c) + .map(ReplaceableBiome::of) + .orElseThrow(() -> new LoadException("No such biome: " + c, depthTracker)); } } diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/extrusions/ReplaceExtrusionTemplate.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/extrusions/ReplaceExtrusionTemplate.java index 1b4743dc4..dd29b282a 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/extrusions/ReplaceExtrusionTemplate.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/extrusions/ReplaceExtrusionTemplate.java @@ -12,10 +12,10 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; public class ReplaceExtrusionTemplate extends SamplerExtrusionTemplate { @Value("to") private @Meta ProbabilityCollection<@Meta ReplaceableBiome> biomes; - + @Value("from") private @Meta String fromTag; - + @Override public Extrusion get() { return new ReplaceExtrusion(sampler, range, biomes, fromTag); diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/extrusions/SamplerExtrusionTemplate.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/extrusions/SamplerExtrusionTemplate.java index d21ef0f64..4389ab28f 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/extrusions/SamplerExtrusionTemplate.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/extrusions/SamplerExtrusionTemplate.java @@ -12,7 +12,7 @@ import com.dfsek.terra.api.util.Range; public abstract class SamplerExtrusionTemplate implements ObjectTemplate { @Value("sampler") protected @Meta NoiseSampler sampler; - + @Value("range") protected @Meta Range range; } diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/extrusions/SetExtrusionTemplate.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/extrusions/SetExtrusionTemplate.java index 1cfbaeb48..0d46b8425 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/extrusions/SetExtrusionTemplate.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/config/extrusions/SetExtrusionTemplate.java @@ -12,7 +12,7 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; public class SetExtrusionTemplate extends SamplerExtrusionTemplate { @Value("to") private @Meta ProbabilityCollection<@Meta ReplaceableBiome> biomes; - + @Override public Extrusion get() { return new SetExtrusion(sampler, range, biomes); diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/extrusions/ReplaceExtrusion.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/extrusions/ReplaceExtrusion.java index 7458c475c..26b1ec4bb 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/extrusions/ReplaceExtrusion.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/extrusions/ReplaceExtrusion.java @@ -18,20 +18,20 @@ import com.dfsek.terra.api.world.biome.Biome; */ public class ReplaceExtrusion implements Extrusion { private final NoiseSampler sampler; - + private final Range range; - + private final ProbabilityCollection biomes; - + private final Predicate hasTag; - + public ReplaceExtrusion(NoiseSampler sampler, Range range, ProbabilityCollection biomes, String tag) { this.sampler = sampler; this.range = range; this.biomes = biomes; this.hasTag = BiomeQueries.has(tag); } - + @Override public Biome extrude(Biome original, int x, int y, int z, long seed) { if(hasTag.test(original)) { @@ -39,14 +39,14 @@ public class ReplaceExtrusion implements Extrusion { } return original; } - + @Override public Collection getBiomes() { return biomes - .getContents() - .stream() - .filter(Predicate.not(ReplaceableBiome::isSelf)) - .map(ReplaceableBiome::get) - .collect(Collectors.toSet()); + .getContents() + .stream() + .filter(Predicate.not(ReplaceableBiome::isSelf)) + .map(ReplaceableBiome::get) + .collect(Collectors.toSet()); } } diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/extrusions/SetExtrusion.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/extrusions/SetExtrusion.java index 79209c28a..b3f4edd62 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/extrusions/SetExtrusion.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/extrusions/SetExtrusion.java @@ -17,29 +17,29 @@ import com.dfsek.terra.api.world.biome.Biome; */ public class SetExtrusion implements Extrusion { private final NoiseSampler sampler; - + private final Range range; - + private final ProbabilityCollection biomes; - + public SetExtrusion(NoiseSampler sampler, Range range, ProbabilityCollection biomes) { this.sampler = sampler; this.range = range; this.biomes = biomes; } - + @Override public Biome extrude(Biome original, int x, int y, int z, long seed) { return range.ifInRange(y, () -> biomes.get(sampler, x, y, z, seed).get(original), original); } - + @Override public Collection getBiomes() { return biomes - .getContents() - .stream() - .filter(Predicate.not(ReplaceableBiome::isSelf)) - .map(ReplaceableBiome::get) - .collect(Collectors.toSet()); + .getContents() + .stream() + .filter(Predicate.not(ReplaceableBiome::isSelf)) + .map(ReplaceableBiome::get) + .collect(Collectors.toSet()); } } diff --git a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java index 6635f5902..073bea70e 100644 --- a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java +++ b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java @@ -17,33 +17,33 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class ImageBiomeProvider implements BiomeProvider { private final int resolution; - + private final ColorConverter colorConverter; - + private final ColorSampler colorSampler; - + public ImageBiomeProvider(ColorConverter colorConverter, ColorSampler colorSampler, int resolution) { this.resolution = resolution; this.colorConverter = colorConverter; this.colorSampler = colorSampler; } - + @Override public Biome getBiome(int x, int y, int z, long seed) { return getBiome(x, z); } - + public Biome getBiome(int x, int z) { x /= resolution; z /= resolution; return colorConverter.apply(colorSampler.apply(x, z)); } - + @Override public Optional getBaseBiome(int x, int z, long seed) { return Optional.of(getBiome(x, z)); } - + @Override public Iterable getBiomes() { return colorConverter.getEntries(); diff --git a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProviderAddon.java b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProviderAddon.java index 9a49b4d0f..8c9763336 100644 --- a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProviderAddon.java +++ b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProviderAddon.java @@ -33,46 +33,46 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class ImageBiomeProviderAddon implements AddonInitializer { public static final TypeKey>> PROVIDER_REGISTRY_KEY = new TypeKey<>() { }; - + public static final TypeKey>>> BIOME_COLOR_CONVERTER_REGISTRY_KEY = new TypeKey<>() { }; - + public static final TypeKey>>> BIOME_COLOR_MAPPING_REGISTRY_KEY = new TypeKey<>() { }; - + @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .priority(501) - .then(event -> { - CheckedRegistry>> providerRegistry = event.getPack().getOrCreateRegistry( - PROVIDER_REGISTRY_KEY); - providerRegistry.register(addon.key("IMAGE"), ImageProviderTemplate::new); - }) - .then(event -> { - CheckedRegistry>>> biomeColorConverterRegistry = - event.getPack().getOrCreateRegistry( - BIOME_COLOR_CONVERTER_REGISTRY_KEY); - biomeColorConverterRegistry.register(addon.key("EXACT"), ExactBiomeColorConverterTemplate::new); - biomeColorConverterRegistry.register(addon.key("CLOSEST"), ClosestBiomeColorConverterTemplate::new); - }) - .then(event -> { - CheckedRegistry>>> biomeColorMappingRegistry = - event.getPack().getOrCreateRegistry( - BIOME_COLOR_MAPPING_REGISTRY_KEY); - biomeColorMappingRegistry.register(addon.key("USE_BIOME_COLORS"), - () -> () -> new BiomeDefinedColorMapping<>(event.getPack().getRegistry(Biome.class), - b -> b)); - biomeColorMappingRegistry.register(addon.key("MAP"), DefinedBiomeColorMappingTemplate::new); - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .priority(501) + .then(event -> { + CheckedRegistry>> providerRegistry = event.getPack().getOrCreateRegistry( + PROVIDER_REGISTRY_KEY); + providerRegistry.register(addon.key("IMAGE"), ImageProviderTemplate::new); + }) + .then(event -> { + CheckedRegistry>>> biomeColorConverterRegistry = + event.getPack().getOrCreateRegistry( + BIOME_COLOR_CONVERTER_REGISTRY_KEY); + biomeColorConverterRegistry.register(addon.key("EXACT"), ExactBiomeColorConverterTemplate::new); + biomeColorConverterRegistry.register(addon.key("CLOSEST"), ClosestBiomeColorConverterTemplate::new); + }) + .then(event -> { + CheckedRegistry>>> biomeColorMappingRegistry = + event.getPack().getOrCreateRegistry( + BIOME_COLOR_MAPPING_REGISTRY_KEY); + biomeColorMappingRegistry.register(addon.key("USE_BIOME_COLORS"), + () -> () -> new BiomeDefinedColorMapping<>(event.getPack().getRegistry(Biome.class), + b -> b)); + biomeColorMappingRegistry.register(addon.key("MAP"), DefinedBiomeColorMappingTemplate::new); + }) + .failThrough(); } } diff --git a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/ImageProviderTemplate.java b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/ImageProviderTemplate.java index 54d9f0327..6596a0a8d 100644 --- a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/ImageProviderTemplate.java +++ b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/ImageProviderTemplate.java @@ -21,18 +21,18 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; @SuppressWarnings("FieldMayBeFinal") public class ImageProviderTemplate implements ObjectTemplate { - + @Value("resolution") @Default @Description("Sets the resolution at which to sample the image.") private int resolution = 1; - + @Value("color-sampler") private ColorSampler colorSampler; - + @Value("color-conversion") private ColorConverter colorConverter; - + @Override public BiomeProvider get() { return new ImageBiomeProvider(colorConverter, colorSampler, resolution); diff --git a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ClosestBiomeColorConverterTemplate.java b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ClosestBiomeColorConverterTemplate.java index 2c9973789..5581aa5a1 100644 --- a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ClosestBiomeColorConverterTemplate.java +++ b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ClosestBiomeColorConverterTemplate.java @@ -8,10 +8,10 @@ import com.dfsek.terra.api.world.biome.Biome; public class ClosestBiomeColorConverterTemplate extends ClosestColorConverterTemplate { - + @Value("match") private ColorMapping match; - + @Override protected ColorMapping getMapping() { return match; diff --git a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ExactBiomeColorConverterTemplate.java b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ExactBiomeColorConverterTemplate.java index ed32a18e8..ce00bcb2f 100644 --- a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ExactBiomeColorConverterTemplate.java +++ b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ExactBiomeColorConverterTemplate.java @@ -9,27 +9,27 @@ import com.dfsek.terra.api.world.biome.Biome; public class ExactBiomeColorConverterTemplate extends ExactColorConverterTemplate { - + @Value("match") private ColorMapping match; - + @Value("else") private Biome fallback; - + @Value("ignore-alpha") @Default private boolean ignoreAlpha = true; - + @Override protected ColorMapping getMapping() { return match; } - + @Override protected Biome getFallback() { return fallback; } - + @Override protected boolean ignoreAlpha() { return ignoreAlpha; diff --git a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/mapping/DefinedBiomeColorMappingTemplate.java b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/mapping/DefinedBiomeColorMappingTemplate.java index ea650d424..8cfc22408 100644 --- a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/mapping/DefinedBiomeColorMappingTemplate.java +++ b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/mapping/DefinedBiomeColorMappingTemplate.java @@ -12,10 +12,10 @@ import com.dfsek.terra.api.world.biome.Biome; public class DefinedBiomeColorMappingTemplate implements ObjectTemplate> { - + @Value("map") Map map; - + @Override public ColorMapping get() { var map = MapUtil.mapKeys(this.map, ColorString::getColor); diff --git a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProvider.java b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProvider.java index 2dfe4cba0..47132b653 100644 --- a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProvider.java +++ b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProvider.java @@ -23,53 +23,53 @@ public class ImageBiomeProvider implements BiomeProvider { private final BufferedImage image; private final int resolution; private final Align align; - + public ImageBiomeProvider(Set registry, BufferedImage image, int resolution, Align align) { this.image = image; this.resolution = resolution; this.align = align; registry.forEach(biome -> colorBiomeMap.put(new Color(biome.getColor()), biome)); } - + private static int distance(Color a, Color b) { return Math.abs(a.getRed() - b.getRed()) + Math.abs(a.getGreen() - b.getGreen()) + Math.abs(a.getBlue() - b.getBlue()); } - + @Override public Biome getBiome(int x, int y, int z, long seed) { return getBiome(x, z); } - + public Biome getBiome(int x, int z) { x /= resolution; z /= resolution; Color color = align.getColor(image, x, z); return colorBiomeMap.get(colorBiomeMap.keySet() - .stream() - .reduce(colorBiomeMap.keySet().stream().findAny().orElseThrow(IllegalStateException::new), - (running, element) -> { - int d1 = distance(color, running); - int d2 = distance(color, element); - return d1 < d2 ? running : element; - })); + .stream() + .reduce(colorBiomeMap.keySet().stream().findAny().orElseThrow(IllegalStateException::new), + (running, element) -> { + int d1 = distance(color, running); + int d2 = distance(color, element); + return d1 < d2 ? running : element; + })); } - + @Override public Optional getBaseBiome(int x, int z, long seed) { return Optional.of(getBiome(x, z)); } - + @Override public Iterable getBiomes() { return colorBiomeMap.values(); } - + public enum Align { CENTER { @Override public Color getColor(BufferedImage image, int x, int z) { return new Color(image.getRGB(Math.floorMod(x - image.getWidth() / 2, image.getWidth()), - Math.floorMod(z - image.getHeight() / 2, image.getHeight()))); + Math.floorMod(z - image.getHeight() / 2, image.getHeight()))); } }, NONE { @@ -78,7 +78,7 @@ public class ImageBiomeProvider implements BiomeProvider { return new Color(image.getRGB(Math.floorMod(x, image.getWidth()), Math.floorMod(z, image.getHeight()))); } }; - + public abstract Color getColor(BufferedImage image, int x, int z); } } diff --git a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java index 02ff7f446..b561910bf 100644 --- a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java +++ b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java @@ -26,31 +26,31 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class ImageBiomeProviderAddon implements AddonInitializer { - + public static final TypeKey>> PROVIDER_REGISTRY_KEY = new TypeKey<>() { }; private static final Logger logger = LoggerFactory.getLogger(ImageBiomeProviderAddon.class); @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> { - CheckedRegistry>> providerRegistry = event.getPack().getOrCreateRegistry( - PROVIDER_REGISTRY_KEY); - providerRegistry.register(addon.key("IMAGE"), - () -> new ImageProviderTemplate(event.getPack().getRegistry(Biome.class))); - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> { + CheckedRegistry>> providerRegistry = event.getPack().getOrCreateRegistry( + PROVIDER_REGISTRY_KEY); + providerRegistry.register(addon.key("IMAGE"), + () -> new ImageProviderTemplate(event.getPack().getRegistry(Biome.class))); + }) + .failThrough(); if(platform.getTerraConfig().isDebugLog()) logger.warn( - "The biome-provider-image addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the " + - "biome-provider-image-v2 addon for future pack development instead."); + "The biome-provider-image addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the " + + "biome-provider-image-v2 addon for future pack development instead."); } } diff --git a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageProviderTemplate.java b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageProviderTemplate.java index 8b0681a1d..01bbffab6 100644 --- a/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageProviderTemplate.java +++ b/common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageProviderTemplate.java @@ -33,11 +33,11 @@ public class ImageProviderTemplate implements ObjectTemplate { @Value("image.align") @Description("Sets the alignment style to use for the image.") private ImageBiomeProvider.Align align; - + public ImageProviderTemplate(Registry set) { this.biomes = set; } - + @Override public BiomeProvider get() { return new ImageBiomeProvider(new HashSet<>(biomes.entries()), image, resolution, align); diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineAddon.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineAddon.java index 0ea11be4a..509651d7d 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineAddon.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineAddon.java @@ -38,52 +38,52 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class BiomePipelineAddon implements AddonInitializer { - + public static final TypeKey>> SOURCE_REGISTRY_KEY = new TypeKey<>() { }; - + public static final TypeKey>> STAGE_REGISTRY_KEY = new TypeKey<>() { }; public static final TypeKey>> PROVIDER_REGISTRY_KEY = new TypeKey<>() { }; @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> { - CheckedRegistry>> providerRegistry = event.getPack().getOrCreateRegistry( - PROVIDER_REGISTRY_KEY); - providerRegistry.register(addon.key("PIPELINE"), BiomePipelineTemplate::new); - }) - .then(event -> { - CheckedRegistry>> sourceRegistry = event.getPack().getOrCreateRegistry( - SOURCE_REGISTRY_KEY); - sourceRegistry.register(addon.key("SAMPLER"), SamplerSourceTemplate::new); - }) - .then(event -> { - CheckedRegistry>> stageRegistry = event.getPack().getOrCreateRegistry( - STAGE_REGISTRY_KEY); - stageRegistry.register(addon.key("FRACTAL_EXPAND"), ExpanderStageTemplate::new); - stageRegistry.register(addon.key("SMOOTH"), SmoothStageTemplate::new); - stageRegistry.register(addon.key("REPLACE"), ReplaceStageTemplate::new); - stageRegistry.register(addon.key("REPLACE_LIST"), ReplaceListStageTemplate::new); - stageRegistry.register(addon.key("BORDER"), BorderStageTemplate::new); - stageRegistry.register(addon.key("BORDER_LIST"), BorderListStageTemplate::new); - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> { + CheckedRegistry>> providerRegistry = event.getPack().getOrCreateRegistry( + PROVIDER_REGISTRY_KEY); + providerRegistry.register(addon.key("PIPELINE"), BiomePipelineTemplate::new); + }) + .then(event -> { + CheckedRegistry>> sourceRegistry = event.getPack().getOrCreateRegistry( + SOURCE_REGISTRY_KEY); + sourceRegistry.register(addon.key("SAMPLER"), SamplerSourceTemplate::new); + }) + .then(event -> { + CheckedRegistry>> stageRegistry = event.getPack().getOrCreateRegistry( + STAGE_REGISTRY_KEY); + stageRegistry.register(addon.key("FRACTAL_EXPAND"), ExpanderStageTemplate::new); + stageRegistry.register(addon.key("SMOOTH"), SmoothStageTemplate::new); + stageRegistry.register(addon.key("REPLACE"), ReplaceStageTemplate::new); + stageRegistry.register(addon.key("REPLACE_LIST"), ReplaceListStageTemplate::new); + stageRegistry.register(addon.key("BORDER"), BorderStageTemplate::new); + stageRegistry.register(addon.key("BORDER_LIST"), BorderListStageTemplate::new); + }) + .failThrough(); platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPostLoadEvent.class) - .then(event -> { - Registry biomeRegistry = event.getPack().getRegistry(Biome.class); - event.getPack().applyLoader(PipelineBiome.class, new PipelineBiomeLoader(biomeRegistry)); - }); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPostLoadEvent.class) + .then(event -> { + Registry biomeRegistry = event.getPack().getRegistry(Biome.class); + event.getPack().applyLoader(PipelineBiome.class, new PipelineBiomeLoader(biomeRegistry)); + }); } } diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineColumn.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineColumn.java index 9b3e1391a..736211517 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineColumn.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineColumn.java @@ -12,11 +12,11 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class BiomePipelineColumn implements Column { private final int min; private final int max; - + private final int x; private final int z; private final Biome biome; - + protected BiomePipelineColumn(BiomeProvider biomeProvider, int min, int max, int x, int z, long seed) { this.min = min; this.max = max; @@ -24,44 +24,44 @@ public class BiomePipelineColumn implements Column { this.z = z; this.biome = biomeProvider.getBiome(x, 0, z, seed); } - + @Override public int getMinY() { return min; } - + @Override public int getMaxY() { return max; } - + @Override public int getX() { return x; } - + @Override public int getZ() { return z; } - + @Override public Biome get(int y) { return biome; } - + @Override public void forRanges(int resolution, IntIntObjConsumer consumer) { consumer.accept(min, max, biome); } - + @Override public void forEach(Consumer consumer) { for(int y = min; y < max; y++) { consumer.accept(biome); } } - + @Override public void forEach(IntObjConsumer consumer) { for(int y = min; y < max; y++) { diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/PipelineBiomeProvider.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/PipelineBiomeProvider.java index 02c7376a3..8c36a7ccf 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/PipelineBiomeProvider.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/PipelineBiomeProvider.java @@ -22,23 +22,23 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class PipelineBiomeProvider implements BiomeProvider { - + private final LoadingCache biomeChunkCache; private final int chunkSize; private final int resolution; private final NoiseSampler mutator; private final double noiseAmp; private final Set biomes; - + public PipelineBiomeProvider(Pipeline pipeline, int resolution, NoiseSampler mutator, double noiseAmp) { this.resolution = resolution; this.mutator = mutator; this.noiseAmp = noiseAmp; this.chunkSize = pipeline.getChunkSize(); this.biomeChunkCache = Caffeine.newBuilder() - .maximumSize(64) - .build(pipeline::generateChunk); - + .maximumSize(64) + .build(pipeline::generateChunk); + Set biomeSet = new HashSet<>(); pipeline.getSource().getBiomes().forEach(biomeSet::add); Iterable result = biomeSet; @@ -49,16 +49,16 @@ public class PipelineBiomeProvider implements BiomeProvider { Iterable finalResult = result; result.forEach(pipelineBiome -> { if(pipelineBiome.isPlaceholder()) { - + StringBuilder biomeList = new StringBuilder("\n"); StreamSupport.stream(finalResult.spliterator(), false) - .sorted(Comparator.comparing(StringIdentifiable::getID)) - .forEach(delegate -> biomeList - .append(" - ") - .append(delegate.getID()) - .append(':') - .append(delegate.getClass().getCanonicalName()) - .append('\n')); + .sorted(Comparator.comparing(StringIdentifiable::getID)) + .forEach(delegate -> biomeList + .append(" - ") + .append(delegate.getID()) + .append(':') + .append(delegate.getClass().getCanonicalName()) + .append('\n')); throw new IllegalArgumentException("Biome Pipeline leaks placeholder biome \"" + pipelineBiome.getID() + "\". Ensure there is a stage to guarantee replacement of the placeholder biome. " + "Biomes: " + @@ -67,47 +67,47 @@ public class PipelineBiomeProvider implements BiomeProvider { this.biomes.add(pipelineBiome.getBiome()); }); } - + @Override public Biome getBiome(int x, int y, int z, long seed) { return getBiome(x, z, seed); } - + public Biome getBiome(int x, int z, long seed) { - + x += mutator.noise(seed + 1, x, z) * noiseAmp; z += mutator.noise(seed + 2, x, z) * noiseAmp; - + x /= resolution; z /= resolution; - + int chunkX = Math.floorDiv(x, chunkSize); int chunkZ = Math.floorDiv(z, chunkSize); - + int chunkWorldX = chunkX * chunkSize; int chunkWorldZ = chunkZ * chunkSize; - + int xInChunk = x - chunkWorldX; int zInChunk = z - chunkWorldZ; - + return biomeChunkCache.get(new SeededVector(seed, chunkWorldX, chunkWorldZ)).get(xInChunk, zInChunk).getBiome(); } - + @Override public Iterable getBiomes() { return biomes; } - + @Override public Optional getBaseBiome(int x, int z, long seed) { return Optional.of(getBiome(x, z, seed)); } - + @Override public Column getColumn(int x, int z, long seed, int min, int max) { return new BiomePipelineColumn(this, min, max, x, z, seed); } - + @Override public int resolution() { return resolution; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/BiomeChunk.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/BiomeChunk.java index 818652f59..93e84fe3b 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/BiomeChunk.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/BiomeChunk.java @@ -5,6 +5,6 @@ import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; public interface BiomeChunk { - + PipelineBiome get(int xInChunk, int zInChunk); } diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Expander.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Expander.java index d3fab5263..abf4416b8 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Expander.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Expander.java @@ -9,14 +9,14 @@ import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl.ViewPoin * filling in null biomes as a result of this resizing. */ public interface Expander extends Stage { - + PipelineBiome fillBiome(ViewPoint viewPoint); - + @Override default int maxRelativeReadDistance() { return 0; } - + @Override default PipelineBiome apply(ViewPoint viewPoint) { PipelineBiome currentBiome = viewPoint.getBiome(); diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Pipeline.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Pipeline.java index cfb9ee9a8..37c8f1db0 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Pipeline.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Pipeline.java @@ -5,10 +5,10 @@ import java.util.List; public interface Pipeline { BiomeChunk generateChunk(SeededVector worldCoordinates); - + int getChunkSize(); - + Source getSource(); - + List getStages(); } diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/SeededVector.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/SeededVector.java index 6581ca50c..bee1f2424 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/SeededVector.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/SeededVector.java @@ -1,7 +1,7 @@ package com.dfsek.terra.addons.biome.pipeline.v2.api; public record SeededVector(long seed, int x, int z) { - + @Override public boolean equals(Object obj) { if(obj instanceof SeededVector that) { @@ -9,7 +9,7 @@ public record SeededVector(long seed, int x, int z) { } return false; } - + @Override public int hashCode() { int code = x; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Source.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Source.java index bfb135653..4a4953e41 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Source.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Source.java @@ -6,6 +6,6 @@ import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; public interface Source { PipelineBiome get(long seed, int x, int z); - + Iterable getBiomes(); } \ No newline at end of file diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Stage.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Stage.java index b0d33667b..973af0882 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Stage.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Stage.java @@ -6,9 +6,9 @@ import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl.ViewPoin public interface Stage { PipelineBiome apply(ViewPoint viewPoint); - + int maxRelativeReadDistance(); - + default Iterable getBiomes(Iterable biomes) { return biomes; } diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/DelegatedPipelineBiome.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/DelegatedPipelineBiome.java index 978e68b06..85e6a99ad 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/DelegatedPipelineBiome.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/DelegatedPipelineBiome.java @@ -7,32 +7,32 @@ import com.dfsek.terra.api.world.biome.Biome; public final class DelegatedPipelineBiome implements PipelineBiome { private final Biome biome; - + public DelegatedPipelineBiome(Biome biome) { this.biome = biome; } - + @Override public Biome getBiome() { return biome; } - + @Override public int hashCode() { return biome.hashCode(); } - + @Override public boolean equals(Object obj) { if(!(obj instanceof DelegatedPipelineBiome that)) return false; return that.biome.equals(this.biome); } - + @Override public Set getTags() { return biome.getTags(); } - + @Override public String getID() { return biome.getID(); diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/PipelineBiome.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/PipelineBiome.java index aeb99f903..9ee5f6a65 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/PipelineBiome.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/PipelineBiome.java @@ -10,26 +10,26 @@ public interface PipelineBiome extends StringIdentifiable { static PipelineBiome placeholder(String id) { return new PlaceholderPipelineBiome(id); } - + static PipelineBiome from(Biome biome) { return new DelegatedPipelineBiome(biome); } - + static PipelineBiome self() { return SelfPipelineBiome.INSTANCE; } - + Biome getBiome(); - + Set getTags(); - + default boolean isPlaceholder() { return false; } - + default boolean isSelf() { return false; } - - + + } \ No newline at end of file diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/PlaceholderPipelineBiome.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/PlaceholderPipelineBiome.java index 87bd67120..b527564e2 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/PlaceholderPipelineBiome.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/PlaceholderPipelineBiome.java @@ -9,43 +9,43 @@ import com.dfsek.terra.api.world.biome.Biome; final class PlaceholderPipelineBiome implements PipelineBiome { private final Set tags; private final String id; - + public PlaceholderPipelineBiome(String id) { this.id = id; tags = new HashSet<>(); tags.add(id); tags.add("ALL"); } - + @Override public Biome getBiome() { throw new UnsupportedOperationException("Cannot get raw biome from placeholder pipeline biome"); } - + @Override public Set getTags() { return tags; } - + @Override public String getID() { return id; } - + @Override public boolean isPlaceholder() { return true; } - + @Override public int hashCode() { return id.hashCode(); } - + @Override public boolean equals(Object obj) { if(!(obj instanceof PlaceholderPipelineBiome that)) return false; - + return this.id.equals(that.id); } } diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/SelfPipelineBiome.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/SelfPipelineBiome.java index a962dadbe..2f0be6d4e 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/SelfPipelineBiome.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/SelfPipelineBiome.java @@ -8,31 +8,31 @@ import com.dfsek.terra.api.world.biome.Biome; final class SelfPipelineBiome implements PipelineBiome { public static final SelfPipelineBiome INSTANCE = new SelfPipelineBiome(); - + private SelfPipelineBiome() { - + } - + @Override public Biome getBiome() { throw new UnsupportedOperationException("Cannot get biome from self delegate"); } - + @Override public boolean isSelf() { return true; } - + @Override public boolean isPlaceholder() { return true; } - + @Override public Set getTags() { return Collections.emptySet(); } - + @Override public String getID() { return "SELF"; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java index 78e115609..937a1b7df 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java @@ -29,7 +29,7 @@ public class BiomePipelineTemplate implements ObjectTemplate { @Default @Description(""" The resolution at which to sample biomes. - + Larger values are quadratically faster, but produce lower quality results. For example, a value of 3 would sample every 3 blocks.""") protected @Meta int resolution = 1; @@ -47,7 +47,7 @@ public class BiomePipelineTemplate implements ObjectTemplate { @Value("pipeline.stages") @Description("A list of pipeline stages to apply to the result of #source") private @Meta List<@Meta Stage> stages; - + @Override public BiomeProvider get() { return new PipelineBiomeProvider(new PipelineImpl(source, stages, resolution, 128), resolution, blendSampler, blendAmplitude); diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/PipelineBiomeLoader.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/PipelineBiomeLoader.java index 5e7a08578..8f8e5d50d 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/PipelineBiomeLoader.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/PipelineBiomeLoader.java @@ -15,18 +15,18 @@ import com.dfsek.terra.api.world.biome.Biome; public class PipelineBiomeLoader implements TypeLoader { private final Registry biomeRegistry; - + public PipelineBiomeLoader(Registry biomeRegistry) { this.biomeRegistry = biomeRegistry; } - + @Override public PipelineBiome load(@NotNull AnnotatedType t, @NotNull Object c, @NotNull ConfigLoader loader, DepthTracker depthTracker) throws LoadException { if(c.equals("SELF")) return PipelineBiome.self(); return biomeRegistry - .getByID((String) c) - .map(PipelineBiome::from) - .orElseGet(() -> PipelineBiome.placeholder((String) c)); + .getByID((String) c) + .map(PipelineBiome::from) + .orElseGet(() -> PipelineBiome.placeholder((String) c)); } } diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/source/SamplerSourceTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/source/SamplerSourceTemplate.java index 97069ebec..8b98cad62 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/source/SamplerSourceTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/source/SamplerSourceTemplate.java @@ -22,11 +22,11 @@ public class SamplerSourceTemplate extends SourceTemplate { @Value("sampler") @Description("The sampler used to distribute biomes.") private @Meta NoiseSampler noise; - + @Value("biomes") @Description("The biomes to be distributed.") private @Meta ProbabilityCollection<@Meta PipelineBiome> biomes; - + @Override public Source get() { return new SamplerSource(biomes, noise); diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderListStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderListStageTemplate.java index 117934d65..0f5ccc6ed 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderListStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderListStageTemplate.java @@ -23,17 +23,17 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; public class BorderListStageTemplate extends StageTemplate { @Value("from") private @Meta String from; - + @Value("default-replace") private @Meta String defaultReplace; - + @Value("default-to") private @Meta ProbabilityCollection<@Meta PipelineBiome> defaultTo; - + @Value("replace") private @Meta Map<@Meta PipelineBiome, @Meta ProbabilityCollection<@Meta PipelineBiome>> replace; - - + + @Override public Stage get() { return new BorderListStage(replace, from, defaultReplace, noise, defaultTo); diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderStageTemplate.java index 60d91af3c..6b6bbe4f8 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderStageTemplate.java @@ -21,13 +21,13 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; public class BorderStageTemplate extends StageTemplate { @Value("from") private @Meta String from; - + @Value("replace") private @Meta String replace; - + @Value("to") private @Meta ProbabilityCollection<@Meta PipelineBiome> to; - + @Override public Stage get() { return new BorderStage(from, replace, noise, to); diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceListStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceListStageTemplate.java index 4583a267b..53d6aff2f 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceListStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceListStageTemplate.java @@ -23,13 +23,13 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; public class ReplaceListStageTemplate extends StageTemplate { @Value("default-from") private @Meta String defaultFrom; - + @Value("default-to") private @Meta ProbabilityCollection<@Meta PipelineBiome> defaultTo; - + @Value("to") private @Meta Map<@Meta PipelineBiome, @Meta ProbabilityCollection<@Meta PipelineBiome>> replace; - + @Override public Stage get() { return new ReplaceListStage(replace, defaultFrom, defaultTo, noise); diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceStageTemplate.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceStageTemplate.java index 30429317e..4a62704c9 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceStageTemplate.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceStageTemplate.java @@ -21,10 +21,10 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; public class ReplaceStageTemplate extends StageTemplate { @Value("from") private @Meta String from; - + @Value("to") private @Meta ProbabilityCollection<@Meta PipelineBiome> to; - + @Override public Stage get() { return new ReplaceStage(from, to, noise); diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/BiomeChunkImpl.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/BiomeChunkImpl.java index 5635bd16a..e9fe9dbb2 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/BiomeChunkImpl.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/BiomeChunkImpl.java @@ -10,44 +10,44 @@ import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; public class BiomeChunkImpl implements BiomeChunk { - + private final SeededVector worldOrigin; private final int chunkOriginArrayIndex; private final int worldCoordinateScale; private PipelineBiome[][] biomes; - + public BiomeChunkImpl(SeededVector worldOrigin, PipelineImpl pipeline) { - + this.worldOrigin = worldOrigin; this.chunkOriginArrayIndex = pipeline.getChunkOriginArrayIndex(); this.worldCoordinateScale = pipeline.getResolution(); - + int size = pipeline.getArraySize(); - + int expanderCount = pipeline.getExpanderCount(); int expansionsApplied = 0; - + // Allocate working arrays this.biomes = new PipelineBiome[size][size]; PipelineBiome[][] lookupArray = new PipelineBiome[size][size]; // A second lookup array is required such that stage application doesn't affect lookups, otherwise application may cascade - + // Construct working grid int gridOrigin = 0; int gridInterval = calculateGridInterval(expanderCount, expansionsApplied); int gridSize = (size / gridInterval); gridSize += expanderCount > 0 ? 1 : 0; // Add an extra border if expansion occurs - + // Fill working grid with initial cells for(int gridX = 0; gridX < gridSize; gridX++) { for(int gridZ = 0; gridZ < gridSize; gridZ++) { int xIndex = gridOrigin + gridX * gridInterval; int zIndex = gridOrigin + gridZ * gridInterval; biomes[xIndex][zIndex] = pipeline.getSource().get(worldOrigin.seed(), xIndexToWorldCoordinate(xIndex), - zIndexToWorldCoordinate(zIndex)); + zIndexToWorldCoordinate(zIndex)); } } - + for(Stage stage : pipeline.getStages()) { if(stage instanceof Expander) { // Shrink working grid size, the expander will fill in null cells (as a result of shrinking the grid) during mutation @@ -55,20 +55,20 @@ public class BiomeChunkImpl implements BiomeChunk { gridInterval = calculateGridInterval(expanderCount, expansionsApplied); gridSize = expandSize(gridSize); } - + int stageReadDistance = stage.maxRelativeReadDistance(); if(stageReadDistance > 0) { // Discard edges such that adjacent lookups are only ran on valid cells gridSize = contractBordersFromSize(gridSize, stageReadDistance); gridOrigin += stageReadDistance * gridInterval; } - + // Cycle arrays, the previously populated array is swapped to be used for lookups, and the result of the stage application // overwrites the previous lookup array. This saves having to allocate a new array copy each time PipelineBiome[][] tempArray = biomes; biomes = lookupArray; lookupArray = tempArray; - + // Apply stage to working grid for(int gridZ = 0; gridZ < gridSize; gridZ = gridZ + 1) { for(int gridX = 0; gridX < gridSize; gridX = gridX + 1) { @@ -79,7 +79,7 @@ public class BiomeChunkImpl implements BiomeChunk { } } } - + protected static int initialSizeToArraySize(int expanderCount, int initialSize) { int size = initialSize; for(int i = 0; i < expanderCount; i++) { @@ -87,18 +87,18 @@ public class BiomeChunkImpl implements BiomeChunk { } return size; } - + protected static int calculateChunkOriginArrayIndex(int totalExpanderCount, List stages) { int finalGridOrigin = calculateFinalGridOrigin(totalExpanderCount, stages); int initialGridInterval = calculateGridInterval(totalExpanderCount, 0); - + // Round the final grid origin up to the nearest multiple of initialGridInterval, such that each // chunk samples points on the same overall grid. // Without this, shared chunk borders (required because of adjacent cell reads) will not be identical // because points would be sampled on grids at different offsets, resulting in artifacts at borders. return (int) Math.ceil((double) finalGridOrigin / initialGridInterval) * initialGridInterval; } - + private static int calculateFinalGridOrigin(int totalExpanderCount, List stages) { int gridOrigin = 0; int expansionsApplied = 0; @@ -112,42 +112,42 @@ public class BiomeChunkImpl implements BiomeChunk { } return gridOrigin; } - + protected static int calculateChunkSize(int arraySize, int chunkOriginArrayIndex, int totalExpanderCount) { return contractBordersFromSize(arraySize, chunkOriginArrayIndex) - (totalExpanderCount > 0 ? 1 : 0); } - + private static int expandSize(int size) { return size * 2 - 1; } - + private static int contractBordersFromSize(int size, int border) { return size - border * 2; } - + private static int calculateGridInterval(int totalExpansions, int expansionsApplied) { return 1 << (totalExpansions - expansionsApplied); } - + @Override public PipelineBiome get(int xInChunk, int zInChunk) { int xIndex = xInChunk + chunkOriginArrayIndex; int zIndex = zInChunk + chunkOriginArrayIndex; return biomes[xIndex][zIndex]; } - + private int xIndexToWorldCoordinate(int xIndex) { return (worldOrigin.x() + xIndex - chunkOriginArrayIndex) * worldCoordinateScale; } - + private int zIndexToWorldCoordinate(int zIndex) { return (worldOrigin.z() + zIndex - chunkOriginArrayIndex) * worldCoordinateScale; } - + private SeededVector getOrigin() { return worldOrigin; } - + /** * Represents a point on the operating grid within the biomes array */ @@ -160,7 +160,7 @@ public class BiomeChunkImpl implements BiomeChunk { private final int xIndex; private final int zIndex; private final PipelineBiome[][] lookupArray; - + private ViewPoint(BiomeChunkImpl chunk, int gridInterval, int gridX, int gridZ, int xIndex, int zIndex, PipelineBiome[][] lookupArray) { this.chunk = chunk; @@ -172,45 +172,45 @@ public class BiomeChunkImpl implements BiomeChunk { this.lookupArray = lookupArray; this.biome = lookupArray[xIndex][zIndex]; } - + public PipelineBiome getRelativeBiome(int x, int z) { int lookupXIndex = this.xIndex + x * gridInterval; int lookupZIndex = this.zIndex + z * gridInterval; return lookupArray[lookupXIndex][lookupZIndex]; } - + public PipelineBiome getBiome() { return biome; } - + /** * @return X position of the point relative to the operating grid */ public int gridX() { return gridX; } - + /** * @return Z position of the point relative to the operating grid */ public int gridZ() { return gridZ; } - + /** * @return X position of the point in the world */ public int worldX() { return chunk.xIndexToWorldCoordinate(xIndex); } - + /** * @return Z position of the point in the world */ public int worldZ() { return chunk.zIndexToWorldCoordinate(zIndex); } - + public long worldSeed() { return chunk.getOrigin().seed(); } diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/PipelineImpl.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/PipelineImpl.java index a9be64bf3..3adef3d8e 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/PipelineImpl.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/PipelineImpl.java @@ -14,9 +14,9 @@ import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage; public class PipelineImpl implements Pipeline { - + private static final Logger logger = LoggerFactory.getLogger(PipelineImpl.class); - + private final Source source; private final List stages; private final int chunkSize; @@ -24,13 +24,13 @@ public class PipelineImpl implements Pipeline { private final int arraySize; private final int chunkOriginArrayIndex; private final int resolution; - + public PipelineImpl(Source source, List stages, int resolution, int idealChunkArraySize) { this.source = source; this.stages = stages; this.resolution = resolution; this.expanderCount = (int) stages.stream().filter(s -> s instanceof Expander).count(); - + // Optimize for the ideal array size int arraySize; int chunkOriginArrayIndex; @@ -43,49 +43,49 @@ public class PipelineImpl implements Pipeline { if(chunkSize > 1 && arraySize >= idealChunkArraySize) break; initialSize++; } - + this.arraySize = arraySize; this.chunkOriginArrayIndex = chunkOriginArrayIndex; this.chunkSize = chunkSize; - + logger.debug("Initialized a new biome pipeline:"); logger.debug("Array size: {} (Target: {})", arraySize, idealChunkArraySize); logger.debug("Internal array origin: {}", chunkOriginArrayIndex); logger.debug("Chunk size: {}", chunkSize); } - + @Override public BiomeChunk generateChunk(SeededVector worldCoordinates) { return new BiomeChunkImpl(worldCoordinates, this); } - + @Override public int getChunkSize() { return chunkSize; } - + @Override public Source getSource() { return source; } - + @Override public List getStages() { return stages; } - + protected int getExpanderCount() { return expanderCount; } - + protected int getArraySize() { return arraySize; } - + protected int getChunkOriginArrayIndex() { return chunkOriginArrayIndex; } - + protected int getResolution() { return resolution; } diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/source/SamplerSource.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/source/SamplerSource.java index f6d66b9e2..6ff9d98cd 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/source/SamplerSource.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/source/SamplerSource.java @@ -9,17 +9,17 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; public class SamplerSource implements Source { private final ProbabilityCollection biomes; private final NoiseSampler sampler; - + public SamplerSource(ProbabilityCollection biomes, NoiseSampler sampler) { this.biomes = biomes; this.sampler = sampler; } - + @Override public PipelineBiome get(long seed, int x, int z) { return biomes.get(sampler, x, z, seed); } - + @Override public Iterable getBiomes() { return biomes.getContents(); diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/source/SingleSource.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/source/SingleSource.java index b8beebd10..5649c3db4 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/source/SingleSource.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/source/SingleSource.java @@ -8,18 +8,18 @@ import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome; public class SingleSource implements Source { - + private final PipelineBiome biome; - + public SingleSource(PipelineBiome biome) { this.biome = biome; } - + @Override public PipelineBiome get(long seed, int x, int z) { return biome; } - + @Override public Set getBiomes() { return Collections.singleton(biome); diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/expander/FractalExpander.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/expander/FractalExpander.java index c4040d8b4..957972e61 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/expander/FractalExpander.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/expander/FractalExpander.java @@ -7,27 +7,27 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class FractalExpander implements Expander { - + private final NoiseSampler sampler; - + public FractalExpander(NoiseSampler sampler) { this.sampler = sampler; } - + @Override public PipelineBiome fillBiome(BiomeChunkImpl.ViewPoint viewPoint) { - + int xMod2 = viewPoint.gridX() % 2; int zMod2 = viewPoint.gridZ() % 2; - + double roll = sampler.noise(viewPoint.worldSeed(), viewPoint.worldX(), viewPoint.worldZ()); - + if(xMod2 == 1 && zMod2 == 0) { // Pick one of 2 neighbors on X axis randomly return roll > 0 ? viewPoint.getRelativeBiome(-1, 0) : viewPoint.getRelativeBiome(1, 0); - + } else if(xMod2 == 0 && zMod2 == 1) { // Pick one of 2 neighbors on Z axis randomly return roll > 0 ? viewPoint.getRelativeBiome(0, -1) : viewPoint.getRelativeBiome(0, 1); - + } else { // Pick one of 4 corners randomly return roll > 0 ? roll > 0.25 ? viewPoint.getRelativeBiome(-1, 1) : viewPoint.getRelativeBiome(1, 1) : diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderListStage.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderListStage.java index 1483816b5..a269fb7f2 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderListStage.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderListStage.java @@ -28,9 +28,9 @@ public class BorderListStage implements Stage { private final ProbabilityCollection replaceDefault; private final String defaultReplace; private final Map> replace; - + private final Vector2Int[] borderPoints; - + public BorderListStage(Map> replace, String border, String defaultReplace, NoiseSampler noiseSampler, ProbabilityCollection replaceDefault) { this.border = border; @@ -38,7 +38,7 @@ public class BorderListStage implements Stage { this.replaceDefault = replaceDefault; this.defaultReplace = defaultReplace; this.replace = replace; - + List points = new ArrayList<>(); for(int x = -1; x <= 1; x++) { for(int z = -1; z <= 1; z++) { @@ -47,9 +47,9 @@ public class BorderListStage implements Stage { } } this.borderPoints = points.toArray(new Vector2Int[0]); - + } - + @Override public Iterable getBiomes(Iterable biomes) { Set biomeSet = new HashSet<>(); @@ -58,7 +58,7 @@ public class BorderListStage implements Stage { replace.forEach((biome, collection) -> biomeSet.addAll(collection.getContents())); return biomeSet; } - + @Override public PipelineBiome apply(BiomeChunkImpl.ViewPoint viewPoint) { PipelineBiome center = viewPoint.getBiome(); @@ -68,18 +68,18 @@ public class BorderListStage implements Stage { if(current != null && current.getTags().contains(border)) { if(replace.containsKey(center)) { PipelineBiome replacement = replace.get(center).get(noiseSampler, viewPoint.worldX(), viewPoint.worldZ(), - viewPoint.worldSeed()); + viewPoint.worldSeed()); return replacement.isSelf() ? center : replacement; } PipelineBiome replacement = replaceDefault.get(noiseSampler, viewPoint.worldX(), viewPoint.worldZ(), - viewPoint.worldSeed()); + viewPoint.worldSeed()); return replacement.isSelf() ? center : replacement; } } } return center; } - + @Override public int maxRelativeReadDistance() { return 1; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderStage.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderStage.java index 1ee2c0416..c1b5dbfba 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderStage.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderStage.java @@ -27,7 +27,7 @@ public class BorderStage implements Stage { private final ProbabilityCollection replace; private final String replaceTag; private final Vector2Int[] borderPoints; - + public BorderStage(String border, String replaceTag, NoiseSampler noiseSampler, ProbabilityCollection replace) { this.border = border; this.noiseSampler = noiseSampler; @@ -42,7 +42,7 @@ public class BorderStage implements Stage { } this.borderPoints = points.toArray(new Vector2Int[0]); } - + @Override public PipelineBiome apply(BiomeChunkImpl.ViewPoint viewPoint) { PipelineBiome center = viewPoint.getBiome(); @@ -57,23 +57,23 @@ public class BorderStage implements Stage { } return center; } - + @Override public Iterable getBiomes(Iterable biomes) { Set biomeSet = new HashSet<>(); biomes.forEach(biomeSet::add); biomeSet.addAll( - replace - .getContents() - .stream() - .filter( - Predicate.not(PipelineBiome::isSelf) - ) - .toList() - ); + replace + .getContents() + .stream() + .filter( + Predicate.not(PipelineBiome::isSelf) + ) + .toList() + ); return biomeSet; } - + @Override public int maxRelativeReadDistance() { return 1; diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceListStage.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceListStage.java index bc3a6db1a..4d86958a2 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceListStage.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceListStage.java @@ -24,7 +24,7 @@ public class ReplaceListStage implements Stage { private final NoiseSampler sampler; private final ProbabilityCollection replaceDefault; private final String defaultTag; - + public ReplaceListStage(Map> replace, String defaultTag, ProbabilityCollection replaceDefault, NoiseSampler sampler) { this.replace = replace; @@ -32,7 +32,7 @@ public class ReplaceListStage implements Stage { this.defaultTag = defaultTag; this.replaceDefault = replaceDefault; } - + @Override public PipelineBiome apply(BiomeChunkImpl.ViewPoint viewPoint) { PipelineBiome center = viewPoint.getBiome(); @@ -46,18 +46,18 @@ public class ReplaceListStage implements Stage { } return center; } - + @Override public int maxRelativeReadDistance() { return 0; } - + @Override public Iterable getBiomes(Iterable biomes) { Set biomeSet = new HashSet<>(); - + Set reject = new HashSet<>(); - + biomes.forEach(biome -> { if(!biome.getTags().contains(defaultTag) && !replace.containsKey(biome)) { biomeSet.add(biome); diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceStage.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceStage.java index 8ddab6fc4..b15986c82 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceStage.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceStage.java @@ -22,13 +22,13 @@ public class ReplaceStage implements Stage { private final String replaceableTag; private final ProbabilityCollection replace; private final NoiseSampler sampler; - + public ReplaceStage(String replaceable, ProbabilityCollection replace, NoiseSampler sampler) { this.replaceableTag = replaceable; this.replace = replace; this.sampler = sampler; } - + @Override public PipelineBiome apply(BiomeChunkImpl.ViewPoint viewPoint) { if(viewPoint.getBiome().getTags().contains(replaceableTag)) { @@ -37,12 +37,12 @@ public class ReplaceStage implements Stage { } return viewPoint.getBiome(); } - + @Override public int maxRelativeReadDistance() { return 0; } - + @Override public Iterable getBiomes(Iterable biomes) { Set biomeSet = new HashSet<>(); diff --git a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/SmoothStage.java b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/SmoothStage.java index fb40f86df..5b8cac234 100644 --- a/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/SmoothStage.java +++ b/common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/SmoothStage.java @@ -16,25 +16,25 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class SmoothStage implements Stage { - + private final NoiseSampler sampler; - + public SmoothStage(NoiseSampler sampler) { this.sampler = sampler; } - + @Override public PipelineBiome apply(BiomeChunkImpl.ViewPoint viewPoint) { PipelineBiome top = viewPoint.getRelativeBiome(1, 0); PipelineBiome bottom = viewPoint.getRelativeBiome(-1, 0); PipelineBiome left = viewPoint.getRelativeBiome(0, 1); PipelineBiome right = viewPoint.getRelativeBiome(0, -1); - + double roll = sampler.noise(viewPoint.worldSeed(), viewPoint.worldX(), viewPoint.worldZ()); - + boolean vert = Objects.equals(top, bottom); boolean horiz = Objects.equals(left, right); - + if(vert && horiz) { return roll > 0 ? roll > 0.25 ? left : right : @@ -48,7 +48,7 @@ public class SmoothStage implements Stage { } return viewPoint.getBiome(); } - + @Override public int maxRelativeReadDistance() { return 1; diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomeHolderImpl.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomeHolderImpl.java index cd38f61a4..73dc95675 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomeHolderImpl.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomeHolderImpl.java @@ -20,7 +20,7 @@ public class BiomeHolderImpl implements BiomeHolder { private final int width; private final int offset; private BiomeDelegate[][] biomes; - + public BiomeHolderImpl(int width, Vector2.Mutable origin) { width += 4; this.width = width; @@ -28,38 +28,38 @@ public class BiomeHolderImpl implements BiomeHolder { this.origin = origin; this.offset = 2; } - + private BiomeHolderImpl(BiomeDelegate[][] biomes, Vector2.Mutable origin, int width, int offset) { this.biomes = biomes; this.origin = origin; this.width = width; this.offset = 2 * offset; } - + @Override public BiomeHolder expand(BiomeExpander expander, long seed) { BiomeDelegate[][] old = biomes; int newWidth = width * 2 - 1; - + biomes = new BiomeDelegate[newWidth][newWidth]; - + for(int x = 0; x < width; x++) { for(int z = 0; z < width; z++) { biomes[x * 2][z * 2] = old[x][z]; if(z != width - 1) biomes[x * 2][z * 2 + 1] = expander.getBetween(x + origin.getX(), z + 1 + origin.getZ(), seed, old[x][z], - old[x][z + 1]); + old[x][z + 1]); if(x != width - 1) biomes[x * 2 + 1][z * 2] = expander.getBetween(x + 1 + origin.getX(), z + origin.getZ(), seed, old[x][z], - old[x + 1][z]); + old[x + 1][z]); if(x != width - 1 && z != width - 1) biomes[x * 2 + 1][z * 2 + 1] = expander.getBetween(x + 1 + origin.getX(), z + 1 + origin.getZ(), seed, old[x][z], - old[x + 1][z + 1], old[x][z + 1], old[x + 1][z]); + old[x + 1][z + 1], old[x][z + 1], old[x + 1][z]); } } return new BiomeHolderImpl(biomes, origin.setX(origin.getX() * 2 - 1).setZ(origin.getZ() * 2 - 1), newWidth, offset); } - + @Override public void mutate(BiomeMutator mutator, long seed) { for(int x = 0; x < width; x++) { @@ -69,7 +69,7 @@ public class BiomeHolderImpl implements BiomeHolder { } } } - + @Override public void fill(BiomeSource source, long seed) { for(int x = 0; x < width; x++) { @@ -78,14 +78,14 @@ public class BiomeHolderImpl implements BiomeHolder { } } } - + @Override public BiomeDelegate getBiome(int x, int z) { x += offset; z += offset; return getBiomeRaw(x, z); } - + @Override public BiomeDelegate getBiomeRaw(int x, int z) { if(x >= width || z >= width || x < 0 || z < 0) return null; diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipeline.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipeline.java index 311fd8f46..e5f5f9ed6 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipeline.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipeline.java @@ -22,14 +22,14 @@ public class BiomePipeline { private final List stages; private final int size; private final int init; - + private BiomePipeline(BiomeSource source, List stages, int size, int init) { this.source = source; this.stages = stages; this.size = size; this.init = init; } - + /** * Get biomes in a chunk * @@ -44,37 +44,37 @@ public class BiomePipeline { for(Stage stage : stages) holder = stage.apply(holder, seed); return holder; } - + public BiomeSource getSource() { return source; } - + public List getStages() { return Collections.unmodifiableList(stages); } - + public int getSize() { return size; } - + public static final class BiomePipelineBuilder { private final int init; private final List stages = new ArrayList<>(); private int expand; - + public BiomePipelineBuilder(int init) { this.init = init; expand = init; } - + public BiomePipeline build(BiomeSource source) { for(Stage stage : stages) { if(stage.isExpansion()) expand = expand * 2 - 1; } - + return new BiomePipeline(source, stages, expand, init); } - + public BiomePipelineBuilder addStage(Stage stage) { stages.add(stage); return this; diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java index ba91c8f9e..5df9c900c 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java @@ -40,7 +40,7 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class BiomePipelineAddon implements AddonInitializer { - + public static final TypeKey>> SOURCE_REGISTRY_KEY = new TypeKey<>() { }; public static final TypeKey>> STAGE_REGISTRY_KEY = new TypeKey<>() { @@ -50,47 +50,47 @@ public class BiomePipelineAddon implements AddonInitializer { private static final Logger logger = LoggerFactory.getLogger(BiomePipelineAddon.class); @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> { - CheckedRegistry>> providerRegistry = event.getPack().getOrCreateRegistry( - PROVIDER_REGISTRY_KEY); - providerRegistry.register(addon.key("PIPELINE"), BiomePipelineTemplate::new); - }) - .then(event -> { - CheckedRegistry>> sourceRegistry = event.getPack().getOrCreateRegistry( - SOURCE_REGISTRY_KEY); - sourceRegistry.register(addon.key("SAMPLER"), SamplerSourceTemplate::new); - }) - .then(event -> { - CheckedRegistry>> stageRegistry = event.getPack().getOrCreateRegistry( - STAGE_REGISTRY_KEY); - stageRegistry.register(addon.key("FRACTAL_EXPAND"), ExpanderStageTemplate::new); - stageRegistry.register(addon.key("SMOOTH"), SmoothMutatorTemplate::new); - stageRegistry.register(addon.key("REPLACE"), ReplaceMutatorTemplate::new); - stageRegistry.register(addon.key("REPLACE_LIST"), ReplaceListMutatorTemplate::new); - stageRegistry.register(addon.key("BORDER"), BorderMutatorTemplate::new); - stageRegistry.register(addon.key("BORDER_LIST"), BorderListMutatorTemplate::new); - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> { + CheckedRegistry>> providerRegistry = event.getPack().getOrCreateRegistry( + PROVIDER_REGISTRY_KEY); + providerRegistry.register(addon.key("PIPELINE"), BiomePipelineTemplate::new); + }) + .then(event -> { + CheckedRegistry>> sourceRegistry = event.getPack().getOrCreateRegistry( + SOURCE_REGISTRY_KEY); + sourceRegistry.register(addon.key("SAMPLER"), SamplerSourceTemplate::new); + }) + .then(event -> { + CheckedRegistry>> stageRegistry = event.getPack().getOrCreateRegistry( + STAGE_REGISTRY_KEY); + stageRegistry.register(addon.key("FRACTAL_EXPAND"), ExpanderStageTemplate::new); + stageRegistry.register(addon.key("SMOOTH"), SmoothMutatorTemplate::new); + stageRegistry.register(addon.key("REPLACE"), ReplaceMutatorTemplate::new); + stageRegistry.register(addon.key("REPLACE_LIST"), ReplaceListMutatorTemplate::new); + stageRegistry.register(addon.key("BORDER"), BorderMutatorTemplate::new); + stageRegistry.register(addon.key("BORDER_LIST"), BorderListMutatorTemplate::new); + }) + .failThrough(); platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPostLoadEvent.class) - .then(event -> { - Registry biomeRegistry = event.getPack().getRegistry(Biome.class); - event.getPack().applyLoader(BiomeDelegate.class, new BiomeDelegateLoader(biomeRegistry)); - }); - + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPostLoadEvent.class) + .then(event -> { + Registry biomeRegistry = event.getPack().getRegistry(Biome.class); + event.getPack().applyLoader(BiomeDelegate.class, new BiomeDelegateLoader(biomeRegistry)); + }); + if(platform.getTerraConfig().isDebugLog()) logger.warn( - "The biome-provider-pipeline addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the" + - " biome-provider-pipeline-v2 addon for future pack development instead."); + "The biome-provider-pipeline addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the" + + " biome-provider-pipeline-v2 addon for future pack development instead."); } } diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineColumn.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineColumn.java index 609d22ee1..1c03359af 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineColumn.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineColumn.java @@ -12,11 +12,11 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; class BiomePipelineColumn implements Column { private final int min; private final int max; - + private final int x; private final int z; private final Biome biome; - + protected BiomePipelineColumn(BiomeProvider biomeProvider, int min, int max, int x, int z, long seed) { this.min = min; this.max = max; @@ -24,44 +24,44 @@ class BiomePipelineColumn implements Column { this.z = z; this.biome = biomeProvider.getBiome(x, 0, z, seed); } - + @Override public int getMinY() { return min; } - + @Override public int getMaxY() { return max; } - + @Override public int getX() { return x; } - + @Override public int getZ() { return z; } - + @Override public Biome get(int y) { return biome; } - + @Override public void forRanges(int resolution, IntIntObjConsumer consumer) { consumer.accept(min, max, biome); } - + @Override public void forEach(Consumer consumer) { for(int y = min; y < max; y++) { consumer.accept(biome); } } - + @Override public void forEach(IntObjConsumer consumer) { for(int y = min; y < max; y++) { diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java index 7f4287e70..ef952736d 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java @@ -32,18 +32,18 @@ public class BiomePipelineProvider implements BiomeProvider { private final int resolution; private final NoiseSampler mutator; private final double noiseAmp; - + private final Set biomes; - + public BiomePipelineProvider(BiomePipeline pipeline, int resolution, NoiseSampler mutator, double noiseAmp) { this.resolution = resolution; this.mutator = mutator; this.noiseAmp = noiseAmp; holderCache = Caffeine.newBuilder() - .maximumSize(1024) - .build(key -> pipeline.getBiomes(key.x, key.z, key.seed)); + .maximumSize(1024) + .build(key -> pipeline.getBiomes(key.x, key.z, key.seed)); this.pipeline = pipeline; - + Set biomeSet = new HashSet<>(); pipeline.getSource().getBiomes().forEach(biomeSet::add); Iterable result = biomeSet; @@ -54,16 +54,16 @@ public class BiomePipelineProvider implements BiomeProvider { Iterable finalResult = result; result.forEach(biomeDelegate -> { if(biomeDelegate.isEphemeral()) { - + StringBuilder biomeList = new StringBuilder("\n"); StreamSupport.stream(finalResult.spliterator(), false) - .sorted(Comparator.comparing(StringIdentifiable::getID)) - .forEach(delegate -> biomeList - .append(" - ") - .append(delegate.getID()) - .append(':') - .append(delegate.getClass().getCanonicalName()) - .append('\n')); + .sorted(Comparator.comparing(StringIdentifiable::getID)) + .forEach(delegate -> biomeList + .append(" - ") + .append(delegate.getID()) + .append(':') + .append(delegate.getClass().getCanonicalName()) + .append('\n')); throw new IllegalArgumentException("Biome Pipeline leaks ephemeral biome \"" + biomeDelegate.getID() + "\". Ensure there is a stage to guarantee replacement of the ephemeral biome. Biomes: " + biomeList); @@ -71,46 +71,46 @@ public class BiomePipelineProvider implements BiomeProvider { this.biomes.add(biomeDelegate.getBiome()); }); } - + @Override public Biome getBiome(int x, int y, int z, long seed) { return getBiome(x, z, seed); } - + public Biome getBiome(int x, int z, long seed) { x += mutator.noise(seed + 1, x, z) * noiseAmp; z += mutator.noise(seed + 2, x, z) * noiseAmp; - - + + x /= resolution; z /= resolution; - + int fdX = Math.floorDiv(x, pipeline.getSize()); int fdZ = Math.floorDiv(z, pipeline.getSize()); return holderCache.get(new SeededVector(fdX, fdZ, seed)).getBiome(x - fdX * pipeline.getSize(), - z - fdZ * pipeline.getSize()).getBiome(); + z - fdZ * pipeline.getSize()).getBiome(); } - + @Override public Optional getBaseBiome(int x, int z, long seed) { return Optional.of(getBiome(x, z, seed)); } - + @Override public Iterable getBiomes() { return biomes; } - + @Override public Column getColumn(int x, int z, long seed, int min, int max) { return new BiomePipelineColumn(this, min, max, x, z, seed); } - + @Override public int resolution() { return resolution; } - + private record SeededVector(int x, int z, long seed) { @Override public boolean equals(Object obj) { @@ -119,7 +119,7 @@ public class BiomePipelineProvider implements BiomeProvider { } return false; } - + @Override public int hashCode() { int code = x; diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/BiomeHolder.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/BiomeHolder.java index a5a51a6c5..5acb166a1 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/BiomeHolder.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/BiomeHolder.java @@ -15,12 +15,12 @@ import com.dfsek.terra.addons.biome.pipeline.source.BiomeSource; public interface BiomeHolder { BiomeHolder expand(BiomeExpander expander, long seed); - + void mutate(BiomeMutator mutator, long seed); - + void fill(BiomeSource source, long seed); - + BiomeDelegate getBiome(int x, int z); - + BiomeDelegate getBiomeRaw(int x, int z); } diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/BiomeDelegate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/BiomeDelegate.java index 7e339285a..c7e96c01e 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/BiomeDelegate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/BiomeDelegate.java @@ -10,26 +10,26 @@ public interface BiomeDelegate extends StringIdentifiable { static BiomeDelegate ephemeral(String id) { return new EphemeralBiomeDelegate(id); } - + static BiomeDelegate from(Biome biome) { return new DelegatedBiome(biome); } - + static BiomeDelegate self() { return SelfDelegate.INSTANCE; } - + Biome getBiome(); - + Set getTags(); - + default boolean isEphemeral() { return false; } - + default boolean isSelf() { return false; } - - + + } diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/DelegatedBiome.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/DelegatedBiome.java index 4085f6a43..ea724928f 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/DelegatedBiome.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/DelegatedBiome.java @@ -7,32 +7,32 @@ import com.dfsek.terra.api.world.biome.Biome; final class DelegatedBiome implements BiomeDelegate { private final Biome biome; - + public DelegatedBiome(Biome biome) { this.biome = biome; } - + @Override public Biome getBiome() { return biome; } - + @Override public int hashCode() { return biome.hashCode(); } - + @Override public boolean equals(Object obj) { if(!(obj instanceof DelegatedBiome that)) return false; return that.biome.equals(this.biome); } - + @Override public Set getTags() { return biome.getTags(); } - + @Override public String getID() { return biome.getID(); diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/EphemeralBiomeDelegate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/EphemeralBiomeDelegate.java index aed7d584f..e8e000dff 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/EphemeralBiomeDelegate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/EphemeralBiomeDelegate.java @@ -1,51 +1,51 @@ package com.dfsek.terra.addons.biome.pipeline.api.delegate; -import com.dfsek.terra.api.world.biome.Biome; - import java.util.HashSet; import java.util.Set; +import com.dfsek.terra.api.world.biome.Biome; + final class EphemeralBiomeDelegate implements BiomeDelegate { private final Set tags; private final String id; - + public EphemeralBiomeDelegate(String id) { this.id = id; tags = new HashSet<>(); tags.add(id); tags.add("ALL"); } - + @Override public Biome getBiome() { throw new UnsupportedOperationException("Cannot get biome from ephemeral delegate"); } - + @Override public Set getTags() { return tags; } - + @Override public String getID() { return id; } - + @Override public boolean isEphemeral() { return true; } - + @Override public int hashCode() { return id.hashCode(); } - + @Override public boolean equals(Object obj) { if(!(obj instanceof EphemeralBiomeDelegate that)) return false; - + return this.id.equals(that.id); } } diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/SelfDelegate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/SelfDelegate.java index ad6a4a721..6b62818d2 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/SelfDelegate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/delegate/SelfDelegate.java @@ -8,31 +8,31 @@ import com.dfsek.terra.api.world.biome.Biome; final class SelfDelegate implements BiomeDelegate { public static final SelfDelegate INSTANCE = new SelfDelegate(); - + private SelfDelegate() { - + } - + @Override public Biome getBiome() { throw new UnsupportedOperationException("Cannot get biome from self delegate"); } - + @Override public boolean isSelf() { return true; } - + @Override public boolean isEphemeral() { return true; } - + @Override public Set getTags() { return Collections.emptySet(); } - + @Override public String getID() { return "SELF"; diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/Stage.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/Stage.java index f82fb8438..d007c6c8f 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/Stage.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/Stage.java @@ -13,8 +13,8 @@ import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate; public interface Stage { BiomeHolder apply(BiomeHolder in, long seed); - + boolean isExpansion(); - + Iterable getBiomes(Iterable biomes); } diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/type/BiomeMutator.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/type/BiomeMutator.java index cc5453efa..6362b582d 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/type/BiomeMutator.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/stage/type/BiomeMutator.java @@ -13,23 +13,23 @@ import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate; public interface BiomeMutator { BiomeDelegate mutate(ViewPoint viewPoint, double x, double z, long seed); - + default Iterable getBiomes(Iterable biomes) { return biomes; } - + class ViewPoint { private final BiomeHolder biomes; private final int offX; private final int offZ; - + public ViewPoint(BiomeHolder biomes, int offX, int offZ) { this.biomes = biomes; this.offX = offX; this.offZ = offZ; } - - + + public BiomeDelegate getBiome(int x, int z) { return biomes.getBiomeRaw(x + offX, z + offZ); } diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomeDelegateLoader.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomeDelegateLoader.java index c416e4804..9c755ce2d 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomeDelegateLoader.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomeDelegateLoader.java @@ -15,18 +15,18 @@ import com.dfsek.terra.api.world.biome.Biome; public class BiomeDelegateLoader implements TypeLoader { private final Registry biomeRegistry; - + public BiomeDelegateLoader(Registry biomeRegistry) { this.biomeRegistry = biomeRegistry; } - + @Override public BiomeDelegate load(@NotNull AnnotatedType t, @NotNull Object c, @NotNull ConfigLoader loader, DepthTracker depthTracker) throws LoadException { if(c.equals("SELF")) return BiomeDelegate.self(); return biomeRegistry - .getByID((String) c) - .map(BiomeDelegate::from) - .orElseGet(() -> BiomeDelegate.ephemeral((String) c)); + .getByID((String) c) + .map(BiomeDelegate::from) + .orElseGet(() -> BiomeDelegate.ephemeral((String) c)); } } diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomePipelineTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomePipelineTemplate.java index d1a6774eb..491f019ba 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomePipelineTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomePipelineTemplate.java @@ -35,15 +35,15 @@ public class BiomePipelineTemplate extends BiomeProviderTemplate { and subtract 1. (The size is also printed to the server console if you have debug mode enabled)""") private @Meta int initialSize = 2; - + @Value("pipeline.source") @Description("The Biome Source to use for initial population of biomes.") private @Meta BiomeSource source; - + @Value("pipeline.stages") @Description("A list of pipeline stages to apply to the result of #source") private @Meta List<@Meta Stage> stages; - + @Override public BiomeProvider get() { BiomePipeline.BiomePipelineBuilder biomePipelineBuilder = new BiomePipeline.BiomePipelineBuilder(initialSize); diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/SamplerSourceTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/SamplerSourceTemplate.java index 469a94c92..b79c2e79a 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/SamplerSourceTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/SamplerSourceTemplate.java @@ -22,11 +22,11 @@ public class SamplerSourceTemplate extends SourceTemplate { @Value("sampler") @Description("The sampler used to distribute biomes.") private @Meta NoiseSampler noise; - + @Value("biomes") @Description("The biomes to be distributed.") private @Meta ProbabilityCollection<@Meta BiomeDelegate> biomes; - + @Override public BiomeSource get() { return new SamplerSource(biomes, noise); diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderListMutatorTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderListMutatorTemplate.java index 8dc5542a6..5cb7287e1 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderListMutatorTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderListMutatorTemplate.java @@ -24,17 +24,17 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; public class BorderListMutatorTemplate extends StageTemplate { @Value("from") private @Meta String from; - + @Value("default-replace") private @Meta String defaultReplace; - + @Value("default-to") private @Meta ProbabilityCollection<@Meta BiomeDelegate> defaultTo; - + @Value("replace") private @Meta Map<@Meta BiomeDelegate, @Meta ProbabilityCollection<@Meta BiomeDelegate>> replace; - - + + @Override public Stage get() { return new MutatorStage(new BorderListMutator(replace, from, defaultReplace, noise, defaultTo)); diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderMutatorTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderMutatorTemplate.java index 4382334be..f9b8888df 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderMutatorTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderMutatorTemplate.java @@ -22,13 +22,13 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; public class BorderMutatorTemplate extends StageTemplate { @Value("from") private @Meta String from; - + @Value("replace") private @Meta String replace; - + @Value("to") private @Meta ProbabilityCollection<@Meta BiomeDelegate> to; - + @Override public Stage get() { return new MutatorStage(new BorderMutator(from, replace, noise, to)); diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceListMutatorTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceListMutatorTemplate.java index 6e1233856..8522f0488 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceListMutatorTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceListMutatorTemplate.java @@ -24,13 +24,13 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; public class ReplaceListMutatorTemplate extends StageTemplate { @Value("default-from") private @Meta String defaultFrom; - + @Value("default-to") private @Meta ProbabilityCollection<@Meta BiomeDelegate> defaultTo; - + @Value("to") private @Meta Map<@Meta BiomeDelegate, @Meta ProbabilityCollection<@Meta BiomeDelegate>> replace; - + @Override public Stage get() { return new MutatorStage(new ReplaceListMutator(replace, defaultFrom, defaultTo, noise)); diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceMutatorTemplate.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceMutatorTemplate.java index 83610a08f..48e3da95b 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceMutatorTemplate.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceMutatorTemplate.java @@ -22,10 +22,10 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; public class ReplaceMutatorTemplate extends StageTemplate { @Value("from") private @Meta String from; - + @Value("to") private @Meta ProbabilityCollection<@Meta BiomeDelegate> to; - + @Override public Stage get() { return new MutatorStage(new ReplaceMutator(from, to, noise)); diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/expand/FractalExpander.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/expand/FractalExpander.java index ce63329ef..aa06967e2 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/expand/FractalExpander.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/expand/FractalExpander.java @@ -15,11 +15,11 @@ import com.dfsek.terra.api.util.MathUtil; public class FractalExpander implements BiomeExpander { private final NoiseSampler sampler; - + public FractalExpander(NoiseSampler sampler) { this.sampler = sampler; } - + @Override public BiomeDelegate getBetween(double x, double z, long seed, BiomeDelegate... others) { return others[MathUtil.normalizeIndex(sampler.noise(seed, x, z), others.length)]; diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderListMutator.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderListMutator.java index 249b3fe62..21ed29efe 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderListMutator.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderListMutator.java @@ -24,7 +24,7 @@ public class BorderListMutator implements BiomeMutator { private final ProbabilityCollection replaceDefault; private final String defaultReplace; private final Map> replace; - + public BorderListMutator(Map> replace, String border, String defaultReplace, NoiseSampler noiseSampler, ProbabilityCollection replaceDefault) { this.border = border; @@ -33,7 +33,7 @@ public class BorderListMutator implements BiomeMutator { this.defaultReplace = defaultReplace; this.replace = replace; } - + @Override public BiomeDelegate mutate(ViewPoint viewPoint, double x, double z, long seed) { BiomeDelegate origin = viewPoint.getBiome(0, 0); @@ -55,7 +55,7 @@ public class BorderListMutator implements BiomeMutator { } return origin; } - + @Override public Iterable getBiomes(Iterable biomes) { Set biomeSet = new HashSet<>(); diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderMutator.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderMutator.java index fef5b3d03..43fd9f663 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderMutator.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderMutator.java @@ -22,14 +22,14 @@ public class BorderMutator implements BiomeMutator { private final NoiseSampler noiseSampler; private final ProbabilityCollection replace; private final String replaceTag; - + public BorderMutator(String border, String replaceTag, NoiseSampler noiseSampler, ProbabilityCollection replace) { this.border = border; this.noiseSampler = noiseSampler; this.replace = replace; this.replaceTag = replaceTag; } - + @Override public BiomeDelegate mutate(ViewPoint viewPoint, double x, double z, long seed) { BiomeDelegate origin = viewPoint.getBiome(0, 0); @@ -47,20 +47,20 @@ public class BorderMutator implements BiomeMutator { } return origin; } - + @Override public Iterable getBiomes(Iterable biomes) { Set biomeSet = new HashSet<>(); biomes.forEach(biomeSet::add); biomeSet.addAll( - replace - .getContents() - .stream() - .filter( - Predicate.not(BiomeDelegate::isSelf) - ) - .toList() - ); + replace + .getContents() + .stream() + .filter( + Predicate.not(BiomeDelegate::isSelf) + ) + .toList() + ); return biomeSet; } } diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceListMutator.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceListMutator.java index e6dff1b50..3939b133b 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceListMutator.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceListMutator.java @@ -23,7 +23,7 @@ public class ReplaceListMutator implements BiomeMutator { private final NoiseSampler sampler; private final ProbabilityCollection replaceDefault; private final String defaultTag; - + public ReplaceListMutator(Map> replace, String defaultTag, ProbabilityCollection replaceDefault, NoiseSampler sampler) { this.replace = replace; @@ -31,7 +31,7 @@ public class ReplaceListMutator implements BiomeMutator { this.defaultTag = defaultTag; this.replaceDefault = replaceDefault; } - + @Override public BiomeDelegate mutate(ViewPoint viewPoint, double x, double z, long seed) { BiomeDelegate center = viewPoint.getBiome(0, 0); @@ -45,13 +45,13 @@ public class ReplaceListMutator implements BiomeMutator { } return center; } - + @Override public Iterable getBiomes(Iterable biomes) { Set biomeSet = new HashSet<>(); - + Set reject = new HashSet<>(); - + biomes.forEach(biome -> { if(!biome.getTags().contains(defaultTag) && !replace.containsKey(biome)) { biomeSet.add(biome); diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceMutator.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceMutator.java index 979679826..f64871b39 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceMutator.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceMutator.java @@ -21,13 +21,13 @@ public class ReplaceMutator implements BiomeMutator { private final String replaceableTag; private final ProbabilityCollection replace; private final NoiseSampler sampler; - + public ReplaceMutator(String replaceable, ProbabilityCollection replace, NoiseSampler sampler) { this.replaceableTag = replaceable; this.replace = replace; this.sampler = sampler; } - + @Override public BiomeDelegate mutate(ViewPoint viewPoint, double x, double z, long seed) { if(viewPoint.getBiome(0, 0).getTags().contains(replaceableTag)) { @@ -36,7 +36,7 @@ public class ReplaceMutator implements BiomeMutator { } return viewPoint.getBiome(0, 0); } - + @Override public Iterable getBiomes(Iterable biomes) { Set biomeSet = new HashSet<>(); diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/SmoothMutator.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/SmoothMutator.java index 97395266b..8d8d01bf2 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/SmoothMutator.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/SmoothMutator.java @@ -16,31 +16,31 @@ import com.dfsek.terra.api.util.MathUtil; public class SmoothMutator implements BiomeMutator { - + private final NoiseSampler sampler; - + public SmoothMutator(NoiseSampler sampler) { this.sampler = sampler; } - + @Override public BiomeDelegate mutate(ViewPoint viewPoint, double x, double z, long seed) { BiomeDelegate top = viewPoint.getBiome(1, 0); BiomeDelegate bottom = viewPoint.getBiome(-1, 0); BiomeDelegate left = viewPoint.getBiome(0, 1); BiomeDelegate right = viewPoint.getBiome(0, -1); - - + + boolean vert = Objects.equals(top, bottom) && top != null; boolean horiz = Objects.equals(left, right) && left != null; - + if(vert && horiz) { return MathUtil.normalizeIndex(sampler.noise(seed, x, z), 2) == 0 ? left : top; } - + if(vert) return top; if(horiz) return left; - + return viewPoint.getBiome(0, 0); } } diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/BiomeSource.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/BiomeSource.java index 96cb20ef7..56b67b7f4 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/BiomeSource.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/BiomeSource.java @@ -12,6 +12,6 @@ import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate; public interface BiomeSource { BiomeDelegate getBiome(double x, double z, long seed); - + Iterable getBiomes(); } diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/SamplerSource.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/SamplerSource.java index 2dff2c198..7fc981d31 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/SamplerSource.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/SamplerSource.java @@ -15,17 +15,17 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; public class SamplerSource implements BiomeSource { private final ProbabilityCollection biomes; private final NoiseSampler sampler; - + public SamplerSource(ProbabilityCollection biomes, NoiseSampler sampler) { this.biomes = biomes; this.sampler = sampler; } - + @Override public BiomeDelegate getBiome(double x, double z, long seed) { return biomes.get(sampler, x, z, seed); } - + @Override public Iterable getBiomes() { return biomes.getContents(); diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/ExpanderStage.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/ExpanderStage.java index c0219faa4..45602fb6b 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/ExpanderStage.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/ExpanderStage.java @@ -15,21 +15,21 @@ import com.dfsek.terra.addons.biome.pipeline.api.stage.type.BiomeExpander; public class ExpanderStage implements Stage { private final BiomeExpander expander; - + public ExpanderStage(BiomeExpander expander) { this.expander = expander; } - + @Override public BiomeHolder apply(BiomeHolder in, long seed) { return in.expand(expander, seed); } - + @Override public boolean isExpansion() { return true; } - + @Override public Iterable getBiomes(Iterable biomes) { return biomes; diff --git a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/MutatorStage.java b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/MutatorStage.java index 86d679a78..8efbaaa27 100644 --- a/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/MutatorStage.java +++ b/common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/MutatorStage.java @@ -15,27 +15,27 @@ import com.dfsek.terra.addons.biome.pipeline.api.stage.type.BiomeMutator; public class MutatorStage implements Stage { private final BiomeMutator mutator; - + public MutatorStage(BiomeMutator mutator) { this.mutator = mutator; } - + @Override public BiomeHolder apply(BiomeHolder in, long seed) { in.mutate(mutator, seed); return in; } - + @Override public boolean isExpansion() { return false; } - + @Override public Iterable getBiomes(Iterable biomes) { return mutator.getBiomes(biomes); } - + public enum Type { REPLACE, REPLACE_LIST, diff --git a/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProvider.java b/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProvider.java index 89e88c3fd..839508981 100644 --- a/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProvider.java +++ b/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProvider.java @@ -16,21 +16,21 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class SingleBiomeProvider implements BiomeProvider { private final Biome biome; - + public SingleBiomeProvider(Biome biome) { this.biome = biome; } - + @Override public Biome getBiome(int x, int y, int z, long seed) { return biome; } - + @Override public Optional getBaseBiome(int x, int z, long seed) { return Optional.of(biome); } - + @Override public Iterable getBiomes() { return Collections.singleton(biome); diff --git a/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderAddon.java b/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderAddon.java index 2362cc028..ebf355e72 100644 --- a/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderAddon.java +++ b/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderAddon.java @@ -25,23 +25,23 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class SingleBiomeProviderAddon implements AddonInitializer { public static final TypeKey>> PROVIDER_REGISTRY_KEY = new TypeKey<>() { }; - + @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> { - CheckedRegistry>> providerRegistry = event.getPack().getOrCreateRegistry( - PROVIDER_REGISTRY_KEY); - providerRegistry.register(addon.key("SINGLE"), SingleBiomeProviderTemplate::new); - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> { + CheckedRegistry>> providerRegistry = event.getPack().getOrCreateRegistry( + PROVIDER_REGISTRY_KEY); + providerRegistry.register(addon.key("SINGLE"), SingleBiomeProviderTemplate::new); + }) + .failThrough(); } } diff --git a/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderTemplate.java b/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderTemplate.java index f0f329275..3a4c3f05e 100644 --- a/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderTemplate.java +++ b/common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderTemplate.java @@ -18,7 +18,7 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class SingleBiomeProviderTemplate implements ObjectTemplate { @Value("biome") private @Meta Biome biome; - + @Override public BiomeProvider get() { return new SingleBiomeProvider(biome); diff --git a/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/BiomeQueryAPIAddon.java b/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/BiomeQueryAPIAddon.java index 9933ea49e..40afa4130 100644 --- a/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/BiomeQueryAPIAddon.java +++ b/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/BiomeQueryAPIAddon.java @@ -21,26 +21,26 @@ public class BiomeQueryAPIAddon implements AddonInitializer { private Platform platform; @Inject private BaseAddon addon; - + @Override public void initialize() { - + platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPostLoadEvent.class) - .then(event -> { - Collection biomes = event - .getPack() - .getRegistry(Biome.class) - .entries(); - - BiomeTagFlattener flattener = new BiomeTagFlattener(biomes - .stream() - .flatMap(biome -> biome.getTags().stream()) - .toList()); - - biomes.forEach(biome -> biome.getContext().put(BIOME_TAG_KEY, new BiomeTagHolder(biome, flattener))); - }) - .global(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPostLoadEvent.class) + .then(event -> { + Collection biomes = event + .getPack() + .getRegistry(Biome.class) + .entries(); + + BiomeTagFlattener flattener = new BiomeTagFlattener(biomes + .stream() + .flatMap(biome -> biome.getTags().stream()) + .toList()); + + biomes.forEach(biome -> biome.getContext().put(BIOME_TAG_KEY, new BiomeTagHolder(biome, flattener))); + }) + .global(); } } diff --git a/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/api/BiomeQueries.java b/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/api/BiomeQueries.java index 6e36b7a45..4066e048e 100644 --- a/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/api/BiomeQueries.java +++ b/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/api/BiomeQueries.java @@ -8,9 +8,9 @@ import com.dfsek.terra.api.world.biome.Biome; public final class BiomeQueries { private BiomeQueries() { - + } - + public static Predicate has(String tag) { return new SingleTagQuery(tag); } diff --git a/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/impl/BiomeTagFlattener.java b/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/impl/BiomeTagFlattener.java index 98a416295..c52851598 100644 --- a/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/impl/BiomeTagFlattener.java +++ b/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/impl/BiomeTagFlattener.java @@ -5,15 +5,15 @@ import java.util.List; public class BiomeTagFlattener { private final List tags; - + public BiomeTagFlattener(List tags) { this.tags = tags; } - + public int index(String tag) { return tags.indexOf(tag); } - + public int size() { return tags.size(); } diff --git a/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/impl/BiomeTagHolder.java b/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/impl/BiomeTagHolder.java index 0e4ab707b..4d4f34fea 100644 --- a/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/impl/BiomeTagHolder.java +++ b/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/impl/BiomeTagHolder.java @@ -7,7 +7,7 @@ import com.dfsek.terra.api.world.biome.Biome; public class BiomeTagHolder implements Properties { private final boolean[] tags; private final BiomeTagFlattener flattener; - + public BiomeTagHolder(Biome biome, BiomeTagFlattener flattener) { this.tags = new boolean[flattener.size()]; this.flattener = flattener; @@ -15,11 +15,11 @@ public class BiomeTagHolder implements Properties { tags[flattener.index(tag)] = true; } } - + boolean get(int index) { return tags[index]; } - + public BiomeTagFlattener getFlattener() { return flattener; } diff --git a/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/impl/SingleTagQuery.java b/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/impl/SingleTagQuery.java index eef1a0a56..1e39408c2 100644 --- a/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/impl/SingleTagQuery.java +++ b/common/addons/biome-query-api/src/main/java/com/dfsek/terra/addons/biome/query/impl/SingleTagQuery.java @@ -9,23 +9,23 @@ import com.dfsek.terra.api.world.biome.Biome; public class SingleTagQuery implements Predicate { private final String tag; private int tagIndex = -1; - + public SingleTagQuery(String tag) { this.tag = tag; } - + @Override public boolean test(Biome biome) { if(tagIndex < 0) { tagIndex = biome - .getContext() - .get(BiomeQueryAPIAddon.BIOME_TAG_KEY) - .getFlattener() - .index(tag); - } - return biome .getContext() .get(BiomeQueryAPIAddon.BIOME_TAG_KEY) - .get(tagIndex); + .getFlattener() + .index(tag); + } + return biome + .getContext() + .get(BiomeQueryAPIAddon.BIOME_TAG_KEY) + .get(tagIndex); } } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/NoiseChunkGenerator3DAddon.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/NoiseChunkGenerator3DAddon.java index 69fa4be73..89f6e038c 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/NoiseChunkGenerator3DAddon.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/NoiseChunkGenerator3DAddon.java @@ -31,54 +31,54 @@ import com.dfsek.terra.api.world.chunk.generation.util.provider.ChunkGeneratorPr public class NoiseChunkGenerator3DAddon implements AddonInitializer { @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { PropertyKey paletteInfoPropertyKey = Context.create(BiomePaletteInfo.class); PropertyKey noisePropertiesPropertyKey = Context.create(BiomeNoiseProperties.class); platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .priority(1000) - .then(event -> { - - event.getPack().applyLoader(SlantHolder.CalculationMethod.class, - (type, o, loader, depthTracker) -> SlantHolder.CalculationMethod.valueOf((String) o)); - - NoiseChunkGeneratorPackConfigTemplate config = event.loadTemplate(new NoiseChunkGeneratorPackConfigTemplate()); - event.getPack().getContext().put(config); - - event.getPack() - .getOrCreateRegistry(ChunkGeneratorProvider.class) - .register(addon.key("NOISE_3D"), - pack -> new NoiseChunkGenerator3D(pack, platform, config.getElevationBlend(), - config.getHorizontalRes(), - config.getVerticalRes(), noisePropertiesPropertyKey, - paletteInfoPropertyKey)); - event.getPack() - .applyLoader(SlantHolder.Layer.class, SlantLayerTemplate::new); - }) - .failThrough(); - + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .priority(1000) + .then(event -> { + + event.getPack().applyLoader(SlantHolder.CalculationMethod.class, + (type, o, loader, depthTracker) -> SlantHolder.CalculationMethod.valueOf((String) o)); + + NoiseChunkGeneratorPackConfigTemplate config = event.loadTemplate(new NoiseChunkGeneratorPackConfigTemplate()); + event.getPack().getContext().put(config); + + event.getPack() + .getOrCreateRegistry(ChunkGeneratorProvider.class) + .register(addon.key("NOISE_3D"), + pack -> new NoiseChunkGenerator3D(pack, platform, config.getElevationBlend(), + config.getHorizontalRes(), + config.getVerticalRes(), noisePropertiesPropertyKey, + paletteInfoPropertyKey)); + event.getPack() + .applyLoader(SlantHolder.Layer.class, SlantLayerTemplate::new); + }) + .failThrough(); + platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigurationLoadEvent.class) - .then(event -> { - if(event.is(Biome.class)) { - NoiseChunkGeneratorPackConfigTemplate config = event.getPack().getContext().get( - NoiseChunkGeneratorPackConfigTemplate.class); - - event.getLoadedObject(Biome.class).getContext().put(paletteInfoPropertyKey, - event.load(new BiomePaletteTemplate(platform, - config.getSlantCalculationMethod())) - .get()); - event.getLoadedObject(Biome.class).getContext().put(noisePropertiesPropertyKey, - event.load(new BiomeNoiseConfigTemplate()).get()); - } - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigurationLoadEvent.class) + .then(event -> { + if(event.is(Biome.class)) { + NoiseChunkGeneratorPackConfigTemplate config = event.getPack().getContext().get( + NoiseChunkGeneratorPackConfigTemplate.class); + + event.getLoadedObject(Biome.class).getContext().put(paletteInfoPropertyKey, + event.load(new BiomePaletteTemplate(platform, + config.getSlantCalculationMethod())) + .get()); + event.getLoadedObject(Biome.class).getContext().put(noisePropertiesPropertyKey, + event.load(new BiomeNoiseConfigTemplate()).get()); + } + }) + .failThrough(); } } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/NoiseChunkGeneratorPackConfigTemplate.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/NoiseChunkGeneratorPackConfigTemplate.java index db9922980..c3828bbbf 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/NoiseChunkGeneratorPackConfigTemplate.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/NoiseChunkGeneratorPackConfigTemplate.java @@ -13,31 +13,31 @@ public class NoiseChunkGeneratorPackConfigTemplate implements ConfigTemplate, Pr @Value("blend.terrain.elevation") @Default private @Meta int elevationBlend = 4; - + @Value("carving.resolution.horizontal") @Default private @Meta int horizontalRes = 4; - + @Value("carving.resolution.vertical") @Default private @Meta int verticalRes = 2; - + @Value("slant.calculation-method") @Default private SlantHolder.@Meta CalculationMethod slantCalculationMethod = SlantHolder.CalculationMethod.Derivative; - + public int getElevationBlend() { return elevationBlend; } - + public int getHorizontalRes() { return horizontalRes; } - + public int getVerticalRes() { return verticalRes; } - + public SlantHolder.CalculationMethod getSlantCalculationMethod() { return slantCalculationMethod; } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/noise/BiomeNoiseConfigTemplate.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/noise/BiomeNoiseConfigTemplate.java index cd034f012..a0231bce8 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/noise/BiomeNoiseConfigTemplate.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/noise/BiomeNoiseConfigTemplate.java @@ -11,34 +11,34 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class BiomeNoiseConfigTemplate implements ObjectTemplate { @Value("terrain.sampler") private @Meta NoiseSampler baseSampler; - + @Value("terrain.sampler-2d") @Default private @Meta NoiseSampler elevationSampler = NoiseSampler.zero(); - + @Value("carving.sampler") @Default private @Meta NoiseSampler carvingSampler = NoiseSampler.zero(); - + @Value("terrain.blend.distance") @Default private @Meta int blendDistance = 3; - + @Value("terrain.blend.weight") @Default private @Meta double blendWeight = 1; - + @Value("terrain.blend.step") @Default private @Meta int blendStep = 4; - + @Value("terrain.blend.weight-2d") @Default private @Meta double elevationWeight = 1; - + @Override public BiomeNoiseProperties get() { return new BiomeNoiseProperties(baseSampler, elevationSampler, carvingSampler, blendDistance, blendStep, blendWeight, - elevationWeight, new ThreadLocalNoiseHolder()); + elevationWeight, new ThreadLocalNoiseHolder()); } } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/noise/ThreadLocalNoiseHolder.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/noise/ThreadLocalNoiseHolder.java index fbb9deed8..22cb181ca 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/noise/ThreadLocalNoiseHolder.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/noise/ThreadLocalNoiseHolder.java @@ -5,14 +5,14 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class ThreadLocalNoiseHolder { private final ThreadLocal holder = ThreadLocal.withInitial(Holder::new); - + public double getNoise(NoiseSampler sampler, int x, int y, int z, long seed) { Holder holder = this.holder.get(); - + if(holder.init && holder.y == y && holder.z == z && holder.x == x && holder.seed == seed) { return holder.noise; } - + double noise = sampler.noise(seed, x, y, z); holder.noise = noise; holder.x = x; @@ -22,7 +22,7 @@ public class ThreadLocalNoiseHolder { holder.init = true; return noise; } - + private static final class Holder { int x, y, z; boolean init = false; diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java index b473a82f3..2d479f1a2 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java @@ -12,6 +12,10 @@ import com.dfsek.tectonic.api.config.template.annotations.Description; import com.dfsek.tectonic.api.config.template.annotations.Value; import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; +import java.util.Collections; +import java.util.List; +import java.util.Map; + import com.dfsek.terra.addons.chunkgenerator.palette.BiomePaletteInfo; import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolder; import com.dfsek.terra.addons.chunkgenerator.palette.slant.SlantHolder; @@ -20,10 +24,6 @@ import com.dfsek.terra.api.block.state.BlockState; import com.dfsek.terra.api.config.meta.Meta; import com.dfsek.terra.api.world.chunk.generation.util.Palette; -import java.util.Collections; -import java.util.List; -import java.util.Map; - public class BiomePaletteTemplate implements ObjectTemplate { private final Platform platform; @@ -55,15 +55,15 @@ public class BiomePaletteTemplate implements ObjectTemplate { @Value("carving.update-palette") @Default private @Meta boolean updatePalette = false; - + public BiomePaletteTemplate(Platform platform, SlantHolder.CalculationMethod slantCalculationMethod) { this.platform = platform; this.slantCalculationMethod = slantCalculationMethod; } - + @Override public BiomePaletteInfo get() { return new BiomePaletteInfo(PaletteHolder.of(palettes), SlantHolder.of(slantLayers, slantDepth, slantCalculationMethod), - oceanPalette, seaLevel, updatePalette); + oceanPalette, seaLevel, updatePalette); } } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/slant/SlantLayerTemplate.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/slant/SlantLayerTemplate.java index 5a4fd646d..8be00abe6 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/slant/SlantLayerTemplate.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/slant/SlantLayerTemplate.java @@ -13,13 +13,13 @@ import com.dfsek.terra.api.world.chunk.generation.util.Palette; public class SlantLayerTemplate implements ObjectTemplate { - + @Value("threshold") private @Meta double threshold; - + @Value("palette") private @Meta List<@Meta Map<@Meta Palette, @Meta Integer>> palettes; - + @Override public SlantHolder.Layer get() { return new SlantHolder.Layer(PaletteHolder.of(palettes), threshold); diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java index 6de99aeff..08dc93cbe 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java @@ -31,17 +31,17 @@ import com.dfsek.terra.api.world.info.WorldProperties; public class NoiseChunkGenerator3D implements ChunkGenerator { private final Platform platform; - + private final SamplerProvider samplerCache; - + private final BlockState air; - + private final int carverHorizontalResolution; private final int carverVerticalResolution; - + private final PropertyKey paletteInfoPropertyKey; private final PropertyKey noisePropertiesKey; - + public NoiseChunkGenerator3D(ConfigPack pack, Platform platform, int elevationBlend, int carverHorizontalResolution, int carverVerticalResolution, PropertyKey noisePropertiesKey, @@ -53,16 +53,16 @@ public class NoiseChunkGenerator3D implements ChunkGenerator { this.paletteInfoPropertyKey = paletteInfoPropertyKey; this.noisePropertiesKey = noisePropertiesKey; int maxBlend = pack - .getBiomeProvider() - .stream() - .map(biome -> biome.getContext().get(noisePropertiesKey)) - .mapToInt(properties -> properties.blendDistance() * properties.blendStep()) - .max() - .orElse(0); - + .getBiomeProvider() + .stream() + .map(biome -> biome.getContext().get(noisePropertiesKey)) + .mapToInt(properties -> properties.blendDistance() * properties.blendStep()) + .max() + .orElse(0); + this.samplerCache = new SamplerProvider(platform, elevationBlend, noisePropertiesKey, maxBlend); } - + @Override @SuppressWarnings("try") public void generateChunkData(@NotNull ProtoChunk chunk, @NotNull WorldProperties world, @@ -71,41 +71,41 @@ public class NoiseChunkGenerator3D implements ChunkGenerator { platform.getProfiler().push("chunk_base_3d"); int xOrig = (chunkX << 4); int zOrig = (chunkZ << 4); - + Sampler3D sampler = samplerCache.getChunk(chunkX, chunkZ, world, biomeProvider); - + long seed = world.getSeed(); - + LazilyEvaluatedInterpolator carver = new LazilyEvaluatedInterpolator(biomeProvider, - chunkX, - chunkZ, - world.getMaxHeight(), - noisePropertiesKey, world.getMinHeight(), - carverHorizontalResolution, - carverVerticalResolution, - seed); + chunkX, + chunkZ, + world.getMaxHeight(), + noisePropertiesKey, world.getMinHeight(), + carverHorizontalResolution, + carverVerticalResolution, + seed); for(int x = 0; x < 16; x++) { for(int z = 0; z < 16; z++) { int paletteLevel = 0; - + int cx = xOrig + x; int cz = zOrig + z; - + BlockState data; Column biomeColumn = biomeProvider.getColumn(cx, cz, world); for(int y = world.getMaxHeight() - 1; y >= world.getMinHeight(); y--) { Biome biome = biomeColumn.get(y); - + BiomePaletteInfo paletteInfo = biome.getContext().get(paletteInfoPropertyKey); - + int sea = paletteInfo.seaLevel(); Palette seaPalette = paletteInfo.ocean(); - + if(sampler.sample(x, y, z) > 0) { if(carver.sample(x, y, z) <= 0) { data = PaletteUtil - .getPalette(x, y, z, sampler, paletteInfo, paletteLevel) - .get(paletteLevel, cx, y, cz, seed); + .getPalette(x, y, z, sampler, paletteInfo, paletteLevel) + .get(paletteLevel, cx, y, cz, seed); chunk.setBlock(x, y, z, data); paletteLevel++; } else if(paletteInfo.updatePaletteWhenCarving()) { @@ -124,17 +124,17 @@ public class NoiseChunkGenerator3D implements ChunkGenerator { } platform.getProfiler().pop("chunk_base_3d"); } - + @Override public BlockState getBlock(WorldProperties world, int x, int y, int z, BiomeProvider biomeProvider) { Biome biome = biomeProvider.getBiome(x, y, z, world.getSeed()); Sampler3D sampler = samplerCache.get(x, z, world, biomeProvider); - + BiomePaletteInfo paletteInfo = biome.getContext().get(paletteInfoPropertyKey); - + int fdX = Math.floorMod(x, 16); int fdZ = Math.floorMod(z, 16); - + Palette palette = PaletteUtil.getPalette(fdX, y, fdZ, sampler, paletteInfo, 0); double noise = sampler.sample(fdX, y, fdZ); if(noise > 0) { @@ -148,22 +148,22 @@ public class NoiseChunkGenerator3D implements ChunkGenerator { return paletteInfo.ocean().get(paletteInfo.seaLevel() - y, x, y, z, world.getSeed()); } else return air; } - + @Override public Palette getPalette(int x, int y, int z, WorldProperties world, BiomeProvider biomeProvider) { return biomeProvider.getBiome(x, y, z, world.getSeed()).getContext().get(paletteInfoPropertyKey).paletteHolder().getPalette(y); } - + public double getSlant(int x, int y, int z, WorldProperties world, BiomeProvider biomeProvider) { int fdX = Math.floorMod(x, 16); int fdZ = Math.floorMod(z, 16); return biomeProvider.getBiome(x, y, z, world.getSeed()) - .getContext() - .get(paletteInfoPropertyKey) - .slantHolder() - .calculateSlant(samplerCache.get(x, z, world, biomeProvider), fdX, y, fdZ); + .getContext() + .get(paletteInfoPropertyKey) + .slantHolder() + .calculateSlant(samplerCache.get(x, z, world, biomeProvider), fdX, y, fdZ); } - + public SamplerProvider samplerProvider() { return samplerCache; } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/PaletteUtil.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/PaletteUtil.java index b2afe23e7..e7c20784c 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/PaletteUtil.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/PaletteUtil.java @@ -14,7 +14,7 @@ import com.dfsek.terra.api.world.chunk.generation.util.Palette; public final class PaletteUtil { - + public static Palette getPalette(int x, int y, int z, Sampler3D sampler, BiomePaletteInfo paletteInfo, int depth) { SlantHolder slantHolder = paletteInfo.slantHolder(); if(slantHolder.isAboveDepth(depth)) { @@ -23,7 +23,7 @@ public final class PaletteUtil { return slantHolder.getPalette(slant).getPalette(y); } } - + return paletteInfo.paletteHolder().getPalette(y); } } \ No newline at end of file diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java index 792d16729..2a2640a91 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator.java @@ -20,10 +20,10 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; */ public class ChunkInterpolator { private final Interpolator3[][][] interpGrid; - + private final int min; private final int max; - + /** * Instantiates a 3D ChunkInterpolator3D at a pair of chunk coordinates. * @@ -37,75 +37,75 @@ public class ChunkInterpolator { PropertyKey noisePropertiesKey, int maxBlend) { this.min = min; this.max = max; - + int xOrigin = chunkX << 4; int zOrigin = chunkZ << 4; - + int range = this.max - this.min + 1; - + int size = range >> 2; - + interpGrid = new Interpolator3[4][size][4]; - + double[][][] noiseStorage = new double[5][5][size + 1]; - + int maxBlendAndChunk = 17 + 2 * maxBlend; - + @SuppressWarnings("unchecked") Column[] columns = new Column[maxBlendAndChunk * maxBlendAndChunk]; - + for(int x = 0; x < 5; x++) { int scaledX = x << 2; int absoluteX = xOrigin + scaledX; for(int z = 0; z < 5; z++) { int scaledZ = z << 2; int absoluteZ = zOrigin + scaledZ; - + int index = (scaledX + maxBlend) + maxBlendAndChunk * (scaledZ + maxBlend); Column biomeColumn = columns[index]; - + if(biomeColumn == null) { biomeColumn = provider.getColumn(absoluteX, absoluteZ, seed, min, max); columns[index] = biomeColumn; } - + for(int y = 0; y < size; y++) { int scaledY = (y << 2) + min; BiomeNoiseProperties generationSettings = biomeColumn.get(scaledY) - .getContext() - .get(noisePropertiesKey); - + .getContext() + .get(noisePropertiesKey); + int step = generationSettings.blendStep(); int blend = generationSettings.blendDistance(); - + double runningNoise = 0; double runningDiv = 0; - + for(int xi = -blend; xi <= blend; xi++) { for(int zi = -blend; zi <= blend; zi++) { int blendX = (xi * step); int blendZ = (zi * step); - + int localIndex = (scaledX + maxBlend + blendX) + maxBlendAndChunk * (scaledZ + maxBlend + blendZ); Column column = columns[localIndex]; - + if(column == null) { column = provider.getColumn(absoluteX + blendX, absoluteZ + blendZ, seed, min, max); columns[localIndex] = column; } - + BiomeNoiseProperties properties = column - .get(scaledY) - .getContext() - .get(noisePropertiesKey); + .get(scaledY) + .getContext() + .get(noisePropertiesKey); double sample = properties.noiseHolder().getNoise(properties.base(), absoluteX, scaledY, absoluteZ, seed); runningNoise += sample * properties.blendWeight(); runningDiv += properties.blendWeight(); } } - + double noise = runningNoise / runningDiv; - + noiseStorage[x][z][y] = noise; if(y == size - 1) { noiseStorage[x][z][size] = noise; @@ -113,28 +113,28 @@ public class ChunkInterpolator { } } } - + for(int x = 0; x < 4; x++) { for(int z = 0; z < 4; z++) { for(int y = 0; y < size; y++) { interpGrid[x][y][z] = new Interpolator3( - noiseStorage[x][z][y], - noiseStorage[x + 1][z][y], - noiseStorage[x][z][y + 1], - noiseStorage[x + 1][z][y + 1], - noiseStorage[x][z + 1][y], - noiseStorage[x + 1][z + 1][y], - noiseStorage[x][z + 1][y + 1], - noiseStorage[x + 1][z + 1][y + 1]); + noiseStorage[x][z][y], + noiseStorage[x + 1][z][y], + noiseStorage[x][z][y + 1], + noiseStorage[x + 1][z][y + 1], + noiseStorage[x][z + 1][y], + noiseStorage[x + 1][z + 1][y], + noiseStorage[x][z + 1][y + 1], + noiseStorage[x + 1][z + 1][y + 1]); } } } } - + private static int reRange(int value, int high) { return Math.max(Math.min(value, high), 0); } - + /** * Gets the noise at a pair of internal chunk coordinates. * @@ -145,15 +145,15 @@ public class ChunkInterpolator { */ public double getNoise(double x, double y, double z) { return interpGrid[reRange(((int) x) / 4, 3)][(Math.max(Math.min(((int) y), max), min) - min) / 4][reRange(((int) z) / 4, - 3)].trilerp( - (x % 4) / 4, (y % 4) / 4, (z % 4) / 4); + 3)].trilerp( + (x % 4) / 4, (y % 4) / 4, (z % 4) / 4); } - + public double getNoise(int x, int y, int z) { return interpGrid[x / 4][(y - min) / 4][z / 4].trilerp( - (double) (x & 3) / 4, // x & 3 == x % 4 - (double) (y & 3) / 4, // x & 3 == x % 4 - (double) (z & 3) / 4 // x & 3 == x % 4 - ); + (double) (x & 3) / 4, // x & 3 == x % 4 + (double) (y & 3) / 4, // x & 3 == x % 4 + (double) (z & 3) / 4 // x & 3 == x % 4 + ); } } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ElevationInterpolator.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ElevationInterpolator.java index 1328bc2de..d5f1c03ad 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ElevationInterpolator.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ElevationInterpolator.java @@ -14,36 +14,36 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class ElevationInterpolator { private final double[][] values = new double[18][18]; - + public ElevationInterpolator(long seed, int chunkX, int chunkZ, BiomeProvider provider, int smooth, PropertyKey noisePropertiesKey) { int xOrigin = chunkX << 4; int zOrigin = chunkZ << 4; - + BiomeNoiseProperties[][] gens = new BiomeNoiseProperties[18 + 2 * smooth][18 + 2 * smooth]; - + // Precompute generators. for(int x = -1 - smooth; x <= 16 + smooth; x++) { for(int z = -1 - smooth; z <= 16 + smooth; z++) { int bx = xOrigin + x; int bz = zOrigin + z; gens[x + 1 + smooth][z + 1 + smooth] = - provider - .getBaseBiome(bx, bz, seed) - .orElseGet(() -> provider.getBiome(bx, 0, bz, seed)) // kind of a hack - .getContext() - .get(noisePropertiesKey); + provider + .getBaseBiome(bx, bz, seed) + .orElseGet(() -> provider.getBiome(bx, 0, bz, seed)) // kind of a hack + .getContext() + .get(noisePropertiesKey); } } - + for(int x = -1; x <= 16; x++) { for(int z = -1; z <= 16; z++) { double noise = 0; double div = 0; - + BiomeNoiseProperties center = gens[x + 1 + smooth][z + 1 + smooth]; boolean same = true; - + for(int xi = -smooth; xi <= smooth; xi++) { for(int zi = -smooth; zi <= smooth; zi++) { if(gens[x + 1 + smooth + xi][z + 1 + smooth + zi] != @@ -53,7 +53,7 @@ public class ElevationInterpolator { } } } - + if(same) { values[x + 1][z + 1] = center.elevation().noise(seed, xOrigin + x, zOrigin + z); // no weighting needed! } else { @@ -69,7 +69,7 @@ public class ElevationInterpolator { } } } - + public double getElevation(int x, int z) { return values[x + 1][z + 1]; } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator.java index 15bef7056..74cc8fd99 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator.java @@ -15,7 +15,7 @@ import com.dfsek.terra.api.util.MathUtil; */ public class Interpolator { private final double v0, v1, v2, v3; - + /** * Constructs an interpolator with given values as vertices of a unit square. * @@ -30,7 +30,7 @@ public class Interpolator { this.v2 = v2; this.v3 = v3; } - + /** * 2D Bilinear interpolation between 4 points on a unit square. * diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator3.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator3.java index 0a6bf7263..5ea8ef578 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator3.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator3.java @@ -16,7 +16,7 @@ import com.dfsek.terra.api.util.MathUtil; public class Interpolator3 { private final Interpolator bottom; private final Interpolator top; - + /** * Constructs an interpolator with given values as vertices of a unit cube. * * @param _000 The value at (t, u, v) = (0, 0, 0). @@ -35,7 +35,7 @@ public class Interpolator3 { this.top = new Interpolator(_000, _010, _001, _011); this.bottom = new Interpolator(_100, _110, _101, _111); } - + public double trilerp(double x, double y, double z) { return MathUtil.lerp(x, top.bilerp(y, z), bottom.bilerp(y, z)); } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/LazilyEvaluatedInterpolator.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/LazilyEvaluatedInterpolator.java index e31d77f52..b215ba809 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/LazilyEvaluatedInterpolator.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/LazilyEvaluatedInterpolator.java @@ -5,23 +5,24 @@ import com.dfsek.terra.api.properties.PropertyKey; import com.dfsek.terra.api.util.MathUtil; import com.dfsek.terra.api.world.biome.generation.BiomeProvider; + public class LazilyEvaluatedInterpolator { private final Double[] samples; // - + private final int chunkX; private final int chunkZ; - + private final int horizontalRes; private final int verticalRes; - + private final BiomeProvider biomeProvider; private final PropertyKey noisePropertiesKey; - + private final long seed; private final int min, max; - + private final int zMul, yMul; - + public LazilyEvaluatedInterpolator(BiomeProvider biomeProvider, int cx, int cz, int max, PropertyKey noisePropertiesKey, int min, int horizontalRes, int verticalRes, long seed) { @@ -40,70 +41,70 @@ public class LazilyEvaluatedInterpolator { this.min = min; this.max = max - 1; } - + private double sample(int xIndex, int yIndex, int zIndex, int ox, int oy, int oz) { int index = xIndex + (zIndex * zMul) + (yIndex * yMul); Double sample = samples[index]; if(sample == null) { int xi = ox + chunkX; int zi = oz + chunkZ; - + int y = Math.min(max, oy); - + sample = biomeProvider - .getBiome(xi, y, zi, seed) - .getContext() - .get(noisePropertiesKey) - .carving() - .noise(seed, xi, y, zi); + .getBiome(xi, y, zi, seed) + .getContext() + .get(noisePropertiesKey) + .carving() + .noise(seed, xi, y, zi); samples[index] = sample; } return sample; } - + public double sample(int x, int y, int z) { int xIndex = x / horizontalRes; int yIndex = (y - min) / verticalRes; int zIndex = z / horizontalRes; - + double sample_0_0_0 = sample(xIndex, yIndex, zIndex, x, y, z); - + boolean yRange = y % verticalRes == 0; if(x % horizontalRes == 0 && yRange && z % horizontalRes == 0) { // we're at the sampling point return sample_0_0_0; } - + double sample_0_0_1 = sample(xIndex, yIndex, zIndex + 1, x, y, z + horizontalRes); - + double sample_1_0_0 = sample(xIndex + 1, yIndex, zIndex, x + horizontalRes, y, z); double sample_1_0_1 = sample(xIndex + 1, yIndex, zIndex + 1, x + horizontalRes, y, z + horizontalRes); - + double xFrac = (double) (x % horizontalRes) / horizontalRes; double zFrac = (double) (z % horizontalRes) / horizontalRes; double lerp_bottom_0 = MathUtil.lerp(zFrac, sample_0_0_0, sample_0_0_1); double lerp_bottom_1 = MathUtil.lerp(zFrac, sample_1_0_0, sample_1_0_1); - + double lerp_bottom = MathUtil.lerp(xFrac, lerp_bottom_0, lerp_bottom_1); - + if(yRange) { // we can do bilerp return lerp_bottom; } - + double yFrac = (double) Math.floorMod(y, verticalRes) / verticalRes; - - + + double sample_0_1_0 = sample(xIndex, yIndex + 1, zIndex, x, y + verticalRes, z); double sample_0_1_1 = sample(xIndex, yIndex + 1, zIndex + 1, x, y + verticalRes, z + horizontalRes); - - + + double sample_1_1_0 = sample(xIndex + 1, yIndex + 1, zIndex, x + horizontalRes, y + verticalRes, z); double sample_1_1_1 = sample(xIndex + 1, yIndex + 1, zIndex + 1, x + horizontalRes, y + verticalRes, z + horizontalRes); - + double lerp_top_0 = MathUtil.lerp(zFrac, sample_0_1_0, sample_0_1_1); double lerp_top_1 = MathUtil.lerp(zFrac, sample_1_1_0, sample_1_1_1); - + double lerp_top = MathUtil.lerp(xFrac, lerp_top_0, lerp_top_1); - + return MathUtil.lerp(yFrac, lerp_bottom, lerp_top); } } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/Sampler3D.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/Sampler3D.java index 9ed0c322e..fcae0ce8c 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/Sampler3D.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/Sampler3D.java @@ -17,18 +17,18 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class Sampler3D { private final ChunkInterpolator interpolator; private final ElevationInterpolator elevationInterpolator; - + public Sampler3D(int x, int z, long seed, int minHeight, int maxHeight, BiomeProvider provider, int elevationSmooth, PropertyKey noisePropertiesKey, int maxBlend) { this.interpolator = new ChunkInterpolator(seed, x, z, provider, - minHeight, maxHeight, noisePropertiesKey, maxBlend); + minHeight, maxHeight, noisePropertiesKey, maxBlend); this.elevationInterpolator = new ElevationInterpolator(seed, x, z, provider, elevationSmooth, noisePropertiesKey); } - + public double sample(double x, double y, double z) { return interpolator.getNoise(x, y, z) + elevationInterpolator.getElevation((int) Math.round(x), (int) Math.round(z)); } - + public double sample(int x, int y, int z) { return interpolator.getNoise(x, y, z) + elevationInterpolator.getElevation(x, z); } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/SamplerProvider.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/SamplerProvider.java index 73a29ef52..a66f7602a 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/SamplerProvider.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/SamplerProvider.java @@ -32,29 +32,29 @@ public class SamplerProvider { private final int elevationSmooth; private final PropertyKey noisePropertiesKey; private final int maxBlend; - + public SamplerProvider(Platform platform, int elevationSmooth, PropertyKey noisePropertiesKey, int maxBlend) { cache = Caffeine - .newBuilder() - .maximumSize(platform.getTerraConfig().getSamplerCache()) - .build(); + .newBuilder() + .maximumSize(platform.getTerraConfig().getSamplerCache()) + .build(); this.elevationSmooth = elevationSmooth; this.noisePropertiesKey = noisePropertiesKey; this.maxBlend = maxBlend; } - + public Sampler3D get(int x, int z, WorldProperties world, BiomeProvider provider) { int cx = Math.floorDiv(x, 16); int cz = Math.floorDiv(z, 16); return getChunk(cx, cz, world, provider); } - + public Sampler3D getChunk(int cx, int cz, WorldProperties world, BiomeProvider provider) { WorldContext context = new WorldContext(cx, cz, world.getSeed(), world.getMinHeight(), world.getMaxHeight()); return cache.get(context, c -> new Sampler3D(c.cx, c.cz, c.seed, c.minHeight, c.maxHeight, provider, - elevationSmooth, noisePropertiesKey, maxBlend)); + elevationSmooth, noisePropertiesKey, maxBlend)); } - + private record WorldContext(int cx, int cz, long seed, int minHeight, int maxHeight) { } } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java index 1f89ce1f9..5b5673770 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java @@ -18,12 +18,12 @@ import com.dfsek.terra.api.world.chunk.generation.util.Palette; public class PaletteHolder { private final Palette[] palettes; private final int offset; - + protected PaletteHolder(Palette[] palettes, int offset) { this.palettes = palettes; this.offset = offset; } - + public static PaletteHolder of(List> palettes) { PaletteHolderBuilder builder = new PaletteHolderBuilder(); for(Map layer : palettes) { @@ -33,7 +33,7 @@ public class PaletteHolder { } return builder.build(); } - + public Palette getPalette(int y) { int index = y + offset; return index >= 0 @@ -42,21 +42,21 @@ public class PaletteHolder { : palettes[palettes.length - 1] : palettes[0]; } - - + + private static class PaletteHolderBuilder { private final TreeMap paletteMap = new TreeMap<>(); - + public PaletteHolderBuilder add(int y, Palette palette) { paletteMap.put(y, palette); return this; } - + public PaletteHolder build() { - + int min = Math.min(paletteMap.keySet().stream().min(Integer::compareTo).orElse(0), 0); int max = Math.max(paletteMap.keySet().stream().max(Integer::compareTo).orElse(255), 255); - + Palette[] palettes = new Palette[paletteMap.lastKey() + 1 - min]; for(int y = min; y <= Math.max(paletteMap.lastKey(), max); y++) { Palette d = null; diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/MultipleSlantHolder.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/MultipleSlantHolder.java index fec070ea7..895c02698 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/MultipleSlantHolder.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/MultipleSlantHolder.java @@ -20,11 +20,11 @@ import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolder; public class MultipleSlantHolder extends SlantHolderImpl { private final NavigableMap layers; private final double slantThreshold; - + MultipleSlantHolder(List slant, int slantDepth, CalculationMethod calculationMethod) { super(slantDepth, calculationMethod); NavigableMap layers = new TreeMap<>( - slant.stream().collect(Collectors.toMap(SlantHolder.Layer::threshold, SlantHolder.Layer::palette))); + slant.stream().collect(Collectors.toMap(SlantHolder.Layer::threshold, SlantHolder.Layer::palette))); Stream thresholds = layers.keySet().stream(); double slantThreshold = floorToThreshold ? thresholds.min(Double::compare).orElseThrow() : @@ -32,12 +32,12 @@ public class MultipleSlantHolder extends SlantHolderImpl { this.layers = layers; this.slantThreshold = slantThreshold; } - + @Override protected double getSlantThreshold() { return slantThreshold; } - + @Override public PaletteHolder getPalette(double slant) { return (floorToThreshold ? diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SingleSlantHolder.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SingleSlantHolder.java index fdc9b27cb..12f29ef18 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SingleSlantHolder.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SingleSlantHolder.java @@ -4,19 +4,19 @@ import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolder; final class SingleSlantHolder extends SlantHolderImpl { - + private final SlantHolder.Layer layer; - + public SingleSlantHolder(SlantHolder.Layer layer, int slantDepth, CalculationMethod calculationMethod) { super(slantDepth, calculationMethod); this.layer = layer; } - + @Override public PaletteHolder getPalette(double slant) { return layer.palette(); } - + @Override protected double getSlantThreshold() { return layer.threshold(); diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolder.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolder.java index 7e084d1ff..359913d41 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolder.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolder.java @@ -8,29 +8,29 @@ import com.dfsek.terra.api.util.vector.Vector3; public interface SlantHolder { - + SlantHolder EMPTY = new SlantHolder() { @Override public double calculateSlant(Sampler3D sampler, double x, double y, double z) { throw new UnsupportedOperationException("Empty holder should not calculate slant"); } - + @Override public boolean isAboveDepth(int depth) { return false; } - + @Override public boolean isInSlantThreshold(double slant) { return false; } - + @Override public PaletteHolder getPalette(double slant) { throw new UnsupportedOperationException("Empty holder cannot return a palette"); } }; - + static SlantHolder of(List layers, int slantDepth, CalculationMethod calculationMethod) { if(layers.isEmpty()) { return EMPTY; @@ -39,29 +39,29 @@ public interface SlantHolder { } return new MultipleSlantHolder(layers, slantDepth, calculationMethod); } - + double calculateSlant(Sampler3D sampler, double x, double y, double z); - + boolean isAboveDepth(int depth); - + boolean isInSlantThreshold(double slant); - + PaletteHolder getPalette(double slant); - - + + enum CalculationMethod { DotProduct { private static final Vector3 DOT_PRODUCT_DIRECTION = Vector3.of(0, 1, 0); - + private static final Vector3[] DOT_PRODUCT_SAMPLE_POINTS = { - Vector3.of(0, 0, -DERIVATIVE_DIST), - Vector3.of(0, 0, DERIVATIVE_DIST), - Vector3.of(0, -DERIVATIVE_DIST, 0), - Vector3.of(0, DERIVATIVE_DIST, 0), - Vector3.of(-DERIVATIVE_DIST, 0, 0), - Vector3.of(DERIVATIVE_DIST, 0, 0) + Vector3.of(0, 0, -DERIVATIVE_DIST), + Vector3.of(0, 0, DERIVATIVE_DIST), + Vector3.of(0, -DERIVATIVE_DIST, 0), + Vector3.of(0, DERIVATIVE_DIST, 0), + Vector3.of(-DERIVATIVE_DIST, 0, 0), + Vector3.of(DERIVATIVE_DIST, 0, 0) }; - + @Override public double slant(Sampler3D sampler, double x, double y, double z) { Vector3.Mutable normalApproximation = Vector3.Mutable.of(0, 0, 0); @@ -71,39 +71,39 @@ public interface SlantHolder { } return DOT_PRODUCT_DIRECTION.dot(normalApproximation.normalize()); } - + @Override public boolean floorToThreshold() { return false; } }, - + Derivative { @Override public double slant(Sampler3D sampler, double x, double y, double z) { double baseSample = sampler.sample(x, y, z); - + double xVal1 = (sampler.sample(x + DERIVATIVE_DIST, y, z) - baseSample) / DERIVATIVE_DIST; double xVal2 = (sampler.sample(x - DERIVATIVE_DIST, y, z) - baseSample) / DERIVATIVE_DIST; double zVal1 = (sampler.sample(x, y, z + DERIVATIVE_DIST) - baseSample) / DERIVATIVE_DIST; double zVal2 = (sampler.sample(x, y, z - DERIVATIVE_DIST) - baseSample) / DERIVATIVE_DIST; double yVal1 = (sampler.sample(x, y + DERIVATIVE_DIST, z) - baseSample) / DERIVATIVE_DIST; double yVal2 = (sampler.sample(x, y - DERIVATIVE_DIST, z) - baseSample) / DERIVATIVE_DIST; - + return Math.sqrt( - ((xVal2 - xVal1) * (xVal2 - xVal1)) + ((zVal2 - zVal1) * (zVal2 - zVal1)) + ((yVal2 - yVal1) * (yVal2 - yVal1))); + ((xVal2 - xVal1) * (xVal2 - xVal1)) + ((zVal2 - zVal1) * (zVal2 - zVal1)) + ((yVal2 - yVal1) * (yVal2 - yVal1))); } - + @Override public boolean floorToThreshold() { return true; } }; - + private static final double DERIVATIVE_DIST = 0.55; - + public abstract double slant(Sampler3D sampler, double x, double y, double z); - + /* * Controls whether palettes should be applied before or after their respective thresholds. * @@ -112,8 +112,8 @@ public interface SlantHolder { */ public abstract boolean floorToThreshold(); } - - + + record Layer(PaletteHolder palette, double threshold) { } } diff --git a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolderImpl.java b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolderImpl.java index 73fabd6ae..13fc68ef1 100644 --- a/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolderImpl.java +++ b/common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolderImpl.java @@ -7,25 +7,25 @@ public abstract class SlantHolderImpl implements SlantHolder { protected final boolean floorToThreshold; private final SlantHolder.CalculationMethod calculationMethod; private final int slantDepth; - + protected SlantHolderImpl(int slantDepth, CalculationMethod calculationMethod) { this.floorToThreshold = calculationMethod.floorToThreshold(); this.calculationMethod = calculationMethod; this.slantDepth = slantDepth; } - + protected abstract double getSlantThreshold(); - + @Override public final double calculateSlant(Sampler3D sampler, double x, double y, double z) { return calculationMethod.slant(sampler, x, y, z); } - + @Override public final boolean isAboveDepth(int depth) { return depth <= slantDepth; } - + @Override public final boolean isInSlantThreshold(double slant) { return (floorToThreshold ? diff --git a/common/addons/command-addons/src/main/java/com/dfsek/terra/addons/commands/addons/AddonsCommandAddon.java b/common/addons/command-addons/src/main/java/com/dfsek/terra/addons/commands/addons/AddonsCommandAddon.java index 2bc66a2d3..58a22ef7a 100644 --- a/common/addons/command-addons/src/main/java/com/dfsek/terra/addons/commands/addons/AddonsCommandAddon.java +++ b/common/addons/command-addons/src/main/java/com/dfsek/terra/addons/commands/addons/AddonsCommandAddon.java @@ -16,54 +16,54 @@ import com.dfsek.terra.api.inject.annotations.Inject; public class AddonsCommandAddon implements AddonInitializer { @Inject private Platform platform; - + @Inject private BaseAddon addon; - - + + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, CommandRegistrationEvent.class) - .then(event -> { - CommandManager manager = event.getCommandManager(); - - manager.command( - manager.commandBuilder("addons", ArgumentDescription.of("List installed Terra addons")) - .permission("terra.addons") - .handler(context -> { - StringBuilder addons = new StringBuilder("Installed addons:\n"); - platform.getAddons() - .forEach(addon -> addons - .append(" - ") - .append(addon.getID()) - .append('@') - .append(addon.getVersion().getFormatted()) - .append('\n')); - context.getSender().sendMessage(addons.toString()); - }) - ) - .command( - manager.commandBuilder("addons") - .argument(RegistryArgument.of("addon", platform.getAddons())) - .permission("terra.addons.info") - .handler(context -> { - BaseAddon addon = context.get("addon"); - StringBuilder addonInfo = new StringBuilder("Addon ").append(addon.getID()).append('\n'); - - addonInfo.append("Version: ").append(addon.getVersion().getFormatted()).append('\n'); - - addonInfo.append("Dependencies:\n"); - addon.getDependencies().forEach((id, versions) -> addonInfo - .append(" - ") - .append(id) - .append('@') - .append(versions.getFormatted()) - .append('\n')); - context.getSender().sendMessage(addonInfo.toString()); - }) - ); - }); + .getHandler(FunctionalEventHandler.class) + .register(addon, CommandRegistrationEvent.class) + .then(event -> { + CommandManager manager = event.getCommandManager(); + + manager.command( + manager.commandBuilder("addons", ArgumentDescription.of("List installed Terra addons")) + .permission("terra.addons") + .handler(context -> { + StringBuilder addons = new StringBuilder("Installed addons:\n"); + platform.getAddons() + .forEach(addon -> addons + .append(" - ") + .append(addon.getID()) + .append('@') + .append(addon.getVersion().getFormatted()) + .append('\n')); + context.getSender().sendMessage(addons.toString()); + }) + ) + .command( + manager.commandBuilder("addons") + .argument(RegistryArgument.of("addon", platform.getAddons())) + .permission("terra.addons.info") + .handler(context -> { + BaseAddon addon = context.get("addon"); + StringBuilder addonInfo = new StringBuilder("Addon ").append(addon.getID()).append('\n'); + + addonInfo.append("Version: ").append(addon.getVersion().getFormatted()).append('\n'); + + addonInfo.append("Dependencies:\n"); + addon.getDependencies().forEach((id, versions) -> addonInfo + .append(" - ") + .append(id) + .append('@') + .append(versions.getFormatted()) + .append('\n')); + context.getSender().sendMessage(addonInfo.toString()); + }) + ); + }); } } diff --git a/common/addons/command-packs/src/main/java/com/dfsek/terra/addons/commands/packs/PacksCommandAddon.java b/common/addons/command-packs/src/main/java/com/dfsek/terra/addons/commands/packs/PacksCommandAddon.java index 2bc9abdeb..1d99af328 100644 --- a/common/addons/command-packs/src/main/java/com/dfsek/terra/addons/commands/packs/PacksCommandAddon.java +++ b/common/addons/command-packs/src/main/java/com/dfsek/terra/addons/commands/packs/PacksCommandAddon.java @@ -18,71 +18,71 @@ import com.dfsek.terra.api.inject.annotations.Inject; public class PacksCommandAddon implements AddonInitializer { private static final Logger logger = LoggerFactory.getLogger(PacksCommandAddon.class); - + @Inject private Platform platform; - + @Inject private BaseAddon addon; - - + + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, CommandRegistrationEvent.class) - .then(event -> { - CommandManager manager = event.getCommandManager(); - - manager.command( - manager.commandBuilder("packs", ArgumentDescription.of("List installed config packs")) - .permission("terra.packs") - .handler(context -> { - StringBuilder packs = new StringBuilder("Installed packs:\n"); - platform.getConfigRegistry().forEach(pack -> packs.append(" - ") - .append(pack.getID()) - .append('@') - .append(pack.getVersion().getFormatted())); - context.getSender().sendMessage(packs.toString()); - }) - ) - .command( - manager.commandBuilder("packs") - .literal("info", ArgumentDescription.of("Get information about a pack")) - .permission("terra.packs.info") - .argument(RegistryArgument.of("pack", platform.getConfigRegistry())) - .handler(context -> { - ConfigPack pack = context.get("pack"); - StringBuilder packInfo = new StringBuilder("Pack ").append(pack.getID()).append('\n'); - - packInfo.append("Version: ").append(pack.getVersion().getFormatted()).append('\n'); - packInfo.append("Author: ").append(pack.getAuthor()).append('\n'); - - packInfo.append("Addon Dependencies:\n"); - pack.addons().forEach((id, versions) -> packInfo - .append(" - ") - .append(id.getID()) - .append('@') - .append(versions.getFormatted()) - .append('\n')); - context.getSender().sendMessage(packInfo.toString()); - })) - .command( - manager.commandBuilder("packs") - .literal("reload", ArgumentDescription.of("Reload config packs")) - .permission("terra.packs.reload") - .handler(context -> { - context.getSender().sendMessage("Reloading Terra..."); - logger.info("Reloading Terra..."); - if(platform.reload()) { - logger.info("Terra reloaded successfully."); - context.getSender().sendMessage("Terra reloaded successfully."); - } else { - logger.error("Terra failed to reload."); - context.getSender().sendMessage( - "Terra failed to reload. See logs for more information."); - } - })); - }); + .getHandler(FunctionalEventHandler.class) + .register(addon, CommandRegistrationEvent.class) + .then(event -> { + CommandManager manager = event.getCommandManager(); + + manager.command( + manager.commandBuilder("packs", ArgumentDescription.of("List installed config packs")) + .permission("terra.packs") + .handler(context -> { + StringBuilder packs = new StringBuilder("Installed packs:\n"); + platform.getConfigRegistry().forEach(pack -> packs.append(" - ") + .append(pack.getID()) + .append('@') + .append(pack.getVersion().getFormatted())); + context.getSender().sendMessage(packs.toString()); + }) + ) + .command( + manager.commandBuilder("packs") + .literal("info", ArgumentDescription.of("Get information about a pack")) + .permission("terra.packs.info") + .argument(RegistryArgument.of("pack", platform.getConfigRegistry())) + .handler(context -> { + ConfigPack pack = context.get("pack"); + StringBuilder packInfo = new StringBuilder("Pack ").append(pack.getID()).append('\n'); + + packInfo.append("Version: ").append(pack.getVersion().getFormatted()).append('\n'); + packInfo.append("Author: ").append(pack.getAuthor()).append('\n'); + + packInfo.append("Addon Dependencies:\n"); + pack.addons().forEach((id, versions) -> packInfo + .append(" - ") + .append(id.getID()) + .append('@') + .append(versions.getFormatted()) + .append('\n')); + context.getSender().sendMessage(packInfo.toString()); + })) + .command( + manager.commandBuilder("packs") + .literal("reload", ArgumentDescription.of("Reload config packs")) + .permission("terra.packs.reload") + .handler(context -> { + context.getSender().sendMessage("Reloading Terra..."); + logger.info("Reloading Terra..."); + if(platform.reload()) { + logger.info("Terra reloaded successfully."); + context.getSender().sendMessage("Terra reloaded successfully."); + } else { + logger.error("Terra failed to reload."); + context.getSender().sendMessage( + "Terra failed to reload. See logs for more information."); + } + })); + }); } } diff --git a/common/addons/command-profiler/src/main/java/com/dfsek/terra/addons/commands/profiler/ProfilerCommandAddon.java b/common/addons/command-profiler/src/main/java/com/dfsek/terra/addons/commands/profiler/ProfilerCommandAddon.java index adf966845..2376c919b 100644 --- a/common/addons/command-profiler/src/main/java/com/dfsek/terra/addons/commands/profiler/ProfilerCommandAddon.java +++ b/common/addons/command-profiler/src/main/java/com/dfsek/terra/addons/commands/profiler/ProfilerCommandAddon.java @@ -16,59 +16,59 @@ import com.dfsek.terra.api.inject.annotations.Inject; public class ProfilerCommandAddon implements AddonInitializer { private static final Logger logger = LoggerFactory.getLogger(ProfilerCommandAddon.class); - + @Inject private Platform platform; - + @Inject private BaseAddon addon; - - + + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, CommandRegistrationEvent.class) - .then(event -> { - CommandManager manager = event.getCommandManager(); - manager - .command( - manager.commandBuilder("profiler", ArgumentDescription.of("Access the profiler")) - .literal("start", ArgumentDescription.of("Start profiling"), "st") - .permission("terra.profiler.start") - .handler(context -> { - platform.getProfiler().start(); - context.getSender().sendMessage("Profiling started."); - })) - .command( - manager.commandBuilder("profiler", ArgumentDescription.of("Access the profiler")) - .literal("stop", ArgumentDescription.of("Stop profiling"), "s") - .permission("terra.profiler.stop") - .handler(context -> { - platform.getProfiler().stop(); - context.getSender().sendMessage("Profiling stopped."); - })) - .command( - manager.commandBuilder("profiler", ArgumentDescription.of("Access the profiler")) - .literal("query", ArgumentDescription.of("Query profiler results"), "q") - .permission("terra.profiler.query") - .handler(context -> { - StringBuilder data = new StringBuilder("Terra Profiler data: \n"); - platform.getProfiler().getTimings().forEach((id, timings) -> data.append(id) - .append(": ") - .append(timings.toString()) - .append('\n')); - logger.info(data.toString()); - context.getSender().sendMessage("Profiling data dumped to console."); - })) - .command( - manager.commandBuilder("profiler", ArgumentDescription.of("Access the profiler")) - .literal("reset", ArgumentDescription.of("Reset the profiler"), "r") - .permission("terra.profiler.reset") - .handler(context -> { - platform.getProfiler().reset(); - context.getSender().sendMessage("Profiler reset."); - })); - }); + .getHandler(FunctionalEventHandler.class) + .register(addon, CommandRegistrationEvent.class) + .then(event -> { + CommandManager manager = event.getCommandManager(); + manager + .command( + manager.commandBuilder("profiler", ArgumentDescription.of("Access the profiler")) + .literal("start", ArgumentDescription.of("Start profiling"), "st") + .permission("terra.profiler.start") + .handler(context -> { + platform.getProfiler().start(); + context.getSender().sendMessage("Profiling started."); + })) + .command( + manager.commandBuilder("profiler", ArgumentDescription.of("Access the profiler")) + .literal("stop", ArgumentDescription.of("Stop profiling"), "s") + .permission("terra.profiler.stop") + .handler(context -> { + platform.getProfiler().stop(); + context.getSender().sendMessage("Profiling stopped."); + })) + .command( + manager.commandBuilder("profiler", ArgumentDescription.of("Access the profiler")) + .literal("query", ArgumentDescription.of("Query profiler results"), "q") + .permission("terra.profiler.query") + .handler(context -> { + StringBuilder data = new StringBuilder("Terra Profiler data: \n"); + platform.getProfiler().getTimings().forEach((id, timings) -> data.append(id) + .append(": ") + .append(timings.toString()) + .append('\n')); + logger.info(data.toString()); + context.getSender().sendMessage("Profiling data dumped to console."); + })) + .command( + manager.commandBuilder("profiler", ArgumentDescription.of("Access the profiler")) + .literal("reset", ArgumentDescription.of("Reset the profiler"), "r") + .permission("terra.profiler.reset") + .handler(context -> { + platform.getProfiler().reset(); + context.getSender().sendMessage("Profiler reset."); + })); + }); } } diff --git a/common/addons/command-structures/src/main/java/com/dfsek/terra/addons/commands/structure/StructureCommandAddon.java b/common/addons/command-structures/src/main/java/com/dfsek/terra/addons/commands/structure/StructureCommandAddon.java index 37bab2508..438546137 100644 --- a/common/addons/command-structures/src/main/java/com/dfsek/terra/addons/commands/structure/StructureCommandAddon.java +++ b/common/addons/command-structures/src/main/java/com/dfsek/terra/addons/commands/structure/StructureCommandAddon.java @@ -26,42 +26,42 @@ import com.dfsek.terra.api.util.reflection.TypeKey; public class StructureCommandAddon implements AddonInitializer { @Inject private Platform platform; - + @Inject private BaseAddon addon; - + private static Registry getStructureRegistry(CommandContext sender) { return sender.getSender().getEntity().orElseThrow().world().getPack().getRegistry(Structure.class); } - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, CommandRegistrationEvent.class) - .then(event -> { - CommandManager manager = event.getCommandManager(); - - manager.command( - manager.commandBuilder("structures", ArgumentDescription.of("Manage or generate structures")) - .literal("generate") - .argument(RegistryArgument.builder("structure", - StructureCommandAddon::getStructureRegistry, - TypeKey.of(Structure.class))) - .argument(LongArgument.optional("seed", 0)) - .argument(EnumArgument.optional(Rotation.class, "rotation", Rotation.NONE)) - .handler(context -> { - Structure structure = context.get("structure"); - Entity sender = context.getSender().getEntity().orElseThrow(); - structure.generate( - sender.position().toInt(), - sender.world(), - ((Long) context.get("seed") == 0) ? new Random() : new Random(context.get("seed")), - context.get("rotation") - ); - }) - .permission("terra.structures.generate") - ); - }); + .getHandler(FunctionalEventHandler.class) + .register(addon, CommandRegistrationEvent.class) + .then(event -> { + CommandManager manager = event.getCommandManager(); + + manager.command( + manager.commandBuilder("structures", ArgumentDescription.of("Manage or generate structures")) + .literal("generate") + .argument(RegistryArgument.builder("structure", + StructureCommandAddon::getStructureRegistry, + TypeKey.of(Structure.class))) + .argument(LongArgument.optional("seed", 0)) + .argument(EnumArgument.optional(Rotation.class, "rotation", Rotation.NONE)) + .handler(context -> { + Structure structure = context.get("structure"); + Entity sender = context.getSender().getEntity().orElseThrow(); + structure.generate( + sender.position().toInt(), + sender.world(), + ((Long) context.get("seed") == 0) ? new Random() : new Random(context.get("seed")), + context.get("rotation") + ); + }) + .permission("terra.structures.generate") + ); + }); } } diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeAddon.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeAddon.java index f09a4726d..01d80e999 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeAddon.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeAddon.java @@ -20,19 +20,19 @@ import com.dfsek.terra.api.inject.annotations.Inject; public class BiomeAddon implements AddonInitializer { @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> { - event.getPack().registerConfigType(new BiomeConfigType(event.getPack()), addon.key("BIOME"), 1000); - event.getPack().applyLoader(PaletteHolder.class, new PaletteHolderLoader()); - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> { + event.getPack().registerConfigType(new BiomeConfigType(event.getPack()), addon.key("BIOME"), 1000); + event.getPack().applyLoader(PaletteHolder.class, new PaletteHolderLoader()); + }) + .failThrough(); } } diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeConfigType.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeConfigType.java index a0eb0c922..8ed5d2aea 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeConfigType.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeConfigType.java @@ -19,21 +19,21 @@ public class BiomeConfigType implements ConfigType { public static final TypeKey BIOME_TYPE_TOKEN = new TypeKey<>() { }; private final BiomeFactory factory; - + public BiomeConfigType(ConfigPack pack) { this.factory = new BiomeFactory(pack); } - + @Override public BiomeTemplate getTemplate(ConfigPack pack, Platform platform) { return new BiomeTemplate(pack, platform); } - + @Override public ConfigFactory getFactory() { return factory; } - + @Override public TypeKey getTypeKey() { return BIOME_TYPE_TOKEN; diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeFactory.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeFactory.java index 0ab3612c6..95029a434 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeFactory.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeFactory.java @@ -15,11 +15,11 @@ import com.dfsek.terra.api.world.biome.Biome; public class BiomeFactory implements ConfigFactory { private final ConfigPack pack; - + public BiomeFactory(ConfigPack pack) { this.pack = pack; } - + @Override public Biome build(BiomeTemplate template, Platform platform) { return new UserDefinedBiome(template.getVanilla(), template); diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeTemplate.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeTemplate.java index f970caca9..9ae2d52f0 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeTemplate.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeTemplate.java @@ -27,19 +27,19 @@ import com.dfsek.terra.api.world.biome.PlatformBiome; @SuppressWarnings({ "FieldMayBeFinal", "unused" }) public class BiomeTemplate implements AbstractableTemplate, ValidatedConfigTemplate { private final ConfigPack pack; - + @Value("id") @Final private @Meta String id; - + @Value("extends") @Final @Default private List extended = Collections.emptyList(); - + @Value("vanilla") private @Meta PlatformBiome vanilla; - + @Value("color") @Final @Default @@ -47,37 +47,37 @@ public class BiomeTemplate implements AbstractableTemplate, ValidatedConfigTempl @Value("tags") @Default private @Meta Set<@Meta String> tags = new HashSet<>(); - + public BiomeTemplate(ConfigPack pack, Platform platform) { this.pack = pack; } - + @Override public boolean validate() { color |= 0xff000000; // Alpha adjustment return true; } - + public List getExtended() { return extended; } - + public Set getTags() { return tags; } - + public int getColor() { return color; } - + public ConfigPack getPack() { return pack; } - + public String getID() { return id; } - + public PlatformBiome getVanilla() { return vanilla; } diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/PaletteSettingsImpl.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/PaletteSettingsImpl.java index f0ff9ba20..57b56cd0e 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/PaletteSettingsImpl.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/PaletteSettingsImpl.java @@ -14,11 +14,11 @@ import com.dfsek.terra.api.world.chunk.generation.util.Palette; public class PaletteSettingsImpl implements PaletteSettings { private final PaletteHolder palette; - + public PaletteSettingsImpl(PaletteHolder palette) { this.palette = palette; } - + @Override public Palette getPalette(int y) { return palette.getPalette(y); diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/UserDefinedBiome.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/UserDefinedBiome.java index ab82f0ef4..8f9ac0d11 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/UserDefinedBiome.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/UserDefinedBiome.java @@ -23,9 +23,9 @@ public class UserDefinedBiome implements Biome { private final BiomeTemplate config; private final int color; private final Set tags; - + private final Context context = new Context(); - + public UserDefinedBiome(PlatformBiome vanilla, BiomeTemplate config) { this.vanilla = vanilla; this.id = config.getID(); @@ -35,12 +35,12 @@ public class UserDefinedBiome implements Biome { tags.add("BIOME:" + id); tags.add("ALL"); } - + @Override public String toString() { return "{BIOME:" + getID() + "}"; } - + /** * Gets the Vanilla biomes to represent the custom biome. * @@ -50,26 +50,26 @@ public class UserDefinedBiome implements Biome { public PlatformBiome getPlatformBiome() { return vanilla; } - + @Override public int getColor() { return color; } - + @Override public Set getTags() { return tags; } - + @Override public String getID() { return id; } - + public BiomeTemplate getConfig() { return config; } - + @Override public Context getContext() { return context; diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolder.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolder.java index 31515ad5f..81a5973aa 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolder.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolder.java @@ -13,12 +13,12 @@ import com.dfsek.terra.api.world.chunk.generation.util.Palette; public class PaletteHolder { private final Palette[] palettes; private final int offset; - + protected PaletteHolder(Palette[] palettes, int offset) { this.palettes = palettes; this.offset = offset; } - + public Palette getPalette(int y) { int index = y + offset; return index >= 0 diff --git a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolderBuilder.java b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolderBuilder.java index fe2dd0c3f..e840f9817 100644 --- a/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolderBuilder.java +++ b/common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolderBuilder.java @@ -15,17 +15,17 @@ import com.dfsek.terra.api.world.chunk.generation.util.Palette; public class PaletteHolderBuilder { private final TreeMap paletteMap = new TreeMap<>(); - + public PaletteHolderBuilder add(int y, Palette palette) { paletteMap.put(y, palette); return this; } - + public PaletteHolder build() { - + int min = Math.min(paletteMap.keySet().stream().min(Integer::compareTo).orElse(0), 0); int max = Math.max(paletteMap.keySet().stream().max(Integer::compareTo).orElse(255), 255); - + Palette[] palettes = new Palette[paletteMap.lastKey() + 1 - min]; for(int y = min; y <= Math.max(paletteMap.lastKey(), max); y++) { Palette d = null; diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/DistributorAddon.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/DistributorAddon.java index 4b0423d9a..0006885a7 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/DistributorAddon.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/DistributorAddon.java @@ -37,32 +37,32 @@ public class DistributorAddon implements AddonInitializer { }; @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> { - CheckedRegistry>> distributorRegistry = event - .getPack() - .getOrCreateRegistry(DISTRIBUTOR_TOKEN); - - distributorRegistry.register(addon.key("SAMPLER"), SamplerDistributorTemplate::new); - distributorRegistry.register(addon.key("POINTS"), PointSetDistributorTemplate::new); - distributorRegistry.register(addon.key("PADDED_GRID"), PaddedGridDistributorTemplate::new); - distributorRegistry.register(addon.key("AND"), AndDistributorTemplate::new); - distributorRegistry.register(addon.key("OR"), OrDistributorTemplate::new); - distributorRegistry.register(addon.key("XOR"), XorDistributorTemplate::new); - distributorRegistry.register(addon.key("YES"), YesDistributorTemplate::new); - distributorRegistry.register(addon.key("NO"), NoDistributorTemplate::new); - - event.getPack() - .applyLoader(Point.class, PointTemplate::new); - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> { + CheckedRegistry>> distributorRegistry = event + .getPack() + .getOrCreateRegistry(DISTRIBUTOR_TOKEN); + + distributorRegistry.register(addon.key("SAMPLER"), SamplerDistributorTemplate::new); + distributorRegistry.register(addon.key("POINTS"), PointSetDistributorTemplate::new); + distributorRegistry.register(addon.key("PADDED_GRID"), PaddedGridDistributorTemplate::new); + distributorRegistry.register(addon.key("AND"), AndDistributorTemplate::new); + distributorRegistry.register(addon.key("OR"), OrDistributorTemplate::new); + distributorRegistry.register(addon.key("XOR"), XorDistributorTemplate::new); + distributorRegistry.register(addon.key("YES"), YesDistributorTemplate::new); + distributorRegistry.register(addon.key("NO"), NoDistributorTemplate::new); + + event.getPack() + .applyLoader(Point.class, PointTemplate::new); + }) + .failThrough(); } } diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/AndDistributorTemplate.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/AndDistributorTemplate.java index 0d07682b3..28408129f 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/AndDistributorTemplate.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/AndDistributorTemplate.java @@ -21,8 +21,8 @@ import com.dfsek.terra.api.structure.feature.Distributor; public class AndDistributorTemplate implements ObjectTemplate, ValidatedConfigTemplate { @Value("distributors") private @Meta List<@Meta Distributor> distributors; - - + + @Override public Distributor get() { Distributor current = distributors.remove(0); @@ -31,7 +31,7 @@ public class AndDistributorTemplate implements ObjectTemplate, Vali } return current; } - + @Override public boolean validate() throws ValidationException { if(distributors.isEmpty()) throw new ValidationException("AND Distributor must specify at least 1 distributor."); diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/OrDistributorTemplate.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/OrDistributorTemplate.java index f332bb64e..a48f912ec 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/OrDistributorTemplate.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/OrDistributorTemplate.java @@ -21,8 +21,8 @@ import com.dfsek.terra.api.structure.feature.Distributor; public class OrDistributorTemplate implements ObjectTemplate, ValidatedConfigTemplate { @Value("distributors") private @Meta List<@Meta Distributor> distributors; - - + + @Override public Distributor get() { Distributor current = distributors.remove(0); @@ -31,7 +31,7 @@ public class OrDistributorTemplate implements ObjectTemplate, Valid } return current; } - + @Override public boolean validate() throws ValidationException { if(distributors.isEmpty()) throw new ValidationException("OR Distributor must specify at least 1 distributor."); diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/PaddedGridDistributorTemplate.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/PaddedGridDistributorTemplate.java index ff77d18be..3c44e266d 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/PaddedGridDistributorTemplate.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/PaddedGridDistributorTemplate.java @@ -11,13 +11,13 @@ import com.dfsek.terra.api.structure.feature.Distributor; public class PaddedGridDistributorTemplate implements ObjectTemplate { @Value("width") private @Meta int width; - + @Value("padding") private @Meta int padding; - + @Value("salt") private @Meta int salt; - + @Override public Distributor get() { return new PaddedGridDistributor(width, padding, salt); diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/PointSetDistributorTemplate.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/PointSetDistributorTemplate.java index befa639d6..ef8e2649b 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/PointSetDistributorTemplate.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/PointSetDistributorTemplate.java @@ -21,7 +21,7 @@ import com.dfsek.terra.api.structure.feature.Distributor; public class PointSetDistributorTemplate implements ObjectTemplate { @Value("points") private @Meta Set<@Meta Point> points; - + @Override public Distributor get() { return new PointSetDistributor(points); diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/SamplerDistributorTemplate.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/SamplerDistributorTemplate.java index c670ead7c..6640fbe01 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/SamplerDistributorTemplate.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/SamplerDistributorTemplate.java @@ -24,7 +24,7 @@ public class SamplerDistributorTemplate implements ObjectTemplate { private @Meta double threshold = 0; @Value("sampler") private @Meta NoiseSampler noise; - + @Override public Distributor get() { return new SamplerDistributor(noise, threshold); diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/XorDistributorTemplate.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/XorDistributorTemplate.java index 8272ec949..ffeaa146b 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/XorDistributorTemplate.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/config/XorDistributorTemplate.java @@ -21,8 +21,8 @@ import com.dfsek.terra.api.structure.feature.Distributor; public class XorDistributorTemplate implements ObjectTemplate, ValidatedConfigTemplate { @Value("distributors") private @Meta List<@Meta Distributor> distributors; - - + + @Override public Distributor get() { Distributor current = distributors.remove(0); @@ -31,7 +31,7 @@ public class XorDistributorTemplate implements ObjectTemplate, Vali } return current; } - + @Override public boolean validate() throws ValidationException { if(distributors.isEmpty()) throw new ValidationException("XOR Distributor must specify at least 1 distributor."); diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PaddedGridDistributor.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PaddedGridDistributor.java index bba9a1a42..1779c98d1 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PaddedGridDistributor.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PaddedGridDistributor.java @@ -8,27 +8,27 @@ import com.dfsek.terra.api.util.MathUtil; public class PaddedGridDistributor implements Distributor { private final int width; - + private final int cellWidth; - + private final int salt; - + public PaddedGridDistributor(int width, int padding, int salt) { this.width = width; this.salt = salt; this.cellWidth = width + padding; } - + @Override public boolean matches(int x, int z, long seed) { int cellX = Math.floorDiv(x, cellWidth); int cellZ = Math.floorDiv(z, cellWidth); - + Random random = new Random((MathUtil.murmur64(MathUtil.squash(cellX, cellZ)) ^ seed) + salt); - + int pointX = random.nextInt(width) + cellX * cellWidth; int pointZ = random.nextInt(width) + cellZ * cellWidth; - + return x == pointX && z == pointZ; } } diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PointSetDistributor.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PointSetDistributor.java index 037906f4a..f85d41e5f 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PointSetDistributor.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PointSetDistributor.java @@ -15,11 +15,11 @@ import com.dfsek.terra.api.structure.feature.Distributor; public class PointSetDistributor implements Distributor { private final Set points; - + public PointSetDistributor(Set points) { this.points = points; } - + @Override public boolean matches(int x, int z, long seed) { return points.contains(new Point(x, z)); diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/SamplerDistributor.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/SamplerDistributor.java index e1d64d0cc..d93c85fa4 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/SamplerDistributor.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/SamplerDistributor.java @@ -13,14 +13,14 @@ import com.dfsek.terra.api.structure.feature.Distributor; public class SamplerDistributor implements Distributor { private final NoiseSampler sampler; - + private final double threshold; - + public SamplerDistributor(NoiseSampler sampler, double threshold) { this.sampler = sampler; this.threshold = threshold; } - + @Override public boolean matches(int x, int z, long seed) { return sampler.noise(seed, x, z) < threshold; diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/Point.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/Point.java index 6cd6c82bc..47248c6e2 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/Point.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/Point.java @@ -10,28 +10,28 @@ package com.dfsek.terra.addons.feature.distributor.util; public class Point { private final int x; private final int z; - + private final int hash; - + public Point(int x, int z) { this.x = x; this.z = z; this.hash = 31 * x + z; } - + public int getX() { return x; } - + public int getZ() { return z; } - + @Override public int hashCode() { return hash; } - + @Override public boolean equals(Object obj) { if(!(obj instanceof Point that)) return false; diff --git a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/PointTemplate.java b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/PointTemplate.java index 9455a261b..aabe7c004 100644 --- a/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/PointTemplate.java +++ b/common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/util/PointTemplate.java @@ -16,10 +16,10 @@ import com.dfsek.terra.api.config.meta.Meta; public class PointTemplate implements ObjectTemplate { @Value("x") private @Meta int x; - + @Value("z") private @Meta int z; - + @Override public Point get() { return new Point(x, z); diff --git a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/ConfiguredFeature.java b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/ConfiguredFeature.java index 6f7280d82..46066c9fb 100644 --- a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/ConfiguredFeature.java +++ b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/ConfiguredFeature.java @@ -18,13 +18,13 @@ import com.dfsek.terra.api.world.WritableWorld; public class ConfiguredFeature implements Feature { private final ProbabilityCollection structures; - + private final NoiseSampler structureSelector; private final Distributor distributor; private final Locator locator; - + private final String id; - + public ConfiguredFeature(ProbabilityCollection structures, NoiseSampler structureSelector, Distributor distributor, Locator locator, String id) { this.structures = structures; @@ -33,22 +33,22 @@ public class ConfiguredFeature implements Feature { this.locator = locator; this.id = id; } - + @Override public Structure getStructure(WritableWorld world, int x, int y, int z) { return structures.get(structureSelector, x, y, z, world.getSeed()); } - + @Override public Distributor getDistributor() { return distributor; } - + @Override public Locator getLocator() { return locator; } - + @Override public String getID() { return id; diff --git a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureAddon.java b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureAddon.java index ed06a7a7f..c8fee225b 100644 --- a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureAddon.java +++ b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureAddon.java @@ -18,16 +18,16 @@ import com.dfsek.terra.api.inject.annotations.Inject; public class FeatureAddon implements AddonInitializer { @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> event.getPack().registerConfigType(new FeatureConfigType(), addon.key("FEATURE"), 500)) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> event.getPack().registerConfigType(new FeatureConfigType(), addon.key("FEATURE"), 500)) + .failThrough(); } } diff --git a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureConfigType.java b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureConfigType.java index caf0f6b63..aeae9f9e0 100644 --- a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureConfigType.java +++ b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureConfigType.java @@ -18,19 +18,19 @@ import com.dfsek.terra.api.util.reflection.TypeKey; public class FeatureConfigType implements ConfigType { public static final TypeKey FEATURE_TYPE_KEY = new TypeKey<>() { }; - + private final FeatureFactory factory = new FeatureFactory(); - + @Override public FeatureTemplate getTemplate(ConfigPack pack, Platform platform) { return new FeatureTemplate(); } - + @Override public ConfigFactory getFactory() { return factory; } - + @Override public TypeKey getTypeKey() { return FEATURE_TYPE_KEY; diff --git a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureFactory.java b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureFactory.java index 981dee045..7d4d2be12 100644 --- a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureFactory.java +++ b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureFactory.java @@ -18,6 +18,6 @@ public class FeatureFactory implements ConfigFactory { @Override public Feature build(FeatureTemplate config, Platform platform) throws LoadException { return new ConfiguredFeature(config.getStructures(), config.getStructureNoise(), config.getDistributor(), config.getLocator(), - config.getID()); + config.getID()); } } diff --git a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureTemplate.java b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureTemplate.java index 3e98c4525..5e3eb95cc 100644 --- a/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureTemplate.java +++ b/common/addons/config-feature/src/main/java/com/dfsek/terra/addons/feature/FeatureTemplate.java @@ -23,36 +23,36 @@ public class FeatureTemplate implements AbstractableTemplate { @Value("id") @Final private String id; - + @Value("distributor") private @Meta Distributor distributor; - + @Value("locator") private @Meta Locator locator; - + @Value("structures.distribution") private @Meta NoiseSampler structureNoise; - + @Value("structures.structures") private @Meta ProbabilityCollection structures; - + @Override public String getID() { return id; } - + public Distributor getDistributor() { return distributor; } - + public Locator getLocator() { return locator; } - + public NoiseSampler getStructureNoise() { return structureNoise; } - + public ProbabilityCollection getStructures() { return structures; } diff --git a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraAddon.java b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraAddon.java index b3e4a4c35..132a52594 100644 --- a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraAddon.java +++ b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraAddon.java @@ -20,19 +20,19 @@ import com.dfsek.terra.api.inject.annotations.Inject; public class FloraAddon implements AddonInitializer { @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> { - event.getPack().registerConfigType(new FloraConfigType(), addon.key("FLORA"), 2); - event.getPack().applyLoader(BlockLayer.class, BlockLayerTemplate::new); - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> { + event.getPack().registerConfigType(new FloraConfigType(), addon.key("FLORA"), 2); + event.getPack().applyLoader(BlockLayer.class, BlockLayerTemplate::new); + }) + .failThrough(); } } diff --git a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraConfigType.java b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraConfigType.java index 259f5aa49..30e0f3ec8 100644 --- a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraConfigType.java +++ b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraConfigType.java @@ -19,17 +19,17 @@ public class FloraConfigType implements ConfigType { public static final TypeKey FLORA_TYPE_TOKEN = new TypeKey<>() { }; private final FloraFactory factory = new FloraFactory(); - + @Override public FloraTemplate getTemplate(ConfigPack pack, Platform platform) { return new FloraTemplate(); } - + @Override public ConfigFactory getFactory() { return factory; } - + @Override public TypeKey getTypeKey() { return FLORA_TYPE_TOKEN; diff --git a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraFactory.java b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraFactory.java index 72c695829..14a50d55a 100644 --- a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraFactory.java +++ b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraFactory.java @@ -17,7 +17,7 @@ public class FloraFactory implements ConfigFactory { @Override public TerraFlora build(FloraTemplate config, Platform platform) { return new TerraFlora(config.getLayers(), config.doPhysics(), config.isCeiling(), - config.getRotatable(), - config.getNoiseDistribution(), config.getID()); + config.getRotatable(), + config.getNoiseDistribution(), config.getID()); } } diff --git a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraTemplate.java b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraTemplate.java index 52a5e06ee..214a17ab4 100644 --- a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraTemplate.java +++ b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/FloraTemplate.java @@ -28,41 +28,41 @@ public class FloraTemplate implements AbstractableTemplate { @Value("rotatable") @Default private @Meta MaterialSet rotatable = MaterialSet.empty(); - + @Value("physics") @Default private @Meta boolean doPhysics = false; - + @Value("ceiling") @Default private @Meta boolean ceiling = false; - + @Value("layers") private @Meta List<@Meta BlockLayer> layers; - + @Value("layer-distribution") private @Meta NoiseSampler noiseDistribution; - + public boolean doPhysics() { return doPhysics; } - + public NoiseSampler getNoiseDistribution() { return noiseDistribution; } - + public List getLayers() { return layers; } - + public String getID() { return id; } - + public boolean isCeiling() { return ceiling; } - + public MaterialSet getRotatable() { return rotatable; } diff --git a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/config/BlockLayerTemplate.java b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/config/BlockLayerTemplate.java index dec0b5087..6b99c8277 100644 --- a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/config/BlockLayerTemplate.java +++ b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/config/BlockLayerTemplate.java @@ -19,10 +19,10 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; public class BlockLayerTemplate implements ObjectTemplate { @Value("layers") private @Meta int layers; - + @Value("materials") private @Meta ProbabilityCollection data; - + @Override public BlockLayer get() { return new BlockLayer(layers, data); diff --git a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/BlockLayer.java b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/BlockLayer.java index 8af76ec70..d372ac2fe 100644 --- a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/BlockLayer.java +++ b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/BlockLayer.java @@ -14,16 +14,16 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; public class BlockLayer { private final int layers; private final ProbabilityCollection blocks; - + public BlockLayer(int layers, ProbabilityCollection blocks) { this.layers = layers; this.blocks = blocks; } - + public int getLayers() { return layers; } - + public ProbabilityCollection getBlocks() { return blocks; } diff --git a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/TerraFlora.java b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/TerraFlora.java index 5707d392f..661b820f2 100644 --- a/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/TerraFlora.java +++ b/common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/TerraFlora.java @@ -27,13 +27,13 @@ public class TerraFlora implements Structure { private final List> layers; private final boolean physics; private final boolean ceiling; - + private final MaterialSet testRotation; - + private final NoiseSampler distribution; - + private final String id; - + public TerraFlora(List layers, boolean physics, boolean ceiling, MaterialSet testRotation, NoiseSampler distribution, String id) { @@ -42,7 +42,7 @@ public class TerraFlora implements Structure { this.ceiling = ceiling; this.distribution = distribution; this.id = id; - + this.layers = new ArrayList<>(); layers.forEach(layer -> { for(int i = 0; i < layer.getLayers(); i++) { @@ -50,17 +50,17 @@ public class TerraFlora implements Structure { } }); } - + private void test(EnumSet faces, Direction f, Vector3Int b, WritableWorld world) { if(testRotation.contains( - world.getBlockState(b.getX() + f.getModX(), b.getY() + f.getModY(), b.getZ() + f.getModZ()).getBlockType())) + world.getBlockState(b.getX() + f.getModX(), b.getY() + f.getModY(), b.getZ() + f.getModZ()).getBlockType())) faces.add(f); } - + private ProbabilityCollection getStateCollection(int layer) { return layers.get(Math.max(Math.min(layer, layers.size() - 1), 0)); } - + private EnumSet getFaces(Vector3Int b, WritableWorld world) { EnumSet faces = EnumSet.noneOf(Direction.class); test(faces, Direction.NORTH, b, world); @@ -69,24 +69,24 @@ public class TerraFlora implements Structure { test(faces, Direction.WEST, b, world); return faces; } - + @Override public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation) { boolean doRotation = testRotation.size() > 0; int size = layers.size(); int c = ceiling ? -1 : 1; - + EnumSet faces = doRotation ? getFaces(location.mutable().add(0, c, 0).immutable(), world) : EnumSet.noneOf( - Direction.class); + Direction.class); if(doRotation && faces.size() == 0) return false; // Don't plant if no faces are valid. - + for(int i = 0; Math.abs(i) < size; i += c) { // Down if ceiling, up if floor int lvl = (Math.abs(i)); BlockState data = getStateCollection((ceiling ? lvl : size - lvl - 1)).get(distribution, location.getX(), location.getY(), - location.getZ(), world.getSeed()); + location.getZ(), world.getSeed()); if(doRotation) { Direction oneFace = new ArrayList<>(faces).get( - new Random(location.getX() ^ location.getZ()).nextInt(faces.size())); // Get random face. + new Random(location.getX() ^ location.getZ()).nextInt(faces.size())); // Get random face. } world.setBlockState(location.mutable().add(0, i + c, 0).immutable(), data, physics); } diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/LocatorAddon.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/LocatorAddon.java index 2a08155cc..8a0896181 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/LocatorAddon.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/LocatorAddon.java @@ -43,52 +43,52 @@ import com.dfsek.terra.api.util.reflection.TypeKey; public class LocatorAddon implements AddonInitializer { - + public static final TypeKey>> LOCATOR_TOKEN = new TypeKey<>() { }; public static final TypeKey>> PATTERN_TOKEN = new TypeKey<>() { }; @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> { - CheckedRegistry>> locatorRegistry = event.getPack().getOrCreateRegistry(LOCATOR_TOKEN); - locatorRegistry.register(addon.key("SURFACE"), SurfaceLocatorTemplate::new); - locatorRegistry.register(addon.key("TOP"), TopLocatorTemplate::new); - - locatorRegistry.register(addon.key("RANDOM"), RandomLocatorTemplate::new); - locatorRegistry.register(addon.key("GAUSSIAN_RANDOM"), GaussianRandomLocatorTemplate::new); - - locatorRegistry.register(addon.key("PATTERN"), PatternLocatorTemplate::new); - locatorRegistry.register(addon.key("ADJACENT_PATTERN"), AdjacentPatternLocatorTemplate::new); - - locatorRegistry.register(addon.key("SAMPLER"), SamplerLocatorTemplate::new); - locatorRegistry.register(addon.key("SAMPLER_3D"), Sampler3DLocatorTemplate::new); - - locatorRegistry.register(addon.key("AND"), AndLocatorTemplate::new); - locatorRegistry.register(addon.key("OR"), OrLocatorTemplate::new); - locatorRegistry.register(addon.key("XOR"), XorLocatorTemplate::new); - }) - .then(event -> { - CheckedRegistry>> patternRegistry = event.getPack().getOrCreateRegistry(PATTERN_TOKEN); - patternRegistry.register(addon.key("MATCH_AIR"), AirMatchPatternTemplate::new); - patternRegistry.register(addon.key("MATCH_SOLID"), SolidMatchPatternTemplate::new); - patternRegistry.register(addon.key("MATCH"), SingleBlockMatchPatternTemplate::new); - patternRegistry.register(addon.key("MATCH_SET"), BlockSetMatchPatternTemplate::new); - - patternRegistry.register(addon.key("AND"), AndPatternTemplate::new); - patternRegistry.register(addon.key("OR"), OrPatternTemplate::new); - patternRegistry.register(addon.key("XOR"), XorPatternTemplate::new); - patternRegistry.register(addon.key("NOT"), NotPatternTemplate::new); - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> { + CheckedRegistry>> locatorRegistry = event.getPack().getOrCreateRegistry(LOCATOR_TOKEN); + locatorRegistry.register(addon.key("SURFACE"), SurfaceLocatorTemplate::new); + locatorRegistry.register(addon.key("TOP"), TopLocatorTemplate::new); + + locatorRegistry.register(addon.key("RANDOM"), RandomLocatorTemplate::new); + locatorRegistry.register(addon.key("GAUSSIAN_RANDOM"), GaussianRandomLocatorTemplate::new); + + locatorRegistry.register(addon.key("PATTERN"), PatternLocatorTemplate::new); + locatorRegistry.register(addon.key("ADJACENT_PATTERN"), AdjacentPatternLocatorTemplate::new); + + locatorRegistry.register(addon.key("SAMPLER"), SamplerLocatorTemplate::new); + locatorRegistry.register(addon.key("SAMPLER_3D"), Sampler3DLocatorTemplate::new); + + locatorRegistry.register(addon.key("AND"), AndLocatorTemplate::new); + locatorRegistry.register(addon.key("OR"), OrLocatorTemplate::new); + locatorRegistry.register(addon.key("XOR"), XorLocatorTemplate::new); + }) + .then(event -> { + CheckedRegistry>> patternRegistry = event.getPack().getOrCreateRegistry(PATTERN_TOKEN); + patternRegistry.register(addon.key("MATCH_AIR"), AirMatchPatternTemplate::new); + patternRegistry.register(addon.key("MATCH_SOLID"), SolidMatchPatternTemplate::new); + patternRegistry.register(addon.key("MATCH"), SingleBlockMatchPatternTemplate::new); + patternRegistry.register(addon.key("MATCH_SET"), BlockSetMatchPatternTemplate::new); + + patternRegistry.register(addon.key("AND"), AndPatternTemplate::new); + patternRegistry.register(addon.key("OR"), OrPatternTemplate::new); + patternRegistry.register(addon.key("XOR"), XorPatternTemplate::new); + patternRegistry.register(addon.key("NOT"), NotPatternTemplate::new); + }) + .failThrough(); } } diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AdjacentPatternLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AdjacentPatternLocatorTemplate.java index 8eddcf37b..9afff0a28 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AdjacentPatternLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AdjacentPatternLocatorTemplate.java @@ -22,14 +22,14 @@ import com.dfsek.terra.api.util.Range; public class AdjacentPatternLocatorTemplate implements ObjectTemplate { @Value("range") private @Meta Range range; - + @Value("pattern") private @Meta Pattern pattern; - + @Value("match-all") @Default private @Meta boolean matchAll = false; - + @Override public Locator get() { return new AdjacentPatternLocator(pattern, range, matchAll); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AndLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AndLocatorTemplate.java index cb7a4d7e8..3de3c59f1 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AndLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/AndLocatorTemplate.java @@ -21,7 +21,7 @@ import com.dfsek.terra.api.structure.feature.Locator; public class AndLocatorTemplate implements ObjectTemplate, ValidatedConfigTemplate { @Value("locators") private @Meta List<@Meta Locator> locators; - + @Override public Locator get() { Locator current = locators.remove(0); @@ -30,7 +30,7 @@ public class AndLocatorTemplate implements ObjectTemplate, ValidatedCon } return current; } - + @Override public boolean validate() throws ValidationException { if(locators.isEmpty()) throw new ValidationException("AND Pattern must specify at least 1 pattern."); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/GaussianRandomLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/GaussianRandomLocatorTemplate.java index 29f5cbc2d..350c818c2 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/GaussianRandomLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/GaussianRandomLocatorTemplate.java @@ -21,17 +21,17 @@ import com.dfsek.terra.api.util.Range; public class GaussianRandomLocatorTemplate implements ObjectTemplate { @Value("height") private @Meta Range height; - + @Value("amount") private @Meta Range amount; - + @Value("standard-deviation") private @Meta double standardDeviation; - + @Value("salt") @Default private @Meta int salt = 0; - + @Override public Locator get() { return new GaussianRandomLocator(height, amount, standardDeviation, salt); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/OrLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/OrLocatorTemplate.java index fbea60548..bbbb10e7f 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/OrLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/OrLocatorTemplate.java @@ -21,7 +21,7 @@ import com.dfsek.terra.api.structure.feature.Locator; public class OrLocatorTemplate implements ObjectTemplate, ValidatedConfigTemplate { @Value("locators") private @Meta List<@Meta Locator> locators; - + @Override public Locator get() { Locator current = locators.remove(0); @@ -30,7 +30,7 @@ public class OrLocatorTemplate implements ObjectTemplate, ValidatedConf } return current; } - + @Override public boolean validate() throws ValidationException { if(locators.isEmpty()) throw new ValidationException("OR Pattern must specify at least 1 pattern."); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/PatternLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/PatternLocatorTemplate.java index d46798288..a7e7c2fa7 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/PatternLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/PatternLocatorTemplate.java @@ -20,10 +20,10 @@ import com.dfsek.terra.api.util.Range; public class PatternLocatorTemplate implements ObjectTemplate { @Value("range") private @Meta Range range; - + @Value("pattern") private @Meta Pattern pattern; - + @Override public Locator get() { return new PatternLocator(pattern, range); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/RandomLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/RandomLocatorTemplate.java index 026729bc9..db73e11bd 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/RandomLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/RandomLocatorTemplate.java @@ -21,14 +21,14 @@ import com.dfsek.terra.api.util.Range; public class RandomLocatorTemplate implements ObjectTemplate { @Value("height") private @Meta Range height; - + @Value("amount") private @Meta Range amount; - + @Value("salt") @Default private @Meta int salt = 0; - + @Override public Locator get() { return new RandomLocator(height, amount, salt); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/Sampler3DLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/Sampler3DLocatorTemplate.java index 1ea0277cc..b0dfaab3d 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/Sampler3DLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/Sampler3DLocatorTemplate.java @@ -19,7 +19,7 @@ import com.dfsek.terra.api.structure.feature.Locator; public class Sampler3DLocatorTemplate implements ObjectTemplate { @Value("sampler") private @Meta NoiseSampler sampler; - + @Override public Locator get() { return new Sampler3DLocator(sampler); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SamplerLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SamplerLocatorTemplate.java index 6e1a16cb8..599d37e66 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SamplerLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SamplerLocatorTemplate.java @@ -21,7 +21,7 @@ import com.dfsek.terra.api.structure.feature.Locator; public class SamplerLocatorTemplate implements ObjectTemplate { @Value("samplers") private @Meta List<@Meta NoiseSampler> samplers; - + @Override public Locator get() { return new SamplerLocator(samplers); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SurfaceLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SurfaceLocatorTemplate.java index ec1c936aa..861adb0fd 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SurfaceLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/SurfaceLocatorTemplate.java @@ -19,7 +19,7 @@ import com.dfsek.terra.api.util.Range; public class SurfaceLocatorTemplate implements ObjectTemplate { @Value("range") private @Meta Range range; - + @Override public Locator get() { return new SurfaceLocator(range); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/TopLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/TopLocatorTemplate.java index 2cc582143..0967e47af 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/TopLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/TopLocatorTemplate.java @@ -17,10 +17,10 @@ import com.dfsek.terra.api.util.Range; public class TopLocatorTemplate implements ObjectTemplate { - + @Value("range") private @Meta Range range; - + @Override public Locator get() { return new TopLocator(range); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/XorLocatorTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/XorLocatorTemplate.java index 51b4e930e..48dca2bb0 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/XorLocatorTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/XorLocatorTemplate.java @@ -21,7 +21,7 @@ import com.dfsek.terra.api.structure.feature.Locator; public class XorLocatorTemplate implements ObjectTemplate, ValidatedConfigTemplate { @Value("locators") private @Meta List<@Meta Locator> locators; - + @Override public Locator get() { Locator current = locators.remove(0); @@ -30,7 +30,7 @@ public class XorLocatorTemplate implements ObjectTemplate, ValidatedCon } return current; } - + @Override public boolean validate() throws ValidationException { if(locators.isEmpty()) throw new ValidationException("XOR Pattern must specify at least 1 pattern."); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AirMatchPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AirMatchPatternTemplate.java index 763cb5d01..41398b9c7 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AirMatchPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AirMatchPatternTemplate.java @@ -20,8 +20,8 @@ import com.dfsek.terra.api.util.Range; public class AirMatchPatternTemplate implements ObjectTemplate { @Value("offset") private @Meta Range offset; - - + + @Override public Pattern get() { return new MatchPattern(offset, BlockState::isAir); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AndPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AndPatternTemplate.java index 34de500ce..59a786e4a 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AndPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/AndPatternTemplate.java @@ -21,7 +21,7 @@ import com.dfsek.terra.api.config.meta.Meta; public class AndPatternTemplate implements ObjectTemplate, ValidatedConfigTemplate { @Value("patterns") private @Meta List<@Meta Pattern> patterns; - + @Override public Pattern get() { Pattern current = patterns.remove(0); @@ -30,7 +30,7 @@ public class AndPatternTemplate implements ObjectTemplate, ValidatedCon } return current; } - + @Override public boolean validate() throws ValidationException { if(patterns.isEmpty()) throw new ValidationException("AND Pattern must specify at least 1 pattern."); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/BlockSetMatchPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/BlockSetMatchPatternTemplate.java index 216701a40..5b9be9beb 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/BlockSetMatchPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/BlockSetMatchPatternTemplate.java @@ -20,10 +20,10 @@ import com.dfsek.terra.api.util.collection.MaterialSet; public class BlockSetMatchPatternTemplate implements ObjectTemplate { @Value("blocks") private @Meta MaterialSet blocks; - + @Value("offset") private @Meta Range offset; - + @Override public Pattern get() { return new MatchPattern(offset, blockState -> blocks.contains(blockState.getBlockType())); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/NotPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/NotPatternTemplate.java index 17a413aac..6aa0d8689 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/NotPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/NotPatternTemplate.java @@ -17,7 +17,7 @@ import com.dfsek.terra.api.config.meta.Meta; public class NotPatternTemplate implements ObjectTemplate { @Value("pattern") private @Meta Pattern pattern; - + @Override public Pattern get() { return pattern.not(); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/OrPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/OrPatternTemplate.java index 429bec379..c97873fb6 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/OrPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/OrPatternTemplate.java @@ -21,7 +21,7 @@ import com.dfsek.terra.api.config.meta.Meta; public class OrPatternTemplate implements ObjectTemplate, ValidatedConfigTemplate { @Value("patterns") private @Meta List<@Meta Pattern> patterns; - + @Override public Pattern get() { Pattern current = patterns.remove(0); @@ -30,7 +30,7 @@ public class OrPatternTemplate implements ObjectTemplate, ValidatedConf } return current; } - + @Override public boolean validate() throws ValidationException { if(patterns.isEmpty()) throw new ValidationException("AND Pattern must specify at least 1 pattern."); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SingleBlockMatchPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SingleBlockMatchPatternTemplate.java index a89a54a99..72c791971 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SingleBlockMatchPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SingleBlockMatchPatternTemplate.java @@ -20,11 +20,11 @@ import com.dfsek.terra.api.util.Range; public class SingleBlockMatchPatternTemplate implements ObjectTemplate { @Value("block") private @Meta BlockState block; - + @Value("offset") private @Meta Range offset; - - + + @Override public Pattern get() { return new MatchPattern(offset, block::matches); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SolidMatchPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SolidMatchPatternTemplate.java index ba6395ad2..b3710d9f1 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SolidMatchPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/SolidMatchPatternTemplate.java @@ -18,7 +18,7 @@ import com.dfsek.terra.api.util.Range; public class SolidMatchPatternTemplate implements ObjectTemplate { @Value("offset") private Range offset; - + @Override public Pattern get() { return new MatchPattern(offset, blockState -> blockState.getBlockType().isSolid()); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/XorPatternTemplate.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/XorPatternTemplate.java index e15c97a75..5250a2129 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/XorPatternTemplate.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/config/pattern/XorPatternTemplate.java @@ -21,7 +21,7 @@ import com.dfsek.terra.api.config.meta.Meta; public class XorPatternTemplate implements ObjectTemplate, ValidatedConfigTemplate { @Value("patterns") private @Meta List<@Meta Pattern> patterns; - + @Override public Pattern get() { Pattern current = patterns.remove(0); @@ -30,7 +30,7 @@ public class XorPatternTemplate implements ObjectTemplate, ValidatedCon } return current; } - + @Override public boolean validate() throws ValidationException { if(patterns.isEmpty()) throw new ValidationException("AND Pattern must specify at least 1 pattern."); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/AdjacentPatternLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/AdjacentPatternLocator.java index ab11dd727..0cbf09c64 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/AdjacentPatternLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/AdjacentPatternLocator.java @@ -19,18 +19,18 @@ public class AdjacentPatternLocator implements Locator { private final Pattern pattern; private final Range search; private final boolean matchAll; - + public AdjacentPatternLocator(Pattern pattern, Range search, boolean matchAll) { this.pattern = pattern; this.search = search; this.matchAll = matchAll; } - + @Override public BinaryColumn getSuitableCoordinates(Column column) { return new BinaryColumn(search, y -> isValid(y, column)); } - + private boolean isValid(int y, Column column) { WritableWorld world = column.getWorld(); int x = column.getX(); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/GaussianRandomLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/GaussianRandomLocator.java index 06d3987f1..db1279ab9 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/GaussianRandomLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/GaussianRandomLocator.java @@ -18,40 +18,40 @@ import com.dfsek.terra.api.world.chunk.generation.util.Column.BinaryColumnBuilde public class GaussianRandomLocator implements Locator { private final double mean; - + private final Range points; - + private final double standardDeviation; - + private final int salt; - - + + public GaussianRandomLocator(Range height, Range points, double standardDeviation, int salt) { this.mean = (height.getMax() + height.getMin()) / 2.0; this.points = points; this.standardDeviation = standardDeviation; this.salt = salt; } - + @Override public BinaryColumn getSuitableCoordinates(Column column) { long seed = column.getWorld().getSeed(); seed = 31 * seed + column.getX(); seed = 31 * seed + column.getZ(); seed += salt; - + Random r = new Random(seed); - + int size = points.get(r); - - + + BinaryColumnBuilder results = column.newBinaryColumn(); for(int i = 0; i < size; i++) { int h = (int) r.nextGaussian(mean, standardDeviation); if(h >= column.getMaxY() || h < column.getMinY()) continue; results.set(h); } - + return results.build(); } } diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/PatternLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/PatternLocator.java index c43eb86ad..869d3cc0e 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/PatternLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/PatternLocator.java @@ -17,12 +17,12 @@ import com.dfsek.terra.api.world.chunk.generation.util.Column; public class PatternLocator implements Locator { private final Pattern pattern; private final Range search; - + public PatternLocator(Pattern pattern, Range search) { this.pattern = pattern; this.search = search; } - + @Override public BinaryColumn getSuitableCoordinates(Column column) { int min = Math.max(column.getMinY(), search.getMin()); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/RandomLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/RandomLocator.java index fc82ef7ef..1f8dbd19a 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/RandomLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/RandomLocator.java @@ -18,35 +18,35 @@ import com.dfsek.terra.api.world.chunk.generation.util.Column.BinaryColumnBuilde public class RandomLocator implements Locator { private final Range height; - + private final Range points; - + private final int salt; - + public RandomLocator(Range height, Range points, int salt) { this.height = height; this.points = points; this.salt = salt; } - + @Override public BinaryColumn getSuitableCoordinates(Column column) { long seed = column.getWorld().getSeed(); seed = 31 * seed + column.getX(); seed = 31 * seed + column.getZ(); seed += salt; - + Random r = new Random(seed); - + int size = points.get(r); - + BinaryColumnBuilder results = column.newBinaryColumn(); for(int i = 0; i < size; i++) { int h = height.get(r); if(h >= column.getMaxY() || h < column.getMinY()) continue; results.set(h); } - + return results.build(); } } diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/Sampler3DLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/Sampler3DLocator.java index eddbf9839..a91049299 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/Sampler3DLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/Sampler3DLocator.java @@ -15,11 +15,11 @@ import com.dfsek.terra.api.world.chunk.generation.util.Column; public class Sampler3DLocator implements Locator { private final NoiseSampler sampler; - + public Sampler3DLocator(NoiseSampler sampler) { this.sampler = sampler; } - + @Override public BinaryColumn getSuitableCoordinates(Column column) { long seed = column.getWorld().getSeed(); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SamplerLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SamplerLocator.java index 800ea3d36..42b04f4d7 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SamplerLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SamplerLocator.java @@ -18,11 +18,11 @@ import com.dfsek.terra.api.world.chunk.generation.util.Column.BinaryColumnBuilde public class SamplerLocator implements Locator { private final List samplers; - + public SamplerLocator(List samplers) { this.samplers = samplers; } - + private static int floorToInt(double value) { int valueInt = (int) value; if(value < 0.0) { @@ -35,18 +35,18 @@ public class SamplerLocator implements Locator { return valueInt; } } - + @Override public BinaryColumn getSuitableCoordinates(Column column) { BinaryColumnBuilder results = column.newBinaryColumn(); - + long seed = column.getWorld().getSeed(); samplers.forEach(sampler -> { int y = floorToInt(sampler.noise(seed, column.getX(), column.getZ())); if(y >= column.getMaxY() || y < column.getMinY()) return; results.set(y); }); - + return results.build(); } } diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SurfaceLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SurfaceLocator.java index 3fac2e7d1..9f7fd625f 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SurfaceLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SurfaceLocator.java @@ -16,11 +16,11 @@ import com.dfsek.terra.api.world.chunk.generation.util.Column.BinaryColumnBuilde public class SurfaceLocator implements Locator { private final Range search; - + public SurfaceLocator(Range search) { this.search = search; } - + @Override public BinaryColumn getSuitableCoordinates(Column column) { BinaryColumnBuilder builder = column.newBinaryColumn(); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/TopLocator.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/TopLocator.java index 9dbac41ca..35547d88d 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/TopLocator.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/TopLocator.java @@ -15,11 +15,11 @@ import com.dfsek.terra.api.world.chunk.generation.util.Column; public class TopLocator implements Locator { private final Range search; - + public TopLocator(Range search) { this.search = search; } - + @Override public BinaryColumn getSuitableCoordinates(Column column) { for(int y = search.getMax(); y >= search.getMin(); y--) { diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/MatchPattern.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/MatchPattern.java index 0832fee15..78a0e0232 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/MatchPattern.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/MatchPattern.java @@ -18,12 +18,12 @@ import com.dfsek.terra.api.world.chunk.generation.util.Column; public class MatchPattern implements Pattern { private final Range range; private final Predicate matches; - + public MatchPattern(Range range, Predicate matches) { this.range = range; this.matches = matches; } - + @Override public boolean matches(int y, Column column) { int min = Math.max(column.getMinY(), range.getMin() + y); @@ -34,7 +34,7 @@ public class MatchPattern implements Pattern { } return true; } - + @Override public boolean matches(WritableWorld world, int x, int y, int z) { int min = Math.max(world.getMinHeight(), range.getMin() + y); diff --git a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/Pattern.java b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/Pattern.java index 04a95e929..9d6617d39 100644 --- a/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/Pattern.java +++ b/common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/Pattern.java @@ -13,24 +13,24 @@ import com.dfsek.terra.api.world.chunk.generation.util.Column; public interface Pattern { boolean matches(int y, Column column); - + default boolean matches(WritableWorld world, int x, int y, int z) { return matches(y, world.column(x, z)); } - - + + default Pattern and(Pattern that) { return (y, column) -> this.matches(y, column) && that.matches(y, column); } - + default Pattern or(Pattern that) { return (y, column) -> this.matches(y, column) || that.matches(y, column); } - + default Pattern xor(Pattern that) { return (y, column) -> this.matches(y, column) ^ that.matches(y, column); } - + default Pattern not() { return (y, column) -> !this.matches(y, column); } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java index 1b3cb6409..ca3aa1a44 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java @@ -73,90 +73,90 @@ public class NoiseAddon implements AddonInitializer { }; @Inject private Platform plugin; - + @Inject private BaseAddon addon; - + @Override public void initialize() { plugin.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> { - CheckedRegistry>> noiseRegistry = event.getPack().getOrCreateRegistry( - NOISE_SAMPLER_TOKEN); - event.getPack() - .applyLoader(CellularSampler.DistanceFunction.class, - (type, o, loader, depthTracker) -> CellularSampler.DistanceFunction.valueOf((String) o)) - .applyLoader(CellularSampler.ReturnType.class, - (type, o, loader, depthTracker) -> CellularSampler.ReturnType.valueOf((String) o)) - .applyLoader(DistanceSampler.DistanceFunction.class, - (type, o, loader, depthTracker) -> DistanceSampler.DistanceFunction.valueOf((String) o)) - .applyLoader(DimensionApplicableNoiseSampler.class, DimensionApplicableNoiseSampler::new) - .applyLoader(FunctionTemplate.class, FunctionTemplate::new) - .applyLoader(CubicSpline.Point.class, CubicSplinePointTemplate::new); - - noiseRegistry.register(addon.key("LINEAR"), LinearNormalizerTemplate::new); - noiseRegistry.register(addon.key("NORMAL"), NormalNormalizerTemplate::new); - noiseRegistry.register(addon.key("CLAMP"), ClampNormalizerTemplate::new); - noiseRegistry.register(addon.key("PROBABILITY"), ProbabilityNormalizerTemplate::new); - noiseRegistry.register(addon.key("SCALE"), ScaleNormalizerTemplate::new); - noiseRegistry.register(addon.key("POSTERIZATION"), PosterizationNormalizerTemplate::new); - noiseRegistry.register(addon.key("CUBIC_SPLINE"), CubicSplineNormalizerTemplate::new); - - noiseRegistry.register(addon.key("IMAGE"), ImageSamplerTemplate::new); - - noiseRegistry.register(addon.key("DOMAIN_WARP"), DomainWarpTemplate::new); - - noiseRegistry.register(addon.key("FBM"), BrownianMotionTemplate::new); - noiseRegistry.register(addon.key("PING_PONG"), PingPongTemplate::new); - noiseRegistry.register(addon.key("RIDGED"), RidgedFractalTemplate::new); - - noiseRegistry.register(addon.key("OPEN_SIMPLEX_2"), () -> new SimpleNoiseTemplate(OpenSimplex2Sampler::new)); - noiseRegistry.register(addon.key("OPEN_SIMPLEX_2S"), () -> new SimpleNoiseTemplate(OpenSimplex2SSampler::new)); - noiseRegistry.register(addon.key("PERLIN"), () -> new SimpleNoiseTemplate(PerlinSampler::new)); - noiseRegistry.register(addon.key("SIMPLEX"), () -> new SimpleNoiseTemplate(SimplexSampler::new)); - noiseRegistry.register(addon.key("GABOR"), GaborNoiseTemplate::new); - - - noiseRegistry.register(addon.key("VALUE"), () -> new SimpleNoiseTemplate(ValueSampler::new)); - noiseRegistry.register(addon.key("VALUE_CUBIC"), () -> new SimpleNoiseTemplate(ValueCubicSampler::new)); - - noiseRegistry.register(addon.key("CELLULAR"), CellularNoiseTemplate::new); - - noiseRegistry.register(addon.key("WHITE_NOISE"), () -> new SimpleNoiseTemplate(WhiteNoiseSampler::new)); - noiseRegistry.register(addon.key("POSITIVE_WHITE_NOISE"), () -> new SimpleNoiseTemplate(PositiveWhiteNoiseSampler::new)); - noiseRegistry.register(addon.key("GAUSSIAN"), () -> new SimpleNoiseTemplate(GaussianNoiseSampler::new)); - - noiseRegistry.register(addon.key("DISTANCE"), DistanceSamplerTemplate::new); - - noiseRegistry.register(addon.key("CONSTANT"), ConstantNoiseTemplate::new); - - noiseRegistry.register(addon.key("KERNEL"), KernelTemplate::new); - - noiseRegistry.register(addon.key("LINEAR_HEIGHTMAP"), LinearHeightmapSamplerTemplate::new); - noiseRegistry.register(addon.key("TRANSLATE"), TranslateSamplerTemplate::new); - - noiseRegistry.register(addon.key("ADD"), () -> new BinaryArithmeticTemplate<>(AdditionSampler::new)); - noiseRegistry.register(addon.key("SUB"), () -> new BinaryArithmeticTemplate<>(SubtractionSampler::new)); - noiseRegistry.register(addon.key("MUL"), () -> new BinaryArithmeticTemplate<>(MultiplicationSampler::new)); - noiseRegistry.register(addon.key("DIV"), () -> new BinaryArithmeticTemplate<>(DivisionSampler::new)); - noiseRegistry.register(addon.key("MAX"), () -> new BinaryArithmeticTemplate<>(MaxSampler::new)); - noiseRegistry.register(addon.key("MIN"), () -> new BinaryArithmeticTemplate<>(MinSampler::new)); - - - Map packSamplers = new LinkedHashMap<>(); - Map packFunctions = new LinkedHashMap<>(); - noiseRegistry.register(addon.key("EXPRESSION"), () -> new ExpressionFunctionTemplate(packSamplers, packFunctions)); - noiseRegistry.register(addon.key("EXPRESSION_NORMALIZER"), - () -> new ExpressionNormalizerTemplate(packSamplers, packFunctions)); - - NoiseConfigPackTemplate template = event.loadTemplate(new NoiseConfigPackTemplate()); - packSamplers.putAll(template.getSamplers()); - packFunctions.putAll(template.getFunctions()); - event.getPack().getContext().put(template); - }) - .priority(50) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> { + CheckedRegistry>> noiseRegistry = event.getPack().getOrCreateRegistry( + NOISE_SAMPLER_TOKEN); + event.getPack() + .applyLoader(CellularSampler.DistanceFunction.class, + (type, o, loader, depthTracker) -> CellularSampler.DistanceFunction.valueOf((String) o)) + .applyLoader(CellularSampler.ReturnType.class, + (type, o, loader, depthTracker) -> CellularSampler.ReturnType.valueOf((String) o)) + .applyLoader(DistanceSampler.DistanceFunction.class, + (type, o, loader, depthTracker) -> DistanceSampler.DistanceFunction.valueOf((String) o)) + .applyLoader(DimensionApplicableNoiseSampler.class, DimensionApplicableNoiseSampler::new) + .applyLoader(FunctionTemplate.class, FunctionTemplate::new) + .applyLoader(CubicSpline.Point.class, CubicSplinePointTemplate::new); + + noiseRegistry.register(addon.key("LINEAR"), LinearNormalizerTemplate::new); + noiseRegistry.register(addon.key("NORMAL"), NormalNormalizerTemplate::new); + noiseRegistry.register(addon.key("CLAMP"), ClampNormalizerTemplate::new); + noiseRegistry.register(addon.key("PROBABILITY"), ProbabilityNormalizerTemplate::new); + noiseRegistry.register(addon.key("SCALE"), ScaleNormalizerTemplate::new); + noiseRegistry.register(addon.key("POSTERIZATION"), PosterizationNormalizerTemplate::new); + noiseRegistry.register(addon.key("CUBIC_SPLINE"), CubicSplineNormalizerTemplate::new); + + noiseRegistry.register(addon.key("IMAGE"), ImageSamplerTemplate::new); + + noiseRegistry.register(addon.key("DOMAIN_WARP"), DomainWarpTemplate::new); + + noiseRegistry.register(addon.key("FBM"), BrownianMotionTemplate::new); + noiseRegistry.register(addon.key("PING_PONG"), PingPongTemplate::new); + noiseRegistry.register(addon.key("RIDGED"), RidgedFractalTemplate::new); + + noiseRegistry.register(addon.key("OPEN_SIMPLEX_2"), () -> new SimpleNoiseTemplate(OpenSimplex2Sampler::new)); + noiseRegistry.register(addon.key("OPEN_SIMPLEX_2S"), () -> new SimpleNoiseTemplate(OpenSimplex2SSampler::new)); + noiseRegistry.register(addon.key("PERLIN"), () -> new SimpleNoiseTemplate(PerlinSampler::new)); + noiseRegistry.register(addon.key("SIMPLEX"), () -> new SimpleNoiseTemplate(SimplexSampler::new)); + noiseRegistry.register(addon.key("GABOR"), GaborNoiseTemplate::new); + + + noiseRegistry.register(addon.key("VALUE"), () -> new SimpleNoiseTemplate(ValueSampler::new)); + noiseRegistry.register(addon.key("VALUE_CUBIC"), () -> new SimpleNoiseTemplate(ValueCubicSampler::new)); + + noiseRegistry.register(addon.key("CELLULAR"), CellularNoiseTemplate::new); + + noiseRegistry.register(addon.key("WHITE_NOISE"), () -> new SimpleNoiseTemplate(WhiteNoiseSampler::new)); + noiseRegistry.register(addon.key("POSITIVE_WHITE_NOISE"), () -> new SimpleNoiseTemplate(PositiveWhiteNoiseSampler::new)); + noiseRegistry.register(addon.key("GAUSSIAN"), () -> new SimpleNoiseTemplate(GaussianNoiseSampler::new)); + + noiseRegistry.register(addon.key("DISTANCE"), DistanceSamplerTemplate::new); + + noiseRegistry.register(addon.key("CONSTANT"), ConstantNoiseTemplate::new); + + noiseRegistry.register(addon.key("KERNEL"), KernelTemplate::new); + + noiseRegistry.register(addon.key("LINEAR_HEIGHTMAP"), LinearHeightmapSamplerTemplate::new); + noiseRegistry.register(addon.key("TRANSLATE"), TranslateSamplerTemplate::new); + + noiseRegistry.register(addon.key("ADD"), () -> new BinaryArithmeticTemplate<>(AdditionSampler::new)); + noiseRegistry.register(addon.key("SUB"), () -> new BinaryArithmeticTemplate<>(SubtractionSampler::new)); + noiseRegistry.register(addon.key("MUL"), () -> new BinaryArithmeticTemplate<>(MultiplicationSampler::new)); + noiseRegistry.register(addon.key("DIV"), () -> new BinaryArithmeticTemplate<>(DivisionSampler::new)); + noiseRegistry.register(addon.key("MAX"), () -> new BinaryArithmeticTemplate<>(MaxSampler::new)); + noiseRegistry.register(addon.key("MIN"), () -> new BinaryArithmeticTemplate<>(MinSampler::new)); + + + Map packSamplers = new LinkedHashMap<>(); + Map packFunctions = new LinkedHashMap<>(); + noiseRegistry.register(addon.key("EXPRESSION"), () -> new ExpressionFunctionTemplate(packSamplers, packFunctions)); + noiseRegistry.register(addon.key("EXPRESSION_NORMALIZER"), + () -> new ExpressionNormalizerTemplate(packSamplers, packFunctions)); + + NoiseConfigPackTemplate template = event.loadTemplate(new NoiseConfigPackTemplate()); + packSamplers.putAll(template.getSamplers()); + packFunctions.putAll(template.getFunctions()); + event.getPack().getContext().put(template); + }) + .priority(50) + .failThrough(); } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseConfigPackTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseConfigPackTemplate.java index 18c7240bb..c41af1763 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseConfigPackTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseConfigPackTemplate.java @@ -25,15 +25,15 @@ public class NoiseConfigPackTemplate implements ConfigTemplate, Properties { @Value("samplers") @Default private @Meta Map noiseBuilderMap = new LinkedHashMap<>(); - + @Value("functions") @Default private @Meta LinkedHashMap expressions = new LinkedHashMap<>(); - + public Map getSamplers() { return noiseBuilderMap; } - + public LinkedHashMap getFunctions() { return expressions; } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/CubicSplinePointTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/CubicSplinePointTemplate.java index d7dea18e5..1a0c7c35a 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/CubicSplinePointTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/CubicSplinePointTemplate.java @@ -8,16 +8,16 @@ import com.dfsek.terra.api.config.meta.Meta; public class CubicSplinePointTemplate implements ObjectTemplate { - + @Value("from") private @Meta double from; - + @Value("to") private @Meta double to; - + @Value("gradient") private @Meta double gradient; - + @Override public Point get() { return new Point(from, to, gradient); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/DimensionApplicableNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/DimensionApplicableNoiseSampler.java index 392994120..bc5d32555 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/DimensionApplicableNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/DimensionApplicableNoiseSampler.java @@ -17,19 +17,19 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class DimensionApplicableNoiseSampler implements ObjectTemplate { @Value("dimensions") private @Meta int dimensions; - + @Value(".") private @Meta NoiseSampler sampler; - + @Override public DimensionApplicableNoiseSampler get() { return this; } - + public int getDimensions() { return dimensions; } - + public NoiseSampler getSampler() { return sampler; } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/BinaryArithmeticTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/BinaryArithmeticTemplate.java index 2f05af842..67427c189 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/BinaryArithmeticTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/BinaryArithmeticTemplate.java @@ -15,11 +15,11 @@ public class BinaryArithmeticTemplate extends private @Meta NoiseSampler left; @Value("right") private @Meta NoiseSampler right; - + public BinaryArithmeticTemplate(BiFunction function) { this.function = function; } - + @Override public T get() { return function.apply(left, right); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/DomainWarpTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/DomainWarpTemplate.java index 442a54a64..6780d593e 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/DomainWarpTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/DomainWarpTemplate.java @@ -19,14 +19,14 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class DomainWarpTemplate extends SamplerTemplate { @Value("warp") private @Meta NoiseSampler warp; - + @Value("sampler") private @Meta NoiseSampler function; - + @Value("amplitude") @Default private @Meta double amplitude = 1; - + @Override public NoiseSampler get() { return new DomainWarpedSampler(function, warp, amplitude); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/FunctionTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/FunctionTemplate.java index e83dfb9aa..543ac908a 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/FunctionTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/FunctionTemplate.java @@ -22,31 +22,31 @@ import com.dfsek.terra.api.config.meta.Meta; public class FunctionTemplate implements ObjectTemplate { @Value("arguments") private List args; - + @Value("expression") private @Meta String function; - + @Value("functions") @Default private @Meta LinkedHashMap functions = new LinkedHashMap<>(); - + @Override public FunctionTemplate get() { return this; } - + public List getArgs() { return args; } - + public String getFunction() { return function; } - + public LinkedHashMap getFunctions() { return functions; } - + @Override public boolean equals(Object o) { if(this == o) return true; @@ -54,7 +54,7 @@ public class FunctionTemplate implements ObjectTemplate { FunctionTemplate that = (FunctionTemplate) o; return args.equals(that.args) && function.equals(that.function) && functions.equals(that.functions); } - + @Override public int hashCode() { return Objects.hash(args, function, functions); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/ImageSamplerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/ImageSamplerTemplate.java index 8d37ad27b..c7359426c 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/ImageSamplerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/ImageSamplerTemplate.java @@ -20,20 +20,20 @@ import com.dfsek.terra.api.noise.NoiseSampler; @SuppressWarnings({ "unused", "FieldMayBeFinal" }) public class ImageSamplerTemplate extends SamplerTemplate { - + private static final Logger logger = LoggerFactory.getLogger(ImageSamplerTemplate.class); - + private static boolean used = false; - + @Value("image") private @Meta BufferedImage image; - + @Value("frequency") private @Meta double frequency; - + @Value("channel") private ImageSampler.@Meta Channel channel; - + @Override public NoiseSampler get() { if(!used) { diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/KernelTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/KernelTemplate.java index baae3f0cb..3d2478e35 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/KernelTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/KernelTemplate.java @@ -20,50 +20,50 @@ import com.dfsek.terra.api.noise.NoiseSampler; @SuppressWarnings({ "unused", "FieldMayBeFinal" }) public class KernelTemplate extends SamplerTemplate { - + @Value("kernel") private @Meta List<@Meta List<@Meta Double>> kernel; - + @Value("factor") @Default private @Meta double factor = 1; - + @Value("sampler") private @Meta NoiseSampler function; - + @Value("frequency") @Default private @Meta double frequency = 1; - + @Override public NoiseSampler get() { double[][] k = new double[kernel.size()][kernel.get(0).size()]; - + for(int x = 0; x < kernel.size(); x++) { for(int y = 0; y < kernel.get(x).size(); y++) { k[x][y] = kernel.get(x).get(y) * factor; } } - + KernelSampler sampler = new KernelSampler(k, function); sampler.setFrequency(frequency); return sampler; } - + @Override public boolean validate() throws ValidationException { - + if(kernel.isEmpty()) throw new ValidationException("Kernel must not be empty."); - + int len = kernel.get(0).size(); - + if(len == 0) throw new ValidationException("Kernel row must contain data."); - + for(int i = 0; i < kernel.size(); i++) { if(kernel.get(i).size() != len) throw new ValidationException("Kernel row " + i + " size mismatch. Expected " + len + ", found " + kernel.get(i).size()); } - + return super.validate(); } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/LinearHeightmapSamplerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/LinearHeightmapSamplerTemplate.java index d4339968e..0ee38f28d 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/LinearHeightmapSamplerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/LinearHeightmapSamplerTemplate.java @@ -13,14 +13,14 @@ public class LinearHeightmapSamplerTemplate extends SamplerTemplate implements Validat @Value("dimensions") @Default private @Meta int dimensions = 2; - + @Override public boolean validate() throws ValidationException { if(dimensions != 2 && dimensions != 3) throw new ValidationException("Illegal amount of dimensions: " + dimensions); return true; } - + public int getDimensions() { return dimensions; } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/TranslateSamplerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/TranslateSamplerTemplate.java index 3e5265ff5..a37d125d0 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/TranslateSamplerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/TranslateSamplerTemplate.java @@ -9,22 +9,22 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class TranslateSamplerTemplate extends SamplerTemplate { - + @Value("sampler") private NoiseSampler sampler; - + @Value("x") @Default private @Meta double x = 0; - + @Value("y") @Default private @Meta double y = 0; - + @Value("z") @Default private @Meta double z = 0; - + @Override public NoiseSampler get() { return new TranslateSampler(sampler, x, y, z); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/CellularNoiseTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/CellularNoiseTemplate.java index 2d282e289..01b370e55 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/CellularNoiseTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/CellularNoiseTemplate.java @@ -21,20 +21,20 @@ public class CellularNoiseTemplate extends NoiseTemplate { @Value("distance") @Default private CellularSampler.@Meta DistanceFunction cellularDistanceFunction = CellularSampler.DistanceFunction.EuclideanSq; - + @Value("return") @Default private CellularSampler.@Meta ReturnType cellularReturnType = CellularSampler.ReturnType.Distance; - + @Value("jitter") @Default private @Meta double cellularJitter = 1.0D; - - + + @Value("lookup") @Default private @Meta NoiseSampler lookup = new OpenSimplex2Sampler(); - + @Override public NoiseSampler get() { CellularSampler sampler = new CellularSampler(); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ConstantNoiseTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ConstantNoiseTemplate.java index 16272bd45..4755f5f8d 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ConstantNoiseTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ConstantNoiseTemplate.java @@ -21,7 +21,7 @@ public class ConstantNoiseTemplate extends SamplerTemplate { @Value("value") @Default private @Meta double value = 0d; - + @Override public NoiseSampler get() { return new ConstantSampler(value); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/DistanceSamplerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/DistanceSamplerTemplate.java index 1bd6fb2dc..f39405cf4 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/DistanceSamplerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/DistanceSamplerTemplate.java @@ -10,31 +10,31 @@ import com.dfsek.terra.api.config.meta.Meta; public class DistanceSamplerTemplate extends SamplerTemplate { - + @Value("distance-function") @Default private DistanceSampler.@Meta DistanceFunction distanceFunction = DistanceFunction.Euclidean; - + @Value("point.x") @Default private @Meta double x = 0; - + @Value("point.y") @Default private @Meta double y = 0; - + @Value("point.z") @Default private @Meta double z = 0; - + @Value("normalize") @Default private @Meta boolean normalize = false; - + @Value("radius") @Default private @Meta double normalizeRadius = 100; - + @Override public DistanceSampler get() { return new DistanceSampler(distanceFunction, x, y, z, normalize, normalizeRadius); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java index 425181589..3268af5b0 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java @@ -40,13 +40,13 @@ public class ExpressionFunctionTemplate extends SamplerTemplate functions = new LinkedHashMap<>(); - + public ExpressionFunctionTemplate(Map globalSamplers, Map globalFunctions) { this.globalSamplers = globalSamplers; this.globalFunctions = globalFunctions; } - + @Override public NoiseSampler get() { var mergedFunctions = new HashMap<>(globalFunctions); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/GaborNoiseTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/GaborNoiseTemplate.java index 0d27ec7f6..ef32def58 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/GaborNoiseTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/GaborNoiseTemplate.java @@ -20,23 +20,23 @@ public class GaborNoiseTemplate extends NoiseTemplate { @Value("rotation") @Default private @Meta double rotation = 0.25; - + @Value("isotropic") @Default private @Meta boolean isotropic = true; - + @Value("deviation") @Default private @Meta double deviation = 1.0; - + @Value("impulses") @Default private @Meta double impulses = 64d; - + @Value("frequency_0") @Default private @Meta double f0 = 0.625; - + @Override public NoiseSampler get() { GaborNoiseSampler gaborNoiseSampler = new GaborNoiseSampler(); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/NoiseTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/NoiseTemplate.java index c039c597f..b83971c14 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/NoiseTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/NoiseTemplate.java @@ -20,7 +20,7 @@ public abstract class NoiseTemplate extends SamplerTemp @Value("frequency") @Default protected @Meta double frequency = 0.02d; - + @Value("salt") @Default protected @Meta long salt = 0; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/SimpleNoiseTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/SimpleNoiseTemplate.java index 6f098eb89..5a9c497a5 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/SimpleNoiseTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/SimpleNoiseTemplate.java @@ -15,11 +15,11 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class SimpleNoiseTemplate extends NoiseTemplate { private final Supplier samplerSupplier; - + public SimpleNoiseTemplate(Supplier samplerSupplier) { this.samplerSupplier = samplerSupplier; } - + @Override public NoiseSampler get() { NoiseFunction sampler = samplerSupplier.get(); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/FractalTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/FractalTemplate.java index af7e7d18f..c363235b3 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/FractalTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/FractalTemplate.java @@ -20,19 +20,19 @@ public abstract class FractalTemplate extends Sa @Value("octaves") @Default protected @Meta int octaves = 3; - + @Value("gain") @Default protected @Meta double fractalGain = 0.5D; - + @Value("lacunarity") @Default protected @Meta double fractalLacunarity = 2.0D; - + @Value("weighted-strength") @Default protected @Meta double weightedStrength = 0.0D; - + @Value("sampler") protected @Meta NoiseSampler function; } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/PingPongTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/PingPongTemplate.java index f37fa3297..3092c7cb8 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/PingPongTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/fractal/PingPongTemplate.java @@ -20,7 +20,7 @@ public class PingPongTemplate extends FractalTemplate { @Value("ping-pong") @Default private @Meta double pingPong = 2.0D; - + @Override public NoiseSampler get() { PingPongSampler sampler = new PingPongSampler(function); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ClampNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ClampNormalizerTemplate.java index 87f1511f4..6e8cdb2e4 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ClampNormalizerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ClampNormalizerTemplate.java @@ -18,10 +18,10 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class ClampNormalizerTemplate extends NormalizerTemplate { @Value("max") private @Meta double max; - + @Value("min") private @Meta double min; - + @Override public NoiseSampler get() { return new ClampNormalizer(function, min, max); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/CubicSplineNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/CubicSplineNormalizerTemplate.java index 67e537fad..672d1db90 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/CubicSplineNormalizerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/CubicSplineNormalizerTemplate.java @@ -12,10 +12,10 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class CubicSplineNormalizerTemplate extends NormalizerTemplate { - + @Value("points") private @Meta List<@Meta Point> points; - + @Override public NoiseSampler get() { return new CubicSplineNoiseSampler(function, new CubicSpline(points)); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java index f0a2e9db1..4254f4798 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java @@ -26,31 +26,31 @@ import static com.dfsek.terra.addons.noise.paralithic.FunctionUtil.convertFuncti @SuppressWarnings({ "unused", "FieldMayBeFinal" }) public class ExpressionNormalizerTemplate extends NormalizerTemplate { - + private final Map globalSamplers; private final Map globalFunctions; - + @Value("expression") private @Meta String expression; - + @Value("variables") @Default private @Meta Map vars = new HashMap<>(); - + @Value("samplers") @Default private @Meta LinkedHashMap samplers = new LinkedHashMap<>(); - + @Value("functions") @Default private @Meta LinkedHashMap functions = new LinkedHashMap<>(); - + public ExpressionNormalizerTemplate(Map globalSamplers, Map globalFunctions) { this.globalSamplers = globalSamplers; this.globalFunctions = globalFunctions; } - + @Override public NoiseSampler get() { var mergedFunctions = new HashMap<>(globalFunctions); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/LinearNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/LinearNormalizerTemplate.java index 61bb3f073..faa0818bc 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/LinearNormalizerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/LinearNormalizerTemplate.java @@ -18,10 +18,10 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class LinearNormalizerTemplate extends NormalizerTemplate { @Value("max") private @Meta double max; - + @Value("min") private @Meta double min; - + @Override public NoiseSampler get() { return new LinearNormalizer(function, min, max); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/NormalNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/NormalNormalizerTemplate.java index e1278d90e..b33e5b2b7 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/NormalNormalizerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/NormalNormalizerTemplate.java @@ -19,14 +19,14 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class NormalNormalizerTemplate extends NormalizerTemplate { @Value("mean") private @Meta double mean; - + @Value("standard-deviation") private @Meta double stdDev; - + @Value("groups") @Default private @Meta int groups = 16384; - + @Override public NoiseSampler get() { return new NormalNormalizer(function, groups, mean, stdDev); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/PosterizationNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/PosterizationNormalizerTemplate.java index 8ea32e6a5..c0ec213d7 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/PosterizationNormalizerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/PosterizationNormalizerTemplate.java @@ -18,7 +18,7 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class PosterizationNormalizerTemplate extends NormalizerTemplate { @Value("steps") private @Meta int steps; - + @Override public NoiseSampler get() { return new PosterizationNormalizer(function, steps); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ScaleNormalizerTemplate.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ScaleNormalizerTemplate.java index 767c7aaca..c21966cd2 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ScaleNormalizerTemplate.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ScaleNormalizerTemplate.java @@ -10,7 +10,7 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class ScaleNormalizerTemplate extends NormalizerTemplate { @Value("amplitude") private @Meta double amplitude; - + @Override public NoiseSampler get() { return new ScaleNormalizer(function, amplitude); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java index fa595b879..a9b0764b6 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java @@ -9,30 +9,30 @@ import static com.dfsek.terra.api.util.MathUtil.lerp; public class CubicSpline { - + private final double[] fromValues; private final double[] toValues; private final double[] gradients; - + public CubicSpline(List points) { Collections.sort(points); - + this.fromValues = new double[points.size()]; this.toValues = new double[points.size()]; this.gradients = new double[points.size()]; - + for(int i = 0; i < points.size(); i++) { fromValues[i] = points.get(i).from; toValues[i] = points.get(i).to; gradients[i] = points.get(i).gradient; } } - + public static double calculate(double in, double[] fromValues, double[] toValues, double[] gradients) { int pointIdx = floorBinarySearch(in, fromValues) - 1; - + int pointIdxLast = fromValues.length - 1; - + if(pointIdx < 0) { // If to left of first point return linear function intersecting said point using point's gradient return gradients[0] * (in - fromValues[0]) + toValues[0]; } else if(pointIdx == pointIdxLast) { // Do same if to right of last point @@ -40,23 +40,23 @@ public class CubicSpline { } else { double fromLeft = fromValues[pointIdx]; double fromRight = fromValues[pointIdx + 1]; - + double toLeft = toValues[pointIdx]; double toRight = toValues[pointIdx + 1]; - + double gradientLeft = gradients[pointIdx]; double gradientRight = gradients[pointIdx + 1]; - + double fromDelta = fromRight - fromLeft; double toDelta = toRight - toLeft; - + double t = (in - fromLeft) / fromDelta; - + return lerp(t, toLeft, toRight) + t * (1.0F - t) * lerp(t, gradientLeft * fromDelta - toDelta, - -gradientRight * fromDelta + toDelta); + -gradientRight * fromDelta + toDelta); } } - + private static int floorBinarySearch(double targetValue, double[] values) { int left = 0; int right = values.length; @@ -73,14 +73,14 @@ public class CubicSpline { } return left; } - + public double apply(double in) { return calculate(in, fromValues, toValues, gradients); } - - + + public record Point(double from, double to, double gradient) implements Comparable { - + @Override public int compareTo(@NotNull CubicSpline.Point o) { return Double.compare(from, o.from); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ClampNormalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ClampNormalizer.java index f195bfddb..76b85de0a 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ClampNormalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ClampNormalizer.java @@ -13,13 +13,13 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class ClampNormalizer extends Normalizer { private final double min; private final double max; - + public ClampNormalizer(NoiseSampler sampler, double min, double max) { super(sampler); this.min = min; this.max = max; } - + @Override public double normalize(double in) { return Math.max(Math.min(in, max), min); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/CubicSplineNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/CubicSplineNoiseSampler.java index 24af8e351..4786d69c6 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/CubicSplineNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/CubicSplineNoiseSampler.java @@ -5,14 +5,14 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class CubicSplineNoiseSampler extends Normalizer { - + private final CubicSpline spline; - + public CubicSplineNoiseSampler(NoiseSampler sampler, CubicSpline spline) { super(sampler); this.spline = spline; } - + @Override public double normalize(double in) { return spline.apply(in); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ExpressionNormalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ExpressionNormalizer.java index 816bba788..68a5dc2d0 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ExpressionNormalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ExpressionNormalizer.java @@ -12,9 +12,9 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class ExpressionNormalizer extends Normalizer { - + private final Expression expression; - + public ExpressionNormalizer(NoiseSampler sampler, Map functions, String eq, Map vars) throws ParseException { super(sampler); @@ -25,7 +25,7 @@ public class ExpressionNormalizer extends Normalizer { functions.forEach(p::registerFunction); expression = p.parse(eq, scope); } - + @Override public double normalize(double in) { return expression.evaluate(in); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/LinearNormalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/LinearNormalizer.java index a13d3dab6..42678ceb5 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/LinearNormalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/LinearNormalizer.java @@ -16,13 +16,13 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class LinearNormalizer extends Normalizer { private final double min; private final double max; - + public LinearNormalizer(NoiseSampler sampler, double min, double max) { super(sampler); this.min = min; this.max = max; } - + @Override public double normalize(double in) { return (in - min) * (2 / (max - min)) - 1; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/NormalNormalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/NormalNormalizer.java index 3e2ee7ceb..c20cc8ee7 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/NormalNormalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/NormalNormalizer.java @@ -15,18 +15,18 @@ import com.dfsek.terra.api.util.MathUtil; * Normalizer to redistribute normally distributed data to a continuous distribution via an automatically generated lookup table. */ public class NormalNormalizer extends Normalizer { - + private final double[] lookup; - + public NormalNormalizer(NoiseSampler sampler, int buckets, double mean, double standardDeviation) { super(sampler); this.lookup = new double[buckets]; - + for(int i = 0; i < buckets; i++) { lookup[i] = MathUtil.normalInverse((double) i / buckets, mean, standardDeviation); } } - + @Override public double normalize(double in) { int start = 0; @@ -41,12 +41,12 @@ public class NormalNormalizer extends Normalizer { } double left = Math.abs(lookup[start] - in); double right = Math.abs(lookup[end] - in); - + double fin; if(left <= right) { fin = (double) start / (lookup.length); } else fin = (double) end / (lookup.length); - + return (fin - 0.5) * 2; } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/Normalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/Normalizer.java index 2489cb84b..60206bc1a 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/Normalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/Normalizer.java @@ -12,18 +12,18 @@ import com.dfsek.terra.api.noise.NoiseSampler; public abstract class Normalizer implements NoiseSampler { private final NoiseSampler sampler; - + public Normalizer(NoiseSampler sampler) { this.sampler = sampler; } - + public abstract double normalize(double in); - + @Override public double noise(long seed, double x, double y) { return normalize(sampler.noise(seed, x, y)); } - + @Override public double noise(long seed, double x, double y, double z) { return normalize(sampler.noise(seed, x, y, z)); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/PosterizationNormalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/PosterizationNormalizer.java index 03d3902d6..eb5fe8085 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/PosterizationNormalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/PosterizationNormalizer.java @@ -12,12 +12,12 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class PosterizationNormalizer extends Normalizer { private final double stepSize; - + public PosterizationNormalizer(NoiseSampler sampler, int steps) { super(sampler); this.stepSize = 2.0 / (steps - 1); } - + @Override public double normalize(double in) { return (int) Math.round((in + 1) / stepSize) * stepSize - 1; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ProbabilityNormalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ProbabilityNormalizer.java index 010973441..e254b2d9c 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ProbabilityNormalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ProbabilityNormalizer.java @@ -7,7 +7,7 @@ public class ProbabilityNormalizer extends Normalizer { public ProbabilityNormalizer(NoiseSampler sampler) { super(sampler); } - + @Override public double normalize(double in) { return (in + 1) / 2; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ScaleNormalizer.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ScaleNormalizer.java index 07b3bd267..2f0baf86d 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ScaleNormalizer.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ScaleNormalizer.java @@ -5,12 +5,12 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class ScaleNormalizer extends Normalizer { private final double scale; - + public ScaleNormalizer(NoiseSampler sampler, double scale) { super(sampler); this.scale = scale; } - + @Override public double normalize(double in) { return in * scale; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java index 55f7ef2c6..5dbc740ec 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java @@ -15,7 +15,7 @@ import com.dfsek.terra.addons.noise.paralithic.noise.NoiseFunction3; public class FunctionUtil { private FunctionUtil() { } - + public static Map convertFunctionsAndSamplers(Map functions, Map samplers) throws ParseException { @@ -24,9 +24,9 @@ public class FunctionUtil { functionMap.put(entry.getKey(), UserDefinedFunction.newInstance(entry.getValue())); } samplers.forEach((id, sampler) -> functionMap.put(id, - sampler.getDimensions() == 2 ? - new NoiseFunction2(sampler.getSampler()) : - new NoiseFunction3(sampler.getSampler()))); + sampler.getDimensions() == 2 ? + new NoiseFunction2(sampler.getSampler()) : + new NoiseFunction3(sampler.getSampler()))); return functionMap; } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/defined/UserDefinedFunction.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/defined/UserDefinedFunction.java index 4d5bf9544..f55fe3e12 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/defined/UserDefinedFunction.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/defined/UserDefinedFunction.java @@ -26,49 +26,49 @@ public class UserDefinedFunction implements DynamicFunction { private static final Map CACHE = new HashMap<>(); private final Expression expression; private final int args; - + protected UserDefinedFunction(Expression expression, int args) { this.expression = expression; this.args = args; } - + public static UserDefinedFunction newInstance(FunctionTemplate template) throws ParseException { UserDefinedFunction function = CACHE.get(template); if(function == null) { Parser parser = new Parser(); Scope parent = new Scope(); - + Scope functionScope = new Scope().withParent(parent); - + template.getArgs().forEach(functionScope::addInvocationVariable); - + for(Entry entry : template.getFunctions().entrySet()) { String id = entry.getKey(); FunctionTemplate nest = entry.getValue(); parser.registerFunction(id, newInstance(nest)); } - + function = new UserDefinedFunction(parser.parse(template.getFunction(), functionScope), template.getArgs().size()); CACHE.put(template, function); } return function; } - + @Override public double eval(double... args) { return expression.evaluate(args); } - + @Override public double eval(Context context, double... args) { return expression.evaluate(context, args); } - + @Override public int getArgNumber() { return args; } - + @Override public Statefulness statefulness() { return Statefulness.STATELESS; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction2.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction2.java index 466845cf6..10844d38c 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction2.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction2.java @@ -16,26 +16,26 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class NoiseFunction2 implements DynamicFunction { private final NoiseSampler gen; - + public NoiseFunction2(NoiseSampler gen) { this.gen = gen; } - + @Override public double eval(double... args) { throw new UnsupportedOperationException("Cannot evaluate seeded function without seed context."); } - + @Override public double eval(Context context, double... args) { return gen.noise(((SeedContext) context).getSeed(), args[0], args[1]); } - + @Override public int getArgNumber() { return 2; } - + @Override public Statefulness statefulness() { return Statefulness.CONTEXTUAL; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction3.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction3.java index 04a93b8b5..725439ad3 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction3.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/NoiseFunction3.java @@ -16,26 +16,26 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class NoiseFunction3 implements DynamicFunction { private final NoiseSampler gen; - + public NoiseFunction3(NoiseSampler gen) { this.gen = gen; } - + @Override public double eval(double... args) { throw new UnsupportedOperationException("Cannot evaluate seeded function without seed context."); } - + @Override public double eval(Context context, double... args) { return gen.noise(((SeedContext) context).getSeed(), args[0], args[1], args[2]); } - + @Override public int getArgNumber() { return 3; } - + @Override public Statefulness statefulness() { return Statefulness.CONTEXTUAL; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/SeedContext.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/SeedContext.java index 31fd42ca5..78d6d3862 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/SeedContext.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/noise/SeedContext.java @@ -12,11 +12,11 @@ import com.dfsek.paralithic.functions.dynamic.Context; public class SeedContext implements Context { private final long seed; - + public SeedContext(long seed) { this.seed = seed; } - + public long getSeed() { return seed; } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/DomainWarpedSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/DomainWarpedSampler.java index b23adce4c..beb4d691b 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/DomainWarpedSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/DomainWarpedSampler.java @@ -14,27 +14,27 @@ public class DomainWarpedSampler implements NoiseSampler { private final NoiseSampler function; private final NoiseSampler warp; private final double amplitude; - + public DomainWarpedSampler(NoiseSampler function, NoiseSampler warp, double amplitude) { this.function = function; this.warp = warp; this.amplitude = amplitude; } - + @Override public double noise(long seed, double x, double y) { return function.noise(seed++, - x + warp.noise(seed++, x, y) * amplitude, - y + warp.noise(seed, x, y) * amplitude - ); + x + warp.noise(seed++, x, y) * amplitude, + y + warp.noise(seed, x, y) * amplitude + ); } - + @Override public double noise(long seed, double x, double y, double z) { return function.noise(seed++, - x + warp.noise(seed++, x, y, z) * amplitude, - y + warp.noise(seed++, x, y, z) * amplitude, - z + warp.noise(seed, x, y, z) * amplitude - ); + x + warp.noise(seed++, x, y, z) * amplitude, + y + warp.noise(seed++, x, y, z) * amplitude, + z + warp.noise(seed, x, y, z) * amplitude + ); } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/ImageSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/ImageSampler.java index 8d9195b5e..13c9ceb6d 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/ImageSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/ImageSampler.java @@ -15,27 +15,27 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class ImageSampler implements NoiseSampler { private final BufferedImage image; private final Channel channel; - + private final double frequency; - + public ImageSampler(BufferedImage image, Channel channel, double frequency) { this.image = image; this.channel = channel; this.frequency = frequency; } - + @Override public double noise(long seed, double x, double y) { return ((channel.getChannel(image.getRGB(Math.floorMod((int) Math.floor(x * frequency), image.getWidth()), - Math.floorMod((int) Math.floor(y * frequency), image.getHeight()))) / 255D) - 0.5) * + Math.floorMod((int) Math.floor(y * frequency), image.getHeight()))) / 255D) - 0.5) * 2; } - + @Override public double noise(long seed, double x, double y, double z) { return noise(seed, x, y); } - + public enum Channel { RED { @Override @@ -67,7 +67,7 @@ public class ImageSampler implements NoiseSampler { return (mashed >> 24) & 0xff; } }; - + public abstract int getChannel(int mashed); } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/KernelSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/KernelSampler.java index b2a2b76fe..96c81bca5 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/KernelSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/KernelSampler.java @@ -14,22 +14,22 @@ public class KernelSampler implements NoiseSampler { private final double[][] kernel; private final NoiseSampler in; private double frequency = 1; - + public KernelSampler(double[][] kernel, NoiseSampler in) { this.kernel = kernel; this.in = in; } - + public void setFrequency(double frequency) { this.frequency = frequency; } - + @Override public double noise(long seed, double x, double y) { x *= frequency; y *= frequency; double accumulator = 0; - + for(int kx = 0; kx < kernel.length; kx++) { for(int ky = 0; ky < kernel[kx].length; ky++) { double k = kernel[kx][ky]; @@ -38,17 +38,17 @@ public class KernelSampler implements NoiseSampler { } } } - + return accumulator; } - + @Override public double noise(long seed, double x, double y, double z) { x *= frequency; y *= frequency; z *= frequency; double accumulator = 0; - + for(int kx = 0; kx < kernel.length; kx++) { for(int ky = 0; ky < kernel[kx].length; ky++) { double k = kernel[kx][ky]; @@ -57,7 +57,7 @@ public class KernelSampler implements NoiseSampler { } } } - + return accumulator; } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/LinearHeightmapSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/LinearHeightmapSampler.java index 1f7726034..500b44e4f 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/LinearHeightmapSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/LinearHeightmapSampler.java @@ -7,19 +7,19 @@ public class LinearHeightmapSampler implements NoiseSampler { private final NoiseSampler sampler; private final double scale; private final double base; - + public LinearHeightmapSampler(NoiseSampler sampler, double scale, double base) { this.sampler = sampler; this.scale = scale; this.base = base; } - - + + @Override public double noise(long seed, double x, double y) { return noise(seed, x, 0, y); } - + @Override public double noise(long seed, double x, double y, double z) { return -y + base + sampler.noise(seed, x, y, z) * scale; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/TranslateSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/TranslateSampler.java index b634da5dc..cb886c948 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/TranslateSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/TranslateSampler.java @@ -4,22 +4,22 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class TranslateSampler implements NoiseSampler { - + private final NoiseSampler sampler; private final double dx, dy, dz; - + public TranslateSampler(NoiseSampler sampler, double dx, double dy, double dz) { this.sampler = sampler; this.dx = dx; this.dy = dy; this.dz = dz; } - + @Override public double noise(long seed, double x, double y) { return sampler.noise(seed, x - dx, y - dz); } - + @Override public double noise(long seed, double x, double y, double z) { return sampler.noise(seed, x - dx, y - dy, z - dz); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/AdditionSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/AdditionSampler.java index 65835b4ae..c393d314d 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/AdditionSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/AdditionSampler.java @@ -7,7 +7,7 @@ public class AdditionSampler extends BinaryArithmeticSampler { public AdditionSampler(NoiseSampler left, NoiseSampler right) { super(left, right); } - + @Override public double operate(double left, double right) { return left + right; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/BinaryArithmeticSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/BinaryArithmeticSampler.java index eb18a60a0..03f3a3794 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/BinaryArithmeticSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/BinaryArithmeticSampler.java @@ -6,21 +6,21 @@ import com.dfsek.terra.api.noise.NoiseSampler; public abstract class BinaryArithmeticSampler implements NoiseSampler { private final NoiseSampler left; private final NoiseSampler right; - + protected BinaryArithmeticSampler(NoiseSampler left, NoiseSampler right) { this.left = left; this.right = right; } - + @Override public double noise(long seed, double x, double y) { return operate(left.noise(seed, x, y), right.noise(seed, x, y)); } - + @Override public double noise(long seed, double x, double y, double z) { return operate(left.noise(seed, x, y, z), right.noise(seed, x, y, z)); } - + public abstract double operate(double left, double right); } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/DivisionSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/DivisionSampler.java index c1b22231f..09169b613 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/DivisionSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/DivisionSampler.java @@ -7,7 +7,7 @@ public class DivisionSampler extends BinaryArithmeticSampler { public DivisionSampler(NoiseSampler left, NoiseSampler right) { super(left, right); } - + @Override public double operate(double left, double right) { return left / right; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MaxSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MaxSampler.java index 0418d2069..e97722614 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MaxSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MaxSampler.java @@ -7,7 +7,7 @@ public class MaxSampler extends BinaryArithmeticSampler { public MaxSampler(NoiseSampler left, NoiseSampler right) { super(left, right); } - + @Override public double operate(double left, double right) { return Math.max(left, right); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MinSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MinSampler.java index a4ada7e26..7fcd42bdc 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MinSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MinSampler.java @@ -7,7 +7,7 @@ public class MinSampler extends BinaryArithmeticSampler { public MinSampler(NoiseSampler left, NoiseSampler right) { super(left, right); } - + @Override public double operate(double left, double right) { return Math.min(left, right); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MultiplicationSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MultiplicationSampler.java index 235e433ec..d9fc46b7e 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MultiplicationSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/MultiplicationSampler.java @@ -7,7 +7,7 @@ public class MultiplicationSampler extends BinaryArithmeticSampler { public MultiplicationSampler(NoiseSampler left, NoiseSampler right) { super(left, right); } - + @Override public double operate(double left, double right) { return left * right; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/SubtractionSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/SubtractionSampler.java index 6136682d9..0b7f0b816 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/SubtractionSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/arithmetic/SubtractionSampler.java @@ -7,7 +7,7 @@ public class SubtractionSampler extends BinaryArithmeticSampler { public SubtractionSampler(NoiseSampler left, NoiseSampler right) { super(left, right); } - + @Override public double operate(double left, double right) { return left - right; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java index 1fe86f21a..6facef332 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java @@ -16,244 +16,244 @@ import com.dfsek.terra.api.noise.NoiseSampler; */ public class CellularSampler extends NoiseFunction { private static final double[] RAND_VECS_3D = { - -0.7292736885d, -0.6618439697d, 0.1735581948d, 0, 0.790292081d, -0.5480887466d, -0.2739291014d, 0, 0.7217578935d, 0.6226212466d, - -0.3023380997d, 0, 0.565683137d, -0.8208298145d, -0.0790000257d, 0, 0.760049034d, -0.5555979497d, -0.3370999617d, 0, - 0.3713945616d, 0.5011264475d, 0.7816254623d, 0, -0.1277062463d, -0.4254438999d, -0.8959289049d, 0, -0.2881560924d, - -0.5815838982d, 0.7607405838d, 0, 0.5849561111d, -0.662820239d, -0.4674352136d, 0, 0.3307171178d, 0.0391653737d, 0.94291689d, 0, - 0.8712121778d, -0.4113374369d, -0.2679381538d, 0, 0.580981015d, 0.7021915846d, 0.4115677815d, 0, 0.503756873d, 0.6330056931d, - -0.5878203852d, 0, 0.4493712205d, 0.601390195d, 0.6606022552d, 0, -0.6878403724d, 0.09018890807d, -0.7202371714d, 0, - -0.5958956522d, -0.6469350577d, 0.475797649d, 0, -0.5127052122d, 0.1946921978d, -0.8361987284d, 0, -0.9911507142d, - -0.05410276466d, -0.1212153153d, 0, -0.2149721042d, 0.9720882117d, -0.09397607749d, 0, -0.7518650936d, -0.5428057603d, - 0.3742469607d, 0, 0.5237068895d, 0.8516377189d, -0.02107817834d, 0, 0.6333504779d, 0.1926167129d, -0.7495104896d, 0, - -0.06788241606d, 0.3998305789d, 0.9140719259d, 0, -0.5538628599d, -0.4729896695d, -0.6852128902d, 0, -0.7261455366d, - -0.5911990757d, 0.3509933228d, 0, -0.9229274737d, -0.1782808786d, 0.3412049336d, 0, -0.6968815002d, 0.6511274338d, - 0.3006480328d, 0, 0.9608044783d, -0.2098363234d, -0.1811724921d, 0, 0.06817146062d, -0.9743405129d, 0.2145069156d, 0, - -0.3577285196d, -0.6697087264d, -0.6507845481d, 0, -0.1868621131d, 0.7648617052d, -0.6164974636d, 0, -0.6541697588d, - 0.3967914832d, 0.6439087246d, 0, 0.6993340405d, -0.6164538506d, 0.3618239211d, 0, -0.1546665739d, 0.6291283928d, 0.7617583057d, - 0, -0.6841612949d, -0.2580482182d, -0.6821542638d, 0, 0.5383980957d, 0.4258654885d, 0.7271630328d, 0, -0.5026987823d, - -0.7939832935d, -0.3418836993d, 0, 0.3202971715d, 0.2834415347d, 0.9039195862d, 0, 0.8683227101d, -0.0003762656404d, - -0.4959995258d, 0, 0.791120031d, -0.08511045745d, 0.6057105799d, 0, -0.04011016052d, -0.4397248749d, 0.8972364289d, 0, - 0.9145119872d, 0.3579346169d, -0.1885487608d, 0, -0.9612039066d, -0.2756484276d, 0.01024666929d, 0, 0.6510361721d, - -0.2877799159d, -0.7023778346d, 0, -0.2041786351d, 0.7365237271d, 0.644859585d, 0, -0.7718263711d, 0.3790626912d, 0.5104855816d, - 0, -0.3060082741d, -0.7692987727d, 0.5608371729d, 0, 0.454007341d, -0.5024843065d, 0.7357899537d, 0, 0.4816795475d, - 0.6021208291d, -0.6367380315d, 0, 0.6961980369d, -0.3222197429d, 0.641469197d, 0, -0.6532160499d, -0.6781148932d, 0.3368515753d, - 0, 0.5089301236d, -0.6154662304d, -0.6018234363d, 0, -0.1635919754d, -0.9133604627d, -0.372840892d, 0, 0.52408019d, - -0.8437664109d, 0.1157505864d, 0, 0.5902587356d, 0.4983817807d, -0.6349883666d, 0, 0.5863227872d, 0.494764745d, 0.6414307729d, - 0, 0.6779335087d, 0.2341345225d, 0.6968408593d, 0, 0.7177054546d, -0.6858979348d, 0.120178631d, 0, -0.5328819713d, - -0.5205125012d, 0.6671608058d, 0, -0.8654874251d, -0.0700727088d, -0.4960053754d, 0, -0.2861810166d, 0.7952089234d, - 0.5345495242d, 0, -0.04849529634d, 0.9810836427d, -0.1874115585d, 0, -0.6358521667d, 0.6058348682d, 0.4781800233d, 0, - 0.6254794696d, -0.2861619734d, 0.7258696564d, 0, -0.2585259868d, 0.5061949264d, -0.8227581726d, 0, 0.02136306781d, - 0.5064016808d, -0.8620330371d, 0, 0.200111773d, 0.8599263484d, 0.4695550591d, 0, 0.4743561372d, 0.6014985084d, -0.6427953014d, - 0, 0.6622993731d, -0.5202474575d, -0.5391679918d, 0, 0.08084972818d, -0.6532720452d, 0.7527940996d, 0, -0.6893687501d, - 0.0592860349d, 0.7219805347d, 0, -0.1121887082d, -0.9673185067d, 0.2273952515d, 0, 0.7344116094d, 0.5979668656d, -0.3210532909d, - 0, 0.5789393465d, -0.2488849713d, 0.7764570201d, 0, 0.6988182827d, 0.3557169806d, -0.6205791146d, 0, -0.8636845529d, - -0.2748771249d, -0.4224826141d, 0, -0.4247027957d, -0.4640880967d, 0.777335046d, 0, 0.5257722489d, -0.8427017621d, - 0.1158329937d, 0, 0.9343830603d, 0.316302472d, -0.1639543925d, 0, -0.1016836419d, -0.8057303073d, -0.5834887393d, 0, - -0.6529238969d, 0.50602126d, -0.5635892736d, 0, -0.2465286165d, -0.9668205684d, -0.06694497494d, 0, -0.9776897119d, - -0.2099250524d, -0.007368825344d, 0, 0.7736893337d, 0.5734244712d, 0.2694238123d, 0, -0.6095087895d, 0.4995678998d, - 0.6155736747d, 0, 0.5794535482d, 0.7434546771d, 0.3339292269d, 0, -0.8226211154d, 0.08142581855d, 0.5627293636d, 0, - -0.510385483d, 0.4703667658d, 0.7199039967d, 0, -0.5764971849d, -0.07231656274d, -0.8138926898d, 0, 0.7250628871d, - 0.3949971505d, -0.5641463116d, 0, -0.1525424005d, 0.4860840828d, -0.8604958341d, 0, -0.5550976208d, -0.4957820792d, - 0.667882296d, 0, -0.1883614327d, 0.9145869398d, 0.357841725d, 0, 0.7625556724d, -0.5414408243d, -0.3540489801d, 0, - -0.5870231946d, -0.3226498013d, -0.7424963803d, 0, 0.3051124198d, 0.2262544068d, -0.9250488391d, 0, 0.6379576059d, 0.577242424d, - -0.5097070502d, 0, -0.5966775796d, 0.1454852398d, -0.7891830656d, 0, -0.658330573d, 0.6555487542d, -0.3699414651d, 0, - 0.7434892426d, 0.2351084581d, 0.6260573129d, 0, 0.5562114096d, 0.8264360377d, -0.0873632843d, 0, -0.3028940016d, -0.8251527185d, - 0.4768419182d, 0, 0.1129343818d, -0.985888439d, -0.1235710781d, 0, 0.5937652891d, -0.5896813806d, 0.5474656618d, 0, - 0.6757964092d, -0.5835758614d, -0.4502648413d, 0, 0.7242302609d, -0.1152719764d, 0.6798550586d, 0, -0.9511914166d, - 0.0753623979d, -0.2992580792d, 0, 0.2539470961d, -0.1886339355d, 0.9486454084d, 0, 0.571433621d, -0.1679450851d, -0.8032795685d, - 0, -0.06778234979d, 0.3978269256d, 0.9149531629d, 0, 0.6074972649d, 0.733060024d, -0.3058922593d, 0, -0.5435478392d, - 0.1675822484d, 0.8224791405d, 0, -0.5876678086d, -0.3380045064d, -0.7351186982d, 0, -0.7967562402d, 0.04097822706d, - -0.6029098428d, 0, -0.1996350917d, 0.8706294745d, 0.4496111079d, 0, -0.02787660336d, -0.9106232682d, -0.4122962022d, 0, - -0.7797625996d, -0.6257634692d, 0.01975775581d, 0, -0.5211232846d, 0.7401644346d, -0.4249554471d, 0, 0.8575424857d, - 0.4053272873d, -0.3167501783d, 0, 0.1045223322d, 0.8390195772d, -0.5339674439d, 0, 0.3501822831d, 0.9242524096d, -0.1520850155d, - 0, 0.1987849858d, 0.07647613266d, 0.9770547224d, 0, 0.7845996363d, 0.6066256811d, -0.1280964233d, 0, 0.09006737436d, - -0.9750989929d, -0.2026569073d, 0, -0.8274343547d, -0.542299559d, 0.1458203587d, 0, -0.3485797732d, -0.415802277d, 0.840000362d, - 0, -0.2471778936d, -0.7304819962d, -0.6366310879d, 0, -0.3700154943d, 0.8577948156d, 0.3567584454d, 0, 0.5913394901d, - -0.548311967d, -0.5913303597d, 0, 0.1204873514d, -0.7626472379d, -0.6354935001d, 0, 0.616959265d, 0.03079647928d, 0.7863922953d, - 0, 0.1258156836d, -0.6640829889d, -0.7369967419d, 0, -0.6477565124d, -0.1740147258d, -0.7417077429d, 0, 0.6217889313d, - -0.7804430448d, -0.06547655076d, 0, 0.6589943422d, -0.6096987708d, 0.4404473475d, 0, -0.2689837504d, -0.6732403169d, - -0.6887635427d, 0, -0.3849775103d, 0.5676542638d, 0.7277093879d, 0, 0.5754444408d, 0.8110471154d, -0.1051963504d, 0, - 0.9141593684d, 0.3832947817d, 0.131900567d, 0, -0.107925319d, 0.9245493968d, 0.3654593525d, 0, 0.377977089d, 0.3043148782d, - 0.8743716458d, 0, -0.2142885215d, -0.8259286236d, 0.5214617324d, 0, 0.5802544474d, 0.4148098596d, -0.7008834116d, 0, - -0.1982660881d, 0.8567161266d, -0.4761596756d, 0, -0.03381553704d, 0.3773180787d, -0.9254661404d, 0, -0.6867922841d, - -0.6656597827d, 0.2919133642d, 0, 0.7731742607d, -0.2875793547d, -0.5652430251d, 0, -0.09655941928d, 0.9193708367d, - -0.3813575004d, 0, 0.2715702457d, -0.9577909544d, -0.09426605581d, 0, 0.2451015704d, -0.6917998565d, -0.6792188003d, 0, - 0.977700782d, -0.1753855374d, 0.1155036542d, 0, -0.5224739938d, 0.8521606816d, 0.02903615945d, 0, -0.7734880599d, - -0.5261292347d, 0.3534179531d, 0, -0.7134492443d, -0.269547243d, 0.6467878011d, 0, 0.1644037271d, 0.5105846203d, -0.8439637196d, - 0, 0.6494635788d, 0.05585611296d, 0.7583384168d, 0, -0.4711970882d, 0.5017280509d, -0.7254255765d, 0, -0.6335764307d, - -0.2381686273d, -0.7361091029d, 0, -0.9021533097d, -0.270947803d, -0.3357181763d, 0, -0.3793711033d, 0.872258117d, - 0.3086152025d, 0, -0.6855598966d, -0.3250143309d, 0.6514394162d, 0, 0.2900942212d, -0.7799057743d, -0.5546100667d, 0, - -0.2098319339d, 0.85037073d, 0.4825351604d, 0, -0.4592603758d, 0.6598504336d, -0.5947077538d, 0, 0.8715945488d, 0.09616365406d, - -0.4807031248d, 0, -0.6776666319d, 0.7118504878d, -0.1844907016d, 0, 0.7044377633d, 0.312427597d, 0.637304036d, 0, - -0.7052318886d, -0.2401093292d, -0.6670798253d, 0, 0.081921007d, -0.7207336136d, -0.6883545647d, 0, -0.6993680906d, - -0.5875763221d, -0.4069869034d, 0, -0.1281454481d, 0.6419895885d, 0.7559286424d, 0, -0.6337388239d, -0.6785471501d, - -0.3714146849d, 0, 0.5565051903d, -0.2168887573d, -0.8020356851d, 0, -0.5791554484d, 0.7244372011d, -0.3738578718d, 0, - 0.1175779076d, -0.7096451073d, 0.6946792478d, 0, -0.6134619607d, 0.1323631078d, 0.7785527795d, 0, 0.6984635305d, - -0.02980516237d, -0.715024719d, 0, 0.8318082963d, -0.3930171956d, 0.3919597455d, 0, 0.1469576422d, 0.05541651717d, - -0.9875892167d, 0, 0.708868575d, -0.2690503865d, 0.6520101478d, 0, 0.2726053183d, 0.67369766d, -0.68688995d, 0, -0.6591295371d, - 0.3035458599d, -0.6880466294d, 0, 0.4815131379d, -0.7528270071d, 0.4487723203d, 0, 0.9430009463d, 0.1675647412d, -0.2875261255d, - 0, 0.434802957d, 0.7695304522d, -0.4677277752d, 0, 0.3931996188d, 0.594473625d, 0.7014236729d, 0, 0.7254336655d, -0.603925654d, - 0.3301814672d, 0, 0.7590235227d, -0.6506083235d, 0.02433313207d, 0, -0.8552768592d, -0.3430042733d, 0.3883935666d, 0, - -0.6139746835d, 0.6981725247d, 0.3682257648d, 0, -0.7465905486d, -0.5752009504d, 0.3342849376d, 0, 0.5730065677d, 0.810555537d, - -0.1210916791d, 0, -0.9225877367d, -0.3475211012d, -0.167514036d, 0, -0.7105816789d, -0.4719692027d, -0.5218416899d, 0, - -0.08564609717d, 0.3583001386d, 0.929669703d, 0, -0.8279697606d, -0.2043157126d, 0.5222271202d, 0, 0.427944023d, 0.278165994d, - 0.8599346446d, 0, 0.5399079671d, -0.7857120652d, -0.3019204161d, 0, 0.5678404253d, -0.5495413974d, -0.6128307303d, 0, - -0.9896071041d, 0.1365639107d, -0.04503418428d, 0, -0.6154342638d, -0.6440875597d, 0.4543037336d, 0, 0.1074204368d, - -0.7946340692d, 0.5975094525d, 0, -0.3595449969d, -0.8885529948d, 0.28495784d, 0, -0.2180405296d, 0.1529888965d, 0.9638738118d, - 0, -0.7277432317d, -0.6164050508d, -0.3007234646d, 0, 0.7249729114d, -0.00669719484d, 0.6887448187d, 0, -0.5553659455d, - -0.5336586252d, 0.6377908264d, 0, 0.5137558015d, 0.7976208196d, -0.3160000073d, 0, -0.3794024848d, 0.9245608561d, - -0.03522751494d, 0, 0.8229248658d, 0.2745365933d, -0.4974176556d, 0, -0.5404114394d, 0.6091141441d, 0.5804613989d, 0, - 0.8036581901d, -0.2703029469d, 0.5301601931d, 0, 0.6044318879d, 0.6832968393d, 0.4095943388d, 0, 0.06389988817d, 0.9658208605d, - -0.2512108074d, 0, 0.1087113286d, 0.7402471173d, -0.6634877936d, 0, -0.713427712d, -0.6926784018d, 0.1059128479d, 0, - 0.6458897819d, -0.5724548511d, -0.5050958653d, 0, -0.6553931414d, 0.7381471625d, 0.159995615d, 0, 0.3910961323d, 0.9188871375d, - -0.05186755998d, 0, -0.4879022471d, -0.5904376907d, 0.6429111375d, 0, 0.6014790094d, 0.7707441366d, -0.2101820095d, 0, - -0.5677173047d, 0.7511360995d, 0.3368851762d, 0, 0.7858573506d, 0.226674665d, 0.5753666838d, 0, -0.4520345543d, -0.604222686d, - -0.6561857263d, 0, 0.002272116345d, 0.4132844051d, -0.9105991643d, 0, -0.5815751419d, -0.5162925989d, 0.6286591339d, 0, - -0.03703704785d, 0.8273785755d, 0.5604221175d, 0, -0.5119692504d, 0.7953543429d, -0.3244980058d, 0, -0.2682417366d, - -0.9572290247d, -0.1084387619d, 0, -0.2322482736d, -0.9679131102d, -0.09594243324d, 0, 0.3554328906d, -0.8881505545d, - 0.2913006227d, 0, 0.7346520519d, -0.4371373164d, 0.5188422971d, 0, 0.9985120116d, 0.04659011161d, -0.02833944577d, 0, - -0.3727687496d, -0.9082481361d, 0.1900757285d, 0, 0.91737377d, -0.3483642108d, 0.1925298489d, 0, 0.2714911074d, 0.4147529736d, - -0.8684886582d, 0, 0.5131763485d, -0.7116334161d, 0.4798207128d, 0, -0.8737353606d, 0.18886992d, -0.4482350644d, 0, - 0.8460043821d, -0.3725217914d, 0.3814499973d, 0, 0.8978727456d, -0.1780209141d, -0.4026575304d, 0, 0.2178065647d, - -0.9698322841d, -0.1094789531d, 0, -0.1518031304d, -0.7788918132d, -0.6085091231d, 0, -0.2600384876d, -0.4755398075d, - -0.8403819825d, 0, 0.572313509d, -0.7474340931d, -0.3373418503d, 0, -0.7174141009d, 0.1699017182d, -0.6756111411d, 0, - -0.684180784d, 0.02145707593d, -0.7289967412d, 0, -0.2007447902d, 0.06555605789d, -0.9774476623d, 0, -0.1148803697d, - -0.8044887315d, 0.5827524187d, 0, -0.7870349638d, 0.03447489231d, 0.6159443543d, 0, -0.2015596421d, 0.6859872284d, - 0.6991389226d, 0, -0.08581082512d, -0.10920836d, -0.9903080513d, 0, 0.5532693395d, 0.7325250401d, -0.396610771d, 0, - -0.1842489331d, -0.9777375055d, -0.1004076743d, 0, 0.0775473789d, -0.9111505856d, 0.4047110257d, 0, 0.1399838409d, - 0.7601631212d, -0.6344734459d, 0, 0.4484419361d, -0.845289248d, 0.2904925424d, 0 + -0.7292736885d, -0.6618439697d, 0.1735581948d, 0, 0.790292081d, -0.5480887466d, -0.2739291014d, 0, 0.7217578935d, 0.6226212466d, + -0.3023380997d, 0, 0.565683137d, -0.8208298145d, -0.0790000257d, 0, 0.760049034d, -0.5555979497d, -0.3370999617d, 0, + 0.3713945616d, 0.5011264475d, 0.7816254623d, 0, -0.1277062463d, -0.4254438999d, -0.8959289049d, 0, -0.2881560924d, + -0.5815838982d, 0.7607405838d, 0, 0.5849561111d, -0.662820239d, -0.4674352136d, 0, 0.3307171178d, 0.0391653737d, 0.94291689d, 0, + 0.8712121778d, -0.4113374369d, -0.2679381538d, 0, 0.580981015d, 0.7021915846d, 0.4115677815d, 0, 0.503756873d, 0.6330056931d, + -0.5878203852d, 0, 0.4493712205d, 0.601390195d, 0.6606022552d, 0, -0.6878403724d, 0.09018890807d, -0.7202371714d, 0, + -0.5958956522d, -0.6469350577d, 0.475797649d, 0, -0.5127052122d, 0.1946921978d, -0.8361987284d, 0, -0.9911507142d, + -0.05410276466d, -0.1212153153d, 0, -0.2149721042d, 0.9720882117d, -0.09397607749d, 0, -0.7518650936d, -0.5428057603d, + 0.3742469607d, 0, 0.5237068895d, 0.8516377189d, -0.02107817834d, 0, 0.6333504779d, 0.1926167129d, -0.7495104896d, 0, + -0.06788241606d, 0.3998305789d, 0.9140719259d, 0, -0.5538628599d, -0.4729896695d, -0.6852128902d, 0, -0.7261455366d, + -0.5911990757d, 0.3509933228d, 0, -0.9229274737d, -0.1782808786d, 0.3412049336d, 0, -0.6968815002d, 0.6511274338d, + 0.3006480328d, 0, 0.9608044783d, -0.2098363234d, -0.1811724921d, 0, 0.06817146062d, -0.9743405129d, 0.2145069156d, 0, + -0.3577285196d, -0.6697087264d, -0.6507845481d, 0, -0.1868621131d, 0.7648617052d, -0.6164974636d, 0, -0.6541697588d, + 0.3967914832d, 0.6439087246d, 0, 0.6993340405d, -0.6164538506d, 0.3618239211d, 0, -0.1546665739d, 0.6291283928d, 0.7617583057d, + 0, -0.6841612949d, -0.2580482182d, -0.6821542638d, 0, 0.5383980957d, 0.4258654885d, 0.7271630328d, 0, -0.5026987823d, + -0.7939832935d, -0.3418836993d, 0, 0.3202971715d, 0.2834415347d, 0.9039195862d, 0, 0.8683227101d, -0.0003762656404d, + -0.4959995258d, 0, 0.791120031d, -0.08511045745d, 0.6057105799d, 0, -0.04011016052d, -0.4397248749d, 0.8972364289d, 0, + 0.9145119872d, 0.3579346169d, -0.1885487608d, 0, -0.9612039066d, -0.2756484276d, 0.01024666929d, 0, 0.6510361721d, + -0.2877799159d, -0.7023778346d, 0, -0.2041786351d, 0.7365237271d, 0.644859585d, 0, -0.7718263711d, 0.3790626912d, 0.5104855816d, + 0, -0.3060082741d, -0.7692987727d, 0.5608371729d, 0, 0.454007341d, -0.5024843065d, 0.7357899537d, 0, 0.4816795475d, + 0.6021208291d, -0.6367380315d, 0, 0.6961980369d, -0.3222197429d, 0.641469197d, 0, -0.6532160499d, -0.6781148932d, 0.3368515753d, + 0, 0.5089301236d, -0.6154662304d, -0.6018234363d, 0, -0.1635919754d, -0.9133604627d, -0.372840892d, 0, 0.52408019d, + -0.8437664109d, 0.1157505864d, 0, 0.5902587356d, 0.4983817807d, -0.6349883666d, 0, 0.5863227872d, 0.494764745d, 0.6414307729d, + 0, 0.6779335087d, 0.2341345225d, 0.6968408593d, 0, 0.7177054546d, -0.6858979348d, 0.120178631d, 0, -0.5328819713d, + -0.5205125012d, 0.6671608058d, 0, -0.8654874251d, -0.0700727088d, -0.4960053754d, 0, -0.2861810166d, 0.7952089234d, + 0.5345495242d, 0, -0.04849529634d, 0.9810836427d, -0.1874115585d, 0, -0.6358521667d, 0.6058348682d, 0.4781800233d, 0, + 0.6254794696d, -0.2861619734d, 0.7258696564d, 0, -0.2585259868d, 0.5061949264d, -0.8227581726d, 0, 0.02136306781d, + 0.5064016808d, -0.8620330371d, 0, 0.200111773d, 0.8599263484d, 0.4695550591d, 0, 0.4743561372d, 0.6014985084d, -0.6427953014d, + 0, 0.6622993731d, -0.5202474575d, -0.5391679918d, 0, 0.08084972818d, -0.6532720452d, 0.7527940996d, 0, -0.6893687501d, + 0.0592860349d, 0.7219805347d, 0, -0.1121887082d, -0.9673185067d, 0.2273952515d, 0, 0.7344116094d, 0.5979668656d, -0.3210532909d, + 0, 0.5789393465d, -0.2488849713d, 0.7764570201d, 0, 0.6988182827d, 0.3557169806d, -0.6205791146d, 0, -0.8636845529d, + -0.2748771249d, -0.4224826141d, 0, -0.4247027957d, -0.4640880967d, 0.777335046d, 0, 0.5257722489d, -0.8427017621d, + 0.1158329937d, 0, 0.9343830603d, 0.316302472d, -0.1639543925d, 0, -0.1016836419d, -0.8057303073d, -0.5834887393d, 0, + -0.6529238969d, 0.50602126d, -0.5635892736d, 0, -0.2465286165d, -0.9668205684d, -0.06694497494d, 0, -0.9776897119d, + -0.2099250524d, -0.007368825344d, 0, 0.7736893337d, 0.5734244712d, 0.2694238123d, 0, -0.6095087895d, 0.4995678998d, + 0.6155736747d, 0, 0.5794535482d, 0.7434546771d, 0.3339292269d, 0, -0.8226211154d, 0.08142581855d, 0.5627293636d, 0, + -0.510385483d, 0.4703667658d, 0.7199039967d, 0, -0.5764971849d, -0.07231656274d, -0.8138926898d, 0, 0.7250628871d, + 0.3949971505d, -0.5641463116d, 0, -0.1525424005d, 0.4860840828d, -0.8604958341d, 0, -0.5550976208d, -0.4957820792d, + 0.667882296d, 0, -0.1883614327d, 0.9145869398d, 0.357841725d, 0, 0.7625556724d, -0.5414408243d, -0.3540489801d, 0, + -0.5870231946d, -0.3226498013d, -0.7424963803d, 0, 0.3051124198d, 0.2262544068d, -0.9250488391d, 0, 0.6379576059d, 0.577242424d, + -0.5097070502d, 0, -0.5966775796d, 0.1454852398d, -0.7891830656d, 0, -0.658330573d, 0.6555487542d, -0.3699414651d, 0, + 0.7434892426d, 0.2351084581d, 0.6260573129d, 0, 0.5562114096d, 0.8264360377d, -0.0873632843d, 0, -0.3028940016d, -0.8251527185d, + 0.4768419182d, 0, 0.1129343818d, -0.985888439d, -0.1235710781d, 0, 0.5937652891d, -0.5896813806d, 0.5474656618d, 0, + 0.6757964092d, -0.5835758614d, -0.4502648413d, 0, 0.7242302609d, -0.1152719764d, 0.6798550586d, 0, -0.9511914166d, + 0.0753623979d, -0.2992580792d, 0, 0.2539470961d, -0.1886339355d, 0.9486454084d, 0, 0.571433621d, -0.1679450851d, -0.8032795685d, + 0, -0.06778234979d, 0.3978269256d, 0.9149531629d, 0, 0.6074972649d, 0.733060024d, -0.3058922593d, 0, -0.5435478392d, + 0.1675822484d, 0.8224791405d, 0, -0.5876678086d, -0.3380045064d, -0.7351186982d, 0, -0.7967562402d, 0.04097822706d, + -0.6029098428d, 0, -0.1996350917d, 0.8706294745d, 0.4496111079d, 0, -0.02787660336d, -0.9106232682d, -0.4122962022d, 0, + -0.7797625996d, -0.6257634692d, 0.01975775581d, 0, -0.5211232846d, 0.7401644346d, -0.4249554471d, 0, 0.8575424857d, + 0.4053272873d, -0.3167501783d, 0, 0.1045223322d, 0.8390195772d, -0.5339674439d, 0, 0.3501822831d, 0.9242524096d, -0.1520850155d, + 0, 0.1987849858d, 0.07647613266d, 0.9770547224d, 0, 0.7845996363d, 0.6066256811d, -0.1280964233d, 0, 0.09006737436d, + -0.9750989929d, -0.2026569073d, 0, -0.8274343547d, -0.542299559d, 0.1458203587d, 0, -0.3485797732d, -0.415802277d, 0.840000362d, + 0, -0.2471778936d, -0.7304819962d, -0.6366310879d, 0, -0.3700154943d, 0.8577948156d, 0.3567584454d, 0, 0.5913394901d, + -0.548311967d, -0.5913303597d, 0, 0.1204873514d, -0.7626472379d, -0.6354935001d, 0, 0.616959265d, 0.03079647928d, 0.7863922953d, + 0, 0.1258156836d, -0.6640829889d, -0.7369967419d, 0, -0.6477565124d, -0.1740147258d, -0.7417077429d, 0, 0.6217889313d, + -0.7804430448d, -0.06547655076d, 0, 0.6589943422d, -0.6096987708d, 0.4404473475d, 0, -0.2689837504d, -0.6732403169d, + -0.6887635427d, 0, -0.3849775103d, 0.5676542638d, 0.7277093879d, 0, 0.5754444408d, 0.8110471154d, -0.1051963504d, 0, + 0.9141593684d, 0.3832947817d, 0.131900567d, 0, -0.107925319d, 0.9245493968d, 0.3654593525d, 0, 0.377977089d, 0.3043148782d, + 0.8743716458d, 0, -0.2142885215d, -0.8259286236d, 0.5214617324d, 0, 0.5802544474d, 0.4148098596d, -0.7008834116d, 0, + -0.1982660881d, 0.8567161266d, -0.4761596756d, 0, -0.03381553704d, 0.3773180787d, -0.9254661404d, 0, -0.6867922841d, + -0.6656597827d, 0.2919133642d, 0, 0.7731742607d, -0.2875793547d, -0.5652430251d, 0, -0.09655941928d, 0.9193708367d, + -0.3813575004d, 0, 0.2715702457d, -0.9577909544d, -0.09426605581d, 0, 0.2451015704d, -0.6917998565d, -0.6792188003d, 0, + 0.977700782d, -0.1753855374d, 0.1155036542d, 0, -0.5224739938d, 0.8521606816d, 0.02903615945d, 0, -0.7734880599d, + -0.5261292347d, 0.3534179531d, 0, -0.7134492443d, -0.269547243d, 0.6467878011d, 0, 0.1644037271d, 0.5105846203d, -0.8439637196d, + 0, 0.6494635788d, 0.05585611296d, 0.7583384168d, 0, -0.4711970882d, 0.5017280509d, -0.7254255765d, 0, -0.6335764307d, + -0.2381686273d, -0.7361091029d, 0, -0.9021533097d, -0.270947803d, -0.3357181763d, 0, -0.3793711033d, 0.872258117d, + 0.3086152025d, 0, -0.6855598966d, -0.3250143309d, 0.6514394162d, 0, 0.2900942212d, -0.7799057743d, -0.5546100667d, 0, + -0.2098319339d, 0.85037073d, 0.4825351604d, 0, -0.4592603758d, 0.6598504336d, -0.5947077538d, 0, 0.8715945488d, 0.09616365406d, + -0.4807031248d, 0, -0.6776666319d, 0.7118504878d, -0.1844907016d, 0, 0.7044377633d, 0.312427597d, 0.637304036d, 0, + -0.7052318886d, -0.2401093292d, -0.6670798253d, 0, 0.081921007d, -0.7207336136d, -0.6883545647d, 0, -0.6993680906d, + -0.5875763221d, -0.4069869034d, 0, -0.1281454481d, 0.6419895885d, 0.7559286424d, 0, -0.6337388239d, -0.6785471501d, + -0.3714146849d, 0, 0.5565051903d, -0.2168887573d, -0.8020356851d, 0, -0.5791554484d, 0.7244372011d, -0.3738578718d, 0, + 0.1175779076d, -0.7096451073d, 0.6946792478d, 0, -0.6134619607d, 0.1323631078d, 0.7785527795d, 0, 0.6984635305d, + -0.02980516237d, -0.715024719d, 0, 0.8318082963d, -0.3930171956d, 0.3919597455d, 0, 0.1469576422d, 0.05541651717d, + -0.9875892167d, 0, 0.708868575d, -0.2690503865d, 0.6520101478d, 0, 0.2726053183d, 0.67369766d, -0.68688995d, 0, -0.6591295371d, + 0.3035458599d, -0.6880466294d, 0, 0.4815131379d, -0.7528270071d, 0.4487723203d, 0, 0.9430009463d, 0.1675647412d, -0.2875261255d, + 0, 0.434802957d, 0.7695304522d, -0.4677277752d, 0, 0.3931996188d, 0.594473625d, 0.7014236729d, 0, 0.7254336655d, -0.603925654d, + 0.3301814672d, 0, 0.7590235227d, -0.6506083235d, 0.02433313207d, 0, -0.8552768592d, -0.3430042733d, 0.3883935666d, 0, + -0.6139746835d, 0.6981725247d, 0.3682257648d, 0, -0.7465905486d, -0.5752009504d, 0.3342849376d, 0, 0.5730065677d, 0.810555537d, + -0.1210916791d, 0, -0.9225877367d, -0.3475211012d, -0.167514036d, 0, -0.7105816789d, -0.4719692027d, -0.5218416899d, 0, + -0.08564609717d, 0.3583001386d, 0.929669703d, 0, -0.8279697606d, -0.2043157126d, 0.5222271202d, 0, 0.427944023d, 0.278165994d, + 0.8599346446d, 0, 0.5399079671d, -0.7857120652d, -0.3019204161d, 0, 0.5678404253d, -0.5495413974d, -0.6128307303d, 0, + -0.9896071041d, 0.1365639107d, -0.04503418428d, 0, -0.6154342638d, -0.6440875597d, 0.4543037336d, 0, 0.1074204368d, + -0.7946340692d, 0.5975094525d, 0, -0.3595449969d, -0.8885529948d, 0.28495784d, 0, -0.2180405296d, 0.1529888965d, 0.9638738118d, + 0, -0.7277432317d, -0.6164050508d, -0.3007234646d, 0, 0.7249729114d, -0.00669719484d, 0.6887448187d, 0, -0.5553659455d, + -0.5336586252d, 0.6377908264d, 0, 0.5137558015d, 0.7976208196d, -0.3160000073d, 0, -0.3794024848d, 0.9245608561d, + -0.03522751494d, 0, 0.8229248658d, 0.2745365933d, -0.4974176556d, 0, -0.5404114394d, 0.6091141441d, 0.5804613989d, 0, + 0.8036581901d, -0.2703029469d, 0.5301601931d, 0, 0.6044318879d, 0.6832968393d, 0.4095943388d, 0, 0.06389988817d, 0.9658208605d, + -0.2512108074d, 0, 0.1087113286d, 0.7402471173d, -0.6634877936d, 0, -0.713427712d, -0.6926784018d, 0.1059128479d, 0, + 0.6458897819d, -0.5724548511d, -0.5050958653d, 0, -0.6553931414d, 0.7381471625d, 0.159995615d, 0, 0.3910961323d, 0.9188871375d, + -0.05186755998d, 0, -0.4879022471d, -0.5904376907d, 0.6429111375d, 0, 0.6014790094d, 0.7707441366d, -0.2101820095d, 0, + -0.5677173047d, 0.7511360995d, 0.3368851762d, 0, 0.7858573506d, 0.226674665d, 0.5753666838d, 0, -0.4520345543d, -0.604222686d, + -0.6561857263d, 0, 0.002272116345d, 0.4132844051d, -0.9105991643d, 0, -0.5815751419d, -0.5162925989d, 0.6286591339d, 0, + -0.03703704785d, 0.8273785755d, 0.5604221175d, 0, -0.5119692504d, 0.7953543429d, -0.3244980058d, 0, -0.2682417366d, + -0.9572290247d, -0.1084387619d, 0, -0.2322482736d, -0.9679131102d, -0.09594243324d, 0, 0.3554328906d, -0.8881505545d, + 0.2913006227d, 0, 0.7346520519d, -0.4371373164d, 0.5188422971d, 0, 0.9985120116d, 0.04659011161d, -0.02833944577d, 0, + -0.3727687496d, -0.9082481361d, 0.1900757285d, 0, 0.91737377d, -0.3483642108d, 0.1925298489d, 0, 0.2714911074d, 0.4147529736d, + -0.8684886582d, 0, 0.5131763485d, -0.7116334161d, 0.4798207128d, 0, -0.8737353606d, 0.18886992d, -0.4482350644d, 0, + 0.8460043821d, -0.3725217914d, 0.3814499973d, 0, 0.8978727456d, -0.1780209141d, -0.4026575304d, 0, 0.2178065647d, + -0.9698322841d, -0.1094789531d, 0, -0.1518031304d, -0.7788918132d, -0.6085091231d, 0, -0.2600384876d, -0.4755398075d, + -0.8403819825d, 0, 0.572313509d, -0.7474340931d, -0.3373418503d, 0, -0.7174141009d, 0.1699017182d, -0.6756111411d, 0, + -0.684180784d, 0.02145707593d, -0.7289967412d, 0, -0.2007447902d, 0.06555605789d, -0.9774476623d, 0, -0.1148803697d, + -0.8044887315d, 0.5827524187d, 0, -0.7870349638d, 0.03447489231d, 0.6159443543d, 0, -0.2015596421d, 0.6859872284d, + 0.6991389226d, 0, -0.08581082512d, -0.10920836d, -0.9903080513d, 0, 0.5532693395d, 0.7325250401d, -0.396610771d, 0, + -0.1842489331d, -0.9777375055d, -0.1004076743d, 0, 0.0775473789d, -0.9111505856d, 0.4047110257d, 0, 0.1399838409d, + 0.7601631212d, -0.6344734459d, 0, 0.4484419361d, -0.845289248d, 0.2904925424d, 0 }; - + private static final double[] RAND_VECS_2D = { - -0.2700222198d, -0.9628540911d, 0.3863092627d, -0.9223693152d, 0.04444859006d, -0.999011673d, -0.5992523158d, -0.8005602176d, - -0.7819280288d, 0.6233687174d, 0.9464672271d, 0.3227999196d, -0.6514146797d, -0.7587218957d, 0.9378472289d, 0.347048376d, - -0.8497875957d, -0.5271252623d, -0.879042592d, 0.4767432447d, -0.892300288d, -0.4514423508d, -0.379844434d, -0.9250503802d, - -0.9951650832d, 0.0982163789d, 0.7724397808d, -0.6350880136d, 0.7573283322d, -0.6530343002d, -0.9928004525d, -0.119780055d, - -0.0532665713d, 0.9985803285d, 0.9754253726d, -0.2203300762d, -0.7665018163d, 0.6422421394d, 0.991636706d, 0.1290606184d, - -0.994696838d, 0.1028503788d, -0.5379205513d, -0.84299554d, 0.5022815471d, -0.8647041387d, 0.4559821461d, -0.8899889226d, - -0.8659131224d, -0.5001944266d, 0.0879458407d, -0.9961252577d, -0.5051684983d, 0.8630207346d, 0.7753185226d, -0.6315704146d, - -0.6921944612d, 0.7217110418d, -0.5191659449d, -0.8546734591d, 0.8978622882d, -0.4402764035d, -0.1706774107d, 0.9853269617d, - -0.9353430106d, -0.3537420705d, -0.9992404798d, 0.03896746794d, -0.2882064021d, -0.9575683108d, -0.9663811329d, 0.2571137995d, - -0.8759714238d, -0.4823630009d, -0.8303123018d, -0.5572983775d, 0.05110133755d, -0.9986934731d, -0.8558373281d, -0.5172450752d, - 0.09887025282d, 0.9951003332d, 0.9189016087d, 0.3944867976d, -0.2439375892d, -0.9697909324d, -0.8121409387d, -0.5834613061d, - -0.9910431363d, 0.1335421355d, 0.8492423985d, -0.5280031709d, -0.9717838994d, -0.2358729591d, 0.9949457207d, 0.1004142068d, - 0.6241065508d, -0.7813392434d, 0.662910307d, 0.7486988212d, -0.7197418176d, 0.6942418282d, -0.8143370775d, -0.5803922158d, - 0.104521054d, -0.9945226741d, -0.1065926113d, -0.9943027784d, 0.445799684d, -0.8951327509d, 0.105547406d, 0.9944142724d, - -0.992790267d, 0.1198644477d, -0.8334366408d, 0.552615025d, 0.9115561563d, -0.4111755999d, 0.8285544909d, -0.5599084351d, - 0.7217097654d, -0.6921957921d, 0.4940492677d, -0.8694339084d, -0.3652321272d, -0.9309164803d, -0.9696606758d, 0.2444548501d, - 0.08925509731d, -0.996008799d, 0.5354071276d, -0.8445941083d, -0.1053576186d, 0.9944343981d, -0.9890284586d, 0.1477251101d, - 0.004856104961d, 0.9999882091d, 0.9885598478d, 0.1508291331d, 0.9286129562d, -0.3710498316d, -0.5832393863d, -0.8123003252d, - 0.3015207509d, 0.9534596146d, -0.9575110528d, 0.2883965738d, 0.9715802154d, -0.2367105511d, 0.229981792d, 0.9731949318d, - 0.955763816d, -0.2941352207d, 0.740956116d, 0.6715534485d, -0.9971513787d, -0.07542630764d, 0.6905710663d, -0.7232645452d, - -0.290713703d, -0.9568100872d, 0.5912777791d, -0.8064679708d, -0.9454592212d, -0.325740481d, 0.6664455681d, 0.74555369d, - 0.6236134912d, 0.7817328275d, 0.9126993851d, -0.4086316587d, -0.8191762011d, 0.5735419353d, -0.8812745759d, -0.4726046147d, - 0.9953313627d, 0.09651672651d, 0.9855650846d, -0.1692969699d, -0.8495980887d, 0.5274306472d, 0.6174853946d, -0.7865823463d, - 0.8508156371d, 0.52546432d, 0.9985032451d, -0.05469249926d, 0.1971371563d, -0.9803759185d, 0.6607855748d, -0.7505747292d, - -0.03097494063d, 0.9995201614d, -0.6731660801d, 0.739491331d, -0.7195018362d, -0.6944905383d, 0.9727511689d, 0.2318515979d, - 0.9997059088d, -0.0242506907d, 0.4421787429d, -0.8969269532d, 0.9981350961d, -0.061043673d, -0.9173660799d, -0.3980445648d, - -0.8150056635d, -0.5794529907d, -0.8789331304d, 0.4769450202d, 0.0158605829d, 0.999874213d, -0.8095464474d, 0.5870558317d, - -0.9165898907d, -0.3998286786d, -0.8023542565d, 0.5968480938d, -0.5176737917d, 0.8555780767d, -0.8154407307d, -0.5788405779d, - 0.4022010347d, -0.9155513791d, -0.9052556868d, -0.4248672045d, 0.7317445619d, 0.6815789728d, -0.5647632201d, -0.8252529947d, - -0.8403276335d, -0.5420788397d, -0.9314281527d, 0.363925262d, 0.5238198472d, 0.8518290719d, 0.7432803869d, -0.6689800195d, - -0.985371561d, -0.1704197369d, 0.4601468731d, 0.88784281d, 0.825855404d, 0.5638819483d, 0.6182366099d, 0.7859920446d, - 0.8331502863d, -0.553046653d, 0.1500307506d, 0.9886813308d, -0.662330369d, -0.7492119075d, -0.668598664d, 0.743623444d, - 0.7025606278d, 0.7116238924d, -0.5419389763d, -0.8404178401d, -0.3388616456d, 0.9408362159d, 0.8331530315d, 0.5530425174d, - -0.2989720662d, -0.9542618632d, 0.2638522993d, 0.9645630949d, 0.124108739d, -0.9922686234d, -0.7282649308d, -0.6852956957d, - 0.6962500149d, 0.7177993569d, -0.9183535368d, 0.3957610156d, -0.6326102274d, -0.7744703352d, -0.9331891859d, -0.359385508d, - -0.1153779357d, -0.9933216659d, 0.9514974788d, -0.3076565421d, -0.08987977445d, -0.9959526224d, 0.6678496916d, 0.7442961705d, - 0.7952400393d, -0.6062947138d, -0.6462007402d, -0.7631674805d, -0.2733598753d, 0.9619118351d, 0.9669590226d, -0.254931851d, - -0.9792894595d, 0.2024651934d, -0.5369502995d, -0.8436138784d, -0.270036471d, -0.9628500944d, -0.6400277131d, 0.7683518247d, - -0.7854537493d, -0.6189203566d, 0.06005905383d, -0.9981948257d, -0.02455770378d, 0.9996984141d, -0.65983623d, 0.751409442d, - -0.6253894466d, -0.7803127835d, -0.6210408851d, -0.7837781695d, 0.8348888491d, 0.5504185768d, -0.1592275245d, 0.9872419133d, - 0.8367622488d, 0.5475663786d, -0.8675753916d, -0.4973056806d, -0.2022662628d, -0.9793305667d, 0.9399189937d, 0.3413975472d, - 0.9877404807d, -0.1561049093d, -0.9034455656d, 0.4287028224d, 0.1269804218d, -0.9919052235d, -0.3819600854d, 0.924178821d, - 0.9754625894d, 0.2201652486d, -0.3204015856d, -0.9472818081d, -0.9874760884d, 0.1577687387d, 0.02535348474d, -0.9996785487d, - 0.4835130794d, -0.8753371362d, -0.2850799925d, -0.9585037287d, -0.06805516006d, -0.99768156d, -0.7885244045d, -0.6150034663d, - 0.3185392127d, -0.9479096845d, 0.8880043089d, 0.4598351306d, 0.6476921488d, -0.7619021462d, 0.9820241299d, 0.1887554194d, - 0.9357275128d, -0.3527237187d, -0.8894895414d, 0.4569555293d, 0.7922791302d, 0.6101588153d, 0.7483818261d, 0.6632681526d, - -0.7288929755d, -0.6846276581d, 0.8729032783d, -0.4878932944d, 0.8288345784d, 0.5594937369d, 0.08074567077d, 0.9967347374d, - 0.9799148216d, -0.1994165048d, -0.580730673d, -0.8140957471d, -0.4700049791d, -0.8826637636d, 0.2409492979d, 0.9705377045d, - 0.9437816757d, -0.3305694308d, -0.8927998638d, -0.4504535528d, -0.8069622304d, 0.5906030467d, 0.06258973166d, 0.9980393407d, - -0.9312597469d, 0.3643559849d, 0.5777449785d, 0.8162173362d, -0.3360095855d, -0.941858566d, 0.697932075d, -0.7161639607d, - -0.002008157227d, -0.9999979837d, -0.1827294312d, -0.9831632392d, -0.6523911722d, 0.7578824173d, -0.4302626911d, -0.9027037258d, - -0.9985126289d, -0.05452091251d, -0.01028102172d, -0.9999471489d, -0.4946071129d, 0.8691166802d, -0.2999350194d, 0.9539596344d, - 0.8165471961d, 0.5772786819d, 0.2697460475d, 0.962931498d, -0.7306287391d, -0.6827749597d, -0.7590952064d, -0.6509796216d, - -0.907053853d, 0.4210146171d, -0.5104861064d, -0.8598860013d, 0.8613350597d, 0.5080373165d, 0.5007881595d, -0.8655698812d, - -0.654158152d, 0.7563577938d, -0.8382755311d, -0.545246856d, 0.6940070834d, 0.7199681717d, 0.06950936031d, 0.9975812994d, - 0.1702942185d, -0.9853932612d, 0.2695973274d, 0.9629731466d, 0.5519612192d, -0.8338697815d, 0.225657487d, -0.9742067022d, - 0.4215262855d, -0.9068161835d, 0.4881873305d, -0.8727388672d, -0.3683854996d, -0.9296731273d, -0.9825390578d, 0.1860564427d, - 0.81256471d, 0.5828709909d, 0.3196460933d, -0.9475370046d, 0.9570913859d, 0.2897862643d, -0.6876655497d, -0.7260276109d, - -0.9988770922d, -0.047376731d, -0.1250179027d, 0.992154486d, -0.8280133617d, 0.560708367d, 0.9324863769d, -0.3612051451d, - 0.6394653183d, 0.7688199442d, -0.01623847064d, -0.9998681473d, -0.9955014666d, -0.09474613458d, -0.81453315d, 0.580117012d, - 0.4037327978d, -0.9148769469d, 0.9944263371d, 0.1054336766d, -0.1624711654d, 0.9867132919d, -0.9949487814d, -0.100383875d, - -0.6995302564d, 0.7146029809d, 0.5263414922d, -0.85027327d, -0.5395221479d, 0.841971408d, 0.6579370318d, 0.7530729462d, - 0.01426758847d, -0.9998982128d, -0.6734383991d, 0.7392433447d, 0.639412098d, -0.7688642071d, 0.9211571421d, 0.3891908523d, - -0.146637214d, -0.9891903394d, -0.782318098d, 0.6228791163d, -0.5039610839d, -0.8637263605d, -0.7743120191d, -0.6328039957d, - }; - - + -0.2700222198d, -0.9628540911d, 0.3863092627d, -0.9223693152d, 0.04444859006d, -0.999011673d, -0.5992523158d, -0.8005602176d, + -0.7819280288d, 0.6233687174d, 0.9464672271d, 0.3227999196d, -0.6514146797d, -0.7587218957d, 0.9378472289d, 0.347048376d, + -0.8497875957d, -0.5271252623d, -0.879042592d, 0.4767432447d, -0.892300288d, -0.4514423508d, -0.379844434d, -0.9250503802d, + -0.9951650832d, 0.0982163789d, 0.7724397808d, -0.6350880136d, 0.7573283322d, -0.6530343002d, -0.9928004525d, -0.119780055d, + -0.0532665713d, 0.9985803285d, 0.9754253726d, -0.2203300762d, -0.7665018163d, 0.6422421394d, 0.991636706d, 0.1290606184d, + -0.994696838d, 0.1028503788d, -0.5379205513d, -0.84299554d, 0.5022815471d, -0.8647041387d, 0.4559821461d, -0.8899889226d, + -0.8659131224d, -0.5001944266d, 0.0879458407d, -0.9961252577d, -0.5051684983d, 0.8630207346d, 0.7753185226d, -0.6315704146d, + -0.6921944612d, 0.7217110418d, -0.5191659449d, -0.8546734591d, 0.8978622882d, -0.4402764035d, -0.1706774107d, 0.9853269617d, + -0.9353430106d, -0.3537420705d, -0.9992404798d, 0.03896746794d, -0.2882064021d, -0.9575683108d, -0.9663811329d, 0.2571137995d, + -0.8759714238d, -0.4823630009d, -0.8303123018d, -0.5572983775d, 0.05110133755d, -0.9986934731d, -0.8558373281d, -0.5172450752d, + 0.09887025282d, 0.9951003332d, 0.9189016087d, 0.3944867976d, -0.2439375892d, -0.9697909324d, -0.8121409387d, -0.5834613061d, + -0.9910431363d, 0.1335421355d, 0.8492423985d, -0.5280031709d, -0.9717838994d, -0.2358729591d, 0.9949457207d, 0.1004142068d, + 0.6241065508d, -0.7813392434d, 0.662910307d, 0.7486988212d, -0.7197418176d, 0.6942418282d, -0.8143370775d, -0.5803922158d, + 0.104521054d, -0.9945226741d, -0.1065926113d, -0.9943027784d, 0.445799684d, -0.8951327509d, 0.105547406d, 0.9944142724d, + -0.992790267d, 0.1198644477d, -0.8334366408d, 0.552615025d, 0.9115561563d, -0.4111755999d, 0.8285544909d, -0.5599084351d, + 0.7217097654d, -0.6921957921d, 0.4940492677d, -0.8694339084d, -0.3652321272d, -0.9309164803d, -0.9696606758d, 0.2444548501d, + 0.08925509731d, -0.996008799d, 0.5354071276d, -0.8445941083d, -0.1053576186d, 0.9944343981d, -0.9890284586d, 0.1477251101d, + 0.004856104961d, 0.9999882091d, 0.9885598478d, 0.1508291331d, 0.9286129562d, -0.3710498316d, -0.5832393863d, -0.8123003252d, + 0.3015207509d, 0.9534596146d, -0.9575110528d, 0.2883965738d, 0.9715802154d, -0.2367105511d, 0.229981792d, 0.9731949318d, + 0.955763816d, -0.2941352207d, 0.740956116d, 0.6715534485d, -0.9971513787d, -0.07542630764d, 0.6905710663d, -0.7232645452d, + -0.290713703d, -0.9568100872d, 0.5912777791d, -0.8064679708d, -0.9454592212d, -0.325740481d, 0.6664455681d, 0.74555369d, + 0.6236134912d, 0.7817328275d, 0.9126993851d, -0.4086316587d, -0.8191762011d, 0.5735419353d, -0.8812745759d, -0.4726046147d, + 0.9953313627d, 0.09651672651d, 0.9855650846d, -0.1692969699d, -0.8495980887d, 0.5274306472d, 0.6174853946d, -0.7865823463d, + 0.8508156371d, 0.52546432d, 0.9985032451d, -0.05469249926d, 0.1971371563d, -0.9803759185d, 0.6607855748d, -0.7505747292d, + -0.03097494063d, 0.9995201614d, -0.6731660801d, 0.739491331d, -0.7195018362d, -0.6944905383d, 0.9727511689d, 0.2318515979d, + 0.9997059088d, -0.0242506907d, 0.4421787429d, -0.8969269532d, 0.9981350961d, -0.061043673d, -0.9173660799d, -0.3980445648d, + -0.8150056635d, -0.5794529907d, -0.8789331304d, 0.4769450202d, 0.0158605829d, 0.999874213d, -0.8095464474d, 0.5870558317d, + -0.9165898907d, -0.3998286786d, -0.8023542565d, 0.5968480938d, -0.5176737917d, 0.8555780767d, -0.8154407307d, -0.5788405779d, + 0.4022010347d, -0.9155513791d, -0.9052556868d, -0.4248672045d, 0.7317445619d, 0.6815789728d, -0.5647632201d, -0.8252529947d, + -0.8403276335d, -0.5420788397d, -0.9314281527d, 0.363925262d, 0.5238198472d, 0.8518290719d, 0.7432803869d, -0.6689800195d, + -0.985371561d, -0.1704197369d, 0.4601468731d, 0.88784281d, 0.825855404d, 0.5638819483d, 0.6182366099d, 0.7859920446d, + 0.8331502863d, -0.553046653d, 0.1500307506d, 0.9886813308d, -0.662330369d, -0.7492119075d, -0.668598664d, 0.743623444d, + 0.7025606278d, 0.7116238924d, -0.5419389763d, -0.8404178401d, -0.3388616456d, 0.9408362159d, 0.8331530315d, 0.5530425174d, + -0.2989720662d, -0.9542618632d, 0.2638522993d, 0.9645630949d, 0.124108739d, -0.9922686234d, -0.7282649308d, -0.6852956957d, + 0.6962500149d, 0.7177993569d, -0.9183535368d, 0.3957610156d, -0.6326102274d, -0.7744703352d, -0.9331891859d, -0.359385508d, + -0.1153779357d, -0.9933216659d, 0.9514974788d, -0.3076565421d, -0.08987977445d, -0.9959526224d, 0.6678496916d, 0.7442961705d, + 0.7952400393d, -0.6062947138d, -0.6462007402d, -0.7631674805d, -0.2733598753d, 0.9619118351d, 0.9669590226d, -0.254931851d, + -0.9792894595d, 0.2024651934d, -0.5369502995d, -0.8436138784d, -0.270036471d, -0.9628500944d, -0.6400277131d, 0.7683518247d, + -0.7854537493d, -0.6189203566d, 0.06005905383d, -0.9981948257d, -0.02455770378d, 0.9996984141d, -0.65983623d, 0.751409442d, + -0.6253894466d, -0.7803127835d, -0.6210408851d, -0.7837781695d, 0.8348888491d, 0.5504185768d, -0.1592275245d, 0.9872419133d, + 0.8367622488d, 0.5475663786d, -0.8675753916d, -0.4973056806d, -0.2022662628d, -0.9793305667d, 0.9399189937d, 0.3413975472d, + 0.9877404807d, -0.1561049093d, -0.9034455656d, 0.4287028224d, 0.1269804218d, -0.9919052235d, -0.3819600854d, 0.924178821d, + 0.9754625894d, 0.2201652486d, -0.3204015856d, -0.9472818081d, -0.9874760884d, 0.1577687387d, 0.02535348474d, -0.9996785487d, + 0.4835130794d, -0.8753371362d, -0.2850799925d, -0.9585037287d, -0.06805516006d, -0.99768156d, -0.7885244045d, -0.6150034663d, + 0.3185392127d, -0.9479096845d, 0.8880043089d, 0.4598351306d, 0.6476921488d, -0.7619021462d, 0.9820241299d, 0.1887554194d, + 0.9357275128d, -0.3527237187d, -0.8894895414d, 0.4569555293d, 0.7922791302d, 0.6101588153d, 0.7483818261d, 0.6632681526d, + -0.7288929755d, -0.6846276581d, 0.8729032783d, -0.4878932944d, 0.8288345784d, 0.5594937369d, 0.08074567077d, 0.9967347374d, + 0.9799148216d, -0.1994165048d, -0.580730673d, -0.8140957471d, -0.4700049791d, -0.8826637636d, 0.2409492979d, 0.9705377045d, + 0.9437816757d, -0.3305694308d, -0.8927998638d, -0.4504535528d, -0.8069622304d, 0.5906030467d, 0.06258973166d, 0.9980393407d, + -0.9312597469d, 0.3643559849d, 0.5777449785d, 0.8162173362d, -0.3360095855d, -0.941858566d, 0.697932075d, -0.7161639607d, + -0.002008157227d, -0.9999979837d, -0.1827294312d, -0.9831632392d, -0.6523911722d, 0.7578824173d, -0.4302626911d, -0.9027037258d, + -0.9985126289d, -0.05452091251d, -0.01028102172d, -0.9999471489d, -0.4946071129d, 0.8691166802d, -0.2999350194d, 0.9539596344d, + 0.8165471961d, 0.5772786819d, 0.2697460475d, 0.962931498d, -0.7306287391d, -0.6827749597d, -0.7590952064d, -0.6509796216d, + -0.907053853d, 0.4210146171d, -0.5104861064d, -0.8598860013d, 0.8613350597d, 0.5080373165d, 0.5007881595d, -0.8655698812d, + -0.654158152d, 0.7563577938d, -0.8382755311d, -0.545246856d, 0.6940070834d, 0.7199681717d, 0.06950936031d, 0.9975812994d, + 0.1702942185d, -0.9853932612d, 0.2695973274d, 0.9629731466d, 0.5519612192d, -0.8338697815d, 0.225657487d, -0.9742067022d, + 0.4215262855d, -0.9068161835d, 0.4881873305d, -0.8727388672d, -0.3683854996d, -0.9296731273d, -0.9825390578d, 0.1860564427d, + 0.81256471d, 0.5828709909d, 0.3196460933d, -0.9475370046d, 0.9570913859d, 0.2897862643d, -0.6876655497d, -0.7260276109d, + -0.9988770922d, -0.047376731d, -0.1250179027d, 0.992154486d, -0.8280133617d, 0.560708367d, 0.9324863769d, -0.3612051451d, + 0.6394653183d, 0.7688199442d, -0.01623847064d, -0.9998681473d, -0.9955014666d, -0.09474613458d, -0.81453315d, 0.580117012d, + 0.4037327978d, -0.9148769469d, 0.9944263371d, 0.1054336766d, -0.1624711654d, 0.9867132919d, -0.9949487814d, -0.100383875d, + -0.6995302564d, 0.7146029809d, 0.5263414922d, -0.85027327d, -0.5395221479d, 0.841971408d, 0.6579370318d, 0.7530729462d, + 0.01426758847d, -0.9998982128d, -0.6734383991d, 0.7392433447d, 0.639412098d, -0.7688642071d, 0.9211571421d, 0.3891908523d, + -0.146637214d, -0.9891903394d, -0.782318098d, 0.6228791163d, -0.5039610839d, -0.8637263605d, -0.7743120191d, -0.6328039957d, + }; + + private DistanceFunction distanceFunction = DistanceFunction.EuclideanSq; private ReturnType returnType = ReturnType.Distance; private double jitterModifier = 1.0; - + private NoiseSampler noiseLookup; - + public CellularSampler() { noiseLookup = new OpenSimplex2Sampler(); } - + public void setDistanceFunction(DistanceFunction distanceFunction) { this.distanceFunction = distanceFunction; } - + public void setJitterModifier(double jitterModifier) { this.jitterModifier = jitterModifier; } - + public void setNoiseLookup(NoiseSampler noiseLookup) { this.noiseLookup = noiseLookup; } - + public void setReturnType(ReturnType returnType) { this.returnType = returnType; } - + @Override public double getNoiseRaw(long sl, double x, double y) { int seed = (int) sl; int xr = (int) Math.round(x); int yr = (int) Math.round(y); - + double distance0 = Double.MAX_VALUE; double distance1 = Double.MAX_VALUE; double distance2 = Double.MAX_VALUE; - + int closestHash = 0; - + double cellularJitter = 0.43701595 * jitterModifier; - + int xPrimed = (xr - 1) * PRIME_X; int yPrimedBase = (yr - 1) * PRIME_Y; - + double centerX = x; double centerY = y; - + for(int xi = xr - 1; xi <= xr + 1; xi++) { int yPrimed = yPrimedBase; - + for(int yi = yr - 1; yi <= yr + 1; yi++) { int hash = hash(seed, xPrimed, yPrimed); int idx = hash & (255 << 1); - + double vecX = (xi - x) + RAND_VECS_2D[idx] * cellularJitter; double vecY = (yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter; - + double newDistance = switch(distanceFunction) { case Manhattan -> Math.abs(vecX) + Math.abs(vecY); case Hybrid -> (Math.abs(vecX) + Math.abs(vecY)) + (vecX * vecX + vecY * vecY); default -> vecX * vecX + vecY * vecY; }; - + distance1 = Math.max(Math.min(distance1, newDistance), distance0); if(newDistance < distance0) { distance0 = newDistance; @@ -270,14 +270,14 @@ public class CellularSampler extends NoiseFunction { } xPrimed += PRIME_X; } - + if(distanceFunction == DistanceFunction.Euclidean && returnType != ReturnType.CellValue) { distance0 = Math.sqrt(distance0); if(returnType != ReturnType.CellValue) { distance1 = Math.sqrt(distance1); } } - + return switch(returnType) { case CellValue -> closestHash * (1 / 2147483648.0); case Distance -> distance0 - 1; @@ -296,43 +296,43 @@ public class CellularSampler extends NoiseFunction { case Angle -> Math.atan2(y / frequency - centerY, x / frequency - centerX); }; } - + @Override public double getNoiseRaw(long sl, double x, double y, double z) { int seed = (int) sl; int xr = (int) Math.round(x); int yr = (int) Math.round(y); int zr = (int) Math.round(z); - + double distance0 = Double.MAX_VALUE; double distance1 = Double.MAX_VALUE; double distance2 = Double.MAX_VALUE; int closestHash = 0; - + double cellularJitter = 0.39614353 * jitterModifier; - + int xPrimed = (xr - 1) * PRIME_X; int yPrimedBase = (yr - 1) * PRIME_Y; int zPrimedBase = (zr - 1) * PRIME_Z; - + double centerX = x; double centerY = y; double centerZ = z; - + for(int xi = xr - 1; xi <= xr + 1; xi++) { int yPrimed = yPrimedBase; - + for(int yi = yr - 1; yi <= yr + 1; yi++) { int zPrimed = zPrimedBase; - + for(int zi = zr - 1; zi <= zr + 1; zi++) { int hash = hash(seed, xPrimed, yPrimed, zPrimed); int idx = hash & (255 << 2); - + double vecX = (xi - x) + RAND_VECS_3D[idx] * cellularJitter; double vecY = (yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter; double vecZ = (zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter; - + double newDistance = 0; switch(distanceFunction) { case Euclidean, EuclideanSq -> newDistance = vecX * vecX + vecY * vecY + vecZ * vecZ; @@ -342,7 +342,7 @@ public class CellularSampler extends NoiseFunction { distance1 = Math.max(Math.min(distance1, newDistance), distance0); } } - + if(newDistance < distance0) { distance0 = newDistance; closestHash = hash; @@ -361,14 +361,14 @@ public class CellularSampler extends NoiseFunction { } xPrimed += PRIME_X; } - + if(distanceFunction == DistanceFunction.Euclidean && returnType != ReturnType.CellValue) { distance0 = Math.sqrt(distance0); if(returnType != ReturnType.CellValue) { distance1 = Math.sqrt(distance1); } } - + return switch(returnType) { case CellValue -> closestHash * (1 / 2147483648.0); case Distance -> distance0 - 1; @@ -387,15 +387,15 @@ public class CellularSampler extends NoiseFunction { case Angle -> Math.atan2(y / frequency - centerY, x / frequency - centerX); }; } - + public enum DistanceFunction { Euclidean, EuclideanSq, Manhattan, Hybrid } - - + + public enum ReturnType { CellValue, Distance, diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ConstantSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ConstantSampler.java index 93d5633e6..a8372bfb7 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ConstantSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ConstantSampler.java @@ -12,16 +12,16 @@ package com.dfsek.terra.addons.noise.samplers.noise; */ public class ConstantSampler extends NoiseFunction { private final double constant; - + public ConstantSampler(double constant) { this.constant = constant; } - + @Override public double getNoiseRaw(long seed, double x, double y) { return constant; } - + @Override public double getNoiseRaw(long seed, double x, double y, double z) { return constant; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java index 72fbbed9a..0cc9087b4 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java @@ -2,14 +2,14 @@ package com.dfsek.terra.addons.noise.samplers.noise; public class DistanceSampler extends NoiseFunction { - + private final DistanceFunction distanceFunction; private final double ox, oy, oz; private final boolean normalize; private final double radius; - + private final double distanceAtRadius; - + public DistanceSampler(DistanceFunction distanceFunction, double ox, double oy, double oz, boolean normalize, double radius) { frequency = 1; this.distanceFunction = distanceFunction; @@ -20,7 +20,7 @@ public class DistanceSampler extends NoiseFunction { this.radius = radius; this.distanceAtRadius = distance2d(distanceFunction, radius, 0); // distance2d and distance3d should return the same value } - + private static double distance2d(DistanceFunction distanceFunction, double x, double z) { return switch(distanceFunction) { case Euclidean -> Math.sqrt(x * x + z * z); @@ -28,7 +28,7 @@ public class DistanceSampler extends NoiseFunction { case Manhattan -> Math.abs(x) + Math.abs(z); }; } - + private static double distance3d(DistanceFunction distanceFunction, double x, double y, double z) { return switch(distanceFunction) { case Euclidean -> Math.sqrt(x * x + y * y + z * z); @@ -36,7 +36,7 @@ public class DistanceSampler extends NoiseFunction { case Manhattan -> Math.abs(x) + Math.abs(y) + Math.abs(z); }; } - + @Override public double getNoiseRaw(long seed, double x, double y) { double dx = x - ox; @@ -46,7 +46,7 @@ public class DistanceSampler extends NoiseFunction { if(normalize) return Math.min(((2 * dist) / distanceAtRadius) - 1, 1); return dist; } - + @Override public double getNoiseRaw(long seed, double x, double y, double z) { double dx = x - ox; @@ -57,7 +57,7 @@ public class DistanceSampler extends NoiseFunction { if(normalize) return Math.min(((2 * dist) / distanceAtRadius) - 1, 1); return dist; } - + public enum DistanceFunction { Euclidean, EuclideanSq, diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ExpressionFunction.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ExpressionFunction.java index e3d43c7b9..15b7dfbb0 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ExpressionFunction.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/ExpressionFunction.java @@ -13,38 +13,38 @@ import com.dfsek.paralithic.eval.parser.Scope; import com.dfsek.paralithic.eval.tokenizer.ParseException; import com.dfsek.paralithic.functions.Function; -import com.dfsek.terra.addons.noise.paralithic.noise.SeedContext; - import java.util.Map; +import com.dfsek.terra.addons.noise.paralithic.noise.SeedContext; + /** * NoiseSampler implementation using a Paralithic expression. */ public class ExpressionFunction extends NoiseFunction { private final Expression expression; - + public ExpressionFunction(Map functions, String eq, Map vars) throws ParseException { Parser p = new Parser(); Scope scope = new Scope(); - + scope.addInvocationVariable("x"); scope.addInvocationVariable("y"); scope.addInvocationVariable("z"); - + vars.forEach(scope::create); - + functions.forEach(p::registerFunction); - + expression = p.parse(eq, scope); frequency = 1; } - + @Override public double getNoiseRaw(long seed, double x, double y) { return expression.evaluate(new SeedContext(seed), x, 0, y); } - + @Override public double getNoiseRaw(long seed, double x, double y, double z) { return expression.evaluate(new SeedContext(seed), x, y, z); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java index acc853035..5d0e763f9 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/GaborNoiseSampler.java @@ -23,19 +23,19 @@ public class GaborNoiseSampler extends NoiseFunction { private double g = Math.exp(-impulsesPerCell); private double omega0 = Math.PI * 0.25; private boolean isotropic = true; - - + + public GaborNoiseSampler() { rand = new WhiteNoiseSampler(); } - + private void recalculateRadiusAndDensity() { kernelRadius = (Math.sqrt(-Math.log(0.05) / Math.PI) / this.a); impulseDensity = (impulsesPerKernel / (Math.PI * kernelRadius * kernelRadius)); impulsesPerCell = impulseDensity * kernelRadius * kernelRadius; g = Math.exp(-impulsesPerCell); } - + private double gaborNoise(long seed, double x, double y) { x /= kernelRadius; y /= kernelRadius; @@ -51,62 +51,62 @@ public class GaborNoiseSampler extends NoiseFunction { } return noise; } - + private double calculateCell(long seed, int xi, int yi, double x, double y) { long mashedSeed = MathUtil.murmur64(31L * xi + yi) + seed; - + double gaussianSource = (rand.getNoiseRaw(mashedSeed++) + 1) / 2; int impulses = 0; while(gaussianSource > g) { impulses++; gaussianSource *= (rand.getNoiseRaw(mashedSeed++) + 1) / 2; } - + double noise = 0; for(int i = 0; i < impulses; i++) { noise += rand.getNoiseRaw(mashedSeed++) * gabor(isotropic ? (rand.getNoiseRaw(mashedSeed++) + 1) * Math.PI : omega0, - x * kernelRadius, y * kernelRadius); + x * kernelRadius, y * kernelRadius); } return noise; } - + private double gabor(double omega_0, double x, double y) { return k * (Math.exp(-Math.PI * (a * a) * (x * x + y * y)) * MathUtil.cos(2 * Math.PI * f0 * (x * MathUtil.cos(omega_0) + y * MathUtil.sin( - omega_0)))); + omega_0)))); } - + public void setA(double a) { this.a = a; recalculateRadiusAndDensity(); } - + public void setDeviation(double k) { this.k = k; } - + public void setFrequency0(double f0) { this.f0 = f0; } - + public void setImpulsesPerKernel(double impulsesPerKernel) { this.impulsesPerKernel = impulsesPerKernel; recalculateRadiusAndDensity(); } - + public void setIsotropic(boolean isotropic) { this.isotropic = isotropic; } - + public void setRotation(double omega0) { this.omega0 = Math.PI * omega0; } - + @Override public double getNoiseRaw(long seed, double x, double z) { return gaborNoise(seed, x, z); } - + @Override public double getNoiseRaw(long seed, double x, double y, double z) { return gaborNoise(seed, x, z); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java index a996ded2a..bdc03618f 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/NoiseFunction.java @@ -15,51 +15,51 @@ public abstract class NoiseFunction implements NoiseSampler { protected static final int PRIME_X = 501125321; protected static final int PRIME_Y = 1136930381; protected static final int PRIME_Z = 1720413743; - + protected double frequency = 0.02d; protected long salt; - + public NoiseFunction() { this.salt = 0; } - + protected static int hash(int seed, int xPrimed, int yPrimed, int zPrimed) { int hash = seed ^ xPrimed ^ yPrimed ^ zPrimed; - + hash *= 0x27d4eb2d; return hash; } - + protected static int hash(int seed, int xPrimed, int yPrimed) { int hash = seed ^ xPrimed ^ yPrimed; - + hash *= 0x27d4eb2d; return hash; } - + public void setSalt(long salt) { this.salt = salt; } - + public double getFrequency() { return frequency; } - + public void setFrequency(double frequency) { this.frequency = frequency; } - + @Override public double noise(long seed, double x, double y) { return getNoiseRaw(seed + salt, x * frequency, y * frequency); } - + @Override public double noise(long seed, double x, double y, double z) { return getNoiseRaw(seed + salt, x * frequency, y * frequency, z * frequency); } - + public abstract double getNoiseRaw(long seed, double x, double y); - + public abstract double getNoiseRaw(long seed, double x, double y, double z); } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/BrownianMotionSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/BrownianMotionSampler.java index 3cc8f6c94..64f4ede05 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/BrownianMotionSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/BrownianMotionSampler.java @@ -15,41 +15,41 @@ public class BrownianMotionSampler extends FractalNoiseFunction { public BrownianMotionSampler(NoiseSampler input) { super(input); } - + @Override public double getNoiseRaw(long seed, double x, double y) { double sum = 0; double amp = fractalBounding; - + for(int i = 0; i < octaves; i++) { double noise = input.noise(seed++, x, y); sum += noise * amp; amp *= MathUtil.lerp(1.0, Math.min(noise + 1, 2) * 0.5, weightedStrength); - + x *= lacunarity; y *= lacunarity; amp *= gain; } - + return sum; } - + @Override public double getNoiseRaw(long seed, double x, double y, double z) { double sum = 0; double amp = fractalBounding; - + for(int i = 0; i < octaves; i++) { double noise = input.noise(seed++, x, y, z); sum += noise * amp; amp *= MathUtil.lerp(1.0, (noise + 1) * 0.5, weightedStrength); - + x *= lacunarity; y *= lacunarity; z *= lacunarity; amp *= gain; } - + return sum; } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/FractalNoiseFunction.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/FractalNoiseFunction.java index 4db8df0cd..6ffdd0528 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/FractalNoiseFunction.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/FractalNoiseFunction.java @@ -18,12 +18,12 @@ public abstract class FractalNoiseFunction extends NoiseFunction { protected double gain = 0.5; protected double lacunarity = 2.0d; protected double weightedStrength = 0.0d; - + public FractalNoiseFunction(NoiseSampler input) { this.input = input; frequency = 1; } - + protected void calculateFractalBounding() { double gain = Math.abs(this.gain); double amp = gain; @@ -34,21 +34,21 @@ public abstract class FractalNoiseFunction extends NoiseFunction { } fractalBounding = 1 / ampFractal; } - + public void setGain(double gain) { this.gain = gain; calculateFractalBounding(); } - + public void setLacunarity(double lacunarity) { this.lacunarity = lacunarity; } - + public void setOctaves(int octaves) { this.octaves = octaves; calculateFractalBounding(); } - + public void setWeightedStrength(double weightedStrength) { this.weightedStrength = weightedStrength; } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/PingPongSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/PingPongSampler.java index dd73222e3..653484fa1 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/PingPongSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/PingPongSampler.java @@ -13,55 +13,55 @@ import com.dfsek.terra.api.util.MathUtil; public class PingPongSampler extends FractalNoiseFunction { private double pingPongStrength = 2.0; - + public PingPongSampler(NoiseSampler input) { super(input); } - - + + private static double pingPong(double t) { t -= (int) (t * 0.5f) << 1; return t < 1 ? t : 2 - t; } - + public void setPingPongStrength(double strength) { this.pingPongStrength = strength; } - + @Override public double getNoiseRaw(long seed, double x, double y) { double sum = 0; double amp = fractalBounding; - + for(int i = 0; i < octaves; i++) { double noise = pingPong((input.noise(seed++, x, y) + 1) * pingPongStrength); sum += (noise - 0.5) * 2 * amp; amp *= MathUtil.lerp(1.0, noise, weightedStrength); - + x *= lacunarity; y *= lacunarity; amp *= gain; } - + return sum; } - + @Override public double getNoiseRaw(long seed, double x, double y, double z) { double sum = 0; double amp = fractalBounding; - + for(int i = 0; i < octaves; i++) { double noise = pingPong((input.noise(seed++, x, y, z) + 1) * pingPongStrength); sum += (noise - 0.5) * 2 * amp; amp *= MathUtil.lerp(1.0, noise, weightedStrength); - + x *= lacunarity; y *= lacunarity; z *= lacunarity; amp *= gain; } - + return sum; } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/RidgedFractalSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/RidgedFractalSampler.java index 3990ac4cd..9ebb20ba0 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/RidgedFractalSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/fractal/RidgedFractalSampler.java @@ -12,45 +12,45 @@ import com.dfsek.terra.api.util.MathUtil; public class RidgedFractalSampler extends FractalNoiseFunction { - + public RidgedFractalSampler(NoiseSampler input) { super(input); } - + @Override public double getNoiseRaw(long seed, double x, double y) { double sum = 0; double amp = fractalBounding; - + for(int i = 0; i < octaves; i++) { double noise = Math.abs(input.noise(seed++, x, y)); sum += (noise * -2 + 1) * amp; amp *= MathUtil.lerp(1.0, 1 - noise, weightedStrength); - + x *= lacunarity; y *= lacunarity; amp *= gain; } - + return sum; } - + @Override public double getNoiseRaw(long seed, double x, double y, double z) { double sum = 0; double amp = fractalBounding; - + for(int i = 0; i < octaves; i++) { double noise = Math.abs(input.noise(seed++, x, y, z)); sum += (noise * -2 + 1) * amp; amp *= MathUtil.lerp(1.0, 1 - noise, weightedStrength); - + x *= lacunarity; y *= lacunarity; z *= lacunarity; amp *= gain; } - + return sum; } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/GaussianNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/GaussianNoiseSampler.java index 95b700b95..6a4be9cbe 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/GaussianNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/GaussianNoiseSampler.java @@ -15,11 +15,11 @@ import com.dfsek.terra.addons.noise.samplers.noise.NoiseFunction; */ public class GaussianNoiseSampler extends NoiseFunction { private final WhiteNoiseSampler whiteNoiseSampler; // Back with a white noise sampler. - + public GaussianNoiseSampler() { whiteNoiseSampler = new WhiteNoiseSampler(); } - + @Override public double getNoiseRaw(long seed, double x, double y) { double v1, v2, s; @@ -31,7 +31,7 @@ public class GaussianNoiseSampler extends NoiseFunction { double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s) / s); return v1 * multiplier; } - + @Override public double getNoiseRaw(long seed, double x, double y, double z) { double v1, v2, s; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/PositiveWhiteNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/PositiveWhiteNoiseSampler.java index 0cbbba151..86be91206 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/PositiveWhiteNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/PositiveWhiteNoiseSampler.java @@ -16,16 +16,16 @@ import com.dfsek.terra.api.util.MathUtil; public class PositiveWhiteNoiseSampler extends WhiteNoiseSampler { private static final long POSITIVE_POW1 = 0b01111111111L << 52; // Bits that when applied to the exponent/sign section of a double, produce a positive number with a power of 1. - + public double getNoiseRaw(long seed) { return (Double.longBitsToDouble((MathUtil.murmur64(seed) & 0x000fffffffffffffL) | POSITIVE_POW1) - 1.5) * 2; } - + @Override public double getNoiseRaw(long seed, double x, double y) { return (getNoiseUnmapped(seed, x, y) - 1); } - + @Override public double getNoiseRaw(long seed, double x, double y, double z) { return (getNoiseUnmapped(seed, x, y, z) - 1); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/WhiteNoiseSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/WhiteNoiseSampler.java index b63665520..482c0cc9c 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/WhiteNoiseSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/random/WhiteNoiseSampler.java @@ -17,43 +17,43 @@ import com.dfsek.terra.api.util.MathUtil; public class WhiteNoiseSampler extends NoiseFunction { private static final long POSITIVE_POW1 = 0b01111111111L << 52; // Bits that when applied to the exponent/sign section of a double, produce a positive number with a power of 1. - + public WhiteNoiseSampler() { } - + public long randomBits(long seed, double x, double y, double z) { long hashX = Double.doubleToRawLongBits(x) ^ seed; long hashZ = Double.doubleToRawLongBits(y) ^ seed; long hash = (((hashX ^ (hashX >>> 32)) + ((hashZ ^ (hashZ >>> 32)) << 32)) ^ seed) + Double.doubleToRawLongBits(z); return MathUtil.murmur64(hash); } - + public long randomBits(long seed, double x, double y) { long hashX = Double.doubleToRawLongBits(x) ^ seed; long hashZ = Double.doubleToRawLongBits(y) ^ seed; long hash = ((hashX ^ (hashX >>> 32)) + ((hashZ ^ (hashZ >>> 32)) << 32)) ^ seed; return MathUtil.murmur64(hash); } - + public double getNoiseRaw(long seed) { return (Double.longBitsToDouble((MathUtil.murmur64(seed) & 0x000fffffffffffffL) | POSITIVE_POW1) - 1.5) * 2; } - + @Override public double getNoiseRaw(long seed, double x, double y) { return (getNoiseUnmapped(seed, x, y) - 1.5) * 2; } - + @Override public double getNoiseRaw(long seed, double x, double y, double z) { return (getNoiseUnmapped(seed, x, y, z) - 1.5) * 2; } - + public double getNoiseUnmapped(long seed, double x, double y, double z) { long base = ((randomBits(seed, x, y, z)) & 0x000fffffffffffffL) | POSITIVE_POW1; // Sign and exponent return Double.longBitsToDouble(base); } - + public double getNoiseUnmapped(long seed, double x, double y) { long base = (randomBits(seed, x, y) & 0x000fffffffffffffL) | POSITIVE_POW1; // Sign and exponent return Double.longBitsToDouble(base); diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2SSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2SSampler.java index 41502af11..e3488a676 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2SSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2SSampler.java @@ -16,38 +16,38 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler { public double getNoiseRaw(long sl, double x, double y) { int seed = (int) sl; // 2D OpenSimplex2S case is a modified 2D simplex noise. - + final double SQRT3 = 1.7320508075688772935274463415059; final double G2 = (3 - SQRT3) / 6; - + final double F2 = 0.5f * (SQRT3 - 1); double s = (x + y) * F2; x += s; y += s; - - + + int i = (int) Math.floor(x); int j = (int) Math.floor(y); double xi = x - i; double yi = y - j; - + i *= PRIME_X; j *= PRIME_Y; int i1 = i + PRIME_X; int j1 = j + PRIME_Y; - + double t = (xi + yi) * G2; double x0 = xi - t; double y0 = yi - t; - + double a0 = (2.0 / 3.0) - x0 * x0 - y0 * y0; double value = (a0 * a0) * (a0 * a0) * gradCoord(seed, i, j, x0, y0); - + double a1 = 2 * (1 - 2 * G2) * (1 / G2 - 2) * t + ((-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a0); double x1 = x0 - (1 - 2 * G2); double y1 = y0 - (1 - 2 * G2); value += (a1 * a1) * (a1 * a1) * gradCoord(seed, i1, j1, x1, y1); - + // Nested conditionals were faster than compact bit logic/arithmetic. double xmyi = xi - yi; if(t > G2) { @@ -66,7 +66,7 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler { value += (a2 * a2) * (a2 * a2) * gradCoord(seed, i, j + PRIME_Y, x2, y2); } } - + if(yi - xmyi > 1) { double x3 = x0 + (3 * G2 - 1); double y3 = y0 + (3 * G2 - 2); @@ -98,7 +98,7 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler { value += (a2 * a2) * (a2 * a2) * gradCoord(seed, i + PRIME_X, j, x2, y2); } } - + if(yi < xmyi) { double x2 = x0 - G2; double y2 = y0 - (G2 - 1); @@ -115,10 +115,10 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler { } } } - + return value * 18.24196194486065; } - + @Override @SuppressWarnings("NumericOverflow") public double getNoiseRaw(long sl, double x, double y, double z) { @@ -129,62 +129,62 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler { x = r - x; y = r - y; z = r - z; - - + + int i = (int) Math.floor(x); int j = (int) Math.floor(y); int k = (int) Math.floor(z); double xi = x - i; double yi = y - j; double zi = z - k; - + i *= PRIME_X; j *= PRIME_Y; k *= PRIME_Z; int seed2 = seed + 1293373; - + int xNMask = (int) (-0.5 - xi); int yNMask = (int) (-0.5 - yi); int zNMask = (int) (-0.5 - zi); - + double x0 = xi + xNMask; double y0 = yi + yNMask; double z0 = zi + zNMask; double a0 = 0.75 - x0 * x0 - y0 * y0 - z0 * z0; double value = (a0 * a0) * (a0 * a0) * gradCoord(seed, i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z), x0, - y0, - z0); - + y0, + z0); + double x1 = xi - 0.5; double y1 = yi - 0.5; double z1 = zi - 0.5; double a1 = 0.75 - x1 * x1 - y1 * y1 - z1 * z1; value += (a1 * a1) * (a1 * a1) * gradCoord(seed2, i + PRIME_X, j + PRIME_Y, k + PRIME_Z, x1, y1, z1); - + double xAFlipMask0 = ((xNMask | 1) << 1) * x1; double yAFlipMask0 = ((yNMask | 1) << 1) * y1; double zAFlipMask0 = ((zNMask | 1) << 1) * z1; double xAFlipMask1 = (-2 - (xNMask << 2)) * x1 - 1.0; double yAFlipMask1 = (-2 - (yNMask << 2)) * y1 - 1.0; double zAFlipMask1 = (-2 - (zNMask << 2)) * z1 - 1.0; - + boolean skip5 = false; double a2 = xAFlipMask0 + a0; if(a2 > 0) { double x2 = x0 - (xNMask | 1); value += (a2 * a2) * (a2 * a2) * gradCoord(seed, i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z), x2, - y0, - z0); + y0, + z0); } else { double a3 = yAFlipMask0 + zAFlipMask0 + a0; if(a3 > 0) { double y3 = y0 - (yNMask | 1); double z3 = z0 - (zNMask | 1); value += (a3 * a3) * (a3 * a3) * gradCoord(seed, i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (~zNMask & PRIME_Z), - x0, - y3, z3); + x0, + y3, z3); } - + double a4 = xAFlipMask1 + a1; if(a4 > 0) { double x4 = (xNMask | 1) + x1; @@ -192,24 +192,24 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler { skip5 = true; } } - + boolean skip9 = false; double a6 = yAFlipMask0 + a0; if(a6 > 0) { double y6 = y0 - (yNMask | 1); value += (a6 * a6) * (a6 * a6) * gradCoord(seed, i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z), x0, - y6, - z0); + y6, + z0); } else { double a7 = xAFlipMask0 + zAFlipMask0 + a0; if(a7 > 0) { double x7 = x0 - (xNMask | 1); double z7 = z0 - (zNMask | 1); value += (a7 * a7) * (a7 * a7) * gradCoord(seed, i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z), - x7, - y0, z7); + x7, + y0, z7); } - + double a8 = yAFlipMask1 + a1; if(a8 > 0) { double y8 = (yNMask | 1) + y1; @@ -217,24 +217,24 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler { skip9 = true; } } - + boolean skipD = false; double aA = zAFlipMask0 + a0; if(aA > 0) { double zA = z0 - (zNMask | 1); value += (aA * aA) * (aA * aA) * gradCoord(seed, i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z), x0, - y0, - zA); + y0, + zA); } else { double aB = xAFlipMask0 + yAFlipMask0 + a0; if(aB > 0) { double xB = x0 - (xNMask | 1); double yB = y0 - (yNMask | 1); value += (aB * aB) * (aB * aB) * gradCoord(seed, i + (~xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z), - xB, - yB, z0); + xB, + yB, z0); } - + double aC = zAFlipMask1 + a1; if(aC > 0) { double zC = (zNMask | 1) + z1; @@ -242,38 +242,38 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler { skipD = true; } } - + if(!skip5) { double a5 = yAFlipMask1 + zAFlipMask1 + a1; if(a5 > 0) { double y5 = (yNMask | 1) + y1; double z5 = (zNMask | 1) + z1; value += (a5 * a5) * (a5 * a5) * gradCoord(seed2, i + PRIME_X, j + (yNMask & (PRIME_Y << 1)), k + (zNMask & (PRIME_Z << 1)), - x1, y5, z5); + x1, y5, z5); } } - + if(!skip9) { double a9 = xAFlipMask1 + zAFlipMask1 + a1; if(a9 > 0) { double x9 = (xNMask | 1) + x1; double z9 = (zNMask | 1) + z1; value += (a9 * a9) * (a9 * a9) * gradCoord(seed2, i + (xNMask & (PRIME_X << 1)), j + PRIME_Y, k + (zNMask & (PRIME_Z << 1)), - x9, - y1, z9); + x9, + y1, z9); } } - + if(!skipD) { double aD = xAFlipMask1 + yAFlipMask1 + a1; if(aD > 0) { double xD = (xNMask | 1) + x1; double yD = (yNMask | 1) + y1; value += (aD * aD) * (aD * aD) * gradCoord(seed2, i + (xNMask & (PRIME_X << 1)), j + (yNMask & (PRIME_Y << 1)), k + PRIME_Z, - xD, yD, z1); + xD, yD, z1); } } - + return value * 9.046026385208288; } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2Sampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2Sampler.java index 56eb4eb32..e4da85a5b 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2Sampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2Sampler.java @@ -12,39 +12,39 @@ package com.dfsek.terra.addons.noise.samplers.noise.simplex; */ public class OpenSimplex2Sampler extends SimplexStyleSampler { private static final double SQRT3 = 1.7320508075688772935274463415059; - + @Override public double getNoiseRaw(long sl, double x, double y) { int seed = (int) sl; // 2D OpenSimplex2 case uses the same algorithm as ordinary Simplex. final double G2 = (3 - SQRT3) / 6; - + final double F2 = 0.5f * (SQRT3 - 1); double s = (x + y) * F2; x += s; y += s; - - + + int i = (int) Math.floor(x); int j = (int) Math.floor(y); double xi = x - i; double yi = y - j; - + double t = (xi + yi) * G2; double x0 = xi - t; double y0 = yi - t; - + i *= PRIME_X; j *= PRIME_Y; - + double n0, n1, n2; - + double a = 0.5 - x0 * x0 - y0 * y0; if(a <= 0) n0 = 0; else { n0 = (a * a) * (a * a) * gradCoord(seed, i, j, x0, y0); } - + double c = 2 * (1 - 2 * G2) * (1 / G2 - 2) * t + ((-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a); if(c <= 0) n2 = 0; else { @@ -52,7 +52,7 @@ public class OpenSimplex2Sampler extends SimplexStyleSampler { double y2 = y0 + (2 * G2 - 1); n2 = (c * c) * (c * c) * gradCoord(seed, i + PRIME_X, j + PRIME_Y, x2, y2); } - + if(y0 > x0) { double x1 = x0 + G2; double y1 = y0 + (G2 - 1); @@ -70,10 +70,10 @@ public class OpenSimplex2Sampler extends SimplexStyleSampler { n1 = (b * b) * (b * b) * gradCoord(seed, i + PRIME_X, j, x1, y1); } } - + return (n0 + n1 + n2) * 99.83685446303647f; } - + @Override public double getNoiseRaw(long sl, double x, double y, double z) { int seed = (int) sl; @@ -83,35 +83,35 @@ public class OpenSimplex2Sampler extends SimplexStyleSampler { x = r - x; y = r - y; z = r - z; - - + + int i = (int) Math.round(x); int j = (int) Math.round(y); int k = (int) Math.round(z); double x0 = x - i; double y0 = y - j; double z0 = z - k; - + int xNSign = (int) (-1.0 - x0) | 1; int yNSign = (int) (-1.0 - y0) | 1; int zNSign = (int) (-1.0 - z0) | 1; - + double ax0 = xNSign * -x0; double ay0 = yNSign * -y0; double az0 = zNSign * -z0; - + i *= PRIME_X; j *= PRIME_Y; k *= PRIME_Z; - + double value = 0; double a = (0.6f - x0 * x0) - (y0 * y0 + z0 * z0); - + for(int l = 0; ; l++) { if(a > 0) { value += (a * a) * (a * a) * gradCoord(seed, i, j, k, x0, y0, z0); } - + if(ax0 >= ay0 && ax0 >= az0) { double b = a + ax0 + ax0; if(b > 1) { @@ -131,30 +131,30 @@ public class OpenSimplex2Sampler extends SimplexStyleSampler { value += (b * b) * (b * b) * gradCoord(seed, i, j, k - zNSign * PRIME_Z, x0, y0, z0 + zNSign); } } - + if(l == 1) break; - + ax0 = 0.5 - ax0; ay0 = 0.5 - ay0; az0 = 0.5 - az0; - + x0 = xNSign * ax0; y0 = yNSign * ay0; z0 = zNSign * az0; - + a += (0.75 - ax0) - (ay0 + az0); - + i += (xNSign >> 1) & PRIME_X; j += (yNSign >> 1) & PRIME_Y; k += (zNSign >> 1) & PRIME_Z; - + xNSign = -xNSign; yNSign = -yNSign; zNSign = -zNSign; - + seed = ~seed; } - + return value * 32.69428253173828125; } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/PerlinSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/PerlinSampler.java index bc7e53962..46ca9af30 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/PerlinSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/PerlinSampler.java @@ -19,59 +19,59 @@ public class PerlinSampler extends SimplexStyleSampler { int seed = (int) sl; int x0 = (int) Math.floor(x); int y0 = (int) Math.floor(y); - + double xd0 = x - x0; double yd0 = y - y0; double xd1 = xd0 - 1; double yd1 = yd0 - 1; - + double xs = MathUtil.interpQuintic(xd0); double ys = MathUtil.interpQuintic(yd0); - + x0 *= PRIME_X; y0 *= PRIME_Y; int x1 = x0 + PRIME_X; int y1 = y0 + PRIME_Y; - + double xf0 = MathUtil.lerp(gradCoord(seed, x0, y0, xd0, yd0), gradCoord(seed, x1, y0, xd1, yd0), xs); double xf1 = MathUtil.lerp(gradCoord(seed, x0, y1, xd0, yd1), gradCoord(seed, x1, y1, xd1, yd1), xs); - + return MathUtil.lerp(xf0, xf1, ys) * 1.4247691104677813; } - + @Override public double getNoiseRaw(long sl, double x, double y, double z) { int seed = (int) sl; int x0 = (int) Math.floor(x); int y0 = (int) Math.floor(y); int z0 = (int) Math.floor(z); - + double xd0 = x - x0; double yd0 = y - y0; double zd0 = z - z0; double xd1 = xd0 - 1; double yd1 = yd0 - 1; double zd1 = zd0 - 1; - + double xs = MathUtil.interpQuintic(xd0); double ys = MathUtil.interpQuintic(yd0); double zs = MathUtil.interpQuintic(zd0); - + x0 *= PRIME_X; y0 *= PRIME_Y; z0 *= PRIME_Z; int x1 = x0 + PRIME_X; int y1 = y0 + PRIME_Y; int z1 = z0 + PRIME_Z; - + double xf00 = MathUtil.lerp(gradCoord(seed, x0, y0, z0, xd0, yd0, zd0), gradCoord(seed, x1, y0, z0, xd1, yd0, zd0), xs); double xf10 = MathUtil.lerp(gradCoord(seed, x0, y1, z0, xd0, yd1, zd0), gradCoord(seed, x1, y1, z0, xd1, yd1, zd0), xs); double xf01 = MathUtil.lerp(gradCoord(seed, x0, y0, z1, xd0, yd0, zd1), gradCoord(seed, x1, y0, z1, xd1, yd0, zd1), xs); double xf11 = MathUtil.lerp(gradCoord(seed, x0, y1, z1, xd0, yd1, zd1), gradCoord(seed, x1, y1, z1, xd1, yd1, zd1), xs); - + double yf0 = MathUtil.lerp(xf00, xf10, ys); double yf1 = MathUtil.lerp(xf01, xf11, ys); - + return MathUtil.lerp(yf0, yf1, zs) * 0.964921414852142333984375; } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexSampler.java index 76861b2f4..1a1f12245 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexSampler.java @@ -9,68 +9,68 @@ package com.dfsek.terra.addons.noise.samplers.noise.simplex; public class SimplexSampler extends SimplexStyleSampler { private static final Double2[] GRAD_2D = { - new Double2(-1, -1), new Double2(1, -1), new Double2(-1, 1), new Double2(1, 1), - new Double2(0, -1), new Double2(-1, 0), new Double2(0, 1), new Double2(1, 0), - }; + new Double2(-1, -1), new Double2(1, -1), new Double2(-1, 1), new Double2(1, 1), + new Double2(0, -1), new Double2(-1, 0), new Double2(0, 1), new Double2(1, 0), + }; private static final Double3[] GRAD_3D = { - new Double3(1, 1, 0), new Double3(-1, 1, 0), new Double3(1, -1, 0), new Double3(-1, -1, 0), - new Double3(1, 0, 1), new Double3(-1, 0, 1), new Double3(1, 0, -1), new Double3(-1, 0, -1), - new Double3(0, 1, 1), new Double3(0, -1, 1), new Double3(0, 1, -1), new Double3(0, -1, -1), - new Double3(1, 1, 0), new Double3(0, -1, 1), new Double3(-1, 1, 0), new Double3(0, -1, -1), - }; - + new Double3(1, 1, 0), new Double3(-1, 1, 0), new Double3(1, -1, 0), new Double3(-1, -1, 0), + new Double3(1, 0, 1), new Double3(-1, 0, 1), new Double3(1, 0, -1), new Double3(-1, 0, -1), + new Double3(0, 1, 1), new Double3(0, -1, 1), new Double3(0, 1, -1), new Double3(0, -1, -1), + new Double3(1, 1, 0), new Double3(0, -1, 1), new Double3(-1, 1, 0), new Double3(0, -1, -1), + }; + private static final double F2 = 1.0 / 2.0; private static final double F3 = (1.0 / 3.0); private static final double G2 = 1.0 / 4.0; private static final double G3 = (1.0 / 6.0); private static final double G33 = G3 * 3 - 1; - + private static final int X_PRIME = 1619; private static final int Y_PRIME = 31337; private static final int Z_PRIME = 6971; - - + + private static double gradCoord3D(int seed, int x, int y, int z, double xd, double yd, double zd) { int hash = seed; hash ^= X_PRIME * x; hash ^= Y_PRIME * y; hash ^= Z_PRIME * z; - + hash = hash * hash * hash * 60493; hash = (hash >> 13) ^ hash; - + Double3 g = GRAD_3D[hash & 15]; - + return xd * g.x + yd * g.y + zd * g.z; } - + private static double gradCoord2D(int seed, int x, int y, double xd, double yd) { int hash = seed; hash ^= X_PRIME * x; hash ^= Y_PRIME * y; - + hash = hash * hash * hash * 60493; hash = (hash >> 13) ^ hash; - + Double2 g = GRAD_2D[hash & 7]; - + return xd * g.x + yd * g.y; } - + @Override public double getNoiseRaw(long sl, double x, double y) { int seed = (int) sl; double t = (x + y) * F2; int i = (int) Math.floor(x + t); int j = (int) Math.floor(y + t); - + t = (i + j) * G2; double X0 = i - t; double Y0 = j - t; - + double x0 = x - X0; double y0 = y - Y0; - + int i1, j1; if(x0 > y0) { i1 = 1; @@ -79,14 +79,14 @@ public class SimplexSampler extends SimplexStyleSampler { i1 = 0; j1 = 1; } - + double x1 = x0 - i1 + G2; double y1 = y0 - j1 + G2; double x2 = x0 - 1 + F2; double y2 = y0 - 1 + F2; - + double n0, n1, n2; - + t = 0.5 - x0 * x0 - y0 * y0; if(t < 0) { n0 = 0; @@ -94,7 +94,7 @@ public class SimplexSampler extends SimplexStyleSampler { t *= t; n0 = t * t * gradCoord2D(seed, i, j, x0, y0); } - + t = 0.5 - x1 * x1 - y1 * y1; if(t < 0) { n1 = 0; @@ -102,7 +102,7 @@ public class SimplexSampler extends SimplexStyleSampler { t *= t; n1 = t * t * gradCoord2D(seed, i + i1, j + j1, x1, y1); } - + t = 0.5 - x2 * x2 - y2 * y2; if(t < 0) { n2 = 0; @@ -110,10 +110,10 @@ public class SimplexSampler extends SimplexStyleSampler { t *= t; n2 = t * t * gradCoord2D(seed, i + 1, j + 1, x2, y2); } - + return 50 * (n0 + n1 + n2); } - + @Override public double getNoiseRaw(long sl, double x, double y, double z) { int seed = (int) sl; @@ -121,15 +121,15 @@ public class SimplexSampler extends SimplexStyleSampler { int i = (int) Math.floor(x + t); int j = (int) Math.floor(y + t); int k = (int) Math.floor(z + t); - + t = (i + j + k) * G3; double x0 = x - (i - t); double y0 = y - (j - t); double z0 = z - (k - t); - + int i1, j1, k1; int i2, j2, k2; - + if(x0 >= y0) { if(y0 >= z0) { i1 = 1; @@ -180,7 +180,7 @@ public class SimplexSampler extends SimplexStyleSampler { k2 = 0; } } - + double x1 = x0 - i1 + G3; double y1 = y0 - j1 + G3; double z1 = z0 - k1 + G3; @@ -190,16 +190,16 @@ public class SimplexSampler extends SimplexStyleSampler { double x3 = x0 + G33; double y3 = y0 + G33; double z3 = z0 + G33; - + double n0, n1, n2, n3; - + t = 0.6 - x0 * x0 - y0 * y0 - z0 * z0; if(t < 0) n0 = 0; else { t *= t; n0 = t * t * gradCoord3D(seed, i, j, k, x0, y0, z0); } - + t = 0.6 - x1 * x1 - y1 * y1 - z1 * z1; if(t < 0) { n1 = 0; @@ -207,7 +207,7 @@ public class SimplexSampler extends SimplexStyleSampler { t *= t; n1 = t * t * gradCoord3D(seed, i + i1, j + j1, k + k1, x1, y1, z1); } - + t = 0.6 - x2 * x2 - y2 * y2 - z2 * z2; if(t < 0) { n2 = 0; @@ -215,7 +215,7 @@ public class SimplexSampler extends SimplexStyleSampler { t *= t; n2 = t * t * gradCoord3D(seed, i + i2, j + j2, k + k2, x2, y2, z2); } - + t = 0.6 - x3 * x3 - y3 * y3 - z3 * z3; if(t < 0) { n3 = 0; @@ -223,23 +223,23 @@ public class SimplexSampler extends SimplexStyleSampler { t *= t; n3 = t * t * gradCoord3D(seed, i + 1, j + 1, k + 1, x3, y3, z3); } - + return 32 * (n0 + n1 + n2 + n3); } - + private static class Double2 { public final double x, y; - + public Double2(double x, double y) { this.x = x; this.y = y; } } - - + + private static class Double3 { public final double x, y, z; - + public Double3(double x, double y, double z) { this.x = x; this.y = y; diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexStyleSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexStyleSampler.java index b6c9b5e3e..eda599a34 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexStyleSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexStyleSampler.java @@ -15,90 +15,90 @@ import com.dfsek.terra.addons.noise.samplers.noise.NoiseFunction; */ public abstract class SimplexStyleSampler extends NoiseFunction { protected static final double[] GRADIENTS_2_D = { - 0.130526192220052d, 0.99144486137381d, 0.38268343236509d, 0.923879532511287d, 0.608761429008721d, 0.793353340291235d, - 0.793353340291235d, 0.608761429008721d, 0.923879532511287d, 0.38268343236509d, 0.99144486137381d, 0.130526192220051d, - 0.99144486137381d, -0.130526192220051d, 0.923879532511287d, -0.38268343236509d, 0.793353340291235d, -0.60876142900872d, - 0.608761429008721d, -0.793353340291235d, 0.38268343236509d, -0.923879532511287d, 0.130526192220052d, -0.99144486137381d, - -0.130526192220052d, -0.99144486137381d, -0.38268343236509d, -0.923879532511287d, -0.608761429008721d, -0.793353340291235d, - -0.793353340291235d, -0.608761429008721d, -0.923879532511287d, -0.38268343236509d, -0.99144486137381d, -0.130526192220052d, - -0.99144486137381d, 0.130526192220051d, -0.923879532511287d, 0.38268343236509d, -0.793353340291235d, 0.608761429008721d, - -0.608761429008721d, 0.793353340291235d, -0.38268343236509d, 0.923879532511287d, -0.130526192220052d, 0.99144486137381d, - 0.130526192220052d, 0.99144486137381d, 0.38268343236509d, 0.923879532511287d, 0.608761429008721d, 0.793353340291235d, - 0.793353340291235d, 0.608761429008721d, 0.923879532511287d, 0.38268343236509d, 0.99144486137381d, 0.130526192220051d, - 0.99144486137381d, -0.130526192220051d, 0.923879532511287d, -0.38268343236509d, 0.793353340291235d, -0.60876142900872d, - 0.608761429008721d, -0.793353340291235d, 0.38268343236509d, -0.923879532511287d, 0.130526192220052d, -0.99144486137381d, - -0.130526192220052d, -0.99144486137381d, -0.38268343236509d, -0.923879532511287d, -0.608761429008721d, -0.793353340291235d, - -0.793353340291235d, -0.608761429008721d, -0.923879532511287d, -0.38268343236509d, -0.99144486137381d, -0.130526192220052d, - -0.99144486137381d, 0.130526192220051d, -0.923879532511287d, 0.38268343236509d, -0.793353340291235d, 0.608761429008721d, - -0.608761429008721d, 0.793353340291235d, -0.38268343236509d, 0.923879532511287d, -0.130526192220052d, 0.99144486137381d, - 0.130526192220052d, 0.99144486137381d, 0.38268343236509d, 0.923879532511287d, 0.608761429008721d, 0.793353340291235d, - 0.793353340291235d, 0.608761429008721d, 0.923879532511287d, 0.38268343236509d, 0.99144486137381d, 0.130526192220051d, - 0.99144486137381d, -0.130526192220051d, 0.923879532511287d, -0.38268343236509d, 0.793353340291235d, -0.60876142900872d, - 0.608761429008721d, -0.793353340291235d, 0.38268343236509d, -0.923879532511287d, 0.130526192220052d, -0.99144486137381d, - -0.130526192220052d, -0.99144486137381d, -0.38268343236509d, -0.923879532511287d, -0.608761429008721d, -0.793353340291235d, - -0.793353340291235d, -0.608761429008721d, -0.923879532511287d, -0.38268343236509d, -0.99144486137381d, -0.130526192220052d, - -0.99144486137381d, 0.130526192220051d, -0.923879532511287d, 0.38268343236509d, -0.793353340291235d, 0.608761429008721d, - -0.608761429008721d, 0.793353340291235d, -0.38268343236509d, 0.923879532511287d, -0.130526192220052d, 0.99144486137381d, - 0.130526192220052d, 0.99144486137381d, 0.38268343236509d, 0.923879532511287d, 0.608761429008721d, 0.793353340291235d, - 0.793353340291235d, 0.608761429008721d, 0.923879532511287d, 0.38268343236509d, 0.99144486137381d, 0.130526192220051d, - 0.99144486137381d, -0.130526192220051d, 0.923879532511287d, -0.38268343236509d, 0.793353340291235d, -0.60876142900872d, - 0.608761429008721d, -0.793353340291235d, 0.38268343236509d, -0.923879532511287d, 0.130526192220052d, -0.99144486137381d, - -0.130526192220052d, -0.99144486137381d, -0.38268343236509d, -0.923879532511287d, -0.608761429008721d, -0.793353340291235d, - -0.793353340291235d, -0.608761429008721d, -0.923879532511287d, -0.38268343236509d, -0.99144486137381d, -0.130526192220052d, - -0.99144486137381d, 0.130526192220051d, -0.923879532511287d, 0.38268343236509d, -0.793353340291235d, 0.608761429008721d, - -0.608761429008721d, 0.793353340291235d, -0.38268343236509d, 0.923879532511287d, -0.130526192220052d, 0.99144486137381d, - 0.130526192220052d, 0.99144486137381d, 0.38268343236509d, 0.923879532511287d, 0.608761429008721d, 0.793353340291235d, - 0.793353340291235d, 0.608761429008721d, 0.923879532511287d, 0.38268343236509d, 0.99144486137381d, 0.130526192220051d, - 0.99144486137381d, -0.130526192220051d, 0.923879532511287d, -0.38268343236509d, 0.793353340291235d, -0.60876142900872d, - 0.608761429008721d, -0.793353340291235d, 0.38268343236509d, -0.923879532511287d, 0.130526192220052d, -0.99144486137381d, - -0.130526192220052d, -0.99144486137381d, -0.38268343236509d, -0.923879532511287d, -0.608761429008721d, -0.793353340291235d, - -0.793353340291235d, -0.608761429008721d, -0.923879532511287d, -0.38268343236509d, -0.99144486137381d, -0.130526192220052d, - -0.99144486137381d, 0.130526192220051d, -0.923879532511287d, 0.38268343236509d, -0.793353340291235d, 0.608761429008721d, - -0.608761429008721d, 0.793353340291235d, -0.38268343236509d, 0.923879532511287d, -0.130526192220052d, 0.99144486137381d, - 0.38268343236509d, 0.923879532511287d, 0.923879532511287d, 0.38268343236509d, 0.923879532511287d, -0.38268343236509d, - 0.38268343236509d, -0.923879532511287d, -0.38268343236509d, -0.923879532511287d, -0.923879532511287d, -0.38268343236509d, - -0.923879532511287d, 0.38268343236509d, -0.38268343236509d, 0.923879532511287d, - }; - + 0.130526192220052d, 0.99144486137381d, 0.38268343236509d, 0.923879532511287d, 0.608761429008721d, 0.793353340291235d, + 0.793353340291235d, 0.608761429008721d, 0.923879532511287d, 0.38268343236509d, 0.99144486137381d, 0.130526192220051d, + 0.99144486137381d, -0.130526192220051d, 0.923879532511287d, -0.38268343236509d, 0.793353340291235d, -0.60876142900872d, + 0.608761429008721d, -0.793353340291235d, 0.38268343236509d, -0.923879532511287d, 0.130526192220052d, -0.99144486137381d, + -0.130526192220052d, -0.99144486137381d, -0.38268343236509d, -0.923879532511287d, -0.608761429008721d, -0.793353340291235d, + -0.793353340291235d, -0.608761429008721d, -0.923879532511287d, -0.38268343236509d, -0.99144486137381d, -0.130526192220052d, + -0.99144486137381d, 0.130526192220051d, -0.923879532511287d, 0.38268343236509d, -0.793353340291235d, 0.608761429008721d, + -0.608761429008721d, 0.793353340291235d, -0.38268343236509d, 0.923879532511287d, -0.130526192220052d, 0.99144486137381d, + 0.130526192220052d, 0.99144486137381d, 0.38268343236509d, 0.923879532511287d, 0.608761429008721d, 0.793353340291235d, + 0.793353340291235d, 0.608761429008721d, 0.923879532511287d, 0.38268343236509d, 0.99144486137381d, 0.130526192220051d, + 0.99144486137381d, -0.130526192220051d, 0.923879532511287d, -0.38268343236509d, 0.793353340291235d, -0.60876142900872d, + 0.608761429008721d, -0.793353340291235d, 0.38268343236509d, -0.923879532511287d, 0.130526192220052d, -0.99144486137381d, + -0.130526192220052d, -0.99144486137381d, -0.38268343236509d, -0.923879532511287d, -0.608761429008721d, -0.793353340291235d, + -0.793353340291235d, -0.608761429008721d, -0.923879532511287d, -0.38268343236509d, -0.99144486137381d, -0.130526192220052d, + -0.99144486137381d, 0.130526192220051d, -0.923879532511287d, 0.38268343236509d, -0.793353340291235d, 0.608761429008721d, + -0.608761429008721d, 0.793353340291235d, -0.38268343236509d, 0.923879532511287d, -0.130526192220052d, 0.99144486137381d, + 0.130526192220052d, 0.99144486137381d, 0.38268343236509d, 0.923879532511287d, 0.608761429008721d, 0.793353340291235d, + 0.793353340291235d, 0.608761429008721d, 0.923879532511287d, 0.38268343236509d, 0.99144486137381d, 0.130526192220051d, + 0.99144486137381d, -0.130526192220051d, 0.923879532511287d, -0.38268343236509d, 0.793353340291235d, -0.60876142900872d, + 0.608761429008721d, -0.793353340291235d, 0.38268343236509d, -0.923879532511287d, 0.130526192220052d, -0.99144486137381d, + -0.130526192220052d, -0.99144486137381d, -0.38268343236509d, -0.923879532511287d, -0.608761429008721d, -0.793353340291235d, + -0.793353340291235d, -0.608761429008721d, -0.923879532511287d, -0.38268343236509d, -0.99144486137381d, -0.130526192220052d, + -0.99144486137381d, 0.130526192220051d, -0.923879532511287d, 0.38268343236509d, -0.793353340291235d, 0.608761429008721d, + -0.608761429008721d, 0.793353340291235d, -0.38268343236509d, 0.923879532511287d, -0.130526192220052d, 0.99144486137381d, + 0.130526192220052d, 0.99144486137381d, 0.38268343236509d, 0.923879532511287d, 0.608761429008721d, 0.793353340291235d, + 0.793353340291235d, 0.608761429008721d, 0.923879532511287d, 0.38268343236509d, 0.99144486137381d, 0.130526192220051d, + 0.99144486137381d, -0.130526192220051d, 0.923879532511287d, -0.38268343236509d, 0.793353340291235d, -0.60876142900872d, + 0.608761429008721d, -0.793353340291235d, 0.38268343236509d, -0.923879532511287d, 0.130526192220052d, -0.99144486137381d, + -0.130526192220052d, -0.99144486137381d, -0.38268343236509d, -0.923879532511287d, -0.608761429008721d, -0.793353340291235d, + -0.793353340291235d, -0.608761429008721d, -0.923879532511287d, -0.38268343236509d, -0.99144486137381d, -0.130526192220052d, + -0.99144486137381d, 0.130526192220051d, -0.923879532511287d, 0.38268343236509d, -0.793353340291235d, 0.608761429008721d, + -0.608761429008721d, 0.793353340291235d, -0.38268343236509d, 0.923879532511287d, -0.130526192220052d, 0.99144486137381d, + 0.130526192220052d, 0.99144486137381d, 0.38268343236509d, 0.923879532511287d, 0.608761429008721d, 0.793353340291235d, + 0.793353340291235d, 0.608761429008721d, 0.923879532511287d, 0.38268343236509d, 0.99144486137381d, 0.130526192220051d, + 0.99144486137381d, -0.130526192220051d, 0.923879532511287d, -0.38268343236509d, 0.793353340291235d, -0.60876142900872d, + 0.608761429008721d, -0.793353340291235d, 0.38268343236509d, -0.923879532511287d, 0.130526192220052d, -0.99144486137381d, + -0.130526192220052d, -0.99144486137381d, -0.38268343236509d, -0.923879532511287d, -0.608761429008721d, -0.793353340291235d, + -0.793353340291235d, -0.608761429008721d, -0.923879532511287d, -0.38268343236509d, -0.99144486137381d, -0.130526192220052d, + -0.99144486137381d, 0.130526192220051d, -0.923879532511287d, 0.38268343236509d, -0.793353340291235d, 0.608761429008721d, + -0.608761429008721d, 0.793353340291235d, -0.38268343236509d, 0.923879532511287d, -0.130526192220052d, 0.99144486137381d, + 0.38268343236509d, 0.923879532511287d, 0.923879532511287d, 0.38268343236509d, 0.923879532511287d, -0.38268343236509d, + 0.38268343236509d, -0.923879532511287d, -0.38268343236509d, -0.923879532511287d, -0.923879532511287d, -0.38268343236509d, + -0.923879532511287d, 0.38268343236509d, -0.38268343236509d, 0.923879532511287d, + }; + protected static final double[] GRADIENTS_3D = { - 0, 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, - 1, 0, 1, 0, -1, 0, 1, 0, 1, 0, -1, 0, -1, 0, -1, 0, - 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, 0, - 0, 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, - 1, 0, 1, 0, -1, 0, 1, 0, 1, 0, -1, 0, -1, 0, -1, 0, - 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, 0, - 0, 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, - 1, 0, 1, 0, -1, 0, 1, 0, 1, 0, -1, 0, -1, 0, -1, 0, - 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, 0, - 0, 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, - 1, 0, 1, 0, -1, 0, 1, 0, 1, 0, -1, 0, -1, 0, -1, 0, - 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, 0, - 0, 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, - 1, 0, 1, 0, -1, 0, 1, 0, 1, 0, -1, 0, -1, 0, -1, 0, - 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, 0, - 1, 1, 0, 0, 0, -1, 1, 0, -1, 1, 0, 0, 0, -1, -1, 0 + 0, 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, + 1, 0, 1, 0, -1, 0, 1, 0, 1, 0, -1, 0, -1, 0, -1, 0, + 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, 0, + 0, 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, + 1, 0, 1, 0, -1, 0, 1, 0, 1, 0, -1, 0, -1, 0, -1, 0, + 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, 0, + 0, 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, + 1, 0, 1, 0, -1, 0, 1, 0, 1, 0, -1, 0, -1, 0, -1, 0, + 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, 0, + 0, 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, + 1, 0, 1, 0, -1, 0, 1, 0, 1, 0, -1, 0, -1, 0, -1, 0, + 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, 0, + 0, 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, + 1, 0, 1, 0, -1, 0, 1, 0, 1, 0, -1, 0, -1, 0, -1, 0, + 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, 0, + 1, 1, 0, 0, 0, -1, 1, 0, -1, 1, 0, 0, 0, -1, -1, 0 }; - + protected static double gradCoord(int seed, int xPrimed, int yPrimed, double xd, double yd) { int hash = hash(seed, xPrimed, yPrimed); hash ^= hash >> 15; hash &= 127 << 1; - + double xg = GRADIENTS_2_D[hash]; double yg = GRADIENTS_2_D[hash | 1]; - + return xd * xg + yd * yg; } - + protected static double gradCoord(int seed, int xPrimed, int yPrimed, int zPrimed, double xd, double yd, double zd) { int hash = hash(seed, xPrimed, yPrimed, zPrimed); hash ^= hash >> 15; hash &= 63 << 2; - + double xg = GRADIENTS_3D[hash]; double yg = GRADIENTS_3D[hash | 1]; double zg = GRADIENTS_3D[hash | 2]; - + return xd * xg + yd * yg + zd * zg; } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java index 8b14d9d2f..811241f52 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueCubicSampler.java @@ -16,10 +16,10 @@ public class ValueCubicSampler extends ValueStyleNoise { int seed = (int) sl; int x1 = (int) Math.floor(x); int y1 = (int) Math.floor(y); - + double xs = x - x1; double ys = y - y1; - + x1 *= PRIME_X; y1 *= PRIME_Y; int x0 = x1 - PRIME_X; @@ -28,34 +28,34 @@ public class ValueCubicSampler extends ValueStyleNoise { int y2 = y1 + PRIME_Y; int x3 = x1 + (PRIME_X << 1); int y3 = y1 + (PRIME_Y << 1); - + return MathUtil.cubicLerp( - MathUtil.cubicLerp(valCoord(seed, x0, y0), valCoord(seed, x1, y0), valCoord(seed, x2, y0), valCoord(seed, x3, y0), - xs), - MathUtil.cubicLerp(valCoord(seed, x0, y1), valCoord(seed, x1, y1), valCoord(seed, x2, y1), valCoord(seed, x3, y1), - xs), - MathUtil.cubicLerp(valCoord(seed, x0, y2), valCoord(seed, x1, y2), valCoord(seed, x2, y2), valCoord(seed, x3, y2), - xs), - MathUtil.cubicLerp(valCoord(seed, x0, y3), valCoord(seed, x1, y3), valCoord(seed, x2, y3), valCoord(seed, x3, y3), - xs), - ys) * (1 / (1.5 * 1.5)); + MathUtil.cubicLerp(valCoord(seed, x0, y0), valCoord(seed, x1, y0), valCoord(seed, x2, y0), valCoord(seed, x3, y0), + xs), + MathUtil.cubicLerp(valCoord(seed, x0, y1), valCoord(seed, x1, y1), valCoord(seed, x2, y1), valCoord(seed, x3, y1), + xs), + MathUtil.cubicLerp(valCoord(seed, x0, y2), valCoord(seed, x1, y2), valCoord(seed, x2, y2), valCoord(seed, x3, y2), + xs), + MathUtil.cubicLerp(valCoord(seed, x0, y3), valCoord(seed, x1, y3), valCoord(seed, x2, y3), valCoord(seed, x3, y3), + xs), + ys) * (1 / (1.5 * 1.5)); } - + @Override public double getNoiseRaw(long sl, double x, double y, double z) { int seed = (int) sl; int x1 = (int) Math.floor(x); int y1 = (int) Math.floor(y); int z1 = (int) Math.floor(z); - + double xs = x - x1; double ys = y - y1; double zs = z - z1; - + x1 *= PRIME_X; y1 *= PRIME_Y; z1 *= PRIME_Z; - + int x0 = x1 - PRIME_X; int y0 = y1 - PRIME_Y; int z0 = z1 - PRIME_Z; @@ -65,48 +65,48 @@ public class ValueCubicSampler extends ValueStyleNoise { int x3 = x1 + (PRIME_X << 1); int y3 = y1 + (PRIME_Y << 1); int z3 = z1 + (PRIME_Z << 1); - + return MathUtil.cubicLerp( - MathUtil.cubicLerp( - MathUtil.cubicLerp(valCoord(seed, x0, y0, z0), valCoord(seed, x1, y0, z0), valCoord(seed, x2, y0, z0), - valCoord(seed, x3, y0, z0), xs), - MathUtil.cubicLerp(valCoord(seed, x0, y1, z0), valCoord(seed, x1, y1, z0), valCoord(seed, x2, y1, z0), - valCoord(seed, x3, y1, z0), xs), - MathUtil.cubicLerp(valCoord(seed, x0, y2, z0), valCoord(seed, x1, y2, z0), valCoord(seed, x2, y2, z0), - valCoord(seed, x3, y2, z0), xs), - MathUtil.cubicLerp(valCoord(seed, x0, y3, z0), valCoord(seed, x1, y3, z0), valCoord(seed, x2, y3, z0), - valCoord(seed, x3, y3, z0), xs), - ys), - MathUtil.cubicLerp( - MathUtil.cubicLerp(valCoord(seed, x0, y0, z1), valCoord(seed, x1, y0, z1), valCoord(seed, x2, y0, z1), - valCoord(seed, x3, y0, z1), xs), - MathUtil.cubicLerp(valCoord(seed, x0, y1, z1), valCoord(seed, x1, y1, z1), valCoord(seed, x2, y1, z1), - valCoord(seed, x3, y1, z1), xs), - MathUtil.cubicLerp(valCoord(seed, x0, y2, z1), valCoord(seed, x1, y2, z1), valCoord(seed, x2, y2, z1), - valCoord(seed, x3, y2, z1), xs), - MathUtil.cubicLerp(valCoord(seed, x0, y3, z1), valCoord(seed, x1, y3, z1), valCoord(seed, x2, y3, z1), - valCoord(seed, x3, y3, z1), xs), - ys), - MathUtil.cubicLerp( - MathUtil.cubicLerp(valCoord(seed, x0, y0, z2), valCoord(seed, x1, y0, z2), valCoord(seed, x2, y0, z2), - valCoord(seed, x3, y0, z2), xs), - MathUtil.cubicLerp(valCoord(seed, x0, y1, z2), valCoord(seed, x1, y1, z2), valCoord(seed, x2, y1, z2), - valCoord(seed, x3, y1, z2), xs), - MathUtil.cubicLerp(valCoord(seed, x0, y2, z2), valCoord(seed, x1, y2, z2), valCoord(seed, x2, y2, z2), - valCoord(seed, x3, y2, z2), xs), - MathUtil.cubicLerp(valCoord(seed, x0, y3, z2), valCoord(seed, x1, y3, z2), valCoord(seed, x2, y3, z2), - valCoord(seed, x3, y3, z2), xs), - ys), - MathUtil.cubicLerp( - MathUtil.cubicLerp(valCoord(seed, x0, y0, z3), valCoord(seed, x1, y0, z3), valCoord(seed, x2, y0, z3), - valCoord(seed, x3, y0, z3), xs), - MathUtil.cubicLerp(valCoord(seed, x0, y1, z3), valCoord(seed, x1, y1, z3), valCoord(seed, x2, y1, z3), - valCoord(seed, x3, y1, z3), xs), - MathUtil.cubicLerp(valCoord(seed, x0, y2, z3), valCoord(seed, x1, y2, z3), valCoord(seed, x2, y2, z3), - valCoord(seed, x3, y2, z3), xs), - MathUtil.cubicLerp(valCoord(seed, x0, y3, z3), valCoord(seed, x1, y3, z3), valCoord(seed, x2, y3, z3), - valCoord(seed, x3, y3, z3), xs), - ys), - zs) * (1 / (1.5 * 1.5 * 1.5)); + MathUtil.cubicLerp( + MathUtil.cubicLerp(valCoord(seed, x0, y0, z0), valCoord(seed, x1, y0, z0), valCoord(seed, x2, y0, z0), + valCoord(seed, x3, y0, z0), xs), + MathUtil.cubicLerp(valCoord(seed, x0, y1, z0), valCoord(seed, x1, y1, z0), valCoord(seed, x2, y1, z0), + valCoord(seed, x3, y1, z0), xs), + MathUtil.cubicLerp(valCoord(seed, x0, y2, z0), valCoord(seed, x1, y2, z0), valCoord(seed, x2, y2, z0), + valCoord(seed, x3, y2, z0), xs), + MathUtil.cubicLerp(valCoord(seed, x0, y3, z0), valCoord(seed, x1, y3, z0), valCoord(seed, x2, y3, z0), + valCoord(seed, x3, y3, z0), xs), + ys), + MathUtil.cubicLerp( + MathUtil.cubicLerp(valCoord(seed, x0, y0, z1), valCoord(seed, x1, y0, z1), valCoord(seed, x2, y0, z1), + valCoord(seed, x3, y0, z1), xs), + MathUtil.cubicLerp(valCoord(seed, x0, y1, z1), valCoord(seed, x1, y1, z1), valCoord(seed, x2, y1, z1), + valCoord(seed, x3, y1, z1), xs), + MathUtil.cubicLerp(valCoord(seed, x0, y2, z1), valCoord(seed, x1, y2, z1), valCoord(seed, x2, y2, z1), + valCoord(seed, x3, y2, z1), xs), + MathUtil.cubicLerp(valCoord(seed, x0, y3, z1), valCoord(seed, x1, y3, z1), valCoord(seed, x2, y3, z1), + valCoord(seed, x3, y3, z1), xs), + ys), + MathUtil.cubicLerp( + MathUtil.cubicLerp(valCoord(seed, x0, y0, z2), valCoord(seed, x1, y0, z2), valCoord(seed, x2, y0, z2), + valCoord(seed, x3, y0, z2), xs), + MathUtil.cubicLerp(valCoord(seed, x0, y1, z2), valCoord(seed, x1, y1, z2), valCoord(seed, x2, y1, z2), + valCoord(seed, x3, y1, z2), xs), + MathUtil.cubicLerp(valCoord(seed, x0, y2, z2), valCoord(seed, x1, y2, z2), valCoord(seed, x2, y2, z2), + valCoord(seed, x3, y2, z2), xs), + MathUtil.cubicLerp(valCoord(seed, x0, y3, z2), valCoord(seed, x1, y3, z2), valCoord(seed, x2, y3, z2), + valCoord(seed, x3, y3, z2), xs), + ys), + MathUtil.cubicLerp( + MathUtil.cubicLerp(valCoord(seed, x0, y0, z3), valCoord(seed, x1, y0, z3), valCoord(seed, x2, y0, z3), + valCoord(seed, x3, y0, z3), xs), + MathUtil.cubicLerp(valCoord(seed, x0, y1, z3), valCoord(seed, x1, y1, z3), valCoord(seed, x2, y1, z3), + valCoord(seed, x3, y1, z3), xs), + MathUtil.cubicLerp(valCoord(seed, x0, y2, z3), valCoord(seed, x1, y2, z3), valCoord(seed, x2, y2, z3), + valCoord(seed, x3, y2, z3), xs), + MathUtil.cubicLerp(valCoord(seed, x0, y3, z3), valCoord(seed, x1, y3, z3), valCoord(seed, x2, y3, z3), + valCoord(seed, x3, y3, z3), xs), + ys), + zs) * (1 / (1.5 * 1.5 * 1.5)); } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueSampler.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueSampler.java index 128f4e35a..09b0574cf 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueSampler.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueSampler.java @@ -16,47 +16,47 @@ public class ValueSampler extends ValueStyleNoise { int seed = (int) sl; int x0 = (int) Math.floor(x); int y0 = (int) Math.floor(y); - + double xs = MathUtil.interpHermite(x - x0); double ys = MathUtil.interpHermite(y - y0); - + x0 *= PRIME_X; y0 *= PRIME_Y; int x1 = x0 + PRIME_X; int y1 = y0 + PRIME_Y; - + double xf0 = MathUtil.lerp(valCoord(seed, x0, y0), valCoord(seed, x1, y0), xs); double xf1 = MathUtil.lerp(valCoord(seed, x0, y1), valCoord(seed, x1, y1), xs); - + return MathUtil.lerp(xf0, xf1, ys); } - + @Override public double getNoiseRaw(long sl, double x, double y, double z) { int seed = (int) sl; int x0 = (int) Math.floor(x); int y0 = (int) Math.floor(y); int z0 = (int) Math.floor(z); - + double xs = MathUtil.interpHermite(x - x0); double ys = MathUtil.interpHermite(y - y0); double zs = MathUtil.interpHermite(z - z0); - + x0 *= PRIME_X; y0 *= PRIME_Y; z0 *= PRIME_Z; int x1 = x0 + PRIME_X; int y1 = y0 + PRIME_Y; int z1 = z0 + PRIME_Z; - + double xf00 = MathUtil.lerp(valCoord(seed, x0, y0, z0), valCoord(seed, x1, y0, z0), xs); double xf10 = MathUtil.lerp(valCoord(seed, x0, y1, z0), valCoord(seed, x1, y1, z0), xs); double xf01 = MathUtil.lerp(valCoord(seed, x0, y0, z1), valCoord(seed, x1, y0, z1), xs); double xf11 = MathUtil.lerp(valCoord(seed, x0, y1, z1), valCoord(seed, x1, y1, z1), xs); - + double yf0 = MathUtil.lerp(xf00, xf10, ys); double yf1 = MathUtil.lerp(xf01, xf11, ys); - + return MathUtil.lerp(yf0, yf1, zs); } } diff --git a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueStyleNoise.java b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueStyleNoise.java index 2cadfe0d1..58212b6fe 100644 --- a/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueStyleNoise.java +++ b/common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/value/ValueStyleNoise.java @@ -11,18 +11,18 @@ import com.dfsek.terra.addons.noise.samplers.noise.NoiseFunction; public abstract class ValueStyleNoise extends NoiseFunction { - + protected static double valCoord(int seed, int xPrimed, int yPrimed) { int hash = hash(seed, xPrimed, yPrimed); - + hash *= hash; hash ^= hash << 19; return hash * (1 / 2147483648.0); } - + protected static double valCoord(int seed, int xPrimed, int yPrimed, int zPrimed) { int hash = hash(seed, xPrimed, yPrimed, zPrimed); - + hash *= hash; hash ^= hash << 19; return hash * (1 / 2147483648.0); diff --git a/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java b/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java index 60ddc8b8c..541249369 100644 --- a/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java +++ b/common/addons/config-number-predicate/src/main/java/com/dfsek/terra/addons/numberpredicate/NumberPredicateAddon.java @@ -18,20 +18,20 @@ import com.dfsek.terra.api.inject.annotations.Inject; public class NumberPredicateAddon implements AddonInitializer { - + @Inject private Platform plugin; - + @Inject private BaseAddon addon; - + @Override public void initialize() { plugin.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> event.getPack().applyLoader(DoublePredicate.class, new DoublePredicateLoader())) - .priority(50) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> event.getPack().applyLoader(DoublePredicate.class, new DoublePredicateLoader())) + .priority(50) + .failThrough(); } } diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java index 7ce09f1d4..9527fa84e 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java @@ -18,17 +18,17 @@ import com.dfsek.terra.api.inject.annotations.Inject; public class OreAddon implements AddonInitializer { @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> event.getPack().registerConfigType(new OreConfigType(), addon.key("ORE"), 1)) - .then(event -> event.getPack().registerConfigType(new ScatteredOreConfigType(), addon.key("SCATTERED_ORE"), 1)) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> event.getPack().registerConfigType(new OreConfigType(), addon.key("ORE"), 1)) + .then(event -> event.getPack().registerConfigType(new ScatteredOreConfigType(), addon.key("SCATTERED_ORE"), 1)) + .failThrough(); } } diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java index af4a7b709..5b3feebd0 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreConfigType.java @@ -19,17 +19,17 @@ public class OreConfigType implements ConfigType { public static final TypeKey ORE_TYPE_TOKEN = new TypeKey<>() { }; private final OreFactory factory = new OreFactory(); - + @Override public OreTemplate getTemplate(ConfigPack pack, Platform platform) { return new OreTemplate(); } - + @Override public ConfigFactory getFactory() { return factory; } - + @Override public TypeKey getTypeKey() { return ORE_TYPE_TOKEN; diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java index cab726f01..23d0daa8d 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreFactory.java @@ -19,6 +19,6 @@ public class OreFactory implements ConfigFactory { public VanillaOre build(OreTemplate config, Platform platform) { BlockState m = config.getMaterial(); return new VanillaOre(m, config.getSize(), config.getReplaceable(), config.doPhysics(), config.isExposed(), - config.getMaterialOverrides()); + config.getMaterialOverrides()); } } diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java index 3456e711b..24bbd6d3c 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreTemplate.java @@ -27,53 +27,53 @@ public class OreTemplate implements AbstractableTemplate { @Value("id") @Final private String id; - + @Value("material") private @Meta BlockState material; - + @Value("material-overrides") @Default private @Meta Map<@Meta BlockType, @Meta BlockState> materials = new HashMap<>(); - + @Value("replace") private @Meta MaterialSet replaceable; - + @Value("physics") @Default private @Meta boolean physics = false; - + @Value("size") private @Meta double size; - + @Value("exposed") @Default @Description("The chance that ore blocks bordering air will be exposed. 0 = 0%, 1 = 100%") private @Meta double exposed = 1; - + public boolean doPhysics() { return physics; } - + public double getSize() { return size; } - + public BlockState getMaterial() { return material; } - + public MaterialSet getReplaceable() { return replaceable; } - + public String getID() { return id; } - + public Map getMaterialOverrides() { return materials; } - + public double isExposed() { return exposed; } diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreConfigType.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreConfigType.java index 71b3ef759..c9749ddde 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreConfigType.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreConfigType.java @@ -19,17 +19,17 @@ public class ScatteredOreConfigType implements ConfigType ORE_TYPE_TOKEN = new TypeKey<>() { }; private final ScatteredOreFactory factory = new ScatteredOreFactory(); - + @Override public ScatteredOreTemplate getTemplate(ConfigPack pack, Platform platform) { return new ScatteredOreTemplate(); } - + @Override public ConfigFactory getFactory() { return factory; } - + @Override public TypeKey getTypeKey() { return ORE_TYPE_TOKEN; diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java index 6023d3de9..6d9178854 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ScatteredOreFactory.java @@ -21,6 +21,6 @@ public class ScatteredOreFactory implements ConfigFactory materials; - + public VanillaOre(BlockState material, double size, MaterialSet replaceable, boolean applyGravity, double exposed, Map materials) { this.material = material; @@ -42,25 +42,25 @@ public class VanillaOre implements Structure { this.exposed = exposed; this.materials = materials; } - + @Override public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation) { float randomRadian = random.nextFloat() * (float) Math.PI; double eighthSize = size / 8.0F; - + // Place points to form a line segment double startX = (double) location.getX() + MathUtil.sin(randomRadian) * eighthSize; double endX = (double) location.getX() - MathUtil.sin(randomRadian) * eighthSize; - + double startZ = (double) location.getZ() + MathUtil.cos(randomRadian) * eighthSize; double endZ = (double) location.getZ() - MathUtil.cos(randomRadian) * eighthSize; - + double startY = location.getY() + random.nextInt(3) - 2; double endY = location.getY() + random.nextInt(3) - 2; - + int sizeInt = (int) size; double[] points = new double[sizeInt * 4]; - + // Compute initial point positions and radius for(int i = 0; i < sizeInt; ++i) { float t = (float) i / (float) sizeInt; @@ -75,7 +75,7 @@ public class VanillaOre implements Structure { points[i * 4 + 2] = zt; points[i * 4 + 3] = radius; } - + // Compare every point to every other point for(int a = 0; a < sizeInt - 1; ++a) { double radiusA = points[a * 4 + 3]; @@ -87,7 +87,7 @@ public class VanillaOre implements Structure { double dyt = points[a * 4 + 1] - points[b * 4 + 1]; double dzt = points[a * 4 + 2] - points[b * 4 + 2]; double dRadius = radiusA - radiusB; - + // If the radius difference is greater than the distance between the two points if(dRadius * dRadius > dxt * dxt + dyt * dyt + dzt * dzt) { // Set smaller of two radii to -1 @@ -101,18 +101,18 @@ public class VanillaOre implements Structure { } } } - + int outset = (int) Math.ceil((size / 16.0F * 2.0F + 1.0F) / 2.0F); int x = (int) (location.getX() - Math.ceil(eighthSize) - outset); int y = location.getY() - 2 - outset; int z = (int) (location.getZ() - Math.ceil(eighthSize) - outset); - + int horizontalSize = (int) (2 * (Math.ceil(eighthSize) + outset)); int verticalSize = 2 * (2 + outset); - + int blockCount = 0; BitSet visited = new BitSet(horizontalSize * verticalSize * horizontalSize); - + // Generate a sphere at each point for(int i = 0; i < sizeInt; ++i) { double radius = points[i * 4 + 3]; @@ -120,16 +120,16 @@ public class VanillaOre implements Structure { double xt = points[i * 4]; double yt = points[i * 4 + 1]; double zt = points[i * 4 + 2]; - + int xLowerBound = (int) Math.max(Math.floor(xt - radius), x); int xUpperBound = (int) Math.max(Math.floor(xt + radius), xLowerBound); - + int yLowerBound = (int) Math.max(Math.floor(yt - radius), y); int yUpperBound = (int) Math.max(Math.floor(yt + radius), yLowerBound); - + int zLowerBound = (int) Math.max(Math.floor(zt - radius), z); int zUpperBound = (int) Math.max(Math.floor(zt + radius), zLowerBound); - + // Iterate over coordinates within bounds for(int xi = xLowerBound; xi <= xUpperBound; ++xi) { double dx = ((double) xi + 0.5 - xt) / radius; @@ -139,12 +139,12 @@ public class VanillaOre implements Structure { if(dx * dx + dy * dy < 1.0) { for(int zi = zLowerBound; zi <= zUpperBound; ++zi) { double dz = ((double) zi + 0.5 - zt) / radius; - + // If position is inside the sphere if(dx * dx + dy * dy + dz * dz < 1.0 && !(yi < world.getMinHeight() || yi >= world.getMaxHeight())) { int index = xi - x + (yi - y) * horizontalSize + (zi - z) * horizontalSize * verticalSize; if(!visited.get(index)) { // Skip blocks that have already been visited - + visited.set(index); BlockType block = world.getBlockState(xi, yi, zi).getBlockType(); if(shouldPlace(getReplaceable(), block, exposed, random, world, xi, yi, zi)) { @@ -160,18 +160,18 @@ public class VanillaOre implements Structure { } } } - + return blockCount > 0; } - + public BlockState getMaterial(BlockType replace) { return materials.getOrDefault(replace, material); } - + public MaterialSet getReplaceable() { return replaceable; } - + public boolean isApplyGravity() { return applyGravity; } diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java index 6a1ce728f..b7b699490 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/ores/VanillaScatteredOre.java @@ -15,19 +15,19 @@ import static com.dfsek.terra.addons.ore.utils.VanillaOreUtils.shouldPlace; public class VanillaScatteredOre extends VanillaOre { protected final int spread; - + public VanillaScatteredOre(BlockState material, double size, MaterialSet replaceable, boolean applyGravity, double exposed, Map materials, int spread) { super(material, size, replaceable, applyGravity, exposed, materials); - + this.spread = spread; } - + @Override public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation) { int i = random.nextInt((int) (size + 1)); Vector3Int.Mutable mutable = Vector3Int.zero().mutable(); - + for(int j = 0; j < i; ++j) { this.setPos(mutable, random, location, Math.min(j, spread)); BlockType block = world.getBlockState(mutable).getBlockType(); @@ -35,10 +35,10 @@ public class VanillaScatteredOre extends VanillaOre { world.setBlockState(mutable, getMaterial(block), isApplyGravity()); } } - + return true; } - + private void setPos(Vector3Int.Mutable mutable, Random random, Vector3Int location, int spread) { int x = this.getSpread(random, spread); int y = this.getSpread(random, spread); @@ -47,7 +47,7 @@ public class VanillaScatteredOre extends VanillaOre { mutable.setY(location.getY() + y); mutable.setZ(location.getZ() + z); } - + private int getSpread(Random random, int spread) { return Math.round((random.nextFloat() - random.nextFloat()) * (float) spread); } diff --git a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java index 48bf3a712..cfef65b57 100644 --- a/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java +++ b/common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java @@ -17,7 +17,7 @@ public class VanillaOreUtils { return random.nextFloat() >= chance; } } - + public static boolean shouldPlace(MaterialSet replaceable, BlockType type, Double exposed, Random random, WritableWorld world, int x, int y, int z) { if(!replaceable.contains(type)) { @@ -33,6 +33,6 @@ public class VanillaOreUtils { world.getBlockState(x + 1, y, z).isAir()); } } - + } diff --git a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteAddon.java b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteAddon.java index 7c10c8999..a7e7c6b10 100644 --- a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteAddon.java +++ b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteAddon.java @@ -20,19 +20,19 @@ import com.dfsek.terra.api.inject.annotations.Inject; public class PaletteAddon implements AddonInitializer { @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> { - event.getPack().registerConfigType(new PaletteConfigType(platform), addon.key("PALETTE"), 2); - event.getPack().applyLoader(PaletteLayerHolder.class, PaletteLayerLoader::new); - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> { + event.getPack().registerConfigType(new PaletteConfigType(platform), addon.key("PALETTE"), 2); + event.getPack().applyLoader(PaletteLayerHolder.class, PaletteLayerLoader::new); + }) + .failThrough(); } } diff --git a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteConfigType.java b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteConfigType.java index 9ac076127..ff0c92800 100644 --- a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteConfigType.java +++ b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteConfigType.java @@ -20,21 +20,21 @@ public class PaletteConfigType implements ConfigType { }; private final PaletteFactory factory = new PaletteFactory(); private final Platform platform; - + public PaletteConfigType(Platform platform) { this.platform = platform; } - + @Override public PaletteTemplate getTemplate(ConfigPack pack, Platform platform) { return new PaletteTemplate(); } - + @Override public ConfigFactory getFactory() { return factory; } - + @Override public TypeKey getTypeKey() { return PALETTE_TYPE_TOKEN; diff --git a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteTemplate.java b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteTemplate.java index c7cd3b6ee..de4af6319 100644 --- a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteTemplate.java +++ b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/PaletteTemplate.java @@ -24,22 +24,22 @@ public class PaletteTemplate implements AbstractableTemplate { @Value("sampler") @Default private @Meta NoiseSampler noise = NoiseSampler.zero(); - + @Value("id") @Final private String id; - + @Value("layers") private @Meta List<@Meta PaletteLayerHolder> palette; - + public String getID() { return id; } - + public List getPalette() { return palette; } - + public NoiseSampler getNoise() { return noise; } diff --git a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteImpl.java b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteImpl.java index 642f78142..e0a314726 100644 --- a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteImpl.java +++ b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteImpl.java @@ -23,18 +23,18 @@ import com.dfsek.terra.api.world.chunk.generation.util.Palette; public class PaletteImpl implements Palette { private final List pallet = new ArrayList<>(); private final NoiseSampler sampler; - + public PaletteImpl(NoiseSampler sampler) { this.sampler = sampler; } - + public Palette add(ProbabilityCollection m, int layers, NoiseSampler sampler) { for(int i = 0; i < layers; i++) { pallet.add(new PaletteLayer(m, sampler)); } return this; } - + @Override public BlockState get(int layer, double x, double y, double z, long seed) { PaletteLayer paletteLayer; @@ -47,23 +47,23 @@ public class PaletteImpl implements Palette { NoiseSampler paletteSampler = paletteLayer.getSampler(); return paletteLayer.get(paletteSampler == null ? sampler : paletteSampler, x, y, z, seed); } - - + + public int getSize() { return pallet.size(); } - + public List getLayers() { return pallet; } - + /** * Class representation of a layer of a BlockPalette. */ public static class PaletteLayer { private final NoiseSampler sampler; private final ProbabilityCollection collection; - + /** * Constructs a PaletteLayerHolder with a ProbabilityCollection of materials and a number of layers. * @@ -74,14 +74,14 @@ public class PaletteImpl implements Palette { this.sampler = sampler; this.collection = type; } - + public BlockState get(NoiseSampler random, double x, double y, double z, long seed) { return this.collection.get(random, x, y, z, seed); } - + public NoiseSampler getSampler() { return sampler; } - + } } diff --git a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerHolder.java b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerHolder.java index 2bf6d5fa1..6ff4bdd8d 100644 --- a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerHolder.java +++ b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerHolder.java @@ -18,22 +18,22 @@ public class PaletteLayerHolder { private final ProbabilityCollection layer; private final NoiseSampler sampler; private final int size; - + public PaletteLayerHolder(@NotNull ProbabilityCollection layer, NoiseSampler sampler, int size) { this.layer = layer; this.sampler = sampler; this.size = size; } - + @NotNull public ProbabilityCollection getLayer() { return layer; } - + public int getSize() { return size; } - + public NoiseSampler getSampler() { return sampler; } diff --git a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerLoader.java b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerLoader.java index ef4689dff..918b9abb4 100644 --- a/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerLoader.java +++ b/common/addons/config-palette/src/main/java/com/dfsek/terra/addons/palette/palette/PaletteLayerLoader.java @@ -20,14 +20,14 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; public class PaletteLayerLoader implements ObjectTemplate { @Value("materials") private @Meta ProbabilityCollection<@Meta BlockState> collection; - + @Value("sampler") @Default private @Meta NoiseSampler sampler = null; - + @Value("layers") private @Meta int layers; - + @Override public PaletteLayerHolder get() { return new PaletteLayerHolder(collection, sampler, layers); diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructures.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructures.java index 3fb9a175b..dfebf0f79 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructures.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructures.java @@ -15,11 +15,11 @@ import com.dfsek.terra.api.structure.configured.ConfiguredStructure; public class BiomeStructures implements Properties { private final Set structures; - + public BiomeStructures(Set structures) { this.structures = structures; } - + public Set getStructures() { return structures; } diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructuresTemplate.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructuresTemplate.java index d7d34e93a..99e80e9bc 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructuresTemplate.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/BiomeStructuresTemplate.java @@ -23,7 +23,7 @@ public class BiomeStructuresTemplate implements ObjectTemplate @Value("structures") @Default private @Meta Set<@Meta ConfiguredStructure> structures = Collections.emptySet(); - + @Override public BiomeStructures get() { return new BiomeStructures(structures); diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureAddon.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureAddon.java index 6ba93bb38..c56823307 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureAddon.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureAddon.java @@ -18,16 +18,16 @@ import com.dfsek.terra.api.inject.annotations.Inject; public class StructureAddon implements AddonInitializer { @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> event.getPack().registerConfigType(new StructureConfigType(), addon.key("STRUCTURE"), 2)) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> event.getPack().registerConfigType(new StructureConfigType(), addon.key("STRUCTURE"), 2)) + .failThrough(); } } diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureConfigType.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureConfigType.java index f4c124753..cf8f662a6 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureConfigType.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureConfigType.java @@ -19,17 +19,17 @@ public class StructureConfigType implements ConfigType CONFIGURED_STRUCTURE_TYPE_KEY = new TypeKey<>() { }; private final ConfigFactory factory = new StructureFactory(); - + @Override public StructureTemplate getTemplate(ConfigPack pack, Platform platform) { return new StructureTemplate(); } - + @Override public ConfigFactory getFactory() { return factory; } - + @Override public TypeKey getTypeKey() { return CONFIGURED_STRUCTURE_TYPE_KEY; diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureTemplate.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureTemplate.java index 9868a39f2..5856ab5a5 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureTemplate.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/StructureTemplate.java @@ -23,28 +23,28 @@ public class StructureTemplate implements AbstractableTemplate { @Value("id") @Final private String id; - + @Value("scripts") private @Meta ProbabilityCollection<@Meta Structure> structure; - + @Value("spawn.start") private @Meta Range y; - + @Value("spawn") private @Meta StructureSpawn spawn; - + public String getID() { return id; } - + public ProbabilityCollection getStructures() { return structure; } - + public Range getY() { return y; } - + public StructureSpawn getSpawn() { return spawn; } diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/TerraStructure.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/TerraStructure.java index 9293a72b5..2fd78f77d 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/TerraStructure.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/TerraStructure.java @@ -18,31 +18,31 @@ public class TerraStructure implements ConfiguredStructure { private final ProbabilityCollection structure; private final Range spawnStart; private final StructureSpawn spawn; - + private final String id; - + public TerraStructure(ProbabilityCollection structures, Range spawnStart, StructureSpawn spawn, String id) { this.structure = structures; this.spawnStart = spawnStart; this.spawn = spawn; this.id = id; } - + @Override public ProbabilityCollection getStructure() { return structure; } - + @Override public Range getSpawnStart() { return spawnStart; } - + @Override public StructureSpawn getSpawn() { return spawn; } - + @Override public String getID() { return id; diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Entry.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Entry.java index 20046dfde..106147229 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Entry.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Entry.java @@ -30,7 +30,7 @@ public class Entry { private final Item item; private final long weight; private final List functions = new ArrayList<>(); - + /** * Instantiates an Entry from a JSON representation. * @@ -39,14 +39,14 @@ public class Entry { public Entry(JSONObject entry, Platform platform) { String id = entry.get("name").toString(); this.item = platform.getItemHandle().createItem(id); - + long weight1; try { weight1 = (long) entry.get("weight"); } catch(NullPointerException e) { weight1 = 1; } - + this.weight = weight1; if(entry.containsKey("functions")) { for(Object function : (JSONArray) entry.get("functions")) { @@ -75,13 +75,13 @@ public class Entry { if(((JSONObject) function).containsKey("disabled_enchants")) disabled = (JSONArray) ((JSONObject) function).get("disabled_enchants"); functions.add( - new EnchantFunction(Math.toIntExact(minEnchant), Math.toIntExact(maxEnchant), disabled, platform)); + new EnchantFunction(Math.toIntExact(minEnchant), Math.toIntExact(maxEnchant), disabled, platform)); } } } } } - + /** * Fetches a single ItemStack from the Entry, applying all functions to it. * @@ -96,7 +96,7 @@ public class Entry { } return item; } - + /** * Gets the weight attribute of the Entry. * diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/LootTableImpl.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/LootTableImpl.java index e9bba93e6..cebf93ef2 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/LootTableImpl.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/LootTableImpl.java @@ -26,7 +26,7 @@ import com.dfsek.terra.api.inventory.ItemStack; */ public class LootTableImpl implements com.dfsek.terra.api.structure.LootTable { private final List pools = new ArrayList<>(); - + /** * Instantiates a LootTable from a JSON String. * @@ -42,7 +42,7 @@ public class LootTableImpl implements com.dfsek.terra.api.structure.LootTable { pools.add(new Pool((JSONObject) pool, platform)); } } - + @Override public void fillInventory(Inventory i, Random r) { List loot = getLoot(r); @@ -68,7 +68,7 @@ public class LootTableImpl implements com.dfsek.terra.api.structure.LootTable { } } } - + @Override public List getLoot(Random r) { List itemList = new ArrayList<>(); diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Pool.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Pool.java index a59b29957..dd80e03ec 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Pool.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/Pool.java @@ -26,7 +26,7 @@ public class Pool { private final int max; private final int min; private final ProbabilityCollection entries; - + /** * Instantiates a Pool from a JSON representation. * @@ -42,13 +42,13 @@ public class Pool { max = Math.toIntExact((Long) ((JSONObject) amount).get("max")); min = Math.toIntExact((Long) ((JSONObject) amount).get("min")); } - + for(Object entryJSON : (JSONArray) pool.get("entries")) { Entry entry = new Entry((JSONObject) entryJSON, platform); entries.add(entry, Math.toIntExact(entry.getWeight())); } } - + /** * Fetches a list of items from the pool using the provided Random instance. * @@ -57,7 +57,7 @@ public class Pool { * @return List<ItemStack> - The list of items fetched. */ public List getItems(Random r) { - + int rolls = r.nextInt(max - min + 1) + min; List items = new ArrayList<>(); for(int i = 0; i < rolls; i++) { diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/AmountFunction.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/AmountFunction.java index 85a95a750..2605840f6 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/AmountFunction.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/AmountFunction.java @@ -19,7 +19,7 @@ import com.dfsek.terra.api.inventory.ItemStack; public class AmountFunction implements LootFunction { private final int max; private final int min; - + /** * Instantiates an AmountFunction. * @@ -30,7 +30,7 @@ public class AmountFunction implements LootFunction { this.min = min; this.max = max; } - + /** * Applies the function to an ItemStack. * diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/DamageFunction.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/DamageFunction.java index 7eb0cb028..c90090199 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/DamageFunction.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/DamageFunction.java @@ -20,7 +20,7 @@ import com.dfsek.terra.api.inventory.item.ItemMeta; public class DamageFunction implements LootFunction { private final int max; private final int min; - + /** * Instantiates a DamageFunction. * @@ -31,7 +31,7 @@ public class DamageFunction implements LootFunction { this.min = min; this.max = max; } - + /** * Applies the function to an ItemStack. * diff --git a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/EnchantFunction.java b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/EnchantFunction.java index 4d11a49e1..e741bd9f5 100644 --- a/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/EnchantFunction.java +++ b/common/addons/config-structure/src/main/java/com/dfsek/terra/addons/structure/structures/loot/functions/EnchantFunction.java @@ -28,15 +28,15 @@ public class EnchantFunction implements LootFunction { private final int max; private final JSONArray disabled; private final Platform platform; - - + + public EnchantFunction(int min, int max, JSONArray disabled, Platform platform) { this.max = max; this.min = min; this.disabled = disabled; this.platform = platform; } - + /** * Applies the function to an ItemStack. * @@ -48,7 +48,7 @@ public class EnchantFunction implements LootFunction { @Override public ItemStack apply(ItemStack original, Random r) { if(original.getItemMeta() == null) return original; - + double enchant = (r.nextDouble() * (max - min)) + min; List possible = new ArrayList<>(); for(Enchantment ench : platform.getItemHandle().getEnchantments()) { @@ -70,9 +70,9 @@ public class EnchantFunction implements LootFunction { meta.addEnchantment(chosen, Math.max(lvl, 1)); } catch(IllegalArgumentException e) { LOGGER.warn( - "Attempted to enchant {} with {} at level {}, but an unexpected exception occurred! Usually this is caused by a " + - "misbehaving enchantment plugin.", - original.getType(), chosen, Math.max(lvl, 1)); + "Attempted to enchant {} with {} at level {}, but an unexpected exception occurred! Usually this is caused by a " + + "misbehaving enchantment plugin.", + original.getType(), chosen, Math.max(lvl, 1)); } } original.setItemMeta(meta); diff --git a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationAddon.java b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationAddon.java index 1e6adbdbe..41009ed0b 100644 --- a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationAddon.java +++ b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationAddon.java @@ -39,57 +39,57 @@ import com.dfsek.terra.api.world.chunk.generation.stage.GenerationStage; public class FeatureGenerationAddon implements AddonInitializer { public static final TypeKey>> STAGE_TYPE_KEY = new TypeKey<>() { }; - + public static final TypeKey<@Meta List<@Meta Feature>> FEATURE_LIST_TYPE_KEY = new TypeKey<>() { }; @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @SuppressWarnings("unchecked") @Override public void initialize() { PropertyKey biomeFeaturesKey = Context.create(BiomeFeatures.class); platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> event.getPack() - .getOrCreateRegistry(STAGE_TYPE_KEY) - .register(addon.key("FEATURE"), () -> new FeatureStageTemplate(platform, biomeFeaturesKey))) - .failThrough(); - + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> event.getPack() + .getOrCreateRegistry(STAGE_TYPE_KEY) + .register(addon.key("FEATURE"), () -> new FeatureStageTemplate(platform, biomeFeaturesKey))) + .failThrough(); + platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigurationLoadEvent.class) - .then(event -> { - if(event.is(Biome.class)) { - DynamicTemplate.Builder templateBuilder = DynamicTemplate.builder(); - - List featureGenerationStages = new ArrayList<>(); - event.getPack().getStages().forEach(stage -> { - if(stage instanceof FeatureGenerationStage featureGenerationStage) { - featureGenerationStages.add(featureGenerationStage); - templateBuilder - .value(featureGenerationStage.getID(), - DynamicValue - .builder("features." + featureGenerationStage.getID(), List.class) - .annotatedType(FEATURE_LIST_TYPE_KEY.getAnnotatedType()) - .setDefault(Collections.emptyList()) - .build()); - } - }); - - DynamicTemplate template = event.load(templateBuilder.build()); - - Map> features = new HashMap<>(); - - featureGenerationStages.forEach(stage -> features.put(stage, template.get(stage.getID(), List.class))); - - event.getLoadedObject(Biome.class).getContext().put(biomeFeaturesKey, new BiomeFeatures(features)); - } - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigurationLoadEvent.class) + .then(event -> { + if(event.is(Biome.class)) { + DynamicTemplate.Builder templateBuilder = DynamicTemplate.builder(); + + List featureGenerationStages = new ArrayList<>(); + event.getPack().getStages().forEach(stage -> { + if(stage instanceof FeatureGenerationStage featureGenerationStage) { + featureGenerationStages.add(featureGenerationStage); + templateBuilder + .value(featureGenerationStage.getID(), + DynamicValue + .builder("features." + featureGenerationStage.getID(), List.class) + .annotatedType(FEATURE_LIST_TYPE_KEY.getAnnotatedType()) + .setDefault(Collections.emptyList()) + .build()); + } + }); + + DynamicTemplate template = event.load(templateBuilder.build()); + + Map> features = new HashMap<>(); + + featureGenerationStages.forEach(stage -> features.put(stage, template.get(stage.getID(), List.class))); + + event.getLoadedObject(Biome.class).getContext().put(biomeFeaturesKey, new BiomeFeatures(features)); + } + }) + .failThrough(); } } diff --git a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationStage.java b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationStage.java index c0b3d715a..6baf88b7a 100644 --- a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationStage.java +++ b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationStage.java @@ -24,14 +24,14 @@ import com.dfsek.terra.api.world.chunk.generation.util.Column; public class FeatureGenerationStage implements GenerationStage, StringIdentifiable { private final Platform platform; - + private final String id; - + private final String profile; - + private final int resolution; private final PropertyKey biomeFeaturesKey; - + public FeatureGenerationStage(Platform platform, String id, int resolution, PropertyKey biomeFeaturesKey) { this.platform = platform; this.id = id; @@ -39,7 +39,7 @@ public class FeatureGenerationStage implements GenerationStage, StringIdentifiab this.resolution = resolution; this.biomeFeaturesKey = biomeFeaturesKey; } - + @Override @SuppressWarnings("try") public void populate(ProtoWorld world) { @@ -52,40 +52,40 @@ public class FeatureGenerationStage implements GenerationStage, StringIdentifiab int tx = cx + chunkX; int tz = cz + chunkZ; world.getBiomeProvider() - .getColumn(tx, tz, world) - .forRanges(resolution, (min, max, biome) -> { - for(int subChunkX = 0; subChunkX < resolution; subChunkX++) { - for(int subChunkZ = 0; subChunkZ < resolution; subChunkZ++) { - int x = subChunkX + tx; - int z = subChunkZ + tz; - long coordinateSeed = (seed * 31 + x) * 31 + z; - Column column = world.column(x, z); - biome.getContext() - .get(biomeFeaturesKey) - .getFeatures() - .getOrDefault(this, Collections.emptyList()) - .forEach(feature -> { - platform.getProfiler().push(feature.getID()); - if(feature.getDistributor().matches(x, z, seed)) { - feature.getLocator() - .getSuitableCoordinates(column.clamp(min, max)) - .forEach(y -> feature.getStructure(world, x, y, z) - .generate(Vector3Int.of(x, y, z), - world, - new Random(coordinateSeed * 31 + y), - Rotation.NONE) - ); - } - platform.getProfiler().pop(feature.getID()); - }); - } - } - }); + .getColumn(tx, tz, world) + .forRanges(resolution, (min, max, biome) -> { + for(int subChunkX = 0; subChunkX < resolution; subChunkX++) { + for(int subChunkZ = 0; subChunkZ < resolution; subChunkZ++) { + int x = subChunkX + tx; + int z = subChunkZ + tz; + long coordinateSeed = (seed * 31 + x) * 31 + z; + Column column = world.column(x, z); + biome.getContext() + .get(biomeFeaturesKey) + .getFeatures() + .getOrDefault(this, Collections.emptyList()) + .forEach(feature -> { + platform.getProfiler().push(feature.getID()); + if(feature.getDistributor().matches(x, z, seed)) { + feature.getLocator() + .getSuitableCoordinates(column.clamp(min, max)) + .forEach(y -> feature.getStructure(world, x, y, z) + .generate(Vector3Int.of(x, y, z), + world, + new Random(coordinateSeed * 31 + y), + Rotation.NONE) + ); + } + platform.getProfiler().pop(feature.getID()); + }); + } + } + }); } } platform.getProfiler().pop(profile); } - + @Override public String getID() { return id; diff --git a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/config/BiomeFeatures.java b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/config/BiomeFeatures.java index 0d4d333ed..afd10efce 100644 --- a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/config/BiomeFeatures.java +++ b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/config/BiomeFeatures.java @@ -17,11 +17,11 @@ import com.dfsek.terra.api.structure.feature.Feature; public class BiomeFeatures implements Properties { private final Map> features; - + public BiomeFeatures(Map> features) { this.features = features; } - + public Map> getFeatures() { return features; } diff --git a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/config/FeatureStageTemplate.java b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/config/FeatureStageTemplate.java index 62e7006db..ffc077f1a 100644 --- a/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/config/FeatureStageTemplate.java +++ b/common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/config/FeatureStageTemplate.java @@ -17,22 +17,22 @@ public class FeatureStageTemplate implements ObjectTemplate, Va private final PropertyKey biomeFeaturesKey; @Value("id") private String id; - + @Value("resolution") @Default private int resolution = 4; - + public FeatureStageTemplate(Platform platform, PropertyKey biomeFeaturesKey) { this.platform = platform; this.biomeFeaturesKey = biomeFeaturesKey; } - - + + @Override public FeatureGenerationStage get() { return new FeatureGenerationStage(platform, id, resolution, biomeFeaturesKey); } - + @Override public boolean validate() throws ValidationException { if(!(resolution == 1 @@ -40,7 +40,7 @@ public class FeatureStageTemplate implements ObjectTemplate, Va || resolution == 4 || resolution == 8 || resolution == 16)) throw new ValidationException( - "Resolution must be power of 2 less than or equal to 16 (1, 2, 4, 8, 16), got: " + resolution); + "Resolution must be power of 2 less than or equal to 16 (1, 2, 4, 8, 16), got: " + resolution); return true; } } diff --git a/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/StructureGenerationAddon.java b/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/StructureGenerationAddon.java index 3bf03ec6f..3b38c6439 100644 --- a/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/StructureGenerationAddon.java +++ b/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/StructureGenerationAddon.java @@ -15,29 +15,29 @@ import com.dfsek.terra.api.world.chunk.generation.util.provider.GenerationStageP public class StructureGenerationAddon implements AddonInitializer { @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> event.getPack() - .getOrCreateRegistry(GenerationStageProvider.class) - .register(addon.key("STRUCTURE"), pack -> new StructureGenerationStage(platform))) - .failThrough(); - + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> event.getPack() + .getOrCreateRegistry(GenerationStageProvider.class) + .register(addon.key("STRUCTURE"), pack -> new StructureGenerationStage(platform))) + .failThrough(); + platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigurationLoadEvent.class) - .then(event -> { - if(event.is(Biome.class)) { - event.getLoadedObject(Biome.class).getContext().put(event.load(new BiomeStructuresTemplate()).get()); - } - }) - .failThrough(); - + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigurationLoadEvent.class) + .then(event -> { + if(event.is(Biome.class)) { + event.getLoadedObject(Biome.class).getContext().put(event.load(new BiomeStructuresTemplate()).get()); + } + }) + .failThrough(); + } } diff --git a/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/StructureGenerationStage.java b/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/StructureGenerationStage.java index 07d9e7128..18b474fa2 100644 --- a/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/StructureGenerationStage.java +++ b/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/StructureGenerationStage.java @@ -7,11 +7,11 @@ import com.dfsek.terra.api.world.chunk.generation.stage.GenerationStage; public class StructureGenerationStage implements GenerationStage { private final Platform platform; - + public StructureGenerationStage(Platform platform) { this.platform = platform; } - + @Override public void populate(ProtoWorld world) { - + } } diff --git a/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/config/BiomeStructures.java b/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/config/BiomeStructures.java index 3a3fc4242..3fff9d19b 100644 --- a/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/config/BiomeStructures.java +++ b/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/config/BiomeStructures.java @@ -8,9 +8,9 @@ import com.dfsek.terra.api.structure.configured.ConfiguredStructure; public class BiomeStructures implements Properties { private final List structures; - + public BiomeStructures(List structures) { this.structures = structures; } - + public List getStructures() { return structures; } diff --git a/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/config/BiomeStructuresTemplate.java b/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/config/BiomeStructuresTemplate.java index 64f65a018..64416abbc 100644 --- a/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/config/BiomeStructuresTemplate.java +++ b/common/addons/generation-stage-structure/src/main/java/com/dfsek/terra/addons/generation/structure/config/BiomeStructuresTemplate.java @@ -15,7 +15,7 @@ public class BiomeStructuresTemplate implements ObjectTemplate @Value("features") @Default private @Meta List<@Meta ConfiguredStructure> features = Collections.emptyList(); - + @Override public BiomeStructures get() { return new BiomeStructures(features); diff --git a/common/addons/language-yaml/src/main/java/com/dfsek/terra/addons/yaml/YamlAddon.java b/common/addons/language-yaml/src/main/java/com/dfsek/terra/addons/yaml/YamlAddon.java index 44565157b..08cb9751a 100644 --- a/common/addons/language-yaml/src/main/java/com/dfsek/terra/addons/yaml/YamlAddon.java +++ b/common/addons/language-yaml/src/main/java/com/dfsek/terra/addons/yaml/YamlAddon.java @@ -20,23 +20,23 @@ import com.dfsek.terra.api.inject.annotations.Inject; public class YamlAddon implements AddonInitializer { - + private static final Logger LOGGER = LoggerFactory.getLogger(YamlAddon.class); @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigurationDiscoveryEvent.class) - .then(event -> event.getLoader().open("", ".yml").thenEntries(entries -> entries.forEach(entry -> { - LOGGER.debug("Discovered config {}", entry.getKey()); - event.register(entry.getKey(), new YamlConfiguration(entry.getValue(), entry.getKey())); - })).close()) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigurationDiscoveryEvent.class) + .then(event -> event.getLoader().open("", ".yml").thenEntries(entries -> entries.forEach(entry -> { + LOGGER.debug("Discovered config {}", entry.getKey()); + event.register(entry.getKey(), new YamlConfiguration(entry.getValue(), entry.getKey())); + })).close()) + .failThrough(); } } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java index 811164b01..b383c4ca7 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java @@ -32,58 +32,58 @@ import com.dfsek.terra.api.util.reflection.TypeKey; public class ImageLibraryAddon implements AddonInitializer { - + public static final TypeKey>> IMAGE_REGISTRY_KEY = new TypeKey<>() { }; - + public static final TypeKey>> COLOR_PICKER_REGISTRY_KEY = new TypeKey<>() { }; - + public static final TypeKey>> NOISE_SAMPLER_TOKEN = new TypeKey<>() { }; @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .priority(10) - .then(event -> { - ImageLibraryPackConfigTemplate config = event.loadTemplate(new ImageLibraryPackConfigTemplate()); - event.getPack().getContext().put(config); - }) - .then(event -> { - ConfigPack pack = event.getPack(); - CheckedRegistry>> imageRegistry = pack.getOrCreateRegistry(IMAGE_REGISTRY_KEY); - imageRegistry.register(addon.key("BITMAP"), () -> new ImageTemplate(pack.getLoader(), pack)); - imageRegistry.register(addon.key("STITCHED_BITMAP"), () -> new StitchedImageTemplate(pack.getLoader(), pack)); - }) - .then(event -> { - event.getPack() - .applyLoader(DistanceTransform.CostFunction.class, - (type, o, loader, depthTracker) -> DistanceTransform.CostFunction.valueOf((String) o)) - .applyLoader(DistanceTransform.Normalization.class, - (type, o, loader, depthTracker) -> DistanceTransform.Normalization.valueOf((String) o)) - .applyLoader(ColorString.class, new ColorLoader()); - - CheckedRegistry>> noiseRegistry = event.getPack().getOrCreateRegistry( - NOISE_SAMPLER_TOKEN); - noiseRegistry.register(addon.key("DISTANCE_TRANSFORM"), DistanceTransformNoiseSamplerTemplate::new); - noiseRegistry.register(addon.key("CHANNEL"), ChannelNoiseSamplerTemplate::new); - }) - .then(event -> { - CheckedRegistry>> colorSamplerRegistry = event.getPack().getOrCreateRegistry( - COLOR_PICKER_REGISTRY_KEY); - colorSamplerRegistry.register(addon.key("SINGLE_IMAGE"), SingleImageColorSamplerTemplate::new); - colorSamplerRegistry.register(addon.key("TILED_IMAGE"), TileImageColorSamplerTemplate::new); - colorSamplerRegistry.register(addon.key("COLOR"), ConstantColorSamplerTemplate::new); - colorSamplerRegistry.register(addon.key("ROTATE"), RotateColorSamplerTemplate::new); - colorSamplerRegistry.register(addon.key("TRANSLATE"), TranslateColorSamplerTemplate::new); - }); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .priority(10) + .then(event -> { + ImageLibraryPackConfigTemplate config = event.loadTemplate(new ImageLibraryPackConfigTemplate()); + event.getPack().getContext().put(config); + }) + .then(event -> { + ConfigPack pack = event.getPack(); + CheckedRegistry>> imageRegistry = pack.getOrCreateRegistry(IMAGE_REGISTRY_KEY); + imageRegistry.register(addon.key("BITMAP"), () -> new ImageTemplate(pack.getLoader(), pack)); + imageRegistry.register(addon.key("STITCHED_BITMAP"), () -> new StitchedImageTemplate(pack.getLoader(), pack)); + }) + .then(event -> { + event.getPack() + .applyLoader(DistanceTransform.CostFunction.class, + (type, o, loader, depthTracker) -> DistanceTransform.CostFunction.valueOf((String) o)) + .applyLoader(DistanceTransform.Normalization.class, + (type, o, loader, depthTracker) -> DistanceTransform.Normalization.valueOf((String) o)) + .applyLoader(ColorString.class, new ColorLoader()); + + CheckedRegistry>> noiseRegistry = event.getPack().getOrCreateRegistry( + NOISE_SAMPLER_TOKEN); + noiseRegistry.register(addon.key("DISTANCE_TRANSFORM"), DistanceTransformNoiseSamplerTemplate::new); + noiseRegistry.register(addon.key("CHANNEL"), ChannelNoiseSamplerTemplate::new); + }) + .then(event -> { + CheckedRegistry>> colorSamplerRegistry = event.getPack().getOrCreateRegistry( + COLOR_PICKER_REGISTRY_KEY); + colorSamplerRegistry.register(addon.key("SINGLE_IMAGE"), SingleImageColorSamplerTemplate::new); + colorSamplerRegistry.register(addon.key("TILED_IMAGE"), TileImageColorSamplerTemplate::new); + colorSamplerRegistry.register(addon.key("COLOR"), ConstantColorSamplerTemplate::new); + colorSamplerRegistry.register(addon.key("ROTATE"), RotateColorSamplerTemplate::new); + colorSamplerRegistry.register(addon.key("TRANSLATE"), TranslateColorSamplerTemplate::new); + }); } } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/ColorSampler.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/ColorSampler.java index 6c0baa7f7..e0eb1fefe 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/ColorSampler.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/ColorSampler.java @@ -2,7 +2,7 @@ package com.dfsek.terra.addons.image.colorsampler; @FunctionalInterface public interface ColorSampler { - + /** * @param x World x coordinate * @param z World z coordinate diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/SingleImageColorSampler.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/SingleImageColorSampler.java index a66dee104..aeec3729e 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/SingleImageColorSampler.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/SingleImageColorSampler.java @@ -6,19 +6,19 @@ import com.dfsek.terra.addons.image.image.Image; public class SingleImageColorSampler implements ColorSampler { - + private final Image image; - + private final ColorSampler fallback; - + private final ImageTransformation transformation; - + public SingleImageColorSampler(Image image, ColorSampler fallback, ImageTransformation transformation) { this.image = image; this.fallback = fallback; this.transformation = transformation; } - + @Override public int apply(int x, int z) { var nx = transformation.transformX(image, x); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/TileImageColorSampler.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/TileImageColorSampler.java index d9106d6ff..fe629f505 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/TileImageColorSampler.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/TileImageColorSampler.java @@ -6,16 +6,16 @@ import com.dfsek.terra.addons.image.image.Image; public class TileImageColorSampler implements ColorSampler { - + private final Image image; - + private final ImageTransformation transformation; - + public TileImageColorSampler(Image image, ImageTransformation transformation) { this.image = image; this.transformation = transformation; } - + @Override public int apply(int x, int z) { x = transformation.transformX(image, x); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/transform/Alignment.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/transform/Alignment.java index 87285171c..42ce341ce 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/transform/Alignment.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/transform/Alignment.java @@ -4,13 +4,13 @@ import com.dfsek.terra.addons.image.image.Image; public enum Alignment implements ImageTransformation { - + NONE() { @Override public int transformX(Image image, int x) { return x; } - + @Override public int transformZ(Image image, int z) { return z; @@ -21,7 +21,7 @@ public enum Alignment implements ImageTransformation { public int transformX(Image image, int x) { return x + image.getWidth() / 2; } - + @Override public int transformZ(Image image, int z) { return z + image.getHeight() / 2; diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/transform/ImageTransformation.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/transform/ImageTransformation.java index cc5b63e7f..b69db92b3 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/transform/ImageTransformation.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/image/transform/ImageTransformation.java @@ -4,8 +4,8 @@ import com.dfsek.terra.addons.image.image.Image; public interface ImageTransformation { - + int transformX(Image image, int x); - + int transformZ(Image image, int z); } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/RotateColorSampler.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/RotateColorSampler.java index aa348b350..a356a0787 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/RotateColorSampler.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/RotateColorSampler.java @@ -5,19 +5,19 @@ import com.dfsek.terra.api.util.MathUtil; public class RotateColorSampler implements ColorSampler { - + private final ColorSampler sampler; - + private final double radians; - + private final RotationMethod rotationMethod; - + public RotateColorSampler(ColorSampler sampler, double degrees) { this.sampler = sampler; - + double normalizedDegrees = degrees % 360.0; if(normalizedDegrees < 0) normalizedDegrees += 360.0; - + if(normalizedDegrees == 0.0) rotationMethod = RotationMethod.DEG_0; else if(normalizedDegrees == 90.0) @@ -28,10 +28,10 @@ public class RotateColorSampler implements ColorSampler { rotationMethod = RotationMethod.DEG_270; else rotationMethod = RotationMethod.RAD_ANY; - + this.radians = Math.toRadians(degrees); } - + @Override public int apply(int x, int z) { int rx = switch(rotationMethod) { @@ -50,7 +50,7 @@ public class RotateColorSampler implements ColorSampler { }; return sampler.apply(rx, rz); } - + private enum RotationMethod { DEG_0, DEG_90, diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/TranslateColorSampler.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/TranslateColorSampler.java index 16d3cb71c..6a71fd774 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/TranslateColorSampler.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/colorsampler/mutate/TranslateColorSampler.java @@ -4,16 +4,16 @@ import com.dfsek.terra.addons.image.colorsampler.ColorSampler; public class TranslateColorSampler implements ColorSampler { - + private final ColorSampler sampler; private final int translateX, translateZ; - + public TranslateColorSampler(ColorSampler sampler, int translateX, int translateZ) { this.sampler = sampler; this.translateX = translateX; this.translateZ = translateZ; } - + @Override public int apply(int x, int z) { return sampler.apply(x - translateX, z - translateZ); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ColorLoader.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ColorLoader.java index 61115f3b6..c541f1110 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ColorLoader.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ColorLoader.java @@ -13,27 +13,27 @@ import com.dfsek.terra.addons.image.util.ColorUtil; public class ColorLoader implements TypeLoader { - + @Override public ColorString load(@NotNull AnnotatedType annotatedType, @NotNull Object o, @NotNull ConfigLoader configLoader, DepthTracker depthTracker) throws LoadException { return new ColorString((String) o); } - + public static class ColorString { - + private final int argb; - + public ColorString(String string) throws IllegalArgumentException { this.argb = parse(string); } - + private static int parse(String string) throws IllegalArgumentException { if(string.length() == 0) throw new IllegalArgumentException("Empty string cannot be parsed as a valid color"); - + String[] split = string.split(","); - + if(split.length == 1) return parseHex(string); else if(split.length == 3) @@ -43,48 +43,48 @@ public class ColorLoader implements TypeLoader { else throw new IllegalArgumentException("Invalid channels provided, required format RED,GREEN,BLUE or ALPHA,RED,GREEN,BLUE"); } - + private static int parseHex(String hex) throws IllegalArgumentException { if(hex.startsWith("#")) hex = hex.substring(1); - + int alpha = 255; int red = 0; int green = 0; int blue = 0; - + try { if(hex.length() == 8) { alpha = Integer.parseInt(hex.substring(0, 2), 16); hex = hex.substring(2); } - + if(hex.length() != 6) throw new IllegalArgumentException("Invalid color channels, required format AARRGGBB or RRGGBB"); - + red = Integer.parseInt(hex.substring(0, 2), 16); green = Integer.parseInt(hex.substring(2, 4), 16); blue = Integer.parseInt(hex.substring(4, 6), 16); - + return ColorUtil.argbValidated(alpha, red, green, blue); } catch(NumberFormatException e) { throw new IllegalArgumentException("Failed to parse hex color", e); } } - + private static int parseChannels(String alpha, String red, String green, String blue) throws IllegalArgumentException { try { int a = Integer.decode(alpha); int r = Integer.decode(red); int g = Integer.decode(green); int b = Integer.decode(blue); - + return ColorUtil.argbValidated(a, r, g, b); } catch(NumberFormatException e) { throw new IllegalArgumentException("Invalid channel value", e); } } - + public int getColor() { return argb; } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java index 1d823f06c..bbdf98876 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/ImageLibraryPackConfigTemplate.java @@ -10,12 +10,12 @@ import com.dfsek.terra.api.properties.Properties; public class ImageLibraryPackConfigTemplate implements ConfigTemplate, Properties { // TODO - These would be better as plugin wide config parameters in config.yml - + @Value("images.cache.load-on-use") @Description("If set to true, images will load into memory upon use rather than on pack load.") @Default private boolean loadOnUse = false; - + @Value("images.cache.timeout") @Description("How many seconds to keep images loaded in the image cache for. " + "If set to a number greater than 0, images will be removed from memory if not used after the timeout, otherwise images " + @@ -24,15 +24,15 @@ public class ImageLibraryPackConfigTemplate implements ConfigTemplate, Propertie " period of time for extra processing time required to perform cache lookups.") @Default private int cacheTimeout = 0; - + public boolean loadOnUse() { return loadOnUse; } - + public boolean unloadOnTimeout() { return cacheTimeout > 0; } - + public int getCacheTimeout() { return cacheTimeout; } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/ConstantColorSamplerTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/ConstantColorSamplerTemplate.java index c2d940480..63e624cfa 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/ConstantColorSamplerTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/ConstantColorSamplerTemplate.java @@ -8,10 +8,10 @@ import com.dfsek.terra.addons.image.config.ColorLoader.ColorString; public class ConstantColorSamplerTemplate implements ObjectTemplate { - + @Value("color") private ColorString color; - + @Override public ColorSampler get() { return ((x, z) -> color.getColor()); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/ImageColorSamplerTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/ImageColorSamplerTemplate.java index 2053b53fe..bb17a3da2 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/ImageColorSamplerTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/ImageColorSamplerTemplate.java @@ -10,12 +10,12 @@ import com.dfsek.terra.addons.image.image.Image; public abstract class ImageColorSamplerTemplate implements ObjectTemplate { - + @Value("image") protected Image image; - + @Value("align") @Default protected Alignment alignment = Alignment.NONE; - + } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/SingleImageColorSamplerTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/SingleImageColorSamplerTemplate.java index 20d8f161f..dd31a3d67 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/SingleImageColorSamplerTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/SingleImageColorSamplerTemplate.java @@ -9,7 +9,7 @@ import com.dfsek.terra.addons.image.colorsampler.image.SingleImageColorSampler; public class SingleImageColorSamplerTemplate extends ImageColorSamplerTemplate { @Value("outside-sampler") private ColorSampler fallback; - + @Override public ColorSampler get() { return new SingleImageColorSampler(image, fallback, alignment); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/TileImageColorSamplerTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/TileImageColorSamplerTemplate.java index 5fa89676e..72421cb58 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/TileImageColorSamplerTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/image/TileImageColorSamplerTemplate.java @@ -5,7 +5,7 @@ import com.dfsek.terra.addons.image.colorsampler.image.TileImageColorSampler; public class TileImageColorSamplerTemplate extends ImageColorSamplerTemplate { - + @Override public ColorSampler get() { return new TileImageColorSampler(image, alignment); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/MutateColorSamplerTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/MutateColorSamplerTemplate.java index 532963837..e34bcad95 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/MutateColorSamplerTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/MutateColorSamplerTemplate.java @@ -7,7 +7,7 @@ import com.dfsek.terra.addons.image.colorsampler.ColorSampler; public abstract class MutateColorSamplerTemplate implements ObjectTemplate { - + @Value("color-sampler") protected ColorSampler sampler; } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/RotateColorSamplerTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/RotateColorSamplerTemplate.java index 662735a54..41503d18d 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/RotateColorSamplerTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/RotateColorSamplerTemplate.java @@ -7,10 +7,10 @@ import com.dfsek.terra.addons.image.colorsampler.mutate.RotateColorSampler; public class RotateColorSamplerTemplate extends MutateColorSamplerTemplate { - + @Value("angle") private double degrees; - + @Override public ColorSampler get() { return new RotateColorSampler(sampler, degrees); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/TranslateColorSamplerTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/TranslateColorSamplerTemplate.java index fa310c378..0f21debc5 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/TranslateColorSamplerTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/colorsampler/mutate/TranslateColorSamplerTemplate.java @@ -7,13 +7,13 @@ import com.dfsek.terra.addons.image.colorsampler.mutate.TranslateColorSampler; public class TranslateColorSamplerTemplate extends MutateColorSamplerTemplate { - + @Value("x") private int translateX; - + @Value("z") private int translateZ; - + @Override public ColorSampler get() { return new TranslateColorSampler(sampler, translateX, translateZ); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/converter/ClosestColorConverterTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/converter/ClosestColorConverterTemplate.java index 61aca4b79..94cc36bc0 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/converter/ClosestColorConverterTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/converter/ClosestColorConverterTemplate.java @@ -6,9 +6,9 @@ import com.dfsek.terra.addons.image.converter.mapping.ColorMapping; public abstract class ClosestColorConverterTemplate implements ColorConverterTemplate { - + protected abstract ColorMapping getMapping(); - + @Override public ColorConverter get() { return new ClosestMatchColorConverter(getMapping().get()); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/converter/ExactColorConverterTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/converter/ExactColorConverterTemplate.java index 17d2fd37d..58c2deb8e 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/converter/ExactColorConverterTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/converter/ExactColorConverterTemplate.java @@ -6,13 +6,13 @@ import com.dfsek.terra.addons.image.converter.mapping.ColorMapping; public abstract class ExactColorConverterTemplate implements ColorConverterTemplate { - + protected abstract ColorMapping getMapping(); - + protected abstract T getFallback(); - + protected abstract boolean ignoreAlpha(); - + @Override public ColorConverter get() { return new ExactColorConverter(getMapping().get(), getFallback(), ignoreAlpha()); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java index ac3ea4800..9283aa4b7 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java @@ -31,7 +31,7 @@ record ImageCache(LoadingCache cache) implements Properties { images = new ImageCache(cacheBuilder.build(s -> loadImage(s, files))); pack.getContext().put(images); } else images = pack.getContext().get(ImageCache.class); - + if(config.loadOnUse()) { if(config.unloadOnTimeout()) { // Grab directly from cache if images are to unload on timeout return new SuppliedImage(() -> images.cache.get(path)); @@ -41,10 +41,10 @@ record ImageCache(LoadingCache cache) implements Properties { return new SuppliedImage(lazyImage::value); } } - + return images.cache.get(path); } - + private static Image loadImage(String path, Loader files) throws IOException { try { return new BufferedImageWrapper(ImageIO.read(files.get(path))); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageTemplate.java index b94096871..dc33bf13c 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageTemplate.java @@ -11,17 +11,17 @@ import com.dfsek.terra.api.config.Loader; public class ImageTemplate implements ObjectTemplate { - + private final Loader files; private final ConfigPack pack; @Value("path") private String path; - + public ImageTemplate(Loader files, ConfigPack pack) { this.files = files; this.pack = pack; } - + @Override public Image get() { try { diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/StitchedImageTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/StitchedImageTemplate.java index e85537d09..3a834a218 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/StitchedImageTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/StitchedImageTemplate.java @@ -15,7 +15,7 @@ import com.dfsek.terra.api.config.Loader; public class StitchedImageTemplate implements ObjectTemplate, ValidatedConfigTemplate { - + private final Loader files; private final ConfigPack pack; @Value("path-format") @@ -27,12 +27,12 @@ public class StitchedImageTemplate implements ObjectTemplate, ValidatedCo @Value("zero-indexed") @Default private boolean zeroIndexed = false; - + public StitchedImageTemplate(Loader files, ConfigPack pack) { this.files = files; this.pack = pack; } - + @Override public Image get() { Image[][] grid = new Image[rows][cols]; @@ -47,7 +47,7 @@ public class StitchedImageTemplate implements ObjectTemplate, ValidatedCo } return new StitchedImage(grid, zeroIndexed); } - + private String getFormattedPath(int row, int column) { if(!zeroIndexed) { row++; @@ -55,7 +55,7 @@ public class StitchedImageTemplate implements ObjectTemplate, ValidatedCo } return path.replaceFirst("\\{row}", String.valueOf(row)).replaceFirst("\\{column}", String.valueOf(column)); } - + @Override public boolean validate() throws ValidationException { if(!path.contains("{row}")) diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/noisesampler/ChannelNoiseSamplerTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/noisesampler/ChannelNoiseSamplerTemplate.java index 4aac073d4..b6631a149 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/noisesampler/ChannelNoiseSamplerTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/noisesampler/ChannelNoiseSamplerTemplate.java @@ -11,20 +11,20 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class ChannelNoiseSamplerTemplate implements ObjectTemplate { - + @Value("color-sampler") private ColorSampler colorSampler; - + @Value("channel") private Channel channel; - + /* * If the channel should be normalized to range [-1, 1] or not */ @Value("normalize") @Default private boolean normalize = true; - + /* * Whether to multiply color channels by the alpha channel or not. If users * are expecting pixel transparency to reduce the output value then this should @@ -33,7 +33,7 @@ public class ChannelNoiseSamplerTemplate implements ObjectTemplate @Value("premultiply") @Default private boolean premultiply = false; - + @Override public NoiseSampler get() { return new ChannelNoiseSampler(colorSampler, channel, normalize, premultiply); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/noisesampler/DistanceTransformNoiseSamplerTemplate.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/noisesampler/DistanceTransformNoiseSamplerTemplate.java index 012b5b8bb..222ff48fd 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/noisesampler/DistanceTransformNoiseSamplerTemplate.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/noisesampler/DistanceTransformNoiseSamplerTemplate.java @@ -13,10 +13,10 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class DistanceTransformNoiseSamplerTemplate implements ObjectTemplate { - + @Value("image") private Image image; - + /** * The threshold value applied to the channel specified in the 'channel' parameter that splits * the image into a binary image. This parameter is only used for cost functions that utilize @@ -25,7 +25,7 @@ public class DistanceTransformNoiseSamplerTemplate implements ObjectTemplate implements ColorConverter { - + private final Map map; - + private final Integer[] colors; - + public ClosestMatchColorConverter(Map map) { this.map = map; this.colors = map.keySet().toArray(new Integer[0]); } - + @Override public T apply(int color) { int closest = 0; @@ -33,7 +33,7 @@ public class ClosestMatchColorConverter implements ColorConverter { } return map.get(closest); } - + @Override public Iterable getEntries() { return map.values(); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/ColorConverter.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/ColorConverter.java index 5f76291d8..89dae3358 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/ColorConverter.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/ColorConverter.java @@ -1,8 +1,8 @@ package com.dfsek.terra.addons.image.converter; public interface ColorConverter { - + T apply(int color); - + Iterable getEntries(); } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/ExactColorConverter.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/ExactColorConverter.java index 054e9397f..8849eae83 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/ExactColorConverter.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/ExactColorConverter.java @@ -10,11 +10,11 @@ import com.dfsek.terra.addons.image.util.MapUtil; public class ExactColorConverter implements ColorConverter { private final Map map; - + private final T fallback; - + private final boolean ignoreAlpha; - + public ExactColorConverter(Map map, T fallback, boolean ignoreAlpha) { if(ignoreAlpha) { map = MapUtil.mapKeys(map, ColorUtil::zeroAlpha); @@ -23,7 +23,7 @@ public class ExactColorConverter implements ColorConverter { this.fallback = fallback; this.ignoreAlpha = ignoreAlpha; } - + @Override public T apply(int color) { if(ignoreAlpha) { @@ -32,7 +32,7 @@ public class ExactColorConverter implements ColorConverter { T lookup = map.get(color); return lookup != null ? lookup : fallback; } - + @Override public Iterable getEntries() { Set entries = new HashSet<>(map.values()); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/mapping/BiomeDefinedColorMapping.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/mapping/BiomeDefinedColorMapping.java index f12d9782c..d0220e58b 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/mapping/BiomeDefinedColorMapping.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/converter/mapping/BiomeDefinedColorMapping.java @@ -12,16 +12,16 @@ import com.dfsek.terra.api.world.biome.Biome; public class BiomeDefinedColorMapping implements ColorMapping { - + Registry biomeRegistry; - + Function converter; - + public BiomeDefinedColorMapping(Registry biomeRegistry, Function converter) { this.biomeRegistry = biomeRegistry; this.converter = converter; } - + @Override public Map get() { Map colorMap = new HashSet<>(biomeRegistry.entries()).stream().collect(Collectors.toMap(b -> b, Biome::getColor)); @@ -31,7 +31,7 @@ public class BiomeDefinedColorMapping implements ColorMapping { output.put(color, biome); } else { throw new IllegalArgumentException( - String.format("Biome %s has same color as %s: %x", biome.getID(), output.get(color).getID(), color)); + String.format("Biome %s has same color as %s: %x", biome.getID(), output.get(color).getID(), color)); } })); return output.entrySet().stream().collect(Collectors.toMap(Entry::getKey, e -> converter.apply(e.getValue()))); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/BufferedImageWrapper.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/BufferedImageWrapper.java index 16df31a74..e9f33323b 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/BufferedImageWrapper.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/BufferedImageWrapper.java @@ -4,23 +4,23 @@ import java.awt.image.BufferedImage; public class BufferedImageWrapper implements Image { - + private final BufferedImage image; - + public BufferedImageWrapper(BufferedImage image) { this.image = image; } - + @Override public int getRGB(int x, int y) { return image.getRGB(x, y); } - + @Override public int getWidth() { return image.getWidth(); } - + @Override public int getHeight() { return image.getHeight(); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/Image.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/Image.java index f8eb83793..57e9cf7d5 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/Image.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/Image.java @@ -2,8 +2,8 @@ package com.dfsek.terra.addons.image.image; public interface Image { int getRGB(int x, int y); - + int getWidth(); - + int getHeight(); } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/StitchedImage.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/StitchedImage.java index 1507cf432..7db2be928 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/StitchedImage.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/StitchedImage.java @@ -1,13 +1,13 @@ package com.dfsek.terra.addons.image.image; public class StitchedImage implements Image { - + private final Image[][] images; - + private final int[] rowOffsets, columnOffsets; - + private final int width, height; - + public StitchedImage(Image[][] images, boolean zeroIndexed) throws IllegalArgumentException { int width = 0; int height = 0; @@ -33,12 +33,12 @@ public class StitchedImage implements Image { throw new IllegalArgumentException("Image widths in column " + (i + (zeroIndexed ? 0 : 1)) + " do not match"); } } - + this.width = width; this.height = height; this.images = images; } - + private int getColumn(int x) { for(int i = columnOffsets.length - 1; i > 0; i--) { if(x >= columnOffsets[i]) @@ -46,7 +46,7 @@ public class StitchedImage implements Image { } return 0; } - + private int getRow(int y) { for(int i = rowOffsets.length - 1; i > 0; i--) { if(y >= rowOffsets[i]) @@ -54,19 +54,19 @@ public class StitchedImage implements Image { } return 0; } - + @Override public int getRGB(int x, int y) { int row = getRow(y); int column = getColumn(x); return images[row][column].getRGB(x - columnOffsets[column], y - rowOffsets[row]); } - + @Override public int getWidth() { return width; } - + @Override public int getHeight() { return height; diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/SuppliedImage.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/SuppliedImage.java index f3e398c50..1bfd61317 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/SuppliedImage.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/image/SuppliedImage.java @@ -4,23 +4,23 @@ import java.util.function.Supplier; public class SuppliedImage implements Image { - + private final Supplier imageSupplier; - + public SuppliedImage(Supplier imageSupplier) { this.imageSupplier = imageSupplier; } - + @Override public int getRGB(int x, int y) { return imageSupplier.get().getRGB(x, y); } - + @Override public int getWidth() { return imageSupplier.get().getWidth(); } - + @Override public int getHeight() { return imageSupplier.get().getHeight(); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/noisesampler/ChannelNoiseSampler.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/noisesampler/ChannelNoiseSampler.java index 52d977591..43410d714 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/noisesampler/ChannelNoiseSampler.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/noisesampler/ChannelNoiseSampler.java @@ -9,22 +9,22 @@ import static com.dfsek.terra.addons.image.util.MathUtil.lerp; public class ChannelNoiseSampler implements NoiseSampler { - + private final ColorSampler colorSampler; - + private final Channel channel; - + private final boolean normalize; - + private final boolean premultiply; - + public ChannelNoiseSampler(ColorSampler colorSampler, Channel channel, boolean normalize, boolean premultiply) { this.colorSampler = colorSampler; this.channel = channel; this.normalize = normalize; this.premultiply = premultiply; } - + @Override public double noise(long seed, double x, double y) { int sample = colorSampler.apply((int) x, (int) y); @@ -32,7 +32,7 @@ public class ChannelNoiseSampler implements NoiseSampler { double channelValue = channel.from(premultiplied); return normalize ? lerp(channelValue, 0, -1, 255, 1) : channelValue; } - + @Override public double noise(long seed, double x, double y, double z) { return noise(seed, x, z); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java index 4f74ca592..62d93710c 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/operator/DistanceTransform.java @@ -15,7 +15,7 @@ import static com.dfsek.terra.addons.image.util.MathUtil.lerp; * by Pedro F. Felzenszwalb and Daniel P. Huttenlocher. */ public class DistanceTransform { - + private static final double MAX_DISTANCE_CAP = 10_000_000; // Arbitrarily large value, doubtful someone would private final double[][] distances; /** @@ -26,7 +26,7 @@ public class DistanceTransform { * Min and max distances of the distance computation. These may change after {@link #normalize(Normalization)} calls. */ private double minDistance, maxDistance; - + // ever use an image large enough to exceed this. public DistanceTransform(Image image, Channel channel, int threshold, boolean clampToMaxEdgeDistance, CostFunction costFunction, boolean invertThreshold) { @@ -37,7 +37,7 @@ public class DistanceTransform { binaryImage[x][y] = ColorUtil.getChannel(image.getRGB(x, y), channel) > threshold ^ invertThreshold; } } - + // Get edges of binary image boolean[][] binaryImageEdge = new boolean[image.getWidth()][image.getHeight()]; for(int x = 0; x < image.getWidth(); x++) { @@ -52,7 +52,7 @@ public class DistanceTransform { y < image.getHeight() - 1 && !binaryImage[x][y + 1]; } } - + double[][] function = new double[image.getWidth()][image.getHeight()]; for(int x = 0; x < image.getWidth(); x++) { for(int y = 0; y < image.getHeight(); y++) { @@ -63,9 +63,9 @@ public class DistanceTransform { }; } } - + distances = calculateDistance2D(function); - + if(costFunction == CostFunction.ThresholdEdgeSigned) { for(int x = 0; x < image.getWidth(); x++) { for(int y = 0; y < image.getHeight(); y++) { @@ -73,9 +73,9 @@ public class DistanceTransform { } } } - + if(clampToMaxEdgeDistance) { - // Find largest value on the edge of the image + // Find the largest value on the edge of the image double max = Double.NEGATIVE_INFINITY; for(int x = 0; x < image.getWidth(); x++) { max = Math.max(max, distances[x][0]); @@ -92,13 +92,13 @@ public class DistanceTransform { } } } - + this.width = image.getWidth(); this.height = image.getHeight(); - + setOutputRange(); } - + private double[][] calculateDistance2D(double[][] f) { double[][] d = new double[f.length][f[0].length]; // Distance pass for each column @@ -117,7 +117,7 @@ public class DistanceTransform { } return d; } - + private double[] calculateDistance1D(double[] f) { double[] d = new double[f.length]; int[] v = new int[f.length]; @@ -128,7 +128,7 @@ public class DistanceTransform { z[1] = Integer.MAX_VALUE; for(int q = 1; q <= f.length - 1; q++) { double fqPlusQ2 = (f[q] + Math.pow(q, 2)); - double twoQ = 2*q; + double twoQ = 2 * q; double s = (fqPlusQ2 - (f[v[k]] + Math.pow(v[k], 2))) / (twoQ - 2 * v[k]); while(s <= z[k]) { k--; @@ -139,7 +139,7 @@ public class DistanceTransform { z[k] = s; z[k + 1] = Integer.MAX_VALUE; } - + k = 0; for(int q = 0; q <= f.length - 1; q++) { while(z[k + 1] < q) @@ -148,7 +148,7 @@ public class DistanceTransform { } return d; } - + /** * Redistributes the stored distance computation according to the provided {@link Normalization} method. */ @@ -178,7 +178,7 @@ public class DistanceTransform { } setOutputRange(); } - + private void setOutputRange() { double minDistance = Double.POSITIVE_INFINITY; double maxDistance = Double.NEGATIVE_INFINITY; @@ -191,26 +191,26 @@ public class DistanceTransform { this.minDistance = minDistance; this.maxDistance = maxDistance; } - + public enum CostFunction { Channel, Threshold, ThresholdEdge, ThresholdEdgeSigned, } - - + + public enum Normalization { /** * Return the raw calculated distances. */ None, - + /** * Redistribute the output values to fit in the range [-1, 1] */ Linear, - + /** * Redistributes smoothly to the range [-1, 1], such that areas where distance = 0 stay 0. * This is only really applicable to signed distance calculations, and will fall back to linear @@ -218,23 +218,23 @@ public class DistanceTransform { */ SmoothPreserveZero, } - - + + public static class Noise implements NoiseSampler { - + private final DistanceTransform transform; - + public Noise(DistanceTransform transform, Normalization normalization) { this.transform = transform; transform.normalize(normalization); } - + @Override public double noise(long seed, double x, double y) { if(x < 0 || y < 0 || x >= transform.width || y >= transform.height) return transform.minDistance; return transform.distances[(int) Math.floor(x)][(int) Math.floor(y)]; } - + @Override public double noise(long seed, double x, double y, double z) { return noise(seed, x, z); diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/ColorUtil.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/ColorUtil.java index dc7316d8c..832915c4b 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/ColorUtil.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/ColorUtil.java @@ -4,15 +4,15 @@ package com.dfsek.terra.addons.image.util; * Utility class for manipulating 8 bit ARGB colors */ public class ColorUtil { - + private ColorUtil() { } - + public static int distance(int a, int b) { return Math.abs(getRed(a) - getRed(b)) + Math.abs(getGreen(a) - getGreen(b)) + Math.abs(getBlue(a) - getBlue(b)); } - + /** * Returns the red channel value of a given ARGB color value. * @@ -23,7 +23,7 @@ public class ColorUtil { public static int getRed(int argb) { return argb >> 16 & 255; } - + /** * Returns the green channel value of a given ARGB color value. * @@ -34,7 +34,7 @@ public class ColorUtil { public static int getGreen(int argb) { return argb >> 8 & 255; } - + /** * Returns the blue channel value of a given ARGB color value. * @@ -45,7 +45,7 @@ public class ColorUtil { public static int getBlue(int argb) { return argb & 255; } - + /** * Returns the alpha channel value of a given ARGB color value. * @@ -56,7 +56,7 @@ public class ColorUtil { public static int getAlpha(int argb) { return argb >> 24 & 255; } - + /** * Returns the grayscale value of a given ARGB color value. * @@ -67,7 +67,7 @@ public class ColorUtil { public static int getGrayscale(int argb) { return (getRed(argb) + getGreen(argb) + getBlue(argb)) / 3; } - + /** * Returns the value of the specified channel for a given ARGB color value. * @@ -79,7 +79,7 @@ public class ColorUtil { public static int getChannel(int argb, Channel channel) { return channel.from(argb); } - + /** * Sets the red channel value of a given ARGB color value to zero. * @@ -90,7 +90,7 @@ public class ColorUtil { public static int zeroRed(int argb) { return argb & ~0x00FF0000; } - + /** * Sets the green channel value of a given ARGB color value to zero. * @@ -101,7 +101,7 @@ public class ColorUtil { public static int zeroGreen(int argb) { return argb & ~0x0000FF00; } - + /** * Sets the blue channel value of a given ARGB color value to zero. * @@ -112,7 +112,7 @@ public class ColorUtil { public static int zeroBlue(int argb) { return argb & ~0x000000FF; } - + /** * Sets the alpha channel value of a given ARGB color value to zero. * This is the same as setting the color to fully transparent. @@ -124,7 +124,7 @@ public class ColorUtil { public static int zeroAlpha(int argb) { return argb & ~0xFF000000; } - + /** * Sets the color channels of a given ARGB color value to zero. * This is the same as setting the color to black, while preserving the alpha. @@ -136,7 +136,7 @@ public class ColorUtil { public static int zeroGrayscale(int argb) { return argb & ~0x00FFFFFF; } - + /** * Sets the specified channel value of a given ARGB color value to zero. * @@ -148,7 +148,7 @@ public class ColorUtil { public static int zeroChannel(int argb, Channel channel) { return channel.zero(argb); } - + /** * Multiply the RGB channels of a given ARGB color value by its alpha channel value. * @@ -163,7 +163,7 @@ public class ColorUtil { int blue = (getBlue(argb) * alpha + 127) / 255; return argb(alpha, red, green, blue); } - + /** * Returns an ARGB color value with the specified values for alpha, red, green, and blue channels. * @@ -177,7 +177,7 @@ public class ColorUtil { public static int argb(int alpha, int red, int green, int blue) { return argbAlpha(alpha) | argbRed(red) | argbGreen(green) | argbBlue(blue); } - + /** * Returns an ARGB color value with the specified values for alpha, red, green, and blue channels, * after validating that each channel value is in the range 0-255. @@ -199,7 +199,7 @@ public class ColorUtil { ) throw new IllegalArgumentException("Channel values must be in range 0-255"); return argb(alpha, red, green, blue); } - + /** * Returns the ARGB color value with the specified alpha channel value and zero * for the red, green, and blue channels. @@ -209,7 +209,7 @@ public class ColorUtil { * @return the resulting ARGB color value */ public static int argbAlpha(int alpha) { return alpha << 24; } - + /** * Returns the ARGB color value with the specified red channel value and zero * for the alpha, green, and blue channels. @@ -219,7 +219,7 @@ public class ColorUtil { * @return the resulting ARGB color value */ public static int argbRed(int red) { return red << 16; } - + /** * Returns the ARGB color value with the specified red channel value and zero * for the alpha, red, and blue channels. @@ -229,7 +229,7 @@ public class ColorUtil { * @return the resulting ARGB color value */ public static int argbGreen(int green) { return green << 8; } - + /** * Returns the ARGB color value with the specified blue channel value and zero * for the alpha, red, and green channels. @@ -239,7 +239,7 @@ public class ColorUtil { * @return the resulting ARGB color value */ public static int argbBlue(int blue) { return blue; } - + /** * Returns an ARGB color value with the specified grayscale value for all four channels. * @@ -248,19 +248,19 @@ public class ColorUtil { * @return the resulting ARGB color value with the specified grayscale value for all four channels */ public static int argbGrayscale(int value) { return argb(value, value, value, value); } - + public enum Channel { RED { @Override public int from(int argb) { return getRed(argb); } - + @Override public int zero(int argb) { return zeroRed(argb); } - + @Override public int argb(int value) { return argbRed(value); @@ -271,12 +271,12 @@ public class ColorUtil { public int from(int argb) { return getGreen(argb); } - + @Override public int zero(int argb) { return zeroGreen(argb); } - + @Override public int argb(int value) { return argbGreen(value); @@ -287,12 +287,12 @@ public class ColorUtil { public int from(int argb) { return getBlue(argb); } - + @Override public int zero(int argb) { return zeroBlue(argb); } - + @Override public int argb(int value) { return argbBlue(value); @@ -303,12 +303,12 @@ public class ColorUtil { public int from(int argb) { return getGrayscale(argb); } - + @Override public int zero(int argb) { return zeroGrayscale(argb); } - + @Override public int argb(int value) { return argbAlpha(value); @@ -319,22 +319,22 @@ public class ColorUtil { public int from(int argb) { return getAlpha(argb); } - + @Override public int zero(int argb) { return zeroAlpha(argb); } - + @Override public int argb(int value) { return argbAlpha(value); } }; - + public abstract int from(int argb); - + public abstract int zero(int argb); - + public abstract int argb(int value); } } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MapUtil.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MapUtil.java index 01b730895..7916b8827 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MapUtil.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MapUtil.java @@ -7,19 +7,19 @@ import java.util.stream.Collectors; public class MapUtil { - + private MapUtil() { } - + /** * Utility method for applying transformations on a map's keys. */ public static Map mapKeys(Map map, Function mappingFunction) { return map - .entrySet() - .stream() - .collect(Collectors.toMap( - e -> mappingFunction.apply(e.getKey()), - Entry::getValue - )); + .entrySet() + .stream() + .collect(Collectors.toMap( + e -> mappingFunction.apply(e.getKey()), + Entry::getValue + )); } } diff --git a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MathUtil.java b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MathUtil.java index ea677eac8..95ab11d99 100644 --- a/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MathUtil.java +++ b/common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/util/MathUtil.java @@ -2,7 +2,7 @@ package com.dfsek.terra.addons.image.util; public class MathUtil { private MathUtil() { } - + public static double lerp(double x, double x1, double y1, double x2, double y2) { return (((y1 - y2) * (x - x1)) / (x1 - x2)) + y1; } diff --git a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocator.java b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocator.java index 615c9ea22..36cb82ec9 100644 --- a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocator.java +++ b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocator.java @@ -11,13 +11,13 @@ import com.dfsek.terra.api.world.chunk.generation.util.Column; public class SlantLocator implements Locator { - + private final DoublePredicate predicate; - + public SlantLocator(DoublePredicate predicate) { this.predicate = predicate; } - + @Override public BinaryColumn getSuitableCoordinates(Column column) { return column.newBinaryColumn(y -> { diff --git a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorAddon.java b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorAddon.java index 9391b0474..a3efecf42 100644 --- a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorAddon.java +++ b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorAddon.java @@ -15,23 +15,23 @@ import com.dfsek.terra.api.util.reflection.TypeKey; public class SlantLocatorAddon implements AddonInitializer { - + public static final TypeKey>> LOCATOR_TOKEN = new TypeKey<>() { }; - + @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .priority(1) - .then(event -> event.getPack().getOrCreateRegistry(LOCATOR_TOKEN).register(addon.key("SLANT"), SlantLocatorTemplate::new)) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .priority(1) + .then(event -> event.getPack().getOrCreateRegistry(LOCATOR_TOKEN).register(addon.key("SLANT"), SlantLocatorTemplate::new)) + .failThrough(); } } diff --git a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java index bcfb8e330..48d255713 100644 --- a/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java +++ b/common/addons/locator-slant-noise-3d/src/main/java/com/dfsek/terra/addon/feature/locator/slant/SlantLocatorTemplate.java @@ -10,10 +10,10 @@ import com.dfsek.terra.api.structure.feature.Locator; public class SlantLocatorTemplate implements ObjectTemplate { - + @Value("condition") private @Meta DoublePredicate predicate; - + @Override public Locator get() { return new SlantLocator(predicate); diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddon.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddon.java index 9175027ec..b3c19d872 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddon.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddon.java @@ -29,34 +29,34 @@ public class ManifestAddon implements BaseAddon { private final List initializers; @Inject private Platform platform; - + public ManifestAddon(AddonManifest manifest, List initializers) { this.manifest = manifest; this.initializers = initializers; } - + public AddonManifest getManifest() { return manifest; } - + @Override public String getID() { return manifest.getID(); } - + public void initialize() { Injector addonInjector = Injector.get(this); addonInjector.addExplicitTarget(BaseAddon.class); - + Injector platformInjector = Injector.get(platform); platformInjector.addExplicitTarget(Platform.class); - + logger.debug("Initializing addon {}", getID()); - + initializers.forEach(initializer -> { Injector loggerInjector = Injector.get(LoggerFactory.getLogger(initializer.getClass())); loggerInjector.addExplicitTarget(Logger.class); - + logger.debug("Invoking entry point {}", initializer.getClass()); addonInjector.inject(initializer); platformInjector.inject(initializer); @@ -64,12 +64,12 @@ public class ManifestAddon implements BaseAddon { initializer.initialize(); }); } - + @Override public Map getDependencies() { return manifest.getDependencies(); } - + @Override public Version getVersion() { return manifest.getVersion(); diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonClassLoader.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonClassLoader.java index a0095f374..109142a98 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonClassLoader.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonClassLoader.java @@ -15,7 +15,7 @@ public class ManifestAddonClassLoader extends URLClassLoader { static { ClassLoader.registerAsParallelCapable(); } - + public ManifestAddonClassLoader(URL[] urls, ClassLoader parent) { super(urls, parent); } diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonLoader.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonLoader.java index 50d571f9f..8055c2101 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonLoader.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/ManifestAddonLoader.java @@ -44,34 +44,34 @@ import com.dfsek.terra.api.addon.bootstrap.BootstrapBaseAddon; public class ManifestAddonLoader implements BootstrapBaseAddon { private static final Logger logger = LoggerFactory.getLogger(ManifestAddonLoader.class); private static final Version VERSION = Versions.getVersion(1, 0, 0); - + private final ConfigLoader manifestLoader = new ConfigLoader() - .registerLoader(Version.class, new VersionLoader()) - .registerLoader(VersionRange.class, new VersionRangeLoader()) - .registerLoader(WebsiteConfig.class, WebsiteConfig::new); - + .registerLoader(Version.class, new VersionLoader()) + .registerLoader(VersionRange.class, new VersionRangeLoader()) + .registerLoader(WebsiteConfig.class, WebsiteConfig::new); + public ManifestAddon loadAddon(Path addonPath, ClassLoader loader) { try(JarFile jar = new JarFile(addonPath.toFile())) { logger.debug("Loading addon from JAR {}", addonPath); - + JarEntry manifestEntry = jar.getJarEntry("terra.addon.yml"); if(manifestEntry == null) { throw new ManifestNotPresentException("Addon " + addonPath + " does not contain addon manifest."); } - - + + //noinspection NestedTryStatement try { AddonManifest manifest = manifestLoader.load(new AddonManifest(), - new YamlConfiguration(jar.getInputStream(manifestEntry), - "terra.addon.yml")); - + new YamlConfiguration(jar.getInputStream(manifestEntry), + "terra.addon.yml")); + logger.debug("Loading addon {}@{}", manifest.getID(), manifest.getVersion().getFormatted()); - + if(manifest.getSchemaVersion() != 1) { throw new AddonException("Addon " + manifest.getID() + " has unknown schema version: " + manifest.getSchemaVersion()); } - + List initializers = manifest.getEntryPoints().stream().map(entryPoint -> { try { Object in = loader.loadClass(entryPoint).getConstructor().newInstance(); @@ -87,9 +87,9 @@ public class ManifestAddonLoader implements BootstrapBaseAddon { throw new AddonException(String.format("Entry point %s not found in JAR.", entryPoint), e); } }).collect(Collectors.toList()); - + return new ManifestAddon(manifest, initializers); - + } catch(LoadException e) { throw new ManifestException("Failed to load addon manifest", e); } @@ -97,19 +97,19 @@ public class ManifestAddonLoader implements BootstrapBaseAddon { throw new AddonException("Failed to load addon from JAR " + addonPath, e); } } - + @Override public Iterable loadAddons(Path addonsFolder, BootstrapAddonClassLoader parent) { logger.debug("Loading addons..."); - + try(Stream files = Files.walk(addonsFolder, 1, FileVisitOption.FOLLOW_LINKS)) { List addons = files - .filter(path -> path.toFile().isFile()) - .filter(path -> path.toFile().canRead()) - .filter(path -> !path.getFileName().startsWith(".")) // ignore hidden files. - .filter(path -> path.toString().endsWith(".jar")) - .toList(); - + .filter(path -> path.toFile().isFile()) + .filter(path -> path.toFile().canRead()) + .filter(path -> !path.getFileName().startsWith(".")) // ignore hidden files. + .filter(path -> path.toString().endsWith(".jar")) + .toList(); + addons.stream().map(path -> { try { return path.toUri().toURL(); @@ -117,20 +117,20 @@ public class ManifestAddonLoader implements BootstrapBaseAddon { throw new UncheckedIOException(e); } }).forEach(parent::addURL); - + return addons.stream() - .map(jar -> loadAddon(jar, parent)) - .collect(Collectors.toList()); + .map(jar -> loadAddon(jar, parent)) + .collect(Collectors.toList()); } catch(IOException e) { throw new UncheckedIOException(e); } } - + @Override public String getID() { return "MANIFEST"; } - + @Override public Version getVersion() { return VERSION; diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/AddonManifest.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/AddonManifest.java index 4739bb145..97cd8332f 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/AddonManifest.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/AddonManifest.java @@ -24,60 +24,60 @@ import com.dfsek.terra.api.registry.key.StringIdentifiable; public class AddonManifest implements ConfigTemplate, StringIdentifiable { @Value("schema-version") private int schemaVersion; - + @Value("id") private String id; - + @Value("version") private Version version; - + @Value("license") private String license; - + @Value("contributors") @Default private List contributors = Collections.emptyList(); - + @Value("entrypoints") private List entryPoints; - + @Value("depends") @Default private Map dependencies = Collections.emptyMap(); - + @Value("website") @Default private WebsiteConfig website; - + @Override public String getID() { return id; } - + public int getSchemaVersion() { return schemaVersion; } - + public Version getVersion() { return version; } - + public List getContributors() { return contributors; } - + public List getEntryPoints() { return entryPoints; } - + public String getLicense() { return license; } - + public WebsiteConfig getWebsite() { return website; } - + public Map getDependencies() { return dependencies; } diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/WebsiteConfig.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/WebsiteConfig.java index 500d753dc..d648223df 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/WebsiteConfig.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/config/WebsiteConfig.java @@ -14,25 +14,25 @@ import com.dfsek.tectonic.api.config.template.object.ObjectTemplate; public class WebsiteConfig implements ObjectTemplate { @Value("issues") private String issues; - + @Value("source") private String source; - + @Value("docs") private String docs; - + public String getDocs() { return docs; } - + public String getIssues() { return issues; } - + public String getSource() { return source; } - + @Override public WebsiteConfig get() { return this; diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/AddonException.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/AddonException.java index ff9b5187f..9db7b67bf 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/AddonException.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/AddonException.java @@ -13,11 +13,11 @@ import java.io.Serial; public class AddonException extends RuntimeException { @Serial private static final long serialVersionUID = -4201912399458420090L; - + public AddonException(String message) { super(message); } - + public AddonException(String message, Throwable cause) { super(message, cause); } diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestException.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestException.java index d0215fc82..e8d8ad5c7 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestException.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestException.java @@ -13,11 +13,11 @@ import java.io.Serial; public class ManifestException extends AddonException { @Serial private static final long serialVersionUID = -2458077663176544645L; - + public ManifestException(String message) { super(message); } - + public ManifestException(String message, Throwable cause) { super(message, cause); } diff --git a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestNotPresentException.java b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestNotPresentException.java index 3a197467c..77b579d12 100644 --- a/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestNotPresentException.java +++ b/common/addons/manifest-addon-loader/src/main/java/com/dfsek/terra/addons/manifest/impl/exception/ManifestNotPresentException.java @@ -13,11 +13,11 @@ import java.io.Serial; public class ManifestNotPresentException extends ManifestException { @Serial private static final long serialVersionUID = -2116663180747013810L; - + public ManifestNotPresentException(String message) { super(message); } - + public ManifestNotPresentException(String message, Throwable cause) { super(message, cause); } diff --git a/common/addons/palette-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/PaletteBlockShortcutAddon.java b/common/addons/palette-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/PaletteBlockShortcutAddon.java index c3a2f3ea4..13db42143 100644 --- a/common/addons/palette-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/PaletteBlockShortcutAddon.java +++ b/common/addons/palette-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/PaletteBlockShortcutAddon.java @@ -15,16 +15,16 @@ public class PaletteBlockShortcutAddon implements AddonInitializer { private BaseAddon addon; @Inject private Platform platform; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> event.getPack() - .registerShortcut(Palette.class, "BLOCK", - (configLoader, input, tracker) -> new SingletonPalette( - configLoader.loadType(BlockState.class, input, tracker)))) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> event.getPack() + .registerShortcut(Palette.class, "BLOCK", + (configLoader, input, tracker) -> new SingletonPalette( + configLoader.loadType(BlockState.class, input, tracker)))) + .failThrough(); } } diff --git a/common/addons/palette-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/SingletonPalette.java b/common/addons/palette-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/SingletonPalette.java index 847c2c2b3..06149aa73 100644 --- a/common/addons/palette-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/SingletonPalette.java +++ b/common/addons/palette-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/SingletonPalette.java @@ -6,11 +6,11 @@ import com.dfsek.terra.api.world.chunk.generation.util.Palette; public class SingletonPalette implements Palette { private final BlockState blockState; - + public SingletonPalette(BlockState blockState) { this.blockState = blockState; } - + @Override public BlockState get(int layer, double x, double y, double z, long seed) { return blockState; diff --git a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/ImageSource.java b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/ImageSource.java index 857e0de34..1d54dec89 100644 --- a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/ImageSource.java +++ b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/ImageSource.java @@ -7,21 +7,21 @@ import com.dfsek.terra.addons.image.converter.ColorConverter; public class ImageSource implements Source { - + private final ColorSampler colorSampler; - + private final ColorConverter colorConverter; - + public ImageSource(ColorSampler colorSampler, ColorConverter colorConverter) { this.colorSampler = colorSampler; this.colorConverter = colorConverter; } - + @Override public PipelineBiome get(long seed, int x, int z) { return colorConverter.apply(colorSampler.apply(x, z)); } - + @Override public Iterable getBiomes() { return colorConverter.getEntries(); diff --git a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/PipelineImageAddon.java b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/PipelineImageAddon.java index df69d9662..34de699af 100644 --- a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/PipelineImageAddon.java +++ b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/PipelineImageAddon.java @@ -27,49 +27,49 @@ import com.dfsek.terra.api.world.biome.Biome; public class PipelineImageAddon implements AddonInitializer { - + public static final TypeKey>>> PIPELINE_BIOME_COLOR_CONVERTER_REGISTRY_KEY = - new TypeKey<>() { - }; - + new TypeKey<>() { + }; + public static final TypeKey>>> PIPELINE_BIOME_COLOR_MAPPING_REGISTRY_KEY = - new TypeKey<>() { - }; - + new TypeKey<>() { + }; + @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { - + platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .priority(500) - .then(event -> { - CheckedRegistry>>> biomeColorConverterRegistry = - event.getPack().getOrCreateRegistry( - PIPELINE_BIOME_COLOR_CONVERTER_REGISTRY_KEY); - biomeColorConverterRegistry.register(addon.key("EXACT"), ExactPipelineBiomeColorConverterTemplate::new); - biomeColorConverterRegistry.register(addon.key("CLOSEST"), ClosestPipelineBiomeColorConverterTemplate::new); - }) - .then(event -> { - CheckedRegistry>> sourceRegistry = event.getPack().getOrCreateRegistry( - BiomePipelineAddon.SOURCE_REGISTRY_KEY); - sourceRegistry.register(addon.key("IMAGE"), ImageSourceTemplate::new); - }) - .then(event -> { - CheckedRegistry>>> biomeColorMappingRegistry = - event.getPack().getOrCreateRegistry( - PIPELINE_BIOME_COLOR_MAPPING_REGISTRY_KEY); - biomeColorMappingRegistry.register(addon.key("USE_BIOME_COLORS"), - () -> () -> new BiomeDefinedColorMapping<>(event.getPack().getRegistry(Biome.class), - DelegatedPipelineBiome::new)); - biomeColorMappingRegistry.register(addon.key("MAP"), DefinedPipelineBiomeColorMappingTemplate::new); - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .priority(500) + .then(event -> { + CheckedRegistry>>> biomeColorConverterRegistry = + event.getPack().getOrCreateRegistry( + PIPELINE_BIOME_COLOR_CONVERTER_REGISTRY_KEY); + biomeColorConverterRegistry.register(addon.key("EXACT"), ExactPipelineBiomeColorConverterTemplate::new); + biomeColorConverterRegistry.register(addon.key("CLOSEST"), ClosestPipelineBiomeColorConverterTemplate::new); + }) + .then(event -> { + CheckedRegistry>> sourceRegistry = event.getPack().getOrCreateRegistry( + BiomePipelineAddon.SOURCE_REGISTRY_KEY); + sourceRegistry.register(addon.key("IMAGE"), ImageSourceTemplate::new); + }) + .then(event -> { + CheckedRegistry>>> biomeColorMappingRegistry = + event.getPack().getOrCreateRegistry( + PIPELINE_BIOME_COLOR_MAPPING_REGISTRY_KEY); + biomeColorMappingRegistry.register(addon.key("USE_BIOME_COLORS"), + () -> () -> new BiomeDefinedColorMapping<>(event.getPack().getRegistry(Biome.class), + DelegatedPipelineBiome::new)); + biomeColorMappingRegistry.register(addon.key("MAP"), DefinedPipelineBiomeColorMappingTemplate::new); + }) + .failThrough(); } } diff --git a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/ImageSourceTemplate.java b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/ImageSourceTemplate.java index 40d2910c8..8814d195b 100644 --- a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/ImageSourceTemplate.java +++ b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/ImageSourceTemplate.java @@ -11,13 +11,13 @@ import com.dfsek.terra.addons.image.converter.ColorConverter; public class ImageSourceTemplate implements ObjectTemplate { - + @Value("color-sampler") private ColorSampler colorSampler; - + @Value("color-conversion") private ColorConverter colorConverter; - + @Override public Source get() { return new ImageSource(colorSampler, colorConverter); diff --git a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ClosestPipelineBiomeColorConverterTemplate.java b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ClosestPipelineBiomeColorConverterTemplate.java index df5fb3471..4c98bfee7 100644 --- a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ClosestPipelineBiomeColorConverterTemplate.java +++ b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ClosestPipelineBiomeColorConverterTemplate.java @@ -8,10 +8,10 @@ import com.dfsek.terra.addons.image.converter.mapping.ColorMapping; public class ClosestPipelineBiomeColorConverterTemplate extends ClosestColorConverterTemplate { - + @Value("match") private ColorMapping match; - + @Override protected ColorMapping getMapping() { return match; diff --git a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ExactPipelineBiomeColorConverterTemplate.java b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ExactPipelineBiomeColorConverterTemplate.java index ac94d2bd9..4f2724008 100644 --- a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ExactPipelineBiomeColorConverterTemplate.java +++ b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/ExactPipelineBiomeColorConverterTemplate.java @@ -9,27 +9,27 @@ import com.dfsek.terra.addons.image.converter.mapping.ColorMapping; public class ExactPipelineBiomeColorConverterTemplate extends ExactColorConverterTemplate { - + @Value("match") private ColorMapping match; - + @Value("else") private PipelineBiome fallback; - + @Value("ignore-alpha") @Default private boolean ignoreAlpha = true; - + @Override protected ColorMapping getMapping() { return match; } - + @Override protected PipelineBiome getFallback() { return fallback; } - + @Override protected boolean ignoreAlpha() { return ignoreAlpha; diff --git a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/mapping/DefinedPipelineBiomeColorMappingTemplate.java b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/mapping/DefinedPipelineBiomeColorMappingTemplate.java index b1d4115f2..1406d8383 100644 --- a/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/mapping/DefinedPipelineBiomeColorMappingTemplate.java +++ b/common/addons/pipeline-image/src/main/java/com/dfsek/terra/addons/biome/pipeline/image/config/converter/mapping/DefinedPipelineBiomeColorMappingTemplate.java @@ -12,10 +12,10 @@ import com.dfsek.terra.addons.image.util.MapUtil; public class DefinedPipelineBiomeColorMappingTemplate implements ObjectTemplate> { - + @Value("map") Map map; - + @Override public ColorMapping get() { var map = MapUtil.mapKeys(this.map, ColorString::getColor); diff --git a/common/addons/structure-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/SingletonStructure.java b/common/addons/structure-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/SingletonStructure.java index 7d14c6ee7..bac5f4373 100644 --- a/common/addons/structure-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/SingletonStructure.java +++ b/common/addons/structure-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/SingletonStructure.java @@ -11,11 +11,11 @@ import com.dfsek.terra.api.world.WritableWorld; public class SingletonStructure implements Structure { private final BlockState blockState; - + public SingletonStructure(BlockState blockState) { this.blockState = blockState; } - + @Override public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation) { world.setBlockState(location, blockState); diff --git a/common/addons/structure-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/StructureBlockShortcutAddon.java b/common/addons/structure-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/StructureBlockShortcutAddon.java index 210ab98d1..5dccef6a7 100644 --- a/common/addons/structure-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/StructureBlockShortcutAddon.java +++ b/common/addons/structure-block-shortcut/src/main/java/com/dfsek/terra/addons/palette/shortcut/block/StructureBlockShortcutAddon.java @@ -15,17 +15,17 @@ public class StructureBlockShortcutAddon implements AddonInitializer { private BaseAddon addon; @Inject private Platform platform; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> event.getPack() - .registerShortcut(Structure.class, "BLOCK", - (configLoader, input, tracker) -> new SingletonStructure( - configLoader.loadType(BlockState.class, input, tracker) - ))) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> event.getPack() + .registerShortcut(Structure.class, "BLOCK", + (configLoader, input, tracker) -> new SingletonStructure( + configLoader.loadType(BlockState.class, input, tracker) + ))) + .failThrough(); } } diff --git a/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/MutatedStructure.java b/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/MutatedStructure.java index a5aafdd1e..30b2d5984 100644 --- a/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/MutatedStructure.java +++ b/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/MutatedStructure.java @@ -17,7 +17,7 @@ public class MutatedStructure implements Structure, Keyed { private final Structure base; private final ReadInterceptor readInterceptor; private final WriteInterceptor writeInterceptor; - + public MutatedStructure(RegistryKey key, Structure base, ReadInterceptor readInterceptor, WriteInterceptor writeInterceptor) { this.key = key; @@ -25,20 +25,20 @@ public class MutatedStructure implements Structure, Keyed { this.readInterceptor = readInterceptor; this.writeInterceptor = writeInterceptor; } - + @Override public RegistryKey getRegistryKey() { return key; } - + @Override public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation) { return base.generate(location, - world - .buffer() - .read(readInterceptor) - .write(writeInterceptor) - .build(), - random, rotation); + world + .buffer() + .read(readInterceptor) + .write(writeInterceptor) + .build(), + random, rotation); } } diff --git a/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/MutatedStructureConfigType.java b/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/MutatedStructureConfigType.java index 23eb5e802..7691b8f48 100644 --- a/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/MutatedStructureConfigType.java +++ b/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/MutatedStructureConfigType.java @@ -11,21 +11,21 @@ import com.dfsek.terra.api.util.reflection.TypeKey; public class MutatedStructureConfigType implements ConfigType { private final BaseAddon addon; - + public MutatedStructureConfigType(BaseAddon addon) { this.addon = addon; } - + @Override public MutatedStructureTemplate getTemplate(ConfigPack pack, Platform platform) { return new MutatedStructureTemplate(); } - + @Override public ConfigFactory getFactory() { return new MutatedStructureFactory(addon); } - + @Override public TypeKey getTypeKey() { return TypeKey.of(MutatedStructure.class); diff --git a/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/MutatedStructureFactory.java b/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/MutatedStructureFactory.java index a8f953d3c..358c7abdc 100644 --- a/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/MutatedStructureFactory.java +++ b/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/MutatedStructureFactory.java @@ -10,16 +10,16 @@ import com.dfsek.terra.api.config.ConfigFactory; public class MutatedStructureFactory implements ConfigFactory { private final BaseAddon addon; - + public MutatedStructureFactory(BaseAddon addon) { this.addon = addon; } - + @Override public MutatedStructure build(MutatedStructureTemplate config, Platform platform) throws LoadException { return new MutatedStructure(addon.key(config.getID()), - config.getDelegate(), - config.getReadInterceptor(), - config.getWriteInterceptor()); + config.getDelegate(), + config.getReadInterceptor(), + config.getWriteInterceptor()); } } diff --git a/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/StructureMutatorAddon.java b/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/StructureMutatorAddon.java index b5a3fab7f..978e472a4 100644 --- a/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/StructureMutatorAddon.java +++ b/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/StructureMutatorAddon.java @@ -11,19 +11,19 @@ import com.dfsek.terra.api.inject.annotations.Inject; public class StructureMutatorAddon implements AddonInitializer { @Inject private Platform platform; - + @Inject private BaseAddon addon; - - + + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> { - event.getPack().registerConfigType(new MutatedStructureConfigType(addon), addon.key("MUTATED_STRUCTURE"), 499); - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> { + event.getPack().registerConfigType(new MutatedStructureConfigType(addon), addon.key("MUTATED_STRUCTURE"), 499); + }) + .failThrough(); } } diff --git a/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/config/MutatedStructureTemplate.java b/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/config/MutatedStructureTemplate.java index 1b8d473d1..2e492a3ea 100644 --- a/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/config/MutatedStructureTemplate.java +++ b/common/addons/structure-mutator/src/main/java/com/dfsek/terra/addons/structure/mutator/config/MutatedStructureTemplate.java @@ -11,29 +11,29 @@ import com.dfsek.terra.api.world.util.WriteInterceptor; public class MutatedStructureTemplate implements AbstractableTemplate { @Value("id") private String id; - + @Value("mutate.read") private ReadInterceptor readInterceptor; - + @Value("mutate.write") private WriteInterceptor writeInterceptor; - + @Value("structure") private Structure delegate; - + @Override public String getID() { return id; } - + public ReadInterceptor getReadInterceptor() { return readInterceptor; } - + public WriteInterceptor getWriteInterceptor() { return writeInterceptor; } - + public Structure getDelegate() { return delegate; } diff --git a/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeSchematicAddon.java b/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeSchematicAddon.java index 4ed00cf8e..199864cd1 100644 --- a/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeSchematicAddon.java +++ b/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeSchematicAddon.java @@ -36,10 +36,10 @@ import com.dfsek.terra.api.util.vector.Vector3Int; public class SpongeSchematicAddon implements AddonInitializer { @Inject private Platform platform; - + @Inject private BaseAddon addon; - + private static InputStream detectDecompression(InputStream is) throws IOException { PushbackInputStream pbis = new PushbackInputStream(is, 2); int signature = (pbis.read() & 0xFF) + (pbis.read() << 8); @@ -50,25 +50,25 @@ public class SpongeSchematicAddon implements AddonInitializer { } return pbis; } - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> { - CheckedRegistry structureRegistry = event.getPack().getOrCreateRegistry(Structure.class); - event.getPack() - .getLoader() - .open("", ".schem") - .thenEntries(entries -> entries - .stream() - .map(entry -> convert(entry.getValue(), StringUtil.fileName(entry.getKey()))) - .forEach(structureRegistry::register)).close(); - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> { + CheckedRegistry structureRegistry = event.getPack().getOrCreateRegistry(Structure.class); + event.getPack() + .getLoader() + .open("", ".schem") + .thenEntries(entries -> entries + .stream() + .map(entry -> convert(entry.getValue(), StringUtil.fileName(entry.getKey()))) + .forEach(structureRegistry::register)).close(); + }) + .failThrough(); } - + public SpongeStructure convert(InputStream in, String id) { try { CompoundTag baseTag = (CompoundTag) new NBTDeserializer(false).fromStream(detectDecompression(in)).getTag(); @@ -76,9 +76,9 @@ public class SpongeSchematicAddon implements AddonInitializer { int wid = baseTag.getShort("Width"); int len = baseTag.getShort("Length"); int hei = baseTag.getShort("Height"); - + CompoundTag metadata = baseTag.getCompoundTag("Metadata"); - + Vector3Int offset = switch(ver) { case 2 -> { // Use WorldEdit defined legacy relative offset if it exists in schematic metadata @@ -102,18 +102,18 @@ public class SpongeSchematicAddon implements AddonInitializer { } default -> throw new IllegalArgumentException("Failed to parse Sponge schematic: Unsupported format version: " + ver); }; - + ByteArrayTag blocks = baseTag.getByteArrayTag("BlockData"); - + CompoundTag palette = (CompoundTag) baseTag.get("Palette"); Map data = new HashMap<>(); - + for(Map.Entry> entry : palette.entrySet()) { data.put(((IntTag) entry.getValue()).asInt(), entry.getKey()); } - + BlockState[][][] states = new BlockState[wid][len][hei]; - + byte[] arr = blocks.getValue(); for(int x = 0; x < wid; x++) { for(int z = 0; z < len; z++) { @@ -124,7 +124,7 @@ public class SpongeSchematicAddon implements AddonInitializer { } } } - + return new SpongeStructure(states, offset, addon.key(id)); } catch(IOException e) { throw new IllegalArgumentException("Failed to parse Sponge schematic: ", e); diff --git a/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeStructure.java b/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeStructure.java index f5f9770c9..12ce1f42b 100644 --- a/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeStructure.java +++ b/common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeStructure.java @@ -20,13 +20,13 @@ import com.dfsek.terra.api.world.WritableWorld; public class SpongeStructure implements Structure, Keyed { - + private final BlockState[][][] blocks; - + private final int offsetX, offsetY, offsetZ; - + private final RegistryKey id; - + public SpongeStructure(BlockState[][][] blocks, Vector3Int offset, RegistryKey id) { this.blocks = blocks; this.offsetX = offset.getX(); @@ -34,7 +34,7 @@ public class SpongeStructure implements Structure, Keyed { this.offsetZ = offset.getZ(); this.id = id; } - + @Override public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation) { int bX = location.getX(); @@ -56,7 +56,7 @@ public class SpongeStructure implements Structure, Keyed { } return true; } - + @Override public RegistryKey getRegistryKey() { return id; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/TerraScriptAddon.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/TerraScriptAddon.java index f283c40a1..b555b7bac 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/TerraScriptAddon.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/TerraScriptAddon.java @@ -25,40 +25,40 @@ import com.dfsek.terra.api.util.StringUtil; public class TerraScriptAddon implements AddonInitializer { @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .then(event -> { - CheckedRegistry structureRegistry = event.getPack().getOrCreateRegistry(Structure.class); - CheckedRegistry lootRegistry = event.getPack().getOrCreateRegistry(LootTable.class); - event.getPack().getLoader().open("", ".tesf").thenEntries( - entries -> - entries.stream() - .parallel() - .map(entry -> { - try { - String id = StringUtil.fileName(entry.getKey()); - return new StructureScript(entry.getValue(), - addon.key(id), - platform, - structureRegistry, - lootRegistry, - event.getPack().getOrCreateRegistry(FunctionBuilder.class)); - } catch(ParseException e) { - throw new RuntimeException("Failed to load script \"" + entry.getKey() + "\"", e); - } - }) - .toList() - .forEach(structureRegistry::register)) - .close(); - }) - .priority(100) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .then(event -> { + CheckedRegistry structureRegistry = event.getPack().getOrCreateRegistry(Structure.class); + CheckedRegistry lootRegistry = event.getPack().getOrCreateRegistry(LootTable.class); + event.getPack().getLoader().open("", ".tesf").thenEntries( + entries -> + entries.stream() + .parallel() + .map(entry -> { + try { + String id = StringUtil.fileName(entry.getKey()); + return new StructureScript(entry.getValue(), + addon.key(id), + platform, + structureRegistry, + lootRegistry, + event.getPack().getOrCreateRegistry(FunctionBuilder.class)); + } catch(ParseException e) { + throw new RuntimeException("Failed to load script \"" + entry.getKey() + "\"", e); + } + }) + .toList() + .forEach(structureRegistry::register)) + .close(); + }) + .priority(100) + .failThrough(); } } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/Parser.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/Parser.java index 82da454dd..1a24c5ee2 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/Parser.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/Parser.java @@ -69,21 +69,21 @@ public class Parser { private final String data; private final Map>> functions = new HashMap<>(); private final List ignoredFunctions = new ArrayList<>(); - + public Parser(String data) { this.data = data; } - + public Parser registerFunction(String name, FunctionBuilder> functionBuilder) { functions.put(name, functionBuilder); return this; } - + public Parser ignoreFunction(String name) { ignoredFunctions.add(name); return this; } - + /** * Parse input * @@ -95,43 +95,43 @@ public class Parser { ScopeBuilder scopeBuilder = new ScopeBuilder(); return new Executable(parseBlock(new Tokenizer(data), false, scopeBuilder), scopeBuilder); } - + private Keyword parseLoopLike(Tokenizer tokens, boolean loop, ScopeBuilder scopeBuilder) throws ParseException { - + Token identifier = tokens.consume(); ParserUtil.checkType(identifier, Token.Type.IF_STATEMENT, Token.Type.WHILE_LOOP, Token.Type.FOR_LOOP); - + ParserUtil.checkType(tokens.consume(), Token.Type.GROUP_BEGIN); - + return switch(identifier.getType()) { case FOR_LOOP -> parseForLoop(tokens, identifier.getPosition(), scopeBuilder); case IF_STATEMENT -> parseIfStatement(tokens, identifier.getPosition(), loop, scopeBuilder); case WHILE_LOOP -> parseWhileLoop(tokens, identifier.getPosition(), scopeBuilder); default -> throw new UnsupportedOperationException( - "Unknown keyword " + identifier.getContent() + ": " + identifier.getPosition()); + "Unknown keyword " + identifier.getContent() + ": " + identifier.getPosition()); }; } - + private WhileKeyword parseWhileLoop(Tokenizer tokens, Position start, ScopeBuilder scopeBuilder) { Returnable first = parseExpression(tokens, true, scopeBuilder); ParserUtil.checkReturnType(first, Returnable.ReturnType.BOOLEAN); - + ParserUtil.checkType(tokens.consume(), Token.Type.GROUP_END); - + return new WhileKeyword(parseStatementBlock(tokens, true, scopeBuilder), (Returnable) first, start); // While loop } - + private IfKeyword parseIfStatement(Tokenizer tokens, Position start, boolean loop, ScopeBuilder scopeBuilder) { Returnable condition = parseExpression(tokens, true, scopeBuilder); ParserUtil.checkReturnType(condition, Returnable.ReturnType.BOOLEAN); - + ParserUtil.checkType(tokens.consume(), Token.Type.GROUP_END); - + Block elseBlock = null; Block statement = parseStatementBlock(tokens, loop, scopeBuilder); - + List, Block>> elseIf = new ArrayList<>(); - + while(tokens.hasNext() && tokens.get().getType().equals(Token.Type.ELSE)) { tokens.consume(); // Consume else. if(tokens.get().getType().equals(Token.Type.IF_STATEMENT)) { @@ -144,12 +144,12 @@ public class Parser { break; // Else must be last. } } - + return new IfKeyword(statement, (Returnable) condition, elseIf, elseBlock, start); // If statement } - + private Block parseStatementBlock(Tokenizer tokens, boolean loop, ScopeBuilder scopeBuilder) { - + if(tokens.get().getType().equals(Token.Type.BLOCK_BEGIN)) { ParserUtil.checkType(tokens.consume(), Token.Type.BLOCK_BEGIN); Block block = parseBlock(tokens, loop, scopeBuilder); @@ -162,7 +162,7 @@ public class Parser { return block; } } - + private ForKeyword parseForLoop(Tokenizer tokens, Position start, ScopeBuilder scopeBuilder) { scopeBuilder = scopeBuilder.sub(); // new scope Token f = tokens.get(); @@ -179,19 +179,19 @@ public class Parser { Returnable conditional = parseExpression(tokens, true, scopeBuilder); ParserUtil.checkReturnType(conditional, Returnable.ReturnType.BOOLEAN); ParserUtil.checkType(tokens.consume(), Token.Type.STATEMENT_END); - + Item incrementer; Token token = tokens.get(); if(scopeBuilder.contains(token.getContent())) { // Assume variable assignment incrementer = parseAssignment(tokens, scopeBuilder); } else incrementer = parseFunction(tokens, true, scopeBuilder); - + ParserUtil.checkType(tokens.consume(), Token.Type.GROUP_END); - + return new ForKeyword(parseStatementBlock(tokens, true, scopeBuilder), initializer, (Returnable) conditional, incrementer, - start); + start); } - + private Returnable parseExpression(Tokenizer tokens, boolean full, ScopeBuilder scopeBuilder) { boolean booleanInverted = false; // Check for boolean not operator boolean negate = false; @@ -202,11 +202,11 @@ public class Parser { negate = true; tokens.consume(); } - + Token id = tokens.get(); - + ParserUtil.checkType(id, Token.Type.IDENTIFIER, Token.Type.BOOLEAN, Token.Type.STRING, Token.Type.NUMBER, Token.Type.GROUP_BEGIN); - + Returnable expression; if(id.isConstant()) { expression = parseConstantExpression(tokens); @@ -225,10 +225,10 @@ public class Parser { case BOOLEAN -> new BoolVariableReferenceNode(id.getPosition(), varType, scopeBuilder.getIndex(varId)); default -> throw new ParseException("Illegal type for variable reference: " + varType, id.getPosition()); }; - + } else throw new ParseException("Unexpected token \" " + id.getContent() + "\"", id.getPosition()); } - + if(booleanInverted) { // Invert operation if boolean not detected ParserUtil.checkReturnType(expression, Returnable.ReturnType.BOOLEAN); expression = new BooleanNotOperation((Returnable) expression, expression.getPosition()); @@ -236,13 +236,13 @@ public class Parser { ParserUtil.checkReturnType(expression, Returnable.ReturnType.NUMBER); expression = new NegationOperation((Returnable) expression, expression.getPosition()); } - + if(full && tokens.get().isBinaryOperator()) { // Parse binary operations return parseBinaryOperation(expression, tokens, scopeBuilder); } return expression; } - + private ConstantExpression parseConstantExpression(Tokenizer tokens) { Token constantToken = tokens.consume(); Position position = constantToken.getPosition(); @@ -256,24 +256,24 @@ public class Parser { return new BooleanConstant(Boolean.parseBoolean(constantToken.getContent()), position); default: throw new UnsupportedOperationException( - "Unsupported constant token: " + constantToken.getType() + " at position: " + position); + "Unsupported constant token: " + constantToken.getType() + " at position: " + position); } } - + private Returnable parseGroup(Tokenizer tokens, ScopeBuilder scopeBuilder) { ParserUtil.checkType(tokens.consume(), Token.Type.GROUP_BEGIN); Returnable expression = parseExpression(tokens, true, scopeBuilder); // Parse inside of group as a separate expression ParserUtil.checkType(tokens.consume(), Token.Type.GROUP_END); return expression; } - + private BinaryOperation parseBinaryOperation(Returnable left, Tokenizer tokens, ScopeBuilder scopeBuilder) { Token binaryOperator = tokens.consume(); ParserUtil.checkBinaryOperator(binaryOperator); - + Returnable right = parseExpression(tokens, false, scopeBuilder); - + Token other = tokens.get(); if(ParserUtil.hasPrecedence(binaryOperator.getType(), other.getType())) { return assemble(left, parseBinaryOperation(right, tokens, scopeBuilder), binaryOperator); @@ -282,7 +282,7 @@ public class Parser { } return assemble(left, right, binaryOperator); } - + private BinaryOperation assemble(Returnable left, Returnable right, Token binaryOperator) { if(binaryOperator.isStrictNumericOperator()) ParserUtil.checkArithmeticOperation(left, right, binaryOperator); // Numeric type checking @@ -309,7 +309,7 @@ public class Parser { return new LessThanStatement((Returnable) left, (Returnable) right, binaryOperator.getPosition()); case GREATER_THAN_OR_EQUALS_OPERATOR: return new GreaterOrEqualsThanStatement((Returnable) left, (Returnable) right, - binaryOperator.getPosition()); + binaryOperator.getPosition()); case LESS_THAN_OR_EQUALS_OPERATOR: return new LessThanOrEqualsStatement((Returnable) left, (Returnable) right, binaryOperator.getPosition()); case BOOLEAN_AND: @@ -322,25 +322,25 @@ public class Parser { throw new UnsupportedOperationException("Unsupported binary operator: " + binaryOperator.getType()); } } - + private VariableAssignmentNode parseVariableDeclaration(Tokenizer tokens, ScopeBuilder scopeBuilder) { Token type = tokens.consume(); ParserUtil.checkType(type, Token.Type.STRING_VARIABLE, Token.Type.BOOLEAN_VARIABLE, Token.Type.NUMBER_VARIABLE); - + Returnable.ReturnType returnType = ParserUtil.getVariableReturnType(type); - + ParserUtil.checkVarType(type, returnType); // Check for type mismatch Token identifier = tokens.consume(); ParserUtil.checkType(identifier, Token.Type.IDENTIFIER); if(functions.containsKey(identifier.getContent()) || scopeBuilder.contains(identifier.getContent())) throw new ParseException(identifier.getContent() + " is already defined in this scope", identifier.getPosition()); ParserUtil.checkType(tokens.consume(), Token.Type.ASSIGNMENT); - + Returnable value = parseExpression(tokens, true, scopeBuilder); ParserUtil.checkReturnType(value, returnType); - + String id = identifier.getContent(); - + return switch(value.returnType()) { case NUMBER -> new NumAssignmentNode((Returnable) value, identifier.getPosition(), scopeBuilder.num(id)); case STRING -> new StrAssignmentNode((Returnable) value, identifier.getPosition(), scopeBuilder.str(id)); @@ -348,14 +348,14 @@ public class Parser { default -> throw new ParseException("Illegal type for variable declaration: " + type, value.getPosition()); }; } - + private Block parseBlock(Tokenizer tokens, boolean loop, ScopeBuilder scopeBuilder) { List> parsedItems = new ArrayList<>(); - + scopeBuilder = scopeBuilder.sub(); - + Token first = tokens.get(); - + while(tokens.hasNext()) { Token token = tokens.get(); if(token.getType().equals(Token.Type.BLOCK_END)) break; // Stop parsing at block end. @@ -367,16 +367,16 @@ public class Parser { } return new Block(parsedItems, first.getPosition()); } - + private Item parseItem(Tokenizer tokens, boolean loop, ScopeBuilder scopeBuilder) { Token token = tokens.get(); if(loop) ParserUtil.checkType(token, Token.Type.IDENTIFIER, Token.Type.IF_STATEMENT, Token.Type.WHILE_LOOP, Token.Type.FOR_LOOP, - Token.Type.NUMBER_VARIABLE, Token.Type.STRING_VARIABLE, Token.Type.BOOLEAN_VARIABLE, - Token.Type.RETURN, Token.Type.BREAK, Token.Type.CONTINUE, Token.Type.FAIL); + Token.Type.NUMBER_VARIABLE, Token.Type.STRING_VARIABLE, Token.Type.BOOLEAN_VARIABLE, + Token.Type.RETURN, Token.Type.BREAK, Token.Type.CONTINUE, Token.Type.FAIL); else ParserUtil.checkType(token, Token.Type.IDENTIFIER, Token.Type.IF_STATEMENT, Token.Type.WHILE_LOOP, Token.Type.FOR_LOOP, - Token.Type.NUMBER_VARIABLE, Token.Type.STRING_VARIABLE, Token.Type.BOOLEAN_VARIABLE, Token.Type.RETURN, - Token.Type.FAIL); - + Token.Type.NUMBER_VARIABLE, Token.Type.STRING_VARIABLE, Token.Type.BOOLEAN_VARIABLE, Token.Type.RETURN, + Token.Type.FAIL); + if(token.isLoopLike()) { // Parse loop-like tokens (if, while, etc) return parseLoopLike(tokens, loop, scopeBuilder); } else if(token.isIdentifier()) { // Parse identifiers @@ -384,31 +384,31 @@ public class Parser { return parseAssignment(tokens, scopeBuilder); } else return parseFunction(tokens, true, scopeBuilder); } else if(token.isVariableDeclaration()) { - + return parseVariableDeclaration(tokens, scopeBuilder); - + } else if(token.getType().equals(Token.Type.RETURN)) return new ReturnKeyword(tokens.consume().getPosition()); else if(token.getType().equals(Token.Type.BREAK)) return new BreakKeyword(tokens.consume().getPosition()); else if(token.getType().equals(Token.Type.CONTINUE)) return new ContinueKeyword(tokens.consume().getPosition()); else if(token.getType().equals(Token.Type.FAIL)) return new FailKeyword(tokens.consume().getPosition()); else throw new UnsupportedOperationException("Unexpected token " + token.getType() + ": " + token.getPosition()); } - + private VariableAssignmentNode parseAssignment(Tokenizer tokens, ScopeBuilder scopeBuilder) { Token identifier = tokens.consume(); - + ParserUtil.checkType(identifier, Token.Type.IDENTIFIER); - + ParserUtil.checkType(tokens.consume(), Token.Type.ASSIGNMENT); - + Returnable value = parseExpression(tokens, true, scopeBuilder); - + String id = identifier.getContent(); - + ParserUtil.checkReturnType(value, scopeBuilder.getType(id)); - + ReturnType type = value.returnType(); - + return switch(type) { case NUMBER -> new NumAssignmentNode((Returnable) value, identifier.getPosition(), scopeBuilder.getIndex(id)); case STRING -> new StrAssignmentNode((Returnable) value, identifier.getPosition(), scopeBuilder.getIndex(id)); @@ -416,48 +416,48 @@ public class Parser { default -> throw new ParseException("Illegal type for variable assignment: " + type, value.getPosition()); }; } - + private Function parseFunction(Tokenizer tokens, boolean fullStatement, ScopeBuilder scopeBuilder) { Token identifier = tokens.consume(); ParserUtil.checkType(identifier, Token.Type.IDENTIFIER); // First token must be identifier - + if(!functions.containsKey(identifier.getContent())) throw new ParseException("No such function \"" + identifier.getContent() + "\"", identifier.getPosition()); - + ParserUtil.checkType(tokens.consume(), Token.Type.GROUP_BEGIN); // Second is body begin - - + + List> args = getArgs(tokens, scopeBuilder); // Extract arguments, consume the rest. - + ParserUtil.checkType(tokens.consume(), Token.Type.GROUP_END); // Remove body end - + if(fullStatement) ParserUtil.checkType(tokens.get(), Token.Type.STATEMENT_END); - + if(ignoredFunctions.contains(identifier.getContent())) { return Function.NULL; } - + if(functions.containsKey(identifier.getContent())) { FunctionBuilder builder = functions.get(identifier.getContent()); - + if(builder.argNumber() != -1 && args.size() != builder.argNumber()) throw new ParseException("Expected " + builder.argNumber() + " arguments, found " + args.size(), identifier.getPosition()); - + for(int i = 0; i < args.size(); i++) { Returnable argument = args.get(i); if(builder.getArgument(i) == null) throw new ParseException("Unexpected argument at position " + i + " in function " + identifier.getContent(), - identifier.getPosition()); + identifier.getPosition()); ParserUtil.checkReturnType(argument, builder.getArgument(i)); } return builder.build(args, identifier.getPosition()); } throw new UnsupportedOperationException("Unsupported function: " + identifier.getContent()); } - + private List> getArgs(Tokenizer tokens, ScopeBuilder scopeBuilder) { List> args = new ArrayList<>(); - + while(!tokens.get().getType().equals(Token.Type.GROUP_END)) { args.add(parseExpression(tokens, true, scopeBuilder)); ParserUtil.checkType(tokens.get(), Token.Type.SEPARATOR, Token.Type.GROUP_END); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/ParserUtil.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/ParserUtil.java index 1475b2da2..4fc805a8f 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/ParserUtil.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/ParserUtil.java @@ -18,72 +18,72 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Token; public class ParserUtil { - + private static final Map> PRECEDENCE = new HashMap<>(); // If second has precedence, true. private static final List ARITHMETIC = Arrays.asList(Token.Type.ADDITION_OPERATOR, Token.Type.SUBTRACTION_OPERATOR, - Token.Type.MULTIPLICATION_OPERATOR, Token.Type.DIVISION_OPERATOR, - Token.Type.MODULO_OPERATOR); + Token.Type.MULTIPLICATION_OPERATOR, Token.Type.DIVISION_OPERATOR, + Token.Type.MODULO_OPERATOR); private static final List COMPARISON = Arrays.asList(Token.Type.EQUALS_OPERATOR, Token.Type.NOT_EQUALS_OPERATOR, - Token.Type.LESS_THAN_OPERATOR, Token.Type.LESS_THAN_OR_EQUALS_OPERATOR, - Token.Type.GREATER_THAN_OPERATOR, - Token.Type.GREATER_THAN_OR_EQUALS_OPERATOR); - + Token.Type.LESS_THAN_OPERATOR, Token.Type.LESS_THAN_OR_EQUALS_OPERATOR, + Token.Type.GREATER_THAN_OPERATOR, + Token.Type.GREATER_THAN_OR_EQUALS_OPERATOR); + static { // Setup precedence Map add = new HashMap<>(); // Addition/subtraction before Multiplication/division. add.put(Token.Type.MULTIPLICATION_OPERATOR, true); add.put(Token.Type.DIVISION_OPERATOR, true); - + PRECEDENCE.put(Token.Type.ADDITION_OPERATOR, add); PRECEDENCE.put(Token.Type.SUBTRACTION_OPERATOR, add); - + Map numericBoolean = new HashMap<>(); - + ARITHMETIC.forEach(op -> numericBoolean.put(op, true)); // Numbers before comparison COMPARISON.forEach(op -> PRECEDENCE.put(op, numericBoolean)); - - + + Map booleanOps = new HashMap<>(); ARITHMETIC.forEach(op -> booleanOps.put(op, true)); // Everything before boolean COMPARISON.forEach(op -> booleanOps.put(op, true)); - - + + PRECEDENCE.put(Token.Type.BOOLEAN_AND, booleanOps); PRECEDENCE.put(Token.Type.BOOLEAN_OR, booleanOps); } - + public static void checkType(Token token, Token.Type... expected) { for(Token.Type type : expected) if(token.getType().equals(type)) return; throw new ParseException("Expected " + Arrays.toString(expected) + " but found " + token.getType(), token.getPosition()); } - + public static void checkReturnType(Returnable returnable, Returnable.ReturnType... types) { for(Returnable.ReturnType type : types) if(returnable.returnType().equals(type)) return; throw new ParseException("Expected " + Arrays.toString(types) + " but found " + returnable.returnType(), returnable.getPosition()); } - + public static void checkArithmeticOperation(Returnable left, Returnable right, Token operation) { if(!left.returnType().equals(Returnable.ReturnType.NUMBER) || !right.returnType().equals(Returnable.ReturnType.NUMBER)) { throw new ParseException( - "Operation " + operation.getType() + " not supported between " + left.returnType() + " and " + right.returnType(), - operation.getPosition()); + "Operation " + operation.getType() + " not supported between " + left.returnType() + " and " + right.returnType(), + operation.getPosition()); } } - + public static void checkBooleanOperation(Returnable left, Returnable right, Token operation) { if(!left.returnType().equals(Returnable.ReturnType.BOOLEAN) || !right.returnType().equals(Returnable.ReturnType.BOOLEAN)) { throw new ParseException( - "Operation " + operation.getType() + " not supported between " + left.returnType() + " and " + right.returnType(), - operation.getPosition()); + "Operation " + operation.getType() + " not supported between " + left.returnType() + " and " + right.returnType(), + operation.getPosition()); } } - + public static void checkVarType(Token token, Returnable.ReturnType returnType) { if(returnType.equals(Returnable.ReturnType.STRING) && token.getType().equals(Token.Type.STRING_VARIABLE)) return; if(returnType.equals(Returnable.ReturnType.NUMBER) && token.getType().equals(Token.Type.NUMBER_VARIABLE)) return; if(returnType.equals(Returnable.ReturnType.BOOLEAN) && token.getType().equals(Token.Type.BOOLEAN_VARIABLE)) return; throw new ParseException("Type mismatch, cannot convert from " + returnType + " to " + token.getType(), token.getPosition()); } - + /** * Checks if token is a binary operator * @@ -95,17 +95,17 @@ public class ParserUtil { if(!token.isBinaryOperator()) throw new ParseException("Expected binary operator, found " + token.getType(), token.getPosition()); } - + public static Returnable.ReturnType getVariableReturnType(Token varToken) { 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()); + varToken.getPosition()); }; } - + public static boolean hasPrecedence(Token.Type first, Token.Type second) { if(!PRECEDENCE.containsKey(first)) return false; Map pre = PRECEDENCE.get(first); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/exceptions/ParseException.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/exceptions/ParseException.java index d72c58aac..9e62ad278 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/exceptions/ParseException.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/exceptions/ParseException.java @@ -16,22 +16,22 @@ public class ParseException extends RuntimeException { @Serial private static final long serialVersionUID = 6744390543046766386L; private final Position position; - + public ParseException(String message, Position position) { super(message); this.position = position; } - + public ParseException(String message, Position position, Throwable cause) { super(message, cause); this.position = position; } - + @Override public String getMessage() { return super.getMessage() + ": " + position; } - + public Position getPosition() { return position; } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Block.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Block.java index d67e6a437..1b49e8ca4 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Block.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Block.java @@ -15,12 +15,12 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class Block implements Item> { private final List> items; private final Position position; - + public Block(List> items, Position position) { this.items = items; this.position = position; } - + @Override public ReturnInfo apply(ImplementationArguments implementationArguments, Scope scope) { for(Item item : items) { @@ -31,44 +31,44 @@ public class Block implements Item> { } return new ReturnInfo<>(ReturnLevel.NONE, null); } - + @Override public Position getPosition() { return position; } - + public enum ReturnLevel { NONE(false), BREAK(false), CONTINUE(false), RETURN(true), FAIL(true); - + private final boolean returnFast; - + ReturnLevel(boolean returnFast) { this.returnFast = returnFast; } - + public boolean isReturnFast() { return returnFast; } } - - + + public static class ReturnInfo { private final ReturnLevel level; private final T data; - + public ReturnInfo(ReturnLevel level, T data) { this.level = level; this.data = data; } - + public ReturnLevel getLevel() { return level; } - + public T getData() { return data; } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Executable.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Executable.java index 09c11f2dc..6f9c026a0 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Executable.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Executable.java @@ -7,12 +7,12 @@ import com.dfsek.terra.addons.terrascript.parser.lang.Scope.ScopeBuilder; public class Executable { private final Block script; private final ThreadLocal scope; - + public Executable(Block script, ScopeBuilder scopeBuilder) { this.script = script; this.scope = ThreadLocal.withInitial(scopeBuilder::build); } - + public boolean execute(ImplementationArguments arguments) { return script.apply(arguments, scope.get()).getLevel() != Block.ReturnLevel.FAIL; } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Item.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Item.java index 6c85741ad..297319fe8 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Item.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Item.java @@ -12,14 +12,14 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public interface Item { T apply(ImplementationArguments implementationArguments, Scope scope); - + default double applyDouble(ImplementationArguments implementationArguments, Scope scope) { throw new UnsupportedOperationException("Cannot apply " + this + " as double"); } - + default boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { throw new UnsupportedOperationException("Cannot apply " + this + " as double"); } - + Position getPosition(); } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Returnable.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Returnable.java index fd0012754..8faaba844 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Returnable.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Returnable.java @@ -9,20 +9,20 @@ package com.dfsek.terra.addons.terrascript.parser.lang; public interface Returnable extends Item { ReturnType returnType(); - + enum ReturnType { NUMBER(true), STRING(true), BOOLEAN(false), VOID(false), OBJECT(false); - + private final boolean comparable; - + ReturnType(boolean comparable) { this.comparable = comparable; } - + public boolean isComparable() { return comparable; } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Scope.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Scope.java index cd2de2393..0c1fd8b2e 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Scope.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/Scope.java @@ -12,46 +12,46 @@ public class Scope { private final double[] num; private final boolean[] bool; private final String[] str; - + private Scope(int numSize, int boolSize, int strSize) { this.num = new double[numSize]; this.bool = new boolean[boolSize]; this.str = new String[strSize]; } - + public double getNum(int index) { return num[index]; } - + public boolean getBool(int index) { return bool[index]; } - + public String getStr(int index) { return str[index]; } - + public void setNum(int index, double value) { num[index] = value; } - + public void setBool(int index, boolean value) { bool[index] = value; } - + public void setStr(int index, String value) { str[index] = value; } - + public static final class ScopeBuilder { private final Map> indices; private int numSize, boolSize, strSize = 0; private ScopeBuilder parent; - + public ScopeBuilder() { this.indices = new HashMap<>(); } - + private ScopeBuilder(ScopeBuilder parent) { this.parent = parent; this.numSize = parent.numSize; @@ -59,22 +59,22 @@ public class Scope { this.strSize = parent.strSize; this.indices = new HashMap<>(parent.indices); } - + public Scope build() { return new Scope(numSize, boolSize, strSize); } - + public ScopeBuilder sub() { return new ScopeBuilder(this); } - + private String check(String id) { if(indices.containsKey(id)) { throw new IllegalArgumentException("Variable with ID " + id + " already registered."); } return id; } - + public int num(String id) { int num = numSize; indices.put(check(id), Pair.of(num, ReturnType.NUMBER)); @@ -82,7 +82,7 @@ public class Scope { updateNumSize(numSize); return num; } - + public int str(String id) { int str = strSize; indices.put(check(id), Pair.of(str, ReturnType.STRING)); @@ -90,7 +90,7 @@ public class Scope { updateStrSize(strSize); return str; } - + public int bool(String id) { int bool = boolSize; indices.put(check(id), Pair.of(bool, ReturnType.BOOLEAN)); @@ -98,37 +98,37 @@ public class Scope { updateBoolSize(boolSize); return bool; } - + private void updateBoolSize(int size) { this.boolSize = Math.max(boolSize, size); if(parent != null) { parent.updateBoolSize(size); } } - + private void updateNumSize(int size) { this.numSize = Math.max(numSize, size); if(parent != null) { parent.updateNumSize(size); } } - + private void updateStrSize(int size) { this.strSize = Math.max(strSize, size); if(parent != null) { parent.updateStrSize(size); } } - + public int getIndex(String id) { return indices.get(id).getLeft(); } - + public ReturnType getType(String id) { return indices.get(id).getRight(); } - - + + public boolean contains(String id) { return indices.containsKey(id); } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/BooleanConstant.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/BooleanConstant.java index cdf1bcb1c..7629beb16 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/BooleanConstant.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/BooleanConstant.java @@ -14,17 +14,17 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class BooleanConstant extends ConstantExpression { private final boolean constant; - + public BooleanConstant(Boolean constant, Position position) { super(constant, position); this.constant = constant; } - + @Override public boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { return constant; } - + @Override public ReturnType returnType() { return ReturnType.BOOLEAN; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/ConstantExpression.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/ConstantExpression.java index a87900658..668f5ab49 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/ConstantExpression.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/ConstantExpression.java @@ -16,22 +16,22 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public abstract class ConstantExpression implements Returnable { private final T constant; private final Position position; - + public ConstantExpression(T constant, Position position) { this.constant = constant; this.position = position; } - + @Override public T apply(ImplementationArguments implementationArguments, Scope scope) { return constant; } - + @Override public Position getPosition() { return position; } - + public T getConstant() { return constant; } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/NumericConstant.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/NumericConstant.java index ad1cb1ad1..e0fe4e352 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/NumericConstant.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/NumericConstant.java @@ -15,17 +15,17 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class NumericConstant extends ConstantExpression { private final double constant; - + public NumericConstant(Number constant, Position position) { super(constant, position); this.constant = constant.doubleValue(); } - + @Override public double applyDouble(ImplementationArguments implementationArguments, Scope scope) { return constant; } - + @Override public Returnable.ReturnType returnType() { return Returnable.ReturnType.NUMBER; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/StringConstant.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/StringConstant.java index d0df4dc0b..db45f04b2 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/StringConstant.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/constants/StringConstant.java @@ -15,7 +15,7 @@ public class StringConstant extends ConstantExpression { public StringConstant(String constant, Position position) { super(constant, position); } - + @Override public Returnable.ReturnType returnType() { return Returnable.ReturnType.STRING; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/Function.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/Function.java index 87c16e700..4a31c0f62 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/Function.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/Function.java @@ -19,23 +19,23 @@ public interface Function extends Returnable { public ReturnType returnType() { return null; } - + @Override public Object apply(ImplementationArguments implementationArguments, Scope scope) { return null; } - + @Override public Position getPosition() { return null; } }; - + @Override default double applyDouble(ImplementationArguments implementationArguments, Scope scope) { return ((Number) apply(implementationArguments, scope)).doubleValue(); } - + @Override default boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { return (Boolean) apply(implementationArguments, scope); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/FunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/FunctionBuilder.java index 808e81691..a29b11643 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/FunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/functions/FunctionBuilder.java @@ -15,8 +15,8 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public interface FunctionBuilder> { T build(List> argumentList, Position position); - + int argNumber(); - + Returnable.ReturnType getArgument(int position); } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/BreakKeyword.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/BreakKeyword.java index 3782ef4ee..6375b0c92 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/BreakKeyword.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/BreakKeyword.java @@ -16,21 +16,21 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class BreakKeyword implements Keyword> { private final Position position; - + public BreakKeyword(Position position) { this.position = position; } - + @Override public Block.ReturnInfo apply(ImplementationArguments implementationArguments, Scope scope) { return new Block.ReturnInfo<>(Block.ReturnLevel.BREAK, null); } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.VOID; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ContinueKeyword.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ContinueKeyword.java index a6f19fec9..5b774c4bb 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ContinueKeyword.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ContinueKeyword.java @@ -16,21 +16,21 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class ContinueKeyword implements Keyword> { private final Position position; - + public ContinueKeyword(Position position) { this.position = position; } - + @Override public Block.ReturnInfo apply(ImplementationArguments implementationArguments, Scope scope) { return new Block.ReturnInfo<>(Block.ReturnLevel.CONTINUE, null); } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.VOID; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/FailKeyword.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/FailKeyword.java index c70b7038b..94a9f43e6 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/FailKeyword.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/FailKeyword.java @@ -16,21 +16,21 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class FailKeyword implements Keyword> { private final Position position; - + public FailKeyword(Position position) { this.position = position; } - + @Override public Block.ReturnInfo apply(ImplementationArguments implementationArguments, Scope scope) { return new Block.ReturnInfo<>(Block.ReturnLevel.FAIL, null); } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.VOID; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ReturnKeyword.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ReturnKeyword.java index 0e624d1b6..01873d4f2 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ReturnKeyword.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/flow/ReturnKeyword.java @@ -16,21 +16,21 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class ReturnKeyword implements Keyword> { private final Position position; - + public ReturnKeyword(Position position) { this.position = position; } - + @Override public Block.ReturnInfo apply(ImplementationArguments implementationArguments, Scope scope) { return new Block.ReturnInfo<>(Block.ReturnLevel.RETURN, null); } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.VOID; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/ForKeyword.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/ForKeyword.java index c96b2d6b8..0cf31eac2 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/ForKeyword.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/ForKeyword.java @@ -22,7 +22,7 @@ public class ForKeyword implements Keyword> { private final Returnable statement; private final Item incrementer; private final Position position; - + public ForKeyword(Block conditional, Item initializer, Returnable statement, Item incrementer, Position position) { this.conditional = conditional; this.initializer = initializer; @@ -30,7 +30,7 @@ public class ForKeyword implements Keyword> { this.incrementer = incrementer; this.position = position; } - + @Override public Block.ReturnInfo apply(ImplementationArguments implementationArguments, Scope scope) { for(initializer.apply(implementationArguments, scope); @@ -42,12 +42,12 @@ public class ForKeyword implements Keyword> { } return new Block.ReturnInfo<>(Block.ReturnLevel.NONE, null); } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.VOID; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/IfKeyword.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/IfKeyword.java index f1687bfac..f7952b8f2 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/IfKeyword.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/IfKeyword.java @@ -26,7 +26,7 @@ public class IfKeyword implements Keyword> { private final Position position; private final List, Block>> elseIf; private final Block elseBlock; - + public IfKeyword(Block conditional, Returnable statement, List, Block>> elseIf, @Nullable Block elseBlock, Position position) { this.conditional = conditional; @@ -35,7 +35,7 @@ public class IfKeyword implements Keyword> { this.elseIf = elseIf; this.elseBlock = elseBlock; } - + @Override public Block.ReturnInfo apply(ImplementationArguments implementationArguments, Scope scope) { if(statement.apply(implementationArguments, scope)) return conditional.apply(implementationArguments, scope); @@ -49,12 +49,12 @@ public class IfKeyword implements Keyword> { } return new Block.ReturnInfo<>(Block.ReturnLevel.NONE, null); } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.VOID; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/WhileKeyword.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/WhileKeyword.java index 5085a4683..1d86c70a0 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/WhileKeyword.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/keywords/looplike/WhileKeyword.java @@ -19,13 +19,13 @@ public class WhileKeyword implements Keyword> { private final Block conditional; private final Returnable statement; private final Position position; - + public WhileKeyword(Block conditional, Returnable statement, Position position) { this.conditional = conditional; this.statement = statement; this.position = position; } - + @Override public Block.ReturnInfo apply(ImplementationArguments implementationArguments, Scope scope) { while(statement.apply(implementationArguments, scope)) { @@ -35,12 +35,12 @@ public class WhileKeyword implements Keyword> { } return new Block.ReturnInfo<>(Block.ReturnLevel.NONE, null); } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.VOID; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BinaryOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BinaryOperation.java index 7b1f5c313..036473537 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BinaryOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BinaryOperation.java @@ -15,13 +15,13 @@ public abstract class BinaryOperation implements Returnable { protected final Returnable left; protected final Returnable right; private final Position start; - + public BinaryOperation(Returnable left, Returnable right, Position start) { this.left = left; this.right = right; this.start = start; } - + @Override public Position getPosition() { return start; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanAndOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanAndOperation.java index cf51cf84c..e936aa172 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanAndOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanAndOperation.java @@ -17,17 +17,17 @@ public class BooleanAndOperation extends BinaryOperation { public BooleanAndOperation(Returnable left, Returnable right, Position start) { super(left, right, start); } - + @Override public ReturnType returnType() { return ReturnType.BOOLEAN; } - + @Override public Boolean apply(ImplementationArguments implementationArguments, Scope scope) { return applyBoolean(implementationArguments, scope); } - + @Override public boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { return left.applyBoolean(implementationArguments, scope) && right.applyBoolean(implementationArguments, scope); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanNotOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanNotOperation.java index 890257146..fedeac9f6 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanNotOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanNotOperation.java @@ -17,17 +17,17 @@ public class BooleanNotOperation extends UnaryOperation { public BooleanNotOperation(Returnable input, Position position) { super(input, position); } - + @Override public Boolean apply(ImplementationArguments implementationArguments, Scope scope) { return applyBoolean(implementationArguments, scope); } - + @Override public boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { return !input.applyBoolean(implementationArguments, scope); } - + @Override public ReturnType returnType() { return ReturnType.BOOLEAN; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanOrOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanOrOperation.java index fa7231221..34a55f566 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanOrOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/BooleanOrOperation.java @@ -17,17 +17,17 @@ public class BooleanOrOperation extends BinaryOperation { public BooleanOrOperation(Returnable left, Returnable right, Position start) { super(left, right, start); } - + @Override public Boolean apply(ImplementationArguments implementationArguments, Scope scope) { return applyBoolean(implementationArguments, scope); } - + @Override public boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { return left.applyBoolean(implementationArguments, scope) || right.applyBoolean(implementationArguments, scope); } - + @Override public ReturnType returnType() { return ReturnType.BOOLEAN; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ConcatenationOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ConcatenationOperation.java index d12835f6b..3b683733d 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ConcatenationOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ConcatenationOperation.java @@ -17,7 +17,7 @@ public class ConcatenationOperation extends BinaryOperation { public ConcatenationOperation(Returnable left, Returnable right, Position position) { super(left, right, position); } - + private static String toString(Object object) { String s = object.toString(); if(object instanceof Double) { @@ -28,12 +28,12 @@ public class ConcatenationOperation extends BinaryOperation { } return s; } - + @Override public Returnable.ReturnType returnType() { return Returnable.ReturnType.STRING; } - + @Override public Object apply(ImplementationArguments implementationArguments, Scope scope) { return toString(left.apply(implementationArguments, scope)) + toString(right.apply(implementationArguments, scope)); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/DivisionOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/DivisionOperation.java index 2cbd44691..7dea11393 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/DivisionOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/DivisionOperation.java @@ -17,17 +17,17 @@ public class DivisionOperation extends BinaryOperation { public DivisionOperation(Returnable left, Returnable right, Position position) { super(left, right, position); } - + @Override public Returnable.ReturnType returnType() { return Returnable.ReturnType.NUMBER; } - + @Override public Number apply(ImplementationArguments implementationArguments, Scope scope) { return applyDouble(implementationArguments, scope); } - + @Override public double applyDouble(ImplementationArguments implementationArguments, Scope scope) { return left.applyDouble(implementationArguments, scope) / right.applyDouble(implementationArguments, scope); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ModuloOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ModuloOperation.java index fcc5023fa..966726e41 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ModuloOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/ModuloOperation.java @@ -17,17 +17,17 @@ public class ModuloOperation extends BinaryOperation { public ModuloOperation(Returnable left, Returnable right, Position start) { super(left, right, start); } - + @Override public Number apply(ImplementationArguments implementationArguments, Scope scope) { return applyDouble(implementationArguments, scope); } - + @Override public double applyDouble(ImplementationArguments implementationArguments, Scope scope) { return left.applyDouble(implementationArguments, scope) % right.applyDouble(implementationArguments, scope); } - + @Override public ReturnType returnType() { return ReturnType.NUMBER; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/MultiplicationOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/MultiplicationOperation.java index bd0acd8c5..25dca639f 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/MultiplicationOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/MultiplicationOperation.java @@ -17,17 +17,17 @@ public class MultiplicationOperation extends BinaryOperation { public MultiplicationOperation(Returnable left, Returnable right, Position position) { super(left, right, position); } - + @Override public Number apply(ImplementationArguments implementationArguments, Scope scope) { return applyDouble(implementationArguments, scope); } - + @Override public double applyDouble(ImplementationArguments implementationArguments, Scope scope) { return left.applyDouble(implementationArguments, scope) * right.applyDouble(implementationArguments, scope); } - + @Override public ReturnType returnType() { return ReturnType.NUMBER; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NegationOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NegationOperation.java index e74959243..a56feb2ca 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NegationOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NegationOperation.java @@ -17,17 +17,17 @@ public class NegationOperation extends UnaryOperation { public NegationOperation(Returnable input, Position position) { super(input, position); } - + @Override public ReturnType returnType() { return ReturnType.NUMBER; } - + @Override public Number apply(ImplementationArguments implementationArguments, Scope scope) { return applyDouble(implementationArguments, scope); } - + @Override public double applyDouble(ImplementationArguments implementationArguments, Scope scope) { return -input.applyDouble(implementationArguments, scope); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NumberAdditionOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NumberAdditionOperation.java index 32c649247..5183bd690 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NumberAdditionOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/NumberAdditionOperation.java @@ -17,17 +17,17 @@ public class NumberAdditionOperation extends BinaryOperation { public NumberAdditionOperation(Returnable left, Returnable right, Position position) { super(left, right, position); } - + @Override public Number apply(ImplementationArguments implementationArguments, Scope scope) { return applyDouble(implementationArguments, scope); } - + @Override public double applyDouble(ImplementationArguments implementationArguments, Scope scope) { return left.applyDouble(implementationArguments, scope) + right.applyDouble(implementationArguments, scope); } - + @Override public ReturnType returnType() { return ReturnType.NUMBER; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/SubtractionOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/SubtractionOperation.java index 427756171..8b8bf5585 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/SubtractionOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/SubtractionOperation.java @@ -17,17 +17,17 @@ public class SubtractionOperation extends BinaryOperation { public SubtractionOperation(Returnable left, Returnable right, Position position) { super(left, right, position); } - + @Override public Number apply(ImplementationArguments implementationArguments, Scope scope) { return applyDouble(implementationArguments, scope); } - + @Override public double applyDouble(ImplementationArguments implementationArguments, Scope scope) { return left.applyDouble(implementationArguments, scope) - right.applyDouble(implementationArguments, scope); } - + @Override public ReturnType returnType() { return ReturnType.NUMBER; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/UnaryOperation.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/UnaryOperation.java index 13ec08b8b..316b884d6 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/UnaryOperation.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/UnaryOperation.java @@ -14,12 +14,12 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public abstract class UnaryOperation implements Returnable { protected final Returnable input; private final Position position; - + public UnaryOperation(Returnable input, Position position) { this.input = input; this.position = position; } - + @Override public Position getPosition() { return position; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java index 746fbd14e..b9b892439 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/EqualsStatement.java @@ -17,22 +17,22 @@ import static com.dfsek.terra.api.util.MathUtil.EPSILON; public class EqualsStatement extends BinaryOperation { - + public EqualsStatement(Returnable left, Returnable right, Position position) { super(left, right, position); } - - + + @Override public Returnable.ReturnType returnType() { return Returnable.ReturnType.BOOLEAN; } - + @Override public Boolean apply(ImplementationArguments implementationArguments, Scope scope) { return applyBoolean(implementationArguments, scope); } - + @Override public boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { Object leftValue = left.apply(implementationArguments, scope); @@ -40,7 +40,7 @@ public class EqualsStatement extends BinaryOperation { if(leftValue instanceof Number l && rightValue instanceof Number r) { return Math.abs(l.doubleValue() - r.doubleValue()) <= EPSILON; } - + return leftValue.equals(rightValue); } } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterOrEqualsThanStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterOrEqualsThanStatement.java index 693f1fdde..4a2b67505 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterOrEqualsThanStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterOrEqualsThanStatement.java @@ -18,17 +18,17 @@ public class GreaterOrEqualsThanStatement extends BinaryOperation left, Returnable right, Position position) { super(left, right, position); } - + @Override public Returnable.ReturnType returnType() { return Returnable.ReturnType.BOOLEAN; } - + @Override public Boolean apply(ImplementationArguments implementationArguments, Scope scope) { return applyBoolean(implementationArguments, scope); } - + @Override public boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { return left.applyDouble(implementationArguments, scope) >= right.applyDouble(implementationArguments, scope); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterThanStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterThanStatement.java index 82c317c19..1119b0adf 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterThanStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/GreaterThanStatement.java @@ -18,18 +18,18 @@ public class GreaterThanStatement extends BinaryOperation { public GreaterThanStatement(Returnable left, Returnable right, Position position) { super(left, right, position); } - - + + @Override public Boolean apply(ImplementationArguments implementationArguments, Scope scope) { return applyBoolean(implementationArguments, scope); } - + @Override public boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { return left.applyDouble(implementationArguments, scope) > right.applyDouble(implementationArguments, scope); } - + @Override public Returnable.ReturnType returnType() { return Returnable.ReturnType.BOOLEAN; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanOrEqualsStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanOrEqualsStatement.java index 6453e8d62..0a72a8da4 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanOrEqualsStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanOrEqualsStatement.java @@ -18,18 +18,18 @@ public class LessThanOrEqualsStatement extends BinaryOperation public LessThanOrEqualsStatement(Returnable left, Returnable right, Position position) { super(left, right, position); } - - + + @Override public Boolean apply(ImplementationArguments implementationArguments, Scope scope) { return applyBoolean(implementationArguments, scope); } - + @Override public boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { return left.applyDouble(implementationArguments, scope) <= right.applyDouble(implementationArguments, scope); } - + @Override public Returnable.ReturnType returnType() { return Returnable.ReturnType.BOOLEAN; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanStatement.java index f710e3630..c56366819 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/LessThanStatement.java @@ -18,18 +18,18 @@ public class LessThanStatement extends BinaryOperation { public LessThanStatement(Returnable left, Returnable right, Position position) { super(left, right, position); } - - + + @Override public Boolean apply(ImplementationArguments implementationArguments, Scope scope) { return applyBoolean(implementationArguments, scope); } - + @Override public boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { return left.applyDouble(implementationArguments, scope) < right.applyDouble(implementationArguments, scope); } - + @Override public Returnable.ReturnType returnType() { return Returnable.ReturnType.BOOLEAN; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/NotEqualsStatement.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/NotEqualsStatement.java index 43373d7fe..fab918c89 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/NotEqualsStatement.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/operations/statements/NotEqualsStatement.java @@ -20,12 +20,12 @@ public class NotEqualsStatement extends BinaryOperation { public NotEqualsStatement(Returnable left, Returnable right, Position position) { super(left, right, position); } - + @Override public Boolean apply(ImplementationArguments implementationArguments, Scope scope) { return applyBoolean(implementationArguments, scope); } - + @Override public boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { Object leftValue = left.apply(implementationArguments, scope); @@ -33,10 +33,10 @@ public class NotEqualsStatement extends BinaryOperation { if(leftValue instanceof Number l && rightValue instanceof Number r) { return Math.abs(l.doubleValue() - r.doubleValue()) > EPSILON; } - + return !leftValue.equals(rightValue); } - + @Override public Returnable.ReturnType returnType() { return Returnable.ReturnType.BOOLEAN; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/BooleanVariable.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/BooleanVariable.java index 7131aa578..9e4c8aa24 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/BooleanVariable.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/BooleanVariable.java @@ -14,27 +14,27 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class BooleanVariable implements Variable { private final Position position; private Boolean value; - + public BooleanVariable(Boolean value, Position position) { this.value = value; this.position = position; } - + @Override public Boolean getValue() { return value; } - + @Override public void setValue(Boolean value) { this.value = value; } - + @Override public Returnable.ReturnType getType() { return Returnable.ReturnType.BOOLEAN; } - + @Override public Position getPosition() { return position; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/NumberVariable.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/NumberVariable.java index bab6fbae3..8d4cfb62b 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/NumberVariable.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/NumberVariable.java @@ -14,27 +14,27 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class NumberVariable implements Variable { private final Position position; private Number value; - + public NumberVariable(Number value, Position position) { this.value = value; this.position = position; } - + @Override public Number getValue() { return value; } - + @Override public void setValue(Number value) { this.value = value; } - + @Override public Returnable.ReturnType getType() { return Returnable.ReturnType.NUMBER; } - + @Override public Position getPosition() { return position; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/StringVariable.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/StringVariable.java index a08fa40bd..564e71ebf 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/StringVariable.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/StringVariable.java @@ -14,27 +14,27 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class StringVariable implements Variable { private final Position position; private String value; - + public StringVariable(String value, Position position) { this.value = value; this.position = position; } - + @Override public String getValue() { return value; } - + @Override public void setValue(String value) { this.value = value; } - + @Override public Returnable.ReturnType getType() { return Returnable.ReturnType.STRING; } - + @Override public Position getPosition() { return position; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/Variable.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/Variable.java index 0deaad477..a19122f37 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/Variable.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/Variable.java @@ -13,10 +13,10 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public interface Variable { T getValue(); - + void setValue(T value); - + Returnable.ReturnType getType(); - + Position getPosition(); } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/BoolAssignmentNode.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/BoolAssignmentNode.java index 8f0f47ee9..a66fb3afd 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/BoolAssignmentNode.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/BoolAssignmentNode.java @@ -10,12 +10,12 @@ public class BoolAssignmentNode extends VariableAssignmentNode { public BoolAssignmentNode(Returnable value, Position position, int index) { super(value, position, index); } - + @Override public Boolean apply(ImplementationArguments implementationArguments, Scope scope) { return applyBoolean(implementationArguments, scope); } - + @Override public boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { boolean val = value.applyBoolean(implementationArguments, scope); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/NumAssignmentNode.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/NumAssignmentNode.java index 1b67e7150..a739995e2 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/NumAssignmentNode.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/NumAssignmentNode.java @@ -10,12 +10,12 @@ public class NumAssignmentNode extends VariableAssignmentNode { public NumAssignmentNode(Returnable value, Position position, int index) { super(value, position, index); } - + @Override public Number apply(ImplementationArguments implementationArguments, Scope scope) { return applyDouble(implementationArguments, scope); } - + @Override public double applyDouble(ImplementationArguments implementationArguments, Scope scope) { double val = value.applyDouble(implementationArguments, scope); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/StrAssignmentNode.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/StrAssignmentNode.java index ee811dbd8..c70150a1a 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/StrAssignmentNode.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/StrAssignmentNode.java @@ -10,12 +10,12 @@ public class StrAssignmentNode extends VariableAssignmentNode { public StrAssignmentNode(Returnable value, Position position, int index) { super(value, position, index); } - + @Override public String apply(ImplementationArguments implementationArguments, Scope scope) { String val = value.apply(implementationArguments, scope); scope.setStr(index, val); return val; } - + } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/VariableAssignmentNode.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/VariableAssignmentNode.java index 9b652793f..634ff152a 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/VariableAssignmentNode.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/assign/VariableAssignmentNode.java @@ -16,14 +16,14 @@ public abstract class VariableAssignmentNode implements Item { protected final Returnable value; protected final int index; private final Position position; - - + + public VariableAssignmentNode(Returnable value, Position position, int index) { this.value = value; this.index = index; this.position = position; } - + @Override public Position getPosition() { return position; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/BoolVariableReferenceNode.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/BoolVariableReferenceNode.java index c2295f2e2..a8eb82b46 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/BoolVariableReferenceNode.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/BoolVariableReferenceNode.java @@ -9,12 +9,12 @@ public class BoolVariableReferenceNode extends VariableReferenceNode { public BoolVariableReferenceNode(Position position, ReturnType type, int index) { super(position, type, index); } - + @Override public Boolean apply(ImplementationArguments implementationArguments, Scope scope) { return scope.getBool(index); } - + @Override public boolean applyBoolean(ImplementationArguments implementationArguments, Scope scope) { return scope.getBool(index); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/NumVariableReferenceNode.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/NumVariableReferenceNode.java index a266dcca9..11b0c961b 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/NumVariableReferenceNode.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/NumVariableReferenceNode.java @@ -9,12 +9,12 @@ public class NumVariableReferenceNode extends VariableReferenceNode { public NumVariableReferenceNode(Position position, ReturnType type, int index) { super(position, type, index); } - + @Override public Number apply(ImplementationArguments implementationArguments, Scope scope) { return scope.getNum(index); } - + @Override public double applyDouble(ImplementationArguments implementationArguments, Scope scope) { return scope.getNum(index); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/StrVariableReferenceNode.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/StrVariableReferenceNode.java index d67acc557..84ecbd933 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/StrVariableReferenceNode.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/StrVariableReferenceNode.java @@ -9,7 +9,7 @@ public class StrVariableReferenceNode extends VariableReferenceNode { public StrVariableReferenceNode(Position position, ReturnType type, int index) { super(position, type, index); } - + @Override public String apply(ImplementationArguments implementationArguments, Scope scope) { return scope.getStr(index); diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/VariableReferenceNode.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/VariableReferenceNode.java index 720b121e9..598828b34 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/VariableReferenceNode.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/lang/variables/reference/VariableReferenceNode.java @@ -15,18 +15,18 @@ public abstract class VariableReferenceNode implements Returnable { protected final int index; private final Position position; private final ReturnType type; - + public VariableReferenceNode(Position position, ReturnType type, int index) { this.position = position; this.type = type; this.index = index; } - + @Override public ReturnType returnType() { return type; } - + @Override public Position getPosition() { return position; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java index bbf9394b7..45b004a22 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/StructureScript.java @@ -53,10 +53,10 @@ public class StructureScript implements Structure, Keyed { private static final Logger LOGGER = LoggerFactory.getLogger(StructureScript.class); private final Executable block; private final RegistryKey id; - + private final String profile; private final Platform platform; - + @SuppressWarnings("rawtypes") public StructureScript(InputStream inputStream, RegistryKey id, Platform platform, Registry registry, Registry lootRegistry, @@ -69,66 +69,66 @@ public class StructureScript implements Structure, Keyed { } this.id = id; this.profile = "terrascript_direct:" + id; - + //noinspection unchecked functionRegistry.forEach((key, function) -> parser.registerFunction(key.getID(), function)); // Register registry functions. - + parser - .registerFunction("block", new BlockFunctionBuilder(platform)) - .registerFunction("debugBlock", new BlockFunctionBuilder(platform)) - .registerFunction("structure", new StructureFunctionBuilder(registry, platform)) - .registerFunction("randomInt", new RandomFunctionBuilder()) - .registerFunction("recursions", new RecursionsFunctionBuilder()) - .registerFunction("setMark", new SetMarkFunctionBuilder()) - .registerFunction("getMark", new GetMarkFunctionBuilder()) - .registerFunction("pull", new PullFunctionBuilder(platform)) - .registerFunction("loot", new LootFunctionBuilder(platform, lootRegistry, this)) - .registerFunction("entity", new EntityFunctionBuilder(platform)) - .registerFunction("getBiome", new BiomeFunctionBuilder(platform)) - .registerFunction("getBlock", new CheckBlockFunctionBuilder()) - .registerFunction("state", new StateFunctionBuilder(platform)) - .registerFunction("setWaterlog", new UnaryBooleanFunctionBuilder((waterlog, args) -> args.setWaterlog(waterlog))) - .registerFunction("originX", new ZeroArgFunctionBuilder(arguments -> arguments.getOrigin().getX(), - Returnable.ReturnType.NUMBER)) - .registerFunction("originY", new ZeroArgFunctionBuilder(arguments -> arguments.getOrigin().getY(), - Returnable.ReturnType.NUMBER)) - .registerFunction("originZ", new ZeroArgFunctionBuilder(arguments -> arguments.getOrigin().getZ(), - Returnable.ReturnType.NUMBER)) - .registerFunction("rotation", new ZeroArgFunctionBuilder<>(arguments -> arguments.getRotation().toString(), - Returnable.ReturnType.STRING)) - .registerFunction("rotationDegrees", new ZeroArgFunctionBuilder<>(arguments -> arguments.getRotation().getDegrees(), - Returnable.ReturnType.NUMBER)) - .registerFunction("print", - new UnaryStringFunctionBuilder(string -> LOGGER.info("[TerraScript:{}] {}", id, string))) - .registerFunction("abs", new UnaryNumberFunctionBuilder(number -> Math.abs(number.doubleValue()))) - .registerFunction("pow2", new UnaryNumberFunctionBuilder(number -> Math.pow(number.doubleValue(), 2))) - .registerFunction("pow", new BinaryNumberFunctionBuilder( - (number, number2) -> Math.pow(number.doubleValue(), number2.doubleValue()))) - .registerFunction("sqrt", new UnaryNumberFunctionBuilder(number -> Math.sqrt(number.doubleValue()))) - .registerFunction("rsqrt", new UnaryNumberFunctionBuilder(number -> MathUtil.invSqrt(number.doubleValue()))) - .registerFunction("floor", new UnaryNumberFunctionBuilder(number -> Math.floor(number.doubleValue()))) - .registerFunction("ceil", new UnaryNumberFunctionBuilder(number -> Math.ceil(number.doubleValue()))) - .registerFunction("log", new UnaryNumberFunctionBuilder(number -> Math.log(number.doubleValue()))) - .registerFunction("round", new UnaryNumberFunctionBuilder(number -> Math.round(number.doubleValue()))) - .registerFunction("sin", new UnaryNumberFunctionBuilder(number -> MathUtil.sin(number.doubleValue()))) - .registerFunction("cos", new UnaryNumberFunctionBuilder(number -> MathUtil.cos(number.doubleValue()))) - .registerFunction("tan", new UnaryNumberFunctionBuilder(number -> MathUtil.tan(number.doubleValue()))) - .registerFunction("asin", new UnaryNumberFunctionBuilder(number -> Math.asin(number.doubleValue()))) - .registerFunction("acos", new UnaryNumberFunctionBuilder(number -> Math.acos(number.doubleValue()))) - .registerFunction("atan", new UnaryNumberFunctionBuilder(number -> Math.atan(number.doubleValue()))) - .registerFunction("max", new BinaryNumberFunctionBuilder( - (number, number2) -> Math.max(number.doubleValue(), number2.doubleValue()))) - .registerFunction("min", new BinaryNumberFunctionBuilder( - (number, number2) -> Math.min(number.doubleValue(), number2.doubleValue()))); - + .registerFunction("block", new BlockFunctionBuilder(platform)) + .registerFunction("debugBlock", new BlockFunctionBuilder(platform)) + .registerFunction("structure", new StructureFunctionBuilder(registry, platform)) + .registerFunction("randomInt", new RandomFunctionBuilder()) + .registerFunction("recursions", new RecursionsFunctionBuilder()) + .registerFunction("setMark", new SetMarkFunctionBuilder()) + .registerFunction("getMark", new GetMarkFunctionBuilder()) + .registerFunction("pull", new PullFunctionBuilder(platform)) + .registerFunction("loot", new LootFunctionBuilder(platform, lootRegistry, this)) + .registerFunction("entity", new EntityFunctionBuilder(platform)) + .registerFunction("getBiome", new BiomeFunctionBuilder(platform)) + .registerFunction("getBlock", new CheckBlockFunctionBuilder()) + .registerFunction("state", new StateFunctionBuilder(platform)) + .registerFunction("setWaterlog", new UnaryBooleanFunctionBuilder((waterlog, args) -> args.setWaterlog(waterlog))) + .registerFunction("originX", new ZeroArgFunctionBuilder(arguments -> arguments.getOrigin().getX(), + Returnable.ReturnType.NUMBER)) + .registerFunction("originY", new ZeroArgFunctionBuilder(arguments -> arguments.getOrigin().getY(), + Returnable.ReturnType.NUMBER)) + .registerFunction("originZ", new ZeroArgFunctionBuilder(arguments -> arguments.getOrigin().getZ(), + Returnable.ReturnType.NUMBER)) + .registerFunction("rotation", new ZeroArgFunctionBuilder<>(arguments -> arguments.getRotation().toString(), + Returnable.ReturnType.STRING)) + .registerFunction("rotationDegrees", new ZeroArgFunctionBuilder<>(arguments -> arguments.getRotation().getDegrees(), + Returnable.ReturnType.NUMBER)) + .registerFunction("print", + new UnaryStringFunctionBuilder(string -> LOGGER.info("[TerraScript:{}] {}", id, string))) + .registerFunction("abs", new UnaryNumberFunctionBuilder(number -> Math.abs(number.doubleValue()))) + .registerFunction("pow2", new UnaryNumberFunctionBuilder(number -> Math.pow(number.doubleValue(), 2))) + .registerFunction("pow", new BinaryNumberFunctionBuilder( + (number, number2) -> Math.pow(number.doubleValue(), number2.doubleValue()))) + .registerFunction("sqrt", new UnaryNumberFunctionBuilder(number -> Math.sqrt(number.doubleValue()))) + .registerFunction("rsqrt", new UnaryNumberFunctionBuilder(number -> MathUtil.invSqrt(number.doubleValue()))) + .registerFunction("floor", new UnaryNumberFunctionBuilder(number -> Math.floor(number.doubleValue()))) + .registerFunction("ceil", new UnaryNumberFunctionBuilder(number -> Math.ceil(number.doubleValue()))) + .registerFunction("log", new UnaryNumberFunctionBuilder(number -> Math.log(number.doubleValue()))) + .registerFunction("round", new UnaryNumberFunctionBuilder(number -> Math.round(number.doubleValue()))) + .registerFunction("sin", new UnaryNumberFunctionBuilder(number -> MathUtil.sin(number.doubleValue()))) + .registerFunction("cos", new UnaryNumberFunctionBuilder(number -> MathUtil.cos(number.doubleValue()))) + .registerFunction("tan", new UnaryNumberFunctionBuilder(number -> MathUtil.tan(number.doubleValue()))) + .registerFunction("asin", new UnaryNumberFunctionBuilder(number -> Math.asin(number.doubleValue()))) + .registerFunction("acos", new UnaryNumberFunctionBuilder(number -> Math.acos(number.doubleValue()))) + .registerFunction("atan", new UnaryNumberFunctionBuilder(number -> Math.atan(number.doubleValue()))) + .registerFunction("max", new BinaryNumberFunctionBuilder( + (number, number2) -> Math.max(number.doubleValue(), number2.doubleValue()))) + .registerFunction("min", new BinaryNumberFunctionBuilder( + (number, number2) -> Math.min(number.doubleValue(), number2.doubleValue()))); + if(!platform.getTerraConfig().isDebugScript()) { parser.ignoreFunction("debugBlock"); } - + block = parser.parse(); this.platform = platform; } - + @Override @SuppressWarnings("try") public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation) { @@ -137,14 +137,14 @@ public class StructureScript implements Structure, Keyed { platform.getProfiler().pop(profile); return result; } - + public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation, int recursions) { platform.getProfiler().push(profile); boolean result = applyBlock(new TerraImplementationArguments(location, rotation, random, world, recursions)); platform.getProfiler().pop(profile); return result; } - + private boolean applyBlock(TerraImplementationArguments arguments) { try { return block.execute(arguments); @@ -153,7 +153,7 @@ public class StructureScript implements Structure, Keyed { return false; } } - + @Override public RegistryKey getRegistryKey() { return id; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/TerraImplementationArguments.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/TerraImplementationArguments.java index b807b07db..97e69feca 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/TerraImplementationArguments.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/TerraImplementationArguments.java @@ -26,7 +26,7 @@ public class TerraImplementationArguments implements ImplementationArguments { private final int recursions; private final Vector3Int origin; private boolean waterlog = false; - + public TerraImplementationArguments(Vector3Int origin, Rotation rotation, Random random, WritableWorld world, int recursions) { this.rotation = rotation; this.random = random; @@ -34,39 +34,39 @@ public class TerraImplementationArguments implements ImplementationArguments { this.recursions = recursions; this.origin = origin; } - + public int getRecursions() { return recursions; } - + public Random getRandom() { return random; } - + public Rotation getRotation() { return rotation; } - + public boolean isWaterlog() { return waterlog; } - + public void setWaterlog(boolean waterlog) { this.waterlog = waterlog; } - + public WritableWorld getWorld() { return world; } - + public Vector3Int getOrigin() { return origin; } - + public void setMark(Vector3 pos, String mark) { marks.put(pos, mark); } - + public String getMark(Vector3 pos) { return marks.get(pos); } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BinaryNumberFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BinaryNumberFunctionBuilder.java index 551b4ebe1..66fdf3555 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BinaryNumberFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BinaryNumberFunctionBuilder.java @@ -19,13 +19,13 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class BinaryNumberFunctionBuilder implements FunctionBuilder> { - + private final BiFunction function; - + public BinaryNumberFunctionBuilder(BiFunction function) { this.function = function; } - + @Override public Function build(List> argumentList, Position position) { return new Function<>() { @@ -33,26 +33,26 @@ public class BinaryNumberFunctionBuilder implements FunctionBuilder) argumentList.get(0)).apply(implementationArguments, scope), - ((Returnable) argumentList.get(1)).apply(implementationArguments, scope)); + ((Returnable) argumentList.get(1)).apply(implementationArguments, scope)); } - + @Override public Position getPosition() { return position; } }; } - + @Override public int argNumber() { return 2; } - + @Override public Returnable.ReturnType getArgument(int position) { if(position == 0 || position == 1) return Returnable.ReturnType.NUMBER; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BiomeFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BiomeFunctionBuilder.java index b68fb4c8b..2b53cfef7 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BiomeFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BiomeFunctionBuilder.java @@ -18,23 +18,23 @@ import com.dfsek.terra.api.Platform; public class BiomeFunctionBuilder implements FunctionBuilder { private final Platform platform; - + public BiomeFunctionBuilder(Platform platform) { this.platform = platform; } - + @SuppressWarnings("unchecked") @Override public BiomeFunction build(List> argumentList, Position position) { return new BiomeFunction((Returnable) argumentList.get(0), (Returnable) argumentList.get(1), - (Returnable) argumentList.get(2), position); + (Returnable) argumentList.get(2), position); } - + @Override public int argNumber() { return 3; } - + @Override public Returnable.ReturnType getArgument(int position) { return switch(position) { diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java index 88183c088..d0621e206 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/BlockFunctionBuilder.java @@ -21,11 +21,11 @@ import com.dfsek.terra.api.Platform; public class BlockFunctionBuilder implements FunctionBuilder { private final Platform platform; - + public BlockFunctionBuilder(Platform platform) { this.platform = platform; } - + @SuppressWarnings("unchecked") @Override public BlockFunction build(List> argumentList, Position position) { @@ -36,19 +36,19 @@ public class BlockFunctionBuilder implements FunctionBuilder { if(argumentList.size() == 6) physics = (Returnable) argumentList.get(5); if(argumentList.get(3) instanceof StringConstant) { return new BlockFunction.Constant((Returnable) argumentList.get(0), (Returnable) argumentList.get(1), - (Returnable) argumentList.get(2), (StringConstant) argumentList.get(3), - overwrite, physics, platform, position); + (Returnable) argumentList.get(2), (StringConstant) argumentList.get(3), + overwrite, physics, platform, position); } return new BlockFunction((Returnable) argumentList.get(0), (Returnable) argumentList.get(1), - (Returnable) argumentList.get(2), (Returnable) argumentList.get(3), overwrite, physics, - platform, position); + (Returnable) argumentList.get(2), (Returnable) argumentList.get(3), overwrite, physics, + platform, position); } - + @Override public int argNumber() { return -1; } - + @Override public Returnable.ReturnType getArgument(int position) { return switch(position) { diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/CheckBlockFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/CheckBlockFunctionBuilder.java index da5f9a633..588b99f53 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/CheckBlockFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/CheckBlockFunctionBuilder.java @@ -20,14 +20,14 @@ public class CheckBlockFunctionBuilder implements FunctionBuilder> argumentList, Position position) { return new CheckBlockFunction((Returnable) argumentList.get(0), (Returnable) argumentList.get(1), - (Returnable) argumentList.get(2), position); + (Returnable) argumentList.get(2), position); } - + @Override public int argNumber() { return 3; } - + @Override public Returnable.ReturnType getArgument(int position) { return switch(position) { diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/EntityFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/EntityFunctionBuilder.java index 9c980a84f..c91f89f11 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/EntityFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/EntityFunctionBuilder.java @@ -18,23 +18,23 @@ import com.dfsek.terra.api.Platform; public class EntityFunctionBuilder implements FunctionBuilder { private final Platform platform; - + public EntityFunctionBuilder(Platform platform) { this.platform = platform; } - + @SuppressWarnings("unchecked") @Override public EntityFunction build(List> argumentList, Position position) { return new EntityFunction((Returnable) argumentList.get(0), (Returnable) argumentList.get(1), - (Returnable) argumentList.get(2), (Returnable) argumentList.get(3), platform, position); + (Returnable) argumentList.get(2), (Returnable) argumentList.get(3), platform, position); } - + @Override public int argNumber() { return 4; } - + @Override public Returnable.ReturnType getArgument(int position) { return switch(position) { diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/GetMarkFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/GetMarkFunctionBuilder.java index 9960d8a4e..487548ab5 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/GetMarkFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/GetMarkFunctionBuilder.java @@ -16,22 +16,22 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class GetMarkFunctionBuilder implements FunctionBuilder { - + public GetMarkFunctionBuilder() { } - + @SuppressWarnings("unchecked") @Override public GetMarkFunction build(List> argumentList, Position position) { return new GetMarkFunction((Returnable) argumentList.get(0), (Returnable) argumentList.get(1), - (Returnable) argumentList.get(2), position); + (Returnable) argumentList.get(2), position); } - + @Override public int argNumber() { return 3; } - + @Override public Returnable.ReturnType getArgument(int position) { return switch(position) { diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/LootFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/LootFunctionBuilder.java index b1c5fb6ba..c26900dd1 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/LootFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/LootFunctionBuilder.java @@ -23,26 +23,26 @@ public class LootFunctionBuilder implements FunctionBuilder { private final Platform platform; private final Registry registry; private final StructureScript script; - + public LootFunctionBuilder(Platform platform, Registry registry, StructureScript script) { this.platform = platform; this.registry = registry; this.script = script; } - + @SuppressWarnings("unchecked") @Override public LootFunction build(List> argumentList, Position position) { return new LootFunction(registry, (Returnable) argumentList.get(0), (Returnable) argumentList.get(1), - (Returnable) argumentList.get(2), (Returnable) argumentList.get(3), platform, position, - script); + (Returnable) argumentList.get(2), (Returnable) argumentList.get(3), platform, position, + script); } - + @Override public int argNumber() { return 4; } - + @Override public Returnable.ReturnType getArgument(int position) { return switch(position) { diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/PullFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/PullFunctionBuilder.java index 1d3e5e67b..e92174323 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/PullFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/PullFunctionBuilder.java @@ -18,23 +18,23 @@ import com.dfsek.terra.api.Platform; public class PullFunctionBuilder implements FunctionBuilder { private final Platform platform; - + public PullFunctionBuilder(Platform platform) { this.platform = platform; } - + @SuppressWarnings("unchecked") @Override public PullFunction build(List> argumentList, Position position) { return new PullFunction((Returnable) argumentList.get(0), (Returnable) argumentList.get(1), - (Returnable) argumentList.get(2), (Returnable) argumentList.get(3), platform, position); + (Returnable) argumentList.get(2), (Returnable) argumentList.get(3), platform, position); } - + @Override public int argNumber() { return 4; } - + @Override public Returnable.ReturnType getArgument(int position) { return switch(position) { diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RandomFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RandomFunctionBuilder.java index 0c3b47534..b83543d9e 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RandomFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RandomFunctionBuilder.java @@ -21,12 +21,12 @@ public class RandomFunctionBuilder implements FunctionBuilder { public RandomFunction build(List> argumentList, Position position) { return new RandomFunction((Returnable) argumentList.get(0), position); } - + @Override public int argNumber() { return 1; } - + @Override public Returnable.ReturnType getArgument(int position) { if(position == 0) return Returnable.ReturnType.NUMBER; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RecursionsFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RecursionsFunctionBuilder.java index 9d228b37a..37827e830 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RecursionsFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/RecursionsFunctionBuilder.java @@ -20,12 +20,12 @@ public class RecursionsFunctionBuilder implements FunctionBuilder> argumentList, Position position) { return new RecursionsFunction(position); } - + @Override public int argNumber() { return 0; } - + @Override public Returnable.ReturnType getArgument(int position) { return null; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/SetMarkFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/SetMarkFunctionBuilder.java index bb1d35949..35bf746c7 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/SetMarkFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/SetMarkFunctionBuilder.java @@ -16,22 +16,22 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class SetMarkFunctionBuilder implements FunctionBuilder { - + public SetMarkFunctionBuilder() { } - + @SuppressWarnings("unchecked") @Override public SetMarkFunction build(List> argumentList, Position position) { return new SetMarkFunction((Returnable) argumentList.get(0), (Returnable) argumentList.get(1), - (Returnable) argumentList.get(2), (Returnable) argumentList.get(3), position); + (Returnable) argumentList.get(2), (Returnable) argumentList.get(3), position); } - + @Override public int argNumber() { return 4; } - + @Override public Returnable.ReturnType getArgument(int position) { return switch(position) { diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StateFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StateFunctionBuilder.java index 6158c0371..3ff527e89 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StateFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StateFunctionBuilder.java @@ -19,24 +19,24 @@ import com.dfsek.terra.api.Platform; public class StateFunctionBuilder implements FunctionBuilder { private final Platform platform; - + public StateFunctionBuilder(Platform platform) { this.platform = platform; } - + @SuppressWarnings("unchecked") @Override public StateFunction build(List> argumentList, Position position) { if(argumentList.size() < 4) throw new ParseException("Expected data", position); return new StateFunction((Returnable) argumentList.get(0), (Returnable) argumentList.get(1), - (Returnable) argumentList.get(2), (Returnable) argumentList.get(3), position); + (Returnable) argumentList.get(2), (Returnable) argumentList.get(3), position); } - + @Override public int argNumber() { return 4; } - + @Override public Returnable.ReturnType getArgument(int position) { return switch(position) { diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StructureFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StructureFunctionBuilder.java index 2be864efe..9985c36b4 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StructureFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/StructureFunctionBuilder.java @@ -23,28 +23,28 @@ import com.dfsek.terra.api.structure.Structure; public class StructureFunctionBuilder implements FunctionBuilder { private final Registry registry; private final Platform platform; - + public StructureFunctionBuilder(Registry registry, Platform platform) { this.registry = registry; this.platform = platform; } - + @SuppressWarnings("unchecked") @Override public StructureFunction build(List> argumentList, Position position) { if(argumentList.size() < 5) throw new ParseException("Expected rotations", position); - + return new StructureFunction((Returnable) argumentList.remove(0), (Returnable) argumentList.remove(0), - (Returnable) argumentList.remove(0), (Returnable) argumentList.remove(0), - argumentList.stream().map(item -> ((Returnable) item)).collect(Collectors.toList()), registry, - position, platform); + (Returnable) argumentList.remove(0), (Returnable) argumentList.remove(0), + argumentList.stream().map(item -> ((Returnable) item)).collect(Collectors.toList()), registry, + position, platform); } - + @Override public int argNumber() { return -1; } - + @Override public Returnable.ReturnType getArgument(int position) { return switch(position) { diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryBooleanFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryBooleanFunctionBuilder.java index 427a663fe..0be9cd209 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryBooleanFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryBooleanFunctionBuilder.java @@ -20,13 +20,13 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class UnaryBooleanFunctionBuilder implements FunctionBuilder> { - + private final BiConsumer function; - + public UnaryBooleanFunctionBuilder(BiConsumer function) { this.function = function; } - + @Override public Function build(List> argumentList, Position position) { return new Function<>() { @@ -34,27 +34,27 @@ public class UnaryBooleanFunctionBuilder implements FunctionBuilder) argumentList.get(0)).apply(implementationArguments, scope), - (TerraImplementationArguments) implementationArguments); + (TerraImplementationArguments) implementationArguments); return null; } - + @Override public Position getPosition() { return position; } }; } - + @Override public int argNumber() { return 1; } - + @Override public Returnable.ReturnType getArgument(int position) { if(position == 0) return Returnable.ReturnType.BOOLEAN; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryNumberFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryNumberFunctionBuilder.java index 28c0ad892..888dedf1a 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryNumberFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryNumberFunctionBuilder.java @@ -18,13 +18,13 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class UnaryNumberFunctionBuilder implements FunctionBuilder> { - + private final java.util.function.Function function; - + public UnaryNumberFunctionBuilder(java.util.function.Function function) { this.function = function; } - + @Override public Function build(List> argumentList, Position position) { return new Function<>() { @@ -32,25 +32,25 @@ public class UnaryNumberFunctionBuilder implements FunctionBuilder) argumentList.get(0)).apply(implementationArguments, scope)); } - + @Override public Position getPosition() { return position; } }; } - + @Override public int argNumber() { return 1; } - + @Override public Returnable.ReturnType getArgument(int position) { if(position == 0) return Returnable.ReturnType.NUMBER; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryStringFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryStringFunctionBuilder.java index 9e8cf4926..fd009b249 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryStringFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/UnaryStringFunctionBuilder.java @@ -18,13 +18,13 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class UnaryStringFunctionBuilder implements FunctionBuilder> { - + private final java.util.function.Consumer function; - + public UnaryStringFunctionBuilder(java.util.function.Consumer function) { this.function = function; } - + @Override public Function build(List> argumentList, Position position) { return new Function<>() { @@ -32,26 +32,26 @@ public class UnaryStringFunctionBuilder implements FunctionBuilder) argumentList.get(0)).apply(implementationArguments, scope)); return null; } - + @Override public Position getPosition() { return position; } }; } - + @Override public int argNumber() { return 1; } - + @Override public Returnable.ReturnType getArgument(int position) { if(position == 0) return Returnable.ReturnType.STRING; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/ZeroArgFunctionBuilder.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/ZeroArgFunctionBuilder.java index 40a2f1b74..55d39bd23 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/ZeroArgFunctionBuilder.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/ZeroArgFunctionBuilder.java @@ -21,12 +21,12 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class ZeroArgFunctionBuilder implements FunctionBuilder> { private final java.util.function.Function function; private final Returnable.ReturnType type; - + public ZeroArgFunctionBuilder(java.util.function.Function function, Returnable.ReturnType type) { this.function = function; this.type = type; } - + @Override public Function build(List> argumentList, Position position) { return new Function<>() { @@ -34,24 +34,24 @@ public class ZeroArgFunctionBuilder implements FunctionBuilder> { public ReturnType returnType() { return type; } - + @Override public T apply(ImplementationArguments implementationArguments, Scope scope) { return function.apply((TerraImplementationArguments) implementationArguments); } - + @Override public Position getPosition() { return position; } }; } - + @Override public int argNumber() { return 0; } - + @Override public Returnable.ReturnType getArgument(int position) { if(position == 0) return type; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BiomeFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BiomeFunction.java index d8329c5ff..21a1d155b 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BiomeFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BiomeFunction.java @@ -22,40 +22,40 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class BiomeFunction implements Function { private final Returnable x, y, z; private final Position position; - - + + public BiomeFunction(Returnable x, Returnable y, Returnable z, Position position) { this.x = x; this.y = y; this.z = z; this.position = position; } - - + + @Override public String apply(ImplementationArguments implementationArguments, Scope scope) { TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments; - + Vector2 xz = RotationUtil.rotateVector(Vector2.of(x.apply(implementationArguments, scope).doubleValue(), - z.apply(implementationArguments, scope).doubleValue()), - arguments.getRotation()); - - + z.apply(implementationArguments, scope).doubleValue()), + arguments.getRotation()); + + BiomeProvider grid = arguments.getWorld().getBiomeProvider(); - + return grid.getBiome(arguments.getOrigin() - .toVector3() - .mutable() - .add(Vector3.of((int) Math.round(xz.getX()), - y.apply(implementationArguments, scope).intValue(), - (int) Math.round(xz.getZ()))).immutable(), arguments.getWorld().getSeed()).getID(); + .toVector3() + .mutable() + .add(Vector3.of((int) Math.round(xz.getX()), + y.apply(implementationArguments, scope).intValue(), + (int) Math.round(xz.getZ()))).immutable(), arguments.getWorld().getSeed()).getID(); } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.STRING; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java index c5ca7eb7e..84130e701 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java @@ -7,8 +7,6 @@ package com.dfsek.terra.addons.terrascript.script.functions; -import com.dfsek.terra.addons.terrascript.parser.lang.constants.BooleanConstant; - import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -18,6 +16,7 @@ import java.util.Map; import com.dfsek.terra.addons.terrascript.parser.lang.ImplementationArguments; import com.dfsek.terra.addons.terrascript.parser.lang.Returnable; import com.dfsek.terra.addons.terrascript.parser.lang.Scope; +import com.dfsek.terra.addons.terrascript.parser.lang.constants.BooleanConstant; import com.dfsek.terra.addons.terrascript.parser.lang.constants.StringConstant; import com.dfsek.terra.addons.terrascript.parser.lang.functions.Function; import com.dfsek.terra.addons.terrascript.script.TerraImplementationArguments; @@ -38,7 +37,7 @@ public class BlockFunction implements Function { private final Returnable overwrite; private final Returnable physics; private final Position position; - + public BlockFunction(Returnable x, Returnable y, Returnable z, Returnable blockData, Returnable overwrite, Platform platform, Position position) { this.x = x; @@ -48,9 +47,9 @@ public class BlockFunction implements Function { this.overwrite = overwrite; this.platform = platform; this.position = position; - this.physics = new BooleanConstant(false, position);; + this.physics = new BooleanConstant(false, position); } - + public BlockFunction(Returnable x, Returnable y, Returnable z, Returnable blockData, Returnable overwrite, Returnable physics, Platform platform, Position position) { this.x = x; @@ -62,7 +61,7 @@ public class BlockFunction implements Function { this.position = position; this.physics = physics; } - + @Override public Void apply(ImplementationArguments implementationArguments, Scope scope) { TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments; @@ -70,25 +69,25 @@ public class BlockFunction implements Function { setBlock(implementationArguments, scope, arguments, rot); return null; } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.VOID; } - + void setBlock(ImplementationArguments implementationArguments, Scope scope, TerraImplementationArguments arguments, BlockState rot) { Vector2 xz = RotationUtil.rotateVector(Vector2.of(x.apply(implementationArguments, scope).doubleValue(), - z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); + z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); try { Vector3.Mutable set = Vector3.of((int) Math.round(xz.getX()), - y.apply(implementationArguments, scope).doubleValue(), - (int) Math.round(xz.getZ())).mutable().add(arguments.getOrigin()); + y.apply(implementationArguments, scope).doubleValue(), + (int) Math.round(xz.getZ())).mutable().add(arguments.getOrigin()); BlockState current = arguments.getWorld().getBlockState(set); if(overwrite.apply(implementationArguments, scope) || current.isAir()) { arguments.getWorld().setBlockState(set, rot, physics.apply(implementationArguments, scope)); @@ -97,21 +96,21 @@ public class BlockFunction implements Function { logger.error("Failed to place block at location {}", arguments.getOrigin(), e); } } - + protected BlockState getBlockState(ImplementationArguments arguments, Scope scope) { return data.computeIfAbsent(blockData.apply(arguments, scope), platform.getWorldHandle()::createBlockState); } - - + + public static class Constant extends BlockFunction { private final BlockState state; - + public Constant(Returnable x, Returnable y, Returnable z, StringConstant blockData, Returnable overwrite, Returnable physics, Platform platform, Position position) { super(x, y, z, blockData, overwrite, physics, platform, position); this.state = platform.getWorldHandle().createBlockState(blockData.getConstant()); } - + @Override protected BlockState getBlockState(ImplementationArguments arguments, Scope scope) { return state; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/CheckBlockFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/CheckBlockFunction.java index 7c94d2a63..8cc0d8864 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/CheckBlockFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/CheckBlockFunction.java @@ -21,41 +21,41 @@ import com.dfsek.terra.api.util.vector.Vector3; public class CheckBlockFunction implements Function { private final Returnable x, y, z; private final Position position; - + public CheckBlockFunction(Returnable x, Returnable y, Returnable z, Position position) { this.x = x; this.y = y; this.z = z; this.position = position; } - - + + @Override public String apply(ImplementationArguments implementationArguments, Scope scope) { TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments; - + Vector2 xz = RotationUtil.rotateVector(Vector2.of(x.apply(implementationArguments, scope).doubleValue(), - z.apply(implementationArguments, scope).doubleValue()), - arguments.getRotation()); - - + z.apply(implementationArguments, scope).doubleValue()), + arguments.getRotation()); + + String data = arguments.getWorld() - .getBlockState(arguments.getOrigin() - .toVector3() - .mutable() - .add(Vector3.of((int) Math.round(xz.getX()), - y.apply(implementationArguments, scope) - .doubleValue(), (int) Math.round(xz.getZ())))) - .getAsString(); + .getBlockState(arguments.getOrigin() + .toVector3() + .mutable() + .add(Vector3.of((int) Math.round(xz.getX()), + y.apply(implementationArguments, scope) + .doubleValue(), (int) Math.round(xz.getZ())))) + .getAsString(); if(data.contains("[")) return data.substring(0, data.indexOf('[')); // Strip properties else return data; } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.STRING; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/EntityFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/EntityFunction.java index d2edbb5db..cf703fbe8 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/EntityFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/EntityFunction.java @@ -29,40 +29,40 @@ public class EntityFunction implements Function { private final Returnable x, y, z; private final Position position; private final Platform platform; - + public EntityFunction(Returnable x, Returnable y, Returnable z, Returnable data, Platform platform, Position position) { this.position = position; this.platform = platform; if(!(data instanceof ConstantExpression)) throw new ParseException("Entity data must be constant", data.getPosition()); - + this.data = platform.getWorldHandle().getEntity(((ConstantExpression) data).getConstant()); this.x = x; this.y = y; this.z = z; } - + @Override public Void apply(ImplementationArguments implementationArguments, Scope scope) { TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments; Vector2 xz = RotationUtil.rotateVector(Vector2.of(x.apply(implementationArguments, scope).doubleValue(), - z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); - + z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); + Entity entity = arguments.getWorld().spawnEntity(Vector3.of(xz.getX(), y.apply(implementationArguments, scope).doubleValue(), - xz.getZ()) - .mutable() - .add(arguments.getOrigin()) - .add(0.5, 0, 0.5) - .immutable(), data); + xz.getZ()) + .mutable() + .add(arguments.getOrigin()) + .add(0.5, 0, 0.5) + .immutable(), data); platform.getEventManager().callEvent(new EntitySpawnEvent(entity.world().getPack(), entity)); return null; } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.VOID; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/GetMarkFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/GetMarkFunction.java index 8f6a31868..613773441 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/GetMarkFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/GetMarkFunction.java @@ -21,34 +21,34 @@ import com.dfsek.terra.api.util.vector.Vector3; public class GetMarkFunction implements Function { private final Returnable x, y, z; private final Position position; - + public GetMarkFunction(Returnable x, Returnable y, Returnable z, Position position) { this.position = position; this.x = x; this.y = y; this.z = z; } - + @Override public String apply(ImplementationArguments implementationArguments, Scope scope) { TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments; Vector2 xz = RotationUtil.rotateVector(Vector2.of(x.apply(implementationArguments, scope).doubleValue(), - z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); - + z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); + String mark = arguments.getMark(Vector3.of((int) Math.floor(xz.getX()), (int) Math.floor( - y.apply(implementationArguments, scope).doubleValue()), - (int) Math.floor(xz.getZ())) - .mutable() - .add(arguments.getOrigin()) - .immutable()); + y.apply(implementationArguments, scope).doubleValue()), + (int) Math.floor(xz.getZ())) + .mutable() + .add(arguments.getOrigin()) + .immutable()); return mark == null ? "" : mark; } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.STRING; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java index aa9f7c21e..67dd7fad3 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/LootFunction.java @@ -39,7 +39,7 @@ public class LootFunction implements Function { private final Position position; private final Platform platform; private final StructureScript script; - + public LootFunction(Registry registry, Returnable x, Returnable y, Returnable z, Returnable data, Platform platform, Position position, StructureScript script) { this.registry = registry; @@ -51,55 +51,55 @@ public class LootFunction implements Function { this.platform = platform; this.script = script; } - + @Override public Void apply(ImplementationArguments implementationArguments, Scope scope) { TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments; Vector2 xz = RotationUtil.rotateVector(Vector2.of(x.apply(implementationArguments, scope).doubleValue(), - z.apply(implementationArguments, scope).doubleValue()), - arguments.getRotation()); - - + z.apply(implementationArguments, scope).doubleValue()), + arguments.getRotation()); + + String id = data.apply(implementationArguments, scope); - - + + registry.get(RegistryKey.parse(id)) - .ifPresentOrElse(table -> { - Vector3 apply = Vector3.of((int) Math.round(xz.getX()), - y.apply(implementationArguments, scope) - .intValue(), - (int) Math.round(xz.getZ())).mutable().add(arguments.getOrigin()).immutable(); - - try { - BlockEntity data = arguments.getWorld().getBlockEntity(apply); - if(!(data instanceof Container container)) { - LOGGER.error("Failed to place loot at {}; block {} is not a container", - apply, data); - return; - } - - LootPopulateEvent event = new LootPopulateEvent(container, table, - arguments.getWorld().getPack(), script); - platform.getEventManager().callEvent(event); - if(event.isCancelled()) return; - - event.getTable().fillInventory(container.getInventory(), - new Random(apply.hashCode())); - data.update(false); - } catch(Exception e) { - LOGGER.error("Could not apply loot at {}", apply, e); - e.printStackTrace(); - } - }, - () -> LOGGER.error("No such loot table {}", id)); + .ifPresentOrElse(table -> { + Vector3 apply = Vector3.of((int) Math.round(xz.getX()), + y.apply(implementationArguments, scope) + .intValue(), + (int) Math.round(xz.getZ())).mutable().add(arguments.getOrigin()).immutable(); + + try { + BlockEntity data = arguments.getWorld().getBlockEntity(apply); + if(!(data instanceof Container container)) { + LOGGER.error("Failed to place loot at {}; block {} is not a container", + apply, data); + return; + } + + LootPopulateEvent event = new LootPopulateEvent(container, table, + arguments.getWorld().getPack(), script); + platform.getEventManager().callEvent(event); + if(event.isCancelled()) return; + + event.getTable().fillInventory(container.getInventory(), + new Random(apply.hashCode())); + data.update(false); + } catch(Exception e) { + LOGGER.error("Could not apply loot at {}", apply, e); + e.printStackTrace(); + } + }, + () -> LOGGER.error("No such loot table {}", id)); return null; } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.VOID; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/PullFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/PullFunction.java index e80ac5df6..600cecae0 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/PullFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/PullFunction.java @@ -26,26 +26,26 @@ public class PullFunction implements Function { private final BlockState data; private final Returnable x, y, z; private final Position position; - + public PullFunction(Returnable x, Returnable y, Returnable z, Returnable data, Platform platform, Position position) { this.position = position; if(!(data instanceof ConstantExpression)) throw new ParseException("Block data must be constant", data.getPosition()); - + this.data = platform.getWorldHandle().createBlockState(((ConstantExpression) data).getConstant()); this.x = x; this.y = y; this.z = z; } - + @Override public Void apply(ImplementationArguments implementationArguments, Scope scope) { TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments; Vector2 xz = RotationUtil.rotateVector(Vector2.of(x.apply(implementationArguments, scope).doubleValue(), - z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); - + z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); + Vector3.Mutable mutable = Vector3.of((int) Math.round(xz.getX()), y.apply(implementationArguments, scope).intValue(), - (int) Math.round(xz.getZ())).mutable().add(arguments.getOrigin()); + (int) Math.round(xz.getZ())).mutable().add(arguments.getOrigin()); while(mutable.getY() > arguments.getWorld().getMinHeight()) { if(!arguments.getWorld().getBlockState(mutable).isAir()) { arguments.getWorld().setBlockState(mutable, data); @@ -55,12 +55,12 @@ public class PullFunction implements Function { } return null; } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.VOID; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RandomFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RandomFunction.java index 3a8fc113e..6b794d776 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RandomFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RandomFunction.java @@ -18,24 +18,24 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class RandomFunction implements Function { private final Returnable numberReturnable; private final Position position; - + public RandomFunction(Returnable numberReturnable, Position position) { this.numberReturnable = numberReturnable; this.position = position; } - - + + @Override public ReturnType returnType() { return ReturnType.NUMBER; } - + @Override public Integer apply(ImplementationArguments implementationArguments, Scope scope) { return ((TerraImplementationArguments) implementationArguments).getRandom().nextInt( - numberReturnable.apply(implementationArguments, scope).intValue()); + numberReturnable.apply(implementationArguments, scope).intValue()); } - + @Override public Position getPosition() { return position; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RecursionsFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RecursionsFunction.java index 7dce74c61..c19329656 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RecursionsFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/RecursionsFunction.java @@ -16,21 +16,21 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class RecursionsFunction implements Function { private final Position position; - + public RecursionsFunction(Position position) { this.position = position; } - + @Override public ReturnType returnType() { return ReturnType.NUMBER; } - + @Override public Number apply(ImplementationArguments implementationArguments, Scope scope) { return ((TerraImplementationArguments) implementationArguments).getRecursions(); } - + @Override public Position getPosition() { return position; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/SetMarkFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/SetMarkFunction.java index 78eb6ddc8..908164030 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/SetMarkFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/SetMarkFunction.java @@ -22,7 +22,7 @@ public class SetMarkFunction implements Function { private final Returnable x, y, z; private final Position position; private final Returnable mark; - + public SetMarkFunction(Returnable x, Returnable y, Returnable z, Returnable mark, Position position) { this.position = position; this.mark = mark; @@ -30,27 +30,27 @@ public class SetMarkFunction implements Function { this.y = y; this.z = z; } - + @Override public Void apply(ImplementationArguments implementationArguments, Scope scope) { TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments; Vector2 xz = RotationUtil.rotateVector(Vector2.of(x.apply(implementationArguments, scope).doubleValue(), - z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); - - + z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); + + arguments.setMark(Vector3.of((int) Math.floor(xz.getX()), - (int) Math.floor( - y.apply(implementationArguments, scope).doubleValue()), - (int) Math.floor(xz.getZ())).mutable().add(arguments.getOrigin()).immutable(), - mark.apply(implementationArguments, scope)); + (int) Math.floor( + y.apply(implementationArguments, scope).doubleValue()), + (int) Math.floor(xz.getZ())).mutable().add(arguments.getOrigin()).immutable(), + mark.apply(implementationArguments, scope)); return null; } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.VOID; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java index 640d52ecc..bed6773a9 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StateFunction.java @@ -27,7 +27,7 @@ public class StateFunction implements Function { private final Returnable data; private final Returnable x, y, z; private final Position position; - + public StateFunction(Returnable x, Returnable y, Returnable z, Returnable data, Position position) { this.position = position; @@ -36,16 +36,16 @@ public class StateFunction implements Function { this.y = y; this.z = z; } - + @Override public Void apply(ImplementationArguments implementationArguments, Scope scope) { TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments; Vector2 xz = RotationUtil.rotateVector(Vector2.of(x.apply(implementationArguments, scope).doubleValue(), - z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); - - + z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); + + Vector3 origin = Vector3.of((int) Math.round(xz.getX()), y.apply(implementationArguments, scope).intValue(), - (int) Math.round(xz.getZ())).mutable().add(arguments.getOrigin()).immutable(); + (int) Math.round(xz.getZ())).mutable().add(arguments.getOrigin()).immutable(); try { BlockEntity state = arguments.getWorld().getBlockEntity(origin); state.applyState(data.apply(implementationArguments, scope)); @@ -56,12 +56,12 @@ public class StateFunction implements Function { } return null; } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.VOID; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StructureFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StructureFunction.java index 6a96da6be..6eb60e8a3 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StructureFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/StructureFunction.java @@ -35,7 +35,7 @@ public class StructureFunction implements Function { private final Position position; private final Platform platform; private final List> rotations; - + public StructureFunction(Returnable x, Returnable y, Returnable z, Returnable id, List> rotations, Registry registry, Position position, Platform platform) { this.registry = registry; @@ -47,23 +47,23 @@ public class StructureFunction implements Function { this.platform = platform; this.rotations = rotations; } - + @Override public ReturnType returnType() { return ReturnType.BOOLEAN; } - + @Override public Boolean apply(ImplementationArguments implementationArguments, Scope scope) { TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments; - + if(arguments.getRecursions() > platform.getTerraConfig().getMaxRecursion()) throw new RuntimeException("Structure recursion too deep: " + arguments.getRecursions()); - + Vector2 xz = RotationUtil.rotateVector(Vector2.of(x.apply(implementationArguments, scope).doubleValue(), - z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); - - + z.apply(implementationArguments, scope).doubleValue()), arguments.getRotation()); + + String app = id.apply(implementationArguments, scope); return registry.getByID(app).map(script -> { Rotation rotation1; @@ -74,29 +74,29 @@ public class StructureFunction implements Function { LOGGER.warn("Invalid rotation {}", rotString); return false; } - + if(script instanceof StructureScript structureScript) { return structureScript.generate(arguments.getOrigin(), - arguments.getWorld() - .buffer((int) Math.round(xz.getX()), - y.apply(implementationArguments, scope).intValue(), - (int) Math.round(xz.getZ())), - arguments.getRandom(), - arguments.getRotation().rotate(rotation1), arguments.getRecursions() + 1); + arguments.getWorld() + .buffer((int) Math.round(xz.getX()), + y.apply(implementationArguments, scope).intValue(), + (int) Math.round(xz.getZ())), + arguments.getRandom(), + arguments.getRotation().rotate(rotation1), arguments.getRecursions() + 1); } return script.generate(arguments.getOrigin(), - arguments.getWorld() - .buffer((int) Math.round(xz.getX()), - y.apply(implementationArguments, scope).intValue(), - (int) Math.round(xz.getZ())), - arguments.getRandom(), - arguments.getRotation().rotate(rotation1)); + arguments.getWorld() + .buffer((int) Math.round(xz.getX()), + y.apply(implementationArguments, scope).intValue(), + (int) Math.round(xz.getZ())), + arguments.getRandom(), + arguments.getRotation().rotate(rotation1)); }).orElseGet(() -> { LOGGER.error("No such structure {}", app); return false; }); } - + @Override public Position getPosition() { return position; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Char.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Char.java index 5e0868160..59d949acd 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Char.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Char.java @@ -11,14 +11,14 @@ public class Char { private final char character; private final int index; private final int line; - - + + public Char(char character, int index, int line) { this.character = character; this.index = index; this.line = line; } - + public boolean is(char... tests) { for(char test : tests) { if(test == character && test != '\0') { @@ -27,36 +27,36 @@ public class Char { } return false; } - + @Override public String toString() { return Character.toString(character); } - + public char getCharacter() { return character; } - + public int getIndex() { return index; } - + public int getLine() { return line; } - + public boolean isWhitespace() { return Character.isWhitespace(character); } - + public boolean isNewLine() { return character == '\n'; } - + public boolean isDigit() { return Character.isDigit(character); } - + public boolean isEOF() { return character == '\0'; } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Lookahead.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Lookahead.java index d1fcd9010..e7c3754c8 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Lookahead.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Lookahead.java @@ -23,11 +23,11 @@ public class Lookahead { private int index = 0; private int line = 0; private boolean end = false; - + public Lookahead(Reader r) { this.input = r; } - + /** * Get the current character without consuming it. * @@ -36,8 +36,8 @@ public class Lookahead { public Char current() { return next(0); } - - + + /** * Consume and return one character. * @@ -48,7 +48,7 @@ public class Lookahead { consume(1); return consumed; } - + /** * Fetch a future character without consuming it. * @@ -58,19 +58,19 @@ public class Lookahead { */ public Char next(int ahead) { if(ahead < 0) throw new IllegalArgumentException(); - + while(buffer.size() <= ahead && !end) { Char item = fetch(); if(item != null) { buffer.add(item); } else end = true; } - + if(ahead >= buffer.size()) { return null; } else return buffer.get(ahead); } - + /** * Consume an amount of characters * @@ -87,18 +87,18 @@ public class Lookahead { } } } - + public boolean matches(String check, boolean consume) { if(check == null) return false; - + for(int i = 0; i < check.length(); i++) { if(!next(i).is(check.charAt(i))) return false; } - + if(consume) consume(check.length()); // Consume string return true; } - + /** * Fetch the next character. * @@ -119,11 +119,11 @@ public class Lookahead { return null; } } - + public int getLine() { return line; } - + public int getIndex() { return index; } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Position.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Position.java index cb59f7dda..9edbadc93 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Position.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Position.java @@ -10,12 +10,12 @@ package com.dfsek.terra.addons.terrascript.tokenizer; public class Position { private final int line; private final int index; - + public Position(int line, int index) { this.line = line; this.index = index; } - + @Override public String toString() { return (line + 1) + ":" + index; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Token.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Token.java index 2d636aed2..b27803fc6 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Token.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Token.java @@ -11,34 +11,34 @@ public class Token { private final String content; private final Type type; private final Position start; - + public Token(String content, Type type, Position start) { this.content = content; this.type = type; this.start = start; } - + @Override public String toString() { return type + ": '" + content + "'"; } - + public Type getType() { return type; } - + public String getContent() { return content; } - + public Position getPosition() { return start; } - + public boolean isConstant() { return this.type.equals(Type.NUMBER) || this.type.equals(Type.STRING) || this.type.equals(Type.BOOLEAN); } - + public boolean isBinaryOperator() { return type.equals(Type.ADDITION_OPERATOR) || type.equals(Type.SUBTRACTION_OPERATOR) @@ -54,7 +54,7 @@ public class Token { || type.equals(Type.BOOLEAN_AND) || type.equals(Type.MODULO_OPERATOR); } - + public boolean isStrictNumericOperator() { return type.equals(Type.SUBTRACTION_OPERATOR) || type.equals(Type.MULTIPLICATION_OPERATOR) @@ -65,34 +65,34 @@ public class Token { || type.equals(Type.GREATER_THAN_OR_EQUALS_OPERATOR) || type.equals(Type.MODULO_OPERATOR); } - + public boolean isStrictBooleanOperator() { return type.equals(Type.BOOLEAN_AND) || type.equals(Type.BOOLEAN_OR); } - + public boolean isVariableDeclaration() { return type.equals(Type.STRING_VARIABLE) || type.equals(Type.BOOLEAN_VARIABLE) || type.equals(Type.NUMBER_VARIABLE); } - + public boolean isLoopLike() { return type.equals(Type.IF_STATEMENT) || type.equals(Type.WHILE_LOOP) || type.equals(Type.FOR_LOOP); } - + public boolean isIdentifier() { return type.equals(Type.IDENTIFIER); } - + public enum Type { /** * Function identifier or language keyword */ IDENTIFIER, - + /** * Numeric literal */ diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Tokenizer.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Tokenizer.java index 4761f708b..1c70a840d 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Tokenizer.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/Tokenizer.java @@ -21,17 +21,17 @@ import com.dfsek.terra.addons.terrascript.tokenizer.exceptions.TokenizerExceptio public class Tokenizer { public static final Set syntaxSignificant = Sets.newHashSet(';', '(', ')', '"', ',', '\\', '=', '{', '}', '+', '-', '*', '/', - '>', '<', '!'); // Reserved chars + '>', '<', '!'); // Reserved chars private final Lookahead reader; private final Stack brackets = new Stack<>(); private Token current; private Token last; - + public Tokenizer(String data) { reader = new Lookahead(new StringReader(data + '\0')); current = fetchCheck(); } - + /** * Get the first token. * @@ -43,7 +43,7 @@ public class Tokenizer { if(!hasNext()) throw new ParseException("Unexpected end of input", last.getPosition()); return current; } - + /** * Consume (get and remove) the first token. * @@ -57,7 +57,7 @@ public class Tokenizer { current = fetchCheck(); return temp; } - + private Token fetchCheck() { Token fetch = fetch(); if(fetch != null) { @@ -72,16 +72,16 @@ public class Tokenizer { } return fetch; } - + private Token fetch() throws TokenizerException { while(!reader.current().isEOF() && reader.current().isWhitespace()) reader.consume(); - + while(reader.matches("//", true)) skipLine(); // Skip line if comment - + if(reader.matches("/*", true)) skipTo("*/"); // Skip multi line comment - + if(reader.current().isEOF()) return null; // EOF - + if(reader.matches("==", true)) return new Token("==", Token.Type.EQUALS_OPERATOR, new Position(reader.getLine(), reader.getIndex())); if(reader.matches("!=", true)) @@ -94,14 +94,14 @@ public class Tokenizer { return new Token(">", Token.Type.GREATER_THAN_OPERATOR, new Position(reader.getLine(), reader.getIndex())); if(reader.matches("<", true)) return new Token("<", Token.Type.LESS_THAN_OPERATOR, new Position(reader.getLine(), reader.getIndex())); - - + + if(reader.matches("||", true)) return new Token("||", Token.Type.BOOLEAN_OR, new Position(reader.getLine(), reader.getIndex())); if(reader.matches("&&", true)) return new Token("&&", Token.Type.BOOLEAN_AND, new Position(reader.getLine(), reader.getIndex())); - - + + if(isNumberStart()) { StringBuilder num = new StringBuilder(); while(!reader.current().isEOF() && isNumberLike()) { @@ -109,7 +109,7 @@ public class Tokenizer { } return new Token(num.toString(), Token.Type.NUMBER, new Position(reader.getLine(), reader.getIndex())); } - + if(reader.current().is('"')) { reader.consume(); // Consume first quote StringBuilder string = new StringBuilder(); @@ -125,10 +125,10 @@ public class Tokenizer { string.append(reader.consume()); } reader.consume(); // Consume last quote - + return new Token(string.toString(), Token.Type.STRING, new Position(reader.getLine(), reader.getIndex())); } - + if(reader.current().is('(')) return new Token(reader.consume().toString(), Token.Type.GROUP_BEGIN, new Position(reader.getLine(), reader.getIndex())); if(reader.current().is(')')) @@ -147,38 +147,38 @@ public class Tokenizer { return new Token(reader.consume().toString(), Token.Type.ADDITION_OPERATOR, new Position(reader.getLine(), reader.getIndex())); if(reader.current().is('-')) return new Token(reader.consume().toString(), Token.Type.SUBTRACTION_OPERATOR, - new Position(reader.getLine(), reader.getIndex())); + new Position(reader.getLine(), reader.getIndex())); if(reader.current().is('*')) return new Token(reader.consume().toString(), Token.Type.MULTIPLICATION_OPERATOR, - new Position(reader.getLine(), reader.getIndex())); + new Position(reader.getLine(), reader.getIndex())); if(reader.current().is('/')) return new Token(reader.consume().toString(), Token.Type.DIVISION_OPERATOR, new Position(reader.getLine(), reader.getIndex())); if(reader.current().is('%')) return new Token(reader.consume().toString(), Token.Type.MODULO_OPERATOR, new Position(reader.getLine(), reader.getIndex())); if(reader.current().is('!')) return new Token(reader.consume().toString(), Token.Type.BOOLEAN_NOT, new Position(reader.getLine(), reader.getIndex())); - + StringBuilder token = new StringBuilder(); while(!reader.current().isEOF() && !isSyntaxSignificant(reader.current().getCharacter())) { Char c = reader.consume(); if(c.isWhitespace()) break; token.append(c); } - + String tokenString = token.toString(); - + if(tokenString.equals("true")) return new Token(tokenString, Token.Type.BOOLEAN, new Position(reader.getLine(), reader.getIndex())); if(tokenString.equals("false")) return new Token(tokenString, Token.Type.BOOLEAN, new Position(reader.getLine(), reader.getIndex())); - + if(tokenString.equals("num")) return new Token(tokenString, Token.Type.NUMBER_VARIABLE, new Position(reader.getLine(), reader.getIndex())); if(tokenString.equals("str")) return new Token(tokenString, Token.Type.STRING_VARIABLE, new Position(reader.getLine(), reader.getIndex())); if(tokenString.equals("bool")) return new Token(tokenString, Token.Type.BOOLEAN_VARIABLE, new Position(reader.getLine(), reader.getIndex())); - + if(tokenString.equals("if")) return new Token(tokenString, Token.Type.IF_STATEMENT, new Position(reader.getLine(), reader.getIndex())); if(tokenString.equals("else")) @@ -187,7 +187,7 @@ public class Tokenizer { return new Token(tokenString, Token.Type.WHILE_LOOP, new Position(reader.getLine(), reader.getIndex())); if(tokenString.equals("for")) return new Token(tokenString, Token.Type.FOR_LOOP, new Position(reader.getLine(), reader.getIndex())); - + if(tokenString.equals("return")) return new Token(tokenString, Token.Type.RETURN, new Position(reader.getLine(), reader.getIndex())); if(tokenString.equals("continue")) @@ -196,19 +196,19 @@ public class Tokenizer { return new Token(tokenString, Token.Type.BREAK, new Position(reader.getLine(), reader.getIndex())); if(tokenString.equals("fail")) return new Token(tokenString, Token.Type.FAIL, new Position(reader.getLine(), reader.getIndex())); - + return new Token(tokenString, Token.Type.IDENTIFIER, new Position(reader.getLine(), reader.getIndex())); } - + private void skipLine() { while(!reader.current().isEOF() && !reader.current().isNewLine()) reader.consume(); consumeWhitespace(); } - + private void consumeWhitespace() { while(!reader.current().isEOF() && reader.current().isWhitespace()) reader.consume(); // Consume whitespace. } - + private void skipTo(String s) throws EOFException { Position begin = new Position(reader.getLine(), reader.getIndex()); while(!reader.current().isEOF()) { @@ -220,7 +220,7 @@ public class Tokenizer { } throw new EOFException("No end of expression found.", begin); } - + /** * Whether this {@code Tokenizer} contains additional tokens. * @@ -229,19 +229,19 @@ public class Tokenizer { public boolean hasNext() { return !(current == null); } - + private boolean isNumberLike() { return reader.current().isDigit() || reader.current().is('_', '.', 'E'); } - + private boolean isNumberStart() { return reader.current().isDigit() || reader.current().is('.') && reader.next(1).isDigit(); } - + public boolean isSyntaxSignificant(char c) { return syntaxSignificant.contains(c); } - + } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/EOFException.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/EOFException.java index 89aff7c8f..d0855664d 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/EOFException.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/EOFException.java @@ -13,14 +13,14 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class EOFException extends TokenizerException { - + @Serial private static final long serialVersionUID = 3980047409902809440L; - + public EOFException(String message, Position position) { super(message, position); } - + public EOFException(String message, Position position, Throwable cause) { super(message, position, cause); } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/FormatException.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/FormatException.java index 4b2cc4847..8154b2d0d 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/FormatException.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/FormatException.java @@ -13,14 +13,14 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class FormatException extends TokenizerException { - + @Serial private static final long serialVersionUID = -791308012940744455L; - + public FormatException(String message, Position position) { super(message, position); } - + public FormatException(String message, Position position, Throwable cause) { super(message, position, cause); } diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/TokenizerException.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/TokenizerException.java index d7e8e2b3c..c1ce67d4f 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/TokenizerException.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/tokenizer/exceptions/TokenizerException.java @@ -14,14 +14,14 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public abstract class TokenizerException extends ParseException { - + @Serial private static final long serialVersionUID = 2792384010083575420L; - + public TokenizerException(String message, Position position) { super(message, position); } - + public TokenizerException(String message, Position position, Throwable cause) { super(message, position, cause); } diff --git a/common/addons/structure-terrascript-loader/src/test/java/structure/LookaheadTest.java b/common/addons/structure-terrascript-loader/src/test/java/structure/LookaheadTest.java index 1a5fea53c..037e67f6e 100644 --- a/common/addons/structure-terrascript-loader/src/test/java/structure/LookaheadTest.java +++ b/common/addons/structure-terrascript-loader/src/test/java/structure/LookaheadTest.java @@ -18,7 +18,7 @@ public class LookaheadTest { @Test public void lookahead() { Lookahead lookahead = new Lookahead(new StringReader("Test string...")); - + for(int i = 0; lookahead.next(i) != null; i++) { System.out.print(lookahead.next(i).getCharacter()); } diff --git a/common/addons/structure-terrascript-loader/src/test/java/structure/ParserTest.java b/common/addons/structure-terrascript-loader/src/test/java/structure/ParserTest.java index ea50a897d..f3f1b4995 100644 --- a/common/addons/structure-terrascript-loader/src/test/java/structure/ParserTest.java +++ b/common/addons/structure-terrascript-loader/src/test/java/structure/ParserTest.java @@ -31,19 +31,19 @@ public class ParserTest { @Test public void parse() throws IOException, ParseException { Parser parser = new Parser( - IOUtils.toString(Objects.requireNonNull(getClass().getResourceAsStream("/test.tesf")), Charset.defaultCharset())); - + IOUtils.toString(Objects.requireNonNull(getClass().getResourceAsStream("/test.tesf")), Charset.defaultCharset())); + parser.registerFunction("test", new FunctionBuilder() { @Override public Test1 build(List> argumentList, Position position) { return new Test1(argumentList.get(0), argumentList.get(1), position); } - + @Override public int argNumber() { return 2; } - + @Override public Returnable.ReturnType getArgument(int position) { return switch(position) { @@ -52,42 +52,42 @@ public class ParserTest { default -> null; }; } - + }); - + long l = System.nanoTime(); Executable block = parser.parse(); long t = System.nanoTime() - l; System.out.println("Took " + (double) t / 1000000); - + block.execute(null); - + block.execute(null); } - + private static class Test1 implements Function { private final Returnable a; private final Returnable b; private final Position position; - + public Test1(Returnable a, Returnable b, Position position) { this.a = a; this.b = b; this.position = position; } - + @Override public Void apply(ImplementationArguments implementationArguments, Scope scope) { System.out.println("string: " + a.apply(implementationArguments, scope) + ", double: " + b.apply(implementationArguments, scope)); return null; } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.VOID; diff --git a/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunction.java b/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunction.java index 485bc4cf9..5cb593a29 100644 --- a/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunction.java +++ b/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunction.java @@ -25,60 +25,60 @@ import com.dfsek.terra.api.world.WritableWorld; public class CheckFunction implements Function { private final Returnable x, y, z; private final Position position; - + public CheckFunction(Returnable x, Returnable y, Returnable z, Position position) { this.x = x; this.y = y; this.z = z; this.position = position; } - - + + @Override public String apply(ImplementationArguments implementationArguments, Scope scope) { - - + + TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments; - - + + Vector2 xz = Vector2.of(x.apply(implementationArguments, scope).doubleValue(), - z.apply(implementationArguments, scope).doubleValue()); - + z.apply(implementationArguments, scope).doubleValue()); + RotationUtil.rotateVector(xz, arguments.getRotation()); - + Vector3 location = arguments.getOrigin().toVector3Mutable().add( - Vector3.of((int) Math.round(xz.getX()), y.apply(implementationArguments, scope).doubleValue(), - (int) Math.round(xz.getZ()))).immutable(); - + Vector3.of((int) Math.round(xz.getX()), y.apply(implementationArguments, scope).doubleValue(), + (int) Math.round(xz.getZ()))).immutable(); + return apply(location, arguments.getWorld()); } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.STRING; } - + private String apply(Vector3 vector, WritableWorld world) { int y = vector.getBlockY(); if(y >= world.getMaxHeight() || y < 0) return "AIR"; SamplerProvider cache = ((NoiseChunkGenerator3D) world.getGenerator()).samplerProvider(); double comp = sample(vector.getX(), vector.getY(), vector.getZ(), cache, world); - + if(comp > 0) return "LAND"; // If noise val is greater than zero, location will always be land. - + //BiomeProvider provider = tw.getBiomeProvider(); //TerraBiome b = provider.getBiome(vector.getBlockX(), vector.getBlockZ()); - + /*if(vector.getY() > c.getSeaLevel())*/ return "AIR"; // Above sea level //return "OCEAN"; // Below sea level } - + private double sample(double x, double y, double z, SamplerProvider cache, World world) { int cx = Math.floorDiv((int) x, 16); int cz = Math.floorDiv((int) z, 16); diff --git a/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunctionBuilder.java b/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunctionBuilder.java index 6757596d6..84e465b1b 100644 --- a/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunctionBuilder.java +++ b/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/CheckFunctionBuilder.java @@ -17,23 +17,23 @@ import com.dfsek.terra.api.Platform; public class CheckFunctionBuilder implements FunctionBuilder { private final Platform platform; - + public CheckFunctionBuilder(Platform platform) { this.platform = platform; } - + @SuppressWarnings("unchecked") @Override public CheckFunction build(List> argumentList, Position position) { return new CheckFunction((Returnable) argumentList.get(0), (Returnable) argumentList.get(1), - (Returnable) argumentList.get(2), position); + (Returnable) argumentList.get(2), position); } - + @Override public int argNumber() { return 3; } - + @Override public Returnable.ReturnType getArgument(int position) { return switch(position) { diff --git a/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/TerraScriptCheckFunctionAddon.java b/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/TerraScriptCheckFunctionAddon.java index 26a1ca358..dac08f701 100644 --- a/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/TerraScriptCheckFunctionAddon.java +++ b/common/addons/terrascript-function-check-noise-3d/src/main/java/com/dfsek/terra/addon/terrascript/check/TerraScriptCheckFunctionAddon.java @@ -12,20 +12,20 @@ import com.dfsek.terra.api.inject.annotations.Inject; public class TerraScriptCheckFunctionAddon implements AddonInitializer { @Inject private Platform platform; - + @Inject private BaseAddon addon; - + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .priority(1) - .then(event -> { - event.getPack().getOrCreateRegistry(FunctionBuilder.class).register(addon.key("check"), - new CheckFunctionBuilder(platform)); - }) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .priority(1) + .then(event -> { + event.getPack().getOrCreateRegistry(FunctionBuilder.class).register(addon.key("check"), + new CheckFunctionBuilder(platform)); + }) + .failThrough(); } } diff --git a/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/ConstantSamplerFunction.java b/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/ConstantSamplerFunction.java index 83cf2563b..7b887bafe 100644 --- a/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/ConstantSamplerFunction.java +++ b/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/ConstantSamplerFunction.java @@ -12,11 +12,11 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class ConstantSamplerFunction implements Function { private final Returnable x, y, z; private final NoiseSampler sampler; - - + + private final boolean twoD; private final Position position; - + public ConstantSamplerFunction(NoiseSampler sampler, Returnable x, Returnable y, @@ -30,14 +30,14 @@ public class ConstantSamplerFunction implements Function { this.twoD = twoD; this.position = position; } - + @Override public Number apply(ImplementationArguments implementationArguments, Scope scope) { TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments; double x = this.x.apply(implementationArguments, scope).doubleValue(); - + double z = this.z.apply(implementationArguments, scope).doubleValue(); - + if(twoD) { return sampler.noise(arguments.getWorld().getSeed(), x, z); } else { @@ -45,12 +45,12 @@ public class ConstantSamplerFunction implements Function { return sampler.noise(arguments.getWorld().getSeed(), x, y, z); } } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.NUMBER; diff --git a/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/SamplerFunction.java b/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/SamplerFunction.java index abaafecab..ac342fc38 100644 --- a/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/SamplerFunction.java +++ b/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/SamplerFunction.java @@ -14,12 +14,12 @@ import com.dfsek.terra.api.noise.NoiseSampler; public class SamplerFunction implements Function { private final Returnable x, y, z; private final Returnable function; - + private final java.util.function.Function, NoiseSampler> samplerFunction; - + private final boolean twoD; private final Position position; - + public SamplerFunction(Returnable function, Returnable x, Returnable y, @@ -35,14 +35,14 @@ public class SamplerFunction implements Function { this.twoD = twoD; this.position = position; } - + @Override public Number apply(ImplementationArguments implementationArguments, Scope scope) { TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments; double x = this.x.apply(implementationArguments, scope).doubleValue(); - + double z = this.z.apply(implementationArguments, scope).doubleValue(); - + NoiseSampler sampler = samplerFunction.apply(() -> function.apply(implementationArguments, scope)); if(twoD) { return sampler.noise(arguments.getWorld().getSeed(), x, z); @@ -51,12 +51,12 @@ public class SamplerFunction implements Function { return sampler.noise(arguments.getWorld().getSeed(), x, y, z); } } - + @Override public Position getPosition() { return position; } - + @Override public ReturnType returnType() { return ReturnType.NUMBER; diff --git a/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/SamplerFunctionBuilder.java b/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/SamplerFunctionBuilder.java index 07ce640fd..604e205b6 100644 --- a/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/SamplerFunctionBuilder.java +++ b/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/SamplerFunctionBuilder.java @@ -17,11 +17,11 @@ import com.dfsek.terra.addons.terrascript.tokenizer.Position; public class SamplerFunctionBuilder implements FunctionBuilder> { private final Map samplers2d; private final Map samplers3d; - + public SamplerFunctionBuilder(Map samplers) { this.samplers2d = new HashMap<>(); this.samplers3d = new HashMap<>(); - + samplers.forEach((id, sampler) -> { if(sampler.getDimensions() == 2) { samplers2d.put(id, sampler); @@ -30,62 +30,62 @@ public class SamplerFunctionBuilder implements FunctionBuilder build(List> argumentList, Position position) { Returnable arg = (Returnable) argumentList.get(0); - + if(argumentList.size() == 3) { // 2D if(arg instanceof StringConstant constant) { return new ConstantSamplerFunction(Objects.requireNonNull(samplers2d.get(constant.getConstant()), - "No such 2D noise function " + constant.getConstant()) - .getSampler(), - (Returnable) argumentList.get(1), - new NumericConstant(0, position), - (Returnable) argumentList.get(2), - true, - position); + "No such 2D noise function " + constant.getConstant()) + .getSampler(), + (Returnable) argumentList.get(1), + new NumericConstant(0, position), + (Returnable) argumentList.get(2), + true, + position); } else { return new SamplerFunction((Returnable) argumentList.get(0), - (Returnable) argumentList.get(1), - new NumericConstant(0, position), - (Returnable) argumentList.get(2), - s -> Objects.requireNonNull(samplers2d.get(s.get()), "No such 2D noise function " + s.get()) - .getSampler(), - true, - position); + (Returnable) argumentList.get(1), + new NumericConstant(0, position), + (Returnable) argumentList.get(2), + s -> Objects.requireNonNull(samplers2d.get(s.get()), "No such 2D noise function " + s.get()) + .getSampler(), + true, + position); } - + } else { // 3D if(arg instanceof StringConstant constant) { return new ConstantSamplerFunction(Objects.requireNonNull(samplers3d.get(constant.getConstant()), - "No such 3D noise function " + constant.getConstant()) - .getSampler(), - (Returnable) argumentList.get(1), - (Returnable) argumentList.get(2), - (Returnable) argumentList.get(3), - true, - position); + "No such 3D noise function " + constant.getConstant()) + .getSampler(), + (Returnable) argumentList.get(1), + (Returnable) argumentList.get(2), + (Returnable) argumentList.get(3), + true, + position); } else { return new SamplerFunction((Returnable) argumentList.get(0), - (Returnable) argumentList.get(1), - (Returnable) argumentList.get(2), - (Returnable) argumentList.get(3), - s -> Objects.requireNonNull(samplers3d.get(s.get()), "No such 3D noise function " + s.get()) - .getSampler(), - true, - position); + (Returnable) argumentList.get(1), + (Returnable) argumentList.get(2), + (Returnable) argumentList.get(3), + s -> Objects.requireNonNull(samplers3d.get(s.get()), "No such 3D noise function " + s.get()) + .getSampler(), + true, + position); } } } - + @Override public int argNumber() { return -1; } - + @Override public ReturnType getArgument(int position) { return switch(position) { diff --git a/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/TerraScriptSamplerFunctionAddon.java b/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/TerraScriptSamplerFunctionAddon.java index cdb4b92bd..374d54f58 100644 --- a/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/TerraScriptSamplerFunctionAddon.java +++ b/common/addons/terrascript-function-sampler/src/main/java/com/dfsek/terra/addons/terrascript/sampler/TerraScriptSamplerFunctionAddon.java @@ -13,22 +13,22 @@ import com.dfsek.terra.api.inject.annotations.Inject; public class TerraScriptSamplerFunctionAddon implements AddonInitializer { @Inject private Platform platform; - + @Inject private BaseAddon addon; - - + + @Override public void initialize() { platform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(addon, ConfigPackPreLoadEvent.class) - .priority(51) - .then(event -> event - .getPack() - .getOrCreateRegistry(FunctionBuilder.class) - .register(addon.key("sampler"), new SamplerFunctionBuilder(event.getPack().getContext().get( - NoiseConfigPackTemplate.class).getSamplers()))) - .failThrough(); + .getHandler(FunctionalEventHandler.class) + .register(addon, ConfigPackPreLoadEvent.class) + .priority(51) + .then(event -> event + .getPack() + .getOrCreateRegistry(FunctionBuilder.class) + .register(addon.key("sampler"), new SamplerFunctionBuilder(event.getPack().getContext().get( + NoiseConfigPackTemplate.class).getSamplers()))) + .failThrough(); } } diff --git a/common/api/src/main/java/com/dfsek/terra/api/Platform.java b/common/api/src/main/java/com/dfsek/terra/api/Platform.java index a6ed29a54..95b00c575 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/Platform.java +++ b/common/api/src/main/java/com/dfsek/terra/api/Platform.java @@ -29,11 +29,11 @@ import com.dfsek.terra.api.tectonic.LoaderRegistrar; */ public interface Platform extends LoaderRegistrar { boolean reload(); - + @NotNull @Contract(pure = true) String platformName(); - + /** * Runs a task that may or may not be thread safe, depending on platform. *

@@ -44,40 +44,40 @@ public interface Platform extends LoaderRegistrar { default void runPossiblyUnsafeTask(@NotNull Runnable task) { task.run(); } - + @NotNull @Contract(pure = true) WorldHandle getWorldHandle(); - + @NotNull @Contract(pure = true) PluginConfig getTerraConfig(); - + @NotNull @Contract(pure = true) File getDataFolder(); - + @NotNull @Contract(pure = true) CheckedRegistry getConfigRegistry(); - + @NotNull @Contract(pure = true) Registry getAddons(); - + @NotNull @Contract(pure = true) ItemHandle getItemHandle(); - + @NotNull @Contract(pure = true) EventManager getEventManager(); - + @Contract(pure = true) default @NotNull String getVersion() { return "@VERSION@"; } - + @NotNull @Contract(pure = true) Profiler getProfiler(); diff --git a/common/api/src/main/java/com/dfsek/terra/api/addon/BaseAddon.java b/common/api/src/main/java/com/dfsek/terra/api/addon/BaseAddon.java index 67b446c2e..ad695d3c5 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/addon/BaseAddon.java +++ b/common/api/src/main/java/com/dfsek/terra/api/addon/BaseAddon.java @@ -25,7 +25,7 @@ public interface BaseAddon extends StringIdentifiable, Namespaced { * Initializes the addon. To be implemented by addons, but never manually invoked. */ default void initialize() { } - + /** * Gets the dependencies of this addon. * @@ -34,14 +34,14 @@ public interface BaseAddon extends StringIdentifiable, Namespaced { default Map getDependencies() { return Collections.emptyMap(); } - + /** * Get the version of the addon * * @return Version of addon */ Version getVersion(); - + default String getNamespace() { return getID(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/addon/bootstrap/BootstrapAddonClassLoader.java b/common/api/src/main/java/com/dfsek/terra/api/addon/bootstrap/BootstrapAddonClassLoader.java index b6b3a67ae..fc84d8387 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/addon/bootstrap/BootstrapAddonClassLoader.java +++ b/common/api/src/main/java/com/dfsek/terra/api/addon/bootstrap/BootstrapAddonClassLoader.java @@ -9,23 +9,23 @@ public class BootstrapAddonClassLoader extends URLClassLoader { public BootstrapAddonClassLoader(URL[] urls, ClassLoader parent) { super(urls, parent); } - + public BootstrapAddonClassLoader(URL[] urls) { super(urls); } - + public BootstrapAddonClassLoader(URL[] urls, ClassLoader parent, URLStreamHandlerFactory factory) { super(urls, parent, factory); } - + public BootstrapAddonClassLoader(String name, URL[] urls, ClassLoader parent) { super(name, urls, parent); } - + public BootstrapAddonClassLoader(String name, URL[] urls, ClassLoader parent, URLStreamHandlerFactory factory) { super(name, urls, parent, factory); } - + @Override public void addURL(URL url) { super.addURL(url); diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/BlockType.java b/common/api/src/main/java/com/dfsek/terra/api/block/BlockType.java index 2f71af6b9..62b117e7b 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/BlockType.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/BlockType.java @@ -21,14 +21,14 @@ public interface BlockType extends Handle { * @return Default block state */ BlockState getDefaultState(); - + /** * Get whether this block is solid. * * @return Whether this block is solid. */ boolean isSolid(); - + /** * Get whether this block is water. * diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/entity/BlockEntity.java b/common/api/src/main/java/com/dfsek/terra/api/block/entity/BlockEntity.java index 12ee49056..40489ab84 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/entity/BlockEntity.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/entity/BlockEntity.java @@ -14,18 +14,18 @@ import com.dfsek.terra.api.util.vector.Vector3; public interface BlockEntity extends Handle { boolean update(boolean applyPhysics); - + default void applyState(String state) { // Do nothing by default. } - + Vector3 getPosition(); - + int getX(); - + int getY(); - + int getZ(); - + BlockState getBlockState(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/entity/MobSpawner.java b/common/api/src/main/java/com/dfsek/terra/api/block/entity/MobSpawner.java index a06427c83..780c391bd 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/entity/MobSpawner.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/entity/MobSpawner.java @@ -14,34 +14,34 @@ import com.dfsek.terra.api.entity.EntityType; public interface MobSpawner extends BlockEntity { EntityType getSpawnedType(); - + void setSpawnedType(@NotNull EntityType creatureType); - + int getDelay(); - + void setDelay(int delay); - + int getMinSpawnDelay(); - + void setMinSpawnDelay(int delay); - + int getMaxSpawnDelay(); - + void setMaxSpawnDelay(int delay); - + int getSpawnCount(); - + void setSpawnCount(int spawnCount); - + int getMaxNearbyEntities(); - + void setMaxNearbyEntities(int maxNearbyEntities); - + int getRequiredPlayerRange(); - + void setRequiredPlayerRange(int requiredPlayerRange); - + int getSpawnRange(); - + void setSpawnRange(int spawnRange); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/entity/SerialState.java b/common/api/src/main/java/com/dfsek/terra/api/block/entity/SerialState.java index 4c654d482..6bd45df22 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/entity/SerialState.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/entity/SerialState.java @@ -13,10 +13,10 @@ import java.util.Map; public class SerialState { protected final Map> properties = new HashMap<>(); - + public SerialState() { } - + public static Map parse(String props) { String[] sep = props.split(","); Map map = new HashMap<>(); @@ -25,7 +25,7 @@ public class SerialState { } return map; } - + @SuppressWarnings("unchecked") public T get(String id, Class clazz) { checkExists(id); @@ -33,69 +33,69 @@ public class SerialState { checkType(clazz, prop.getValue(), id); return (T) prop.getValue(); } - + private void checkExists(String prop) { if(!properties.containsKey(prop)) throw new IllegalArgumentException("No such property \"" + prop + "\""); } - + private void checkType(Class clazz, Object o, String id) { if(!clazz.isInstance(o)) throw new IllegalArgumentException("Invalid data for property " + id + ": " + o); } - + public void setProperty(String id, Object value) { checkExists(id); Property prop = properties.get(id); checkType(prop.getValueClass(), value, id); prop.setValue(value); } - + public int getInteger(String id) { checkExists(id); Property prop = properties.get(id); checkType(Integer.class, prop.getValue(), id); return (Integer) prop.getValue(); } - + public String getString(String id) { checkExists(id); Property prop = properties.get(id); checkType(String.class, prop.getValue(), id); return (String) prop.getValue(); } - + public long getLong(String id) { checkExists(id); Property prop = properties.get(id); checkType(Long.class, prop.getValue(), id); return (Long) prop.getValue(); } - + public boolean getBoolean(String id) { checkExists(id); Property prop = properties.get(id); checkType(Boolean.class, prop.getValue(), id); return (Boolean) prop.getValue(); } - - + + protected static class Property { private final Class clazz; private Object value; - + public Property(Class clazz) { this.clazz = clazz; } - + public Class getValueClass() { return clazz; } - + @SuppressWarnings("unchecked") public T getValue() { return (T) value; } - + public void setValue(Object value) { this.value = value; } diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/entity/Sign.java b/common/api/src/main/java/com/dfsek/terra/api/block/entity/Sign.java index 230088e67..adc0bc359 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/entity/Sign.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/entity/Sign.java @@ -12,8 +12,8 @@ import org.jetbrains.annotations.NotNull; public interface Sign extends BlockEntity { void setLine(int index, @NotNull String line) throws IndexOutOfBoundsException; - + @NotNull String[] getLines(); - + @NotNull String getLine(int index) throws IndexOutOfBoundsException; } diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/BlockState.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/BlockState.java index 9b7328683..d62c77d8d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/BlockState.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/BlockState.java @@ -18,7 +18,7 @@ import com.dfsek.terra.api.block.state.properties.Property; * Contains basic data about a {@link BlockType} in the world */ public interface BlockState extends Handle { - + /** * Whether this {@link BlockState} matches another. *

@@ -29,7 +29,7 @@ public interface BlockState extends Handle { * @return Whether this state matches the other */ boolean matches(BlockState other); - + /** * Check whether this {@link BlockState} has a {@link Property}. * @@ -38,7 +38,7 @@ public interface BlockState extends Handle { * @return Whether this state has the property. */ > boolean has(Property property); - + /** * Get the value of a {@link Property} on this state. * @@ -47,7 +47,7 @@ public interface BlockState extends Handle { * @return Value of the property */ > T get(Property property); - + /** * Return a new {@link BlockState} with a {@link Property} set to a value. * @@ -57,7 +57,7 @@ public interface BlockState extends Handle { * @return New {@link BlockState} with property set. */ > BlockState set(Property property, T value); - + /** * Perform an action on this {@link BlockState} if it contains a {@link Property} * @@ -70,7 +70,7 @@ public interface BlockState extends Handle { if(has(property)) action.accept(this); return this; } - + /** * Set the value of a {@link Property} on this {@link BlockState} if it is present. * @@ -83,14 +83,14 @@ public interface BlockState extends Handle { if(has(property)) set(property, value); return this; } - + /** * Get the {@link BlockType} this state applies to. * * @return Block type. */ BlockType getBlockType(); - + /** * Get this state and its properties as a String * @@ -99,7 +99,7 @@ public interface BlockState extends Handle { default String getAsString() { return getAsString(true); } - + /** * Get this state and its properties as a String * @@ -108,7 +108,7 @@ public interface BlockState extends Handle { * @return String representation of this state */ String getAsString(boolean properties); - + /** * Get whether this BlockState is air * diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/Property.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/Property.java index d3456a771..1a209010c 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/Property.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/Property.java @@ -22,7 +22,7 @@ public interface Property extends StringIdentifiable { * @return All values of this property */ Collection values(); - + /** * Get the type of this property. * diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/BooleanProperty.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/BooleanProperty.java index f22df1f42..9044051a0 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/BooleanProperty.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/BooleanProperty.java @@ -17,19 +17,19 @@ public interface BooleanProperty extends Property { static BooleanProperty of(String name) { return new BooleanProperty() { private static final Collection BOOLEANS = Arrays.asList(true, false); - + @Override public Collection values() { return BOOLEANS; } - + @Override public String getID() { return name; } }; } - + @Override default Class getType() { return Boolean.class; diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/EnumProperty.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/EnumProperty.java index 42bc7259d..ca3797fa6 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/EnumProperty.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/EnumProperty.java @@ -18,17 +18,17 @@ public interface EnumProperty> extends Property { static > EnumProperty of(String name, Class clazz) { return new EnumProperty<>() { private final Lazy> constants = Lazy.lazy(() -> Arrays.asList(clazz.getEnumConstants())); - + @Override public Collection values() { return constants.value(); } - + @Override public Class getType() { return clazz; } - + @Override public String getID() { return name; diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/IntProperty.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/IntProperty.java index bc4cc7601..59cd63017 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/IntProperty.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/base/IntProperty.java @@ -25,19 +25,19 @@ public interface IntProperty extends Property { } return ints; }); - + @Override public Collection values() { return collection; } - + @Override public String getID() { return name; } }; } - + @Override default Class getType() { return Integer.class; diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Direction.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Direction.java index 47ba1a47f..ea7bf8b8f 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Direction.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Direction.java @@ -18,29 +18,29 @@ public enum Direction { WEST(3, -1, 0, 0), UP(-1, 0, 1, 0), DOWN(-1, 0, -1, 0); - + private static final Direction[] rotations = Construct.construct(() -> new Direction[]{ NORTH, SOUTH, EAST, WEST }); - + private final int rotation; - + private final int modX; private final int modY; private final int modZ; - + Direction(int rotation, int modX, int modY, int modZ) { this.rotation = rotation; this.modX = modX; this.modY = modY; this.modZ = modZ; } - + public Direction rotate(Rotation rotation) { return switch(this) { case UP, DOWN -> this; default -> rotations[(this.rotation + rotation.getDegrees() / 90) % 4]; }; } - + public Direction opposite() { return switch(this) { case DOWN -> UP; @@ -51,15 +51,15 @@ public enum Direction { case SOUTH -> NORTH; }; } - + public int getModX() { return modX; } - + public int getModY() { return modY; } - + public int getModZ() { return modZ; } diff --git a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Half.java b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Half.java index 7070f3d16..42b0e7123 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Half.java +++ b/common/api/src/main/java/com/dfsek/terra/api/block/state/properties/enums/Half.java @@ -16,7 +16,7 @@ public enum Half { * The bottom half of the block, normally with the lower y coordinate. */ BOTTOM, - + /** * Some blocks, e.g. slabs, can occupy both halves. */ diff --git a/common/api/src/main/java/com/dfsek/terra/api/command/CommandSender.java b/common/api/src/main/java/com/dfsek/terra/api/command/CommandSender.java index 81320a0b9..b58da77f2 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/command/CommandSender.java +++ b/common/api/src/main/java/com/dfsek/terra/api/command/CommandSender.java @@ -16,8 +16,8 @@ import com.dfsek.terra.api.entity.Player; public interface CommandSender extends Handle { void sendMessage(String message); - + Optional getEntity(); - + Optional getPlayer(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/command/arguments/RegistryArgument.java b/common/api/src/main/java/com/dfsek/terra/api/command/arguments/RegistryArgument.java index 7cb8f731f..e89298751 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/command/arguments/RegistryArgument.java +++ b/common/api/src/main/java/com/dfsek/terra/api/command/arguments/RegistryArgument.java @@ -24,99 +24,99 @@ import com.dfsek.terra.api.util.reflection.TypeKey; public class RegistryArgument extends CommandArgument { private RegistryArgument( - boolean required, - @NonNull String name, - Function, Registry> registryFunction, - TypeToken typeToken, - @NonNull String defaultValue, - @Nullable BiFunction, String, List> suggestionsProvider, - @NonNull ArgumentDescription description - ) { + boolean required, + @NonNull String name, + Function, Registry> registryFunction, + TypeToken typeToken, + @NonNull String defaultValue, + @Nullable BiFunction, String, List> suggestionsProvider, + @NonNull ArgumentDescription description + ) { super(required, - name, - new RegistryArgumentParser<>(registryFunction), - defaultValue, - typeToken, - suggestionsProvider, - description); + name, + new RegistryArgumentParser<>(registryFunction), + defaultValue, + typeToken, + suggestionsProvider, + description); } - + public static Builder builder(String name, Registry registry) { return new Builder<>(name, registry); } - + public static CommandArgument of(String name, Registry registry) { return RegistryArgument.builder(name, registry).build(); } - + public static CommandArgument optional(String name, Registry registry) { return RegistryArgument.builder(name, registry).asOptional().build(); } - + public static CommandArgument optional(String name, Registry registry, String defaultKey) { return RegistryArgument.builder(name, registry).asOptionalWithDefault(defaultKey).build(); } - + @SuppressWarnings("unchecked") public static Builder builder(String name, Function, Registry> registryFunction, TypeKey registryType) { return new Builder<>(name, registryFunction, (TypeToken) TypeToken.get(registryType.getType())); } - + public static CommandArgument of(String name, Function, Registry> registryFunction, TypeKey registryType) { return RegistryArgument.builder(name, registryFunction, registryType).build(); } - + public static CommandArgument optional(String name, Function, Registry> registryFunction, TypeKey registryType) { return RegistryArgument.builder(name, registryFunction, registryType).asOptional().build(); } - + public static CommandArgument optional(String name, Function, Registry> registryFunction, TypeKey registryType, String defaultKey) { return RegistryArgument.builder(name, registryFunction, registryType).asOptionalWithDefault(defaultKey).build(); } - + public static final class Builder extends CommandArgument.Builder { private final Function, Registry> registryFunction; private final TypeToken typeToken; - + @SuppressWarnings("unchecked") private Builder(@NonNull String name, Registry registry) { super((TypeToken) TypeToken.get(registry.getType().getType()), name); this.registryFunction = commandContext -> registry; this.typeToken = (TypeToken) TypeToken.get(registry.getType().getType()); } - + private Builder(@NonNull String name, Function, Registry> registryFunction, TypeToken typeToken) { super(typeToken, name); this.typeToken = typeToken; this.registryFunction = registryFunction; } - + @Override public @NonNull RegistryArgument build() { return new RegistryArgument<>( - isRequired(), - getName(), - registryFunction, - typeToken, - getDefaultValue(), - getSuggestionsProvider(), - getDefaultDescription() + isRequired(), + getName(), + registryFunction, + typeToken, + getDefaultValue(), + getSuggestionsProvider(), + getDefaultDescription() ); } } - - + + private static final class RegistryArgumentParser implements ArgumentParser { private final Function, Registry> registryFunction; - + private RegistryArgumentParser(Function, Registry> registryFunction) { this.registryFunction = registryFunction; } - + @Override public @NonNull ArgumentParseResult<@NonNull R> parse(@NonNull CommandContext<@NonNull T> commandContext, @NonNull Queue<@NonNull String> inputQueue) { @@ -126,9 +126,9 @@ public class RegistryArgument extends CommandArgument { input += inputQueue.remove(); input += inputQueue.remove(); } - + Registry registry = registryFunction.apply(commandContext); - + Optional result; try { result = registry.get(RegistryKey.parse(input)); @@ -139,12 +139,12 @@ public class RegistryArgument extends CommandArgument { return ArgumentParseResult.failure(e1); } } - + return result - .map(ArgumentParseResult::success) - .orElse(ArgumentParseResult.failure(new NoSuchEntryException("No such entry: " + input))); + .map(ArgumentParseResult::success) + .orElse(ArgumentParseResult.failure(new NoSuchEntryException("No such entry: " + input))); } - + @Override public @NonNull List<@NonNull String> suggestions(@NonNull CommandContext commandContext, @NonNull String input) { return registryFunction.apply(commandContext).keys().stream().map(RegistryKey::toString).sorted().collect(Collectors.toList()); diff --git a/common/api/src/main/java/com/dfsek/terra/api/config/ConfigPack.java b/common/api/src/main/java/com/dfsek/terra/api/config/ConfigPack.java index b70ce84b4..8e0214ff0 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/config/ConfigPack.java +++ b/common/api/src/main/java/com/dfsek/terra/api/config/ConfigPack.java @@ -34,26 +34,26 @@ public interface ConfigPack extends LoaderRegistrar, RegistryProvider, Keyed, PropertyHolder { - + ConfigPack registerConfigType(ConfigType type, RegistryKey id, int priority); - + Map addons(); - + BiomeProvider getBiomeProvider(); - + List getStages(); - + Loader getLoader(); - + String getAuthor(); - + Version getVersion(); - + ConfigPack registerShortcut(TypeKey clazz, String shortcut, ShortcutLoader loader); - + default ConfigPack registerShortcut(Class clazz, String shortcut, ShortcutLoader loader) { return registerShortcut(TypeKey.of(clazz), shortcut, loader); } - + ChunkGeneratorProvider getGeneratorProvider(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/config/ConfigType.java b/common/api/src/main/java/com/dfsek/terra/api/config/ConfigType.java index 25bcacb98..c577f533b 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/config/ConfigType.java +++ b/common/api/src/main/java/com/dfsek/terra/api/config/ConfigType.java @@ -13,8 +13,8 @@ import com.dfsek.terra.api.util.reflection.TypeKey; public interface ConfigType { T getTemplate(ConfigPack pack, Platform platform); - + ConfigFactory getFactory(); - + TypeKey getTypeKey(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/config/Loader.java b/common/api/src/main/java/com/dfsek/terra/api/config/Loader.java index 196678e4f..5b12e43c2 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/config/Loader.java +++ b/common/api/src/main/java/com/dfsek/terra/api/config/Loader.java @@ -18,11 +18,11 @@ import java.util.function.Consumer; public interface Loader { - + Loader thenNames(Consumer> consumer) throws ConfigException; - + Loader thenEntries(Consumer>> consumer) throws ConfigException; - + /** * Get a single file from this Loader. * @@ -31,7 +31,7 @@ public interface Loader { * @return InputStream from file. */ InputStream get(String singleFile) throws IOException; - + /** * Open a subdirectory. * @@ -39,7 +39,7 @@ public interface Loader { * @param extension File extension */ Loader open(String directory, String extension); - + /** * Close all InputStreams opened. */ diff --git a/common/api/src/main/java/com/dfsek/terra/api/config/PluginConfig.java b/common/api/src/main/java/com/dfsek/terra/api/config/PluginConfig.java index 30c1c7e1f..7946d0ec9 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/config/PluginConfig.java +++ b/common/api/src/main/java/com/dfsek/terra/api/config/PluginConfig.java @@ -12,24 +12,24 @@ import com.dfsek.terra.api.Platform; public interface PluginConfig { void load(Platform platform); - + boolean dumpDefaultConfig(); - + boolean isDebugCommands(); - + boolean isDebugProfiler(); - + boolean isDebugScript(); - + boolean isDebugLog(); - + int getBiomeSearchResolution(); - + int getStructureCache(); - + int getSamplerCache(); - + int getMaxRecursion(); - + int getProviderCache(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/entity/Entity.java b/common/api/src/main/java/com/dfsek/terra/api/entity/Entity.java index e2bf23009..aaa53ce4e 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/entity/Entity.java +++ b/common/api/src/main/java/com/dfsek/terra/api/entity/Entity.java @@ -14,10 +14,10 @@ import com.dfsek.terra.api.world.ServerWorld; public interface Entity extends Handle { Vector3 position(); - + void position(Vector3 position); - + void world(ServerWorld world); - + ServerWorld world(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/EventManager.java b/common/api/src/main/java/com/dfsek/terra/api/event/EventManager.java index 9fa7b9c01..c705e4beb 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/EventManager.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/EventManager.java @@ -20,8 +20,8 @@ public interface EventManager { * @param event Event to pass to all registered EventListeners. */ T callEvent(T event); - + void registerHandler(Class clazz, T handler); - + T getHandler(Class clazz); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/AbstractCancellable.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/AbstractCancellable.java index 0a27a8f2a..f13858638 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/AbstractCancellable.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/AbstractCancellable.java @@ -15,12 +15,12 @@ import com.dfsek.terra.api.util.mutable.MutableBoolean; */ public abstract class AbstractCancellable implements Cancellable { private final MutableBoolean cancelled = new MutableBoolean(false); - + @Override public boolean isCancelled() { return cancelled.get(); } - + @Override public void setCancelled(boolean cancelled) { this.cancelled.set(cancelled); diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/Cancellable.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/Cancellable.java index 6a49c0612..e3967a598 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/Cancellable.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/Cancellable.java @@ -19,7 +19,7 @@ public interface Cancellable extends Event { * @return Whether event is cancelled. */ boolean isCancelled(); - + /** * Set the cancellation status of the event. * diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/ConfigurationDiscoveryEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/ConfigurationDiscoveryEvent.java index 74be475a0..fbe1c8a28 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/ConfigurationDiscoveryEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/ConfigurationDiscoveryEvent.java @@ -26,24 +26,24 @@ import com.dfsek.terra.api.event.events.PackEvent; public class ConfigurationDiscoveryEvent implements PackEvent, FailThroughEvent { private final ConfigPack pack; private final Loader loader; - + private final BiConsumer consumer; - + public ConfigurationDiscoveryEvent(ConfigPack pack, Loader loader, BiConsumer consumer) { this.pack = pack; this.loader = loader; this.consumer = consumer; } - + public void register(String identifier, Configuration config) { consumer.accept(identifier, config); } - + @Override public ConfigPack getPack() { return pack; } - + public Loader getLoader() { return loader; } diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/ConfigurationLoadEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/ConfigurationLoadEvent.java index e7529e7fd..ba832dff9 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/ConfigurationLoadEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/ConfigurationLoadEvent.java @@ -30,9 +30,9 @@ public class ConfigurationLoadEvent implements PackEvent, FailThroughEvent { private final AbstractConfiguration configuration; private final Consumer loader; private final ConfigType type; - + private final Object loaded; - + public ConfigurationLoadEvent(ConfigPack pack, AbstractConfiguration configuration, Consumer loader, ConfigType type, Object loaded) { this.pack = pack; @@ -41,38 +41,38 @@ public class ConfigurationLoadEvent implements PackEvent, FailThroughEvent { this.type = type; this.loaded = loaded; } - + public T load(T template) { loader.accept(template); return template; } - + public boolean is(Class clazz) { return clazz.isAssignableFrom(type.getTypeKey().getRawType()); } - + @Override public ConfigPack getPack() { return pack; } - + public AbstractConfiguration getConfiguration() { return configuration; } - + public ConfigType getType() { return type; } - + @SuppressWarnings("unchecked") public T getLoadedObject(Class clazz) { if(!clazz.isAssignableFrom(type.getTypeKey().getRawType())) throw new ClassCastException( - "Cannot assign object from loader of type " + ReflectionUtil.typeToString(type.getTypeKey().getType()) + " to class " + - clazz.getCanonicalName()); + "Cannot assign object from loader of type " + ReflectionUtil.typeToString(type.getTypeKey().getType()) + " to class " + + clazz.getCanonicalName()); return (T) loaded; } - + @SuppressWarnings("unchecked") public T getLoadedObject() { return (T) loaded; diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackLoadEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackLoadEvent.java index 9c83d6e0e..f18e32109 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackLoadEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/pack/ConfigPackLoadEvent.java @@ -21,12 +21,12 @@ import com.dfsek.terra.api.event.events.PackEvent; public abstract class ConfigPackLoadEvent implements PackEvent, FailThroughEvent { private final ConfigPack pack; private final ExceptionalConsumer configLoader; - + public ConfigPackLoadEvent(ConfigPack pack, ExceptionalConsumer configLoader) { this.pack = pack; this.configLoader = configLoader; } - + /** * Load a custom {@link ConfigTemplate} using the pack manifest. * @@ -36,12 +36,12 @@ public abstract class ConfigPackLoadEvent implements PackEvent, FailThroughEvent configLoader.accept(template); return template; } - + @Override public ConfigPack getPack() { return pack; } - + public interface ExceptionalConsumer { void accept(T value) throws ConfigException; } diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypeLoadEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypeLoadEvent.java index 28caacfee..517460a7c 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypeLoadEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/config/type/ConfigTypeLoadEvent.java @@ -18,30 +18,30 @@ import com.dfsek.terra.api.util.reflection.ReflectionUtil; public abstract class ConfigTypeLoadEvent implements PackEvent, FailThroughEvent { private final ConfigType type; private final CheckedRegistry registry; - + private final ConfigPack pack; - + public ConfigTypeLoadEvent(ConfigType type, CheckedRegistry registry, ConfigPack pack) { this.type = type; this.registry = registry; this.pack = pack; } - + public boolean is(Class clazz) { return clazz.isAssignableFrom(type.getTypeKey().getRawType()); } - + @Override public ConfigPack getPack() { return pack; } - + @SuppressWarnings("unchecked") public CheckedRegistry getRegistry(Class clazz) { if(!clazz.isAssignableFrom(type.getTypeKey().getRawType())) throw new ClassCastException( - "Cannot assign object from loader of type " + ReflectionUtil.typeToString(type.getTypeKey().getType()) + " to class " + - clazz.getCanonicalName()); + "Cannot assign object from loader of type " + ReflectionUtil.typeToString(type.getTypeKey().getType()) + " to class " + + clazz.getCanonicalName()); return (CheckedRegistry) registry; } } diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/platform/CommandRegistrationEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/platform/CommandRegistrationEvent.java index 40d113079..de13f061a 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/platform/CommandRegistrationEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/platform/CommandRegistrationEvent.java @@ -8,11 +8,11 @@ import com.dfsek.terra.api.event.events.Event; public class CommandRegistrationEvent implements Event { private final CommandManager commandManager; - + public CommandRegistrationEvent(CommandManager commandManager) { this.commandManager = commandManager; } - + public CommandManager getCommandManager() { return commandManager; } diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/EntitySpawnEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/EntitySpawnEvent.java index 088b0d661..bebbfa21e 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/EntitySpawnEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/EntitySpawnEvent.java @@ -18,17 +18,17 @@ import com.dfsek.terra.api.event.events.PackEvent; public class EntitySpawnEvent implements PackEvent { private final ConfigPack pack; private final Entity entity; - + public EntitySpawnEvent(ConfigPack pack, Entity entity) { this.pack = pack; this.entity = entity; } - + @Override public ConfigPack getPack() { return pack; } - + /** * Get the entity that triggered the event. * diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/LootPopulateEvent.java b/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/LootPopulateEvent.java index 9b11ac248..b03f897af 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/LootPopulateEvent.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/events/world/generation/LootPopulateEvent.java @@ -26,23 +26,23 @@ public class LootPopulateEvent extends AbstractCancellable implements PackEvent private final ConfigPack pack; private final Structure structure; private LootTable table; - + public LootPopulateEvent(Container container, LootTable table, ConfigPack pack, Structure structure) { this.container = container; this.table = table; this.pack = pack; this.structure = structure; } - + @Override public ConfigPack getPack() { return pack; } - + public Vector3 getPosition() { return container.getPosition(); } - + /** * Get the {@link Container} representing the inventory. * @@ -51,7 +51,7 @@ public class LootPopulateEvent extends AbstractCancellable implements PackEvent public Container getContainer() { return container; } - + /** * Get the loot table to be populated. * @@ -60,7 +60,7 @@ public class LootPopulateEvent extends AbstractCancellable implements PackEvent public LootTable getTable() { return table; } - + /** * Set the loot table to be populated. * @@ -69,7 +69,7 @@ public class LootPopulateEvent extends AbstractCancellable implements PackEvent public void setTable(@NotNull LootTable table) { this.table = table; } - + /** * Get the script used to generate the structure. * diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/functional/EventContext.java b/common/api/src/main/java/com/dfsek/terra/api/event/functional/EventContext.java index 52670bb3c..c09396059 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/functional/EventContext.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/functional/EventContext.java @@ -14,10 +14,10 @@ import com.dfsek.terra.api.event.events.Event; public interface EventContext { EventContext then(Consumer action); - + EventContext priority(int priority); - + EventContext failThrough(); - + EventContext global(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/event/functional/FunctionalEventHandler.java b/common/api/src/main/java/com/dfsek/terra/api/event/functional/FunctionalEventHandler.java index 6f6a203de..a4af619de 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/event/functional/FunctionalEventHandler.java +++ b/common/api/src/main/java/com/dfsek/terra/api/event/functional/FunctionalEventHandler.java @@ -15,6 +15,6 @@ import com.dfsek.terra.api.util.reflection.TypeKey; public interface FunctionalEventHandler extends EventHandler { EventContext register(BaseAddon addon, Class clazz); - + EventContext register(BaseAddon addon, TypeKey clazz); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/handle/ItemHandle.java b/common/api/src/main/java/com/dfsek/terra/api/handle/ItemHandle.java index 9aaf2e141..83295c5fd 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/handle/ItemHandle.java +++ b/common/api/src/main/java/com/dfsek/terra/api/handle/ItemHandle.java @@ -14,10 +14,10 @@ import com.dfsek.terra.api.inventory.item.Enchantment; public interface ItemHandle { - + Item createItem(String data); - + Enchantment getEnchantment(String id); - + Set getEnchantments(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/handle/WorldHandle.java b/common/api/src/main/java/com/dfsek/terra/api/handle/WorldHandle.java index 3518b9685..be1bb893a 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/handle/WorldHandle.java +++ b/common/api/src/main/java/com/dfsek/terra/api/handle/WorldHandle.java @@ -21,11 +21,11 @@ public interface WorldHandle { @NotNull @Contract("_ -> new") BlockState createBlockState(@NotNull String data); - + @NotNull @Contract(pure = true) BlockState air(); - + @NotNull EntityType getEntity(@NotNull String id); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/inject/Injector.java b/common/api/src/main/java/com/dfsek/terra/api/inject/Injector.java index f7db74d83..87eec5263 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inject/Injector.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inject/Injector.java @@ -23,14 +23,14 @@ public interface Injector { static Injector get(T1 value) { return new InjectorImpl<>(value); } - + /** * Add an explicit class as a target. Useful for applications where subclasses may cause issues with DI. * * @param target Target class type. */ void addExplicitTarget(Class target); - + /** * Inject the stored object into an object. *

diff --git a/common/api/src/main/java/com/dfsek/terra/api/inject/exception/InjectionException.java b/common/api/src/main/java/com/dfsek/terra/api/inject/exception/InjectionException.java index f0ebef673..a395d5369 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inject/exception/InjectionException.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inject/exception/InjectionException.java @@ -18,11 +18,11 @@ import com.dfsek.terra.api.inject.Injector; public class InjectionException extends RuntimeException { @Serial private static final long serialVersionUID = -6929631447064215387L; - + public InjectionException(String message) { super(message); } - + public InjectionException(String message, Throwable cause) { super(message, cause); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/inject/impl/InjectorImpl.java b/common/api/src/main/java/com/dfsek/terra/api/inject/impl/InjectorImpl.java index c34965101..f0e870e07 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inject/impl/InjectorImpl.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inject/impl/InjectorImpl.java @@ -21,7 +21,7 @@ import com.dfsek.terra.api.util.reflection.ReflectionUtil; public class InjectorImpl implements Injector { private final T value; private final Set> targets = new HashSet<>(); - + /** * Instantiate an Injector with a value to inject * @@ -30,14 +30,14 @@ public class InjectorImpl implements Injector { public InjectorImpl(T value) { this.value = value; } - - + + @Override public void addExplicitTarget(Class target) { targets.add(target); } - - + + @Override public void inject(Object object) throws InjectionException { for(Field field : ReflectionUtil.getFields(object.getClass())) { diff --git a/common/api/src/main/java/com/dfsek/terra/api/inventory/Inventory.java b/common/api/src/main/java/com/dfsek/terra/api/inventory/Inventory.java index 5a7e3a508..0b6c3ab1c 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inventory/Inventory.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inventory/Inventory.java @@ -12,8 +12,8 @@ import com.dfsek.terra.api.Handle; public interface Inventory extends Handle { void setItem(int slot, ItemStack newStack); - + int getSize(); - + ItemStack getItem(int slot); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/inventory/Item.java b/common/api/src/main/java/com/dfsek/terra/api/inventory/Item.java index 1943f878f..bc9a92b6c 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inventory/Item.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inventory/Item.java @@ -15,6 +15,6 @@ import com.dfsek.terra.api.Handle; */ public interface Item extends Handle { ItemStack newItemStack(int amount); - + double getMaxDurability(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/inventory/ItemStack.java b/common/api/src/main/java/com/dfsek/terra/api/inventory/ItemStack.java index 2ab7a3dc5..070efaf73 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inventory/ItemStack.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inventory/ItemStack.java @@ -14,15 +14,15 @@ import com.dfsek.terra.api.inventory.item.ItemMeta; public interface ItemStack extends Handle { int getAmount(); - + void setAmount(int i); - + Item getType(); - + ItemMeta getItemMeta(); - + void setItemMeta(ItemMeta meta); - + default boolean isDamageable() { return getItemMeta() instanceof Damageable; } diff --git a/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Damageable.java b/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Damageable.java index 62d03dbf4..121c3652c 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Damageable.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Damageable.java @@ -12,8 +12,8 @@ import com.dfsek.terra.api.Handle; public interface Damageable extends Handle { int getDamage(); - + void setDamage(int damage); - + boolean hasDamage(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Enchantment.java b/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Enchantment.java index 3fa065abf..a8c7e07b3 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Enchantment.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inventory/item/Enchantment.java @@ -13,10 +13,10 @@ import com.dfsek.terra.api.inventory.ItemStack; public interface Enchantment extends Handle { boolean canEnchantItem(ItemStack itemStack); - + boolean conflictsWith(Enchantment other); - + String getID(); - + int getMaxLevel(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/inventory/item/ItemMeta.java b/common/api/src/main/java/com/dfsek/terra/api/inventory/item/ItemMeta.java index 268c7ec94..b2bc68ca9 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/inventory/item/ItemMeta.java +++ b/common/api/src/main/java/com/dfsek/terra/api/inventory/item/ItemMeta.java @@ -14,6 +14,6 @@ import com.dfsek.terra.api.Handle; public interface ItemMeta extends Handle { void addEnchantment(Enchantment enchantment, int level); - + Map getEnchantments(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/noise/NoiseSampler.java b/common/api/src/main/java/com/dfsek/terra/api/noise/NoiseSampler.java index e01c469ba..06021126e 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/noise/NoiseSampler.java +++ b/common/api/src/main/java/com/dfsek/terra/api/noise/NoiseSampler.java @@ -21,39 +21,39 @@ public interface NoiseSampler { public double noise(long seed, double x, double y) { return 0; } - + @Override public double noise(long seed, double x, double y, double z) { return 0; } }; } - + default double noise(Vector3 vector3, long seed) { return noise(seed, vector3.getX(), vector3.getY(), vector3.getZ()); } - + default double noise(Vector3Int vector3, long seed) { return noise(seed, vector3.getX(), vector3.getY(), vector3.getZ()); } - - + + default double noise(Vector2 vector2, long seed) { return noise(seed, vector2.getX(), vector2.getZ()); } - + default double noise(Vector2Int vector2, long seed) { return noise(seed, vector2.getX(), vector2.getZ()); } - + double noise(long seed, double x, double y); - + default double noise(long seed, int x, int y) { return noise(seed, (double) x, y); } - + double noise(long seed, double x, double y, double z); - + default double noise(long seed, int x, int y, int z) { return noise(seed, (double) x, y, z); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/profiler/Profiler.java b/common/api/src/main/java/com/dfsek/terra/api/profiler/Profiler.java index 3d210d38c..0e8122891 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/profiler/Profiler.java +++ b/common/api/src/main/java/com/dfsek/terra/api/profiler/Profiler.java @@ -17,7 +17,7 @@ public interface Profiler { * @param frame ID of frame. */ void push(String frame); - + /** * Pop a frame from this profiler. * @@ -25,22 +25,22 @@ public interface Profiler { * at the top of the profiler stack. */ void pop(String frame); - + /** * Start profiling. */ void start(); - + /** * Stop profiling. */ void stop(); - + /** * Clear the profiler data. */ void reset(); - + /** * Get the profiler data. * diff --git a/common/api/src/main/java/com/dfsek/terra/api/profiler/Timings.java b/common/api/src/main/java/com/dfsek/terra/api/profiler/Timings.java index bcd2d06c7..6beae577d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/profiler/Timings.java +++ b/common/api/src/main/java/com/dfsek/terra/api/profiler/Timings.java @@ -18,46 +18,46 @@ import java.util.Set; public class Timings { private final Map subItems = new HashMap<>(); - + private final List timings = new ArrayList<>(); - + public void addTime(long time) { timings.add(time); } - + public double average() { return (double) timings.stream().reduce(0L, Long::sum) / timings.size(); } - + public long max() { return timings.stream().mapToLong(Long::longValue).max().orElse(0L); } - + public long min() { return timings.stream().mapToLong(Long::longValue).min().orElse(0L); } - + public double sum() { return timings.stream().mapToDouble(Long::doubleValue).sum(); } - + @Override public String toString() { return toString(1, this, Collections.emptySet()); } - + private String toString(int indent, Timings parent, Set branches) { StringBuilder builder = new StringBuilder(); - + builder.append((double) min() / 1000000).append("ms min / ").append(average() / 1000000).append("ms avg / ") - .append((double) max() / 1000000).append("ms max (").append(timings.size()).append(" samples, ") - .append((sum() / parent.sum()) * 100).append("% of parent)"); - + .append((double) max() / 1000000).append("ms max (").append(timings.size()).append(" samples, ") + .append((sum() / parent.sum()) * 100).append("% of parent)"); + List frames = new ArrayList<>(); Set newBranches = new HashSet<>(branches); newBranches.add(indent); subItems.forEach((id, timings) -> frames.add(id + ": " + timings.toString(indent + 1, this, newBranches))); - + for(int i = 0; i < frames.size(); i++) { builder.append('\n'); for(int j = 0; j < indent; j++) { @@ -70,11 +70,11 @@ public class Timings { } return builder.toString(); } - + public List getTimings() { return timings; } - + public Timings getSubItem(String id) { return subItems.computeIfAbsent(id, s -> new Timings()); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/properties/Context.java b/common/api/src/main/java/com/dfsek/terra/api/properties/Context.java index 9eeaaf8b3..45e5ea07e 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/properties/Context.java +++ b/common/api/src/main/java/com/dfsek/terra/api/properties/Context.java @@ -18,26 +18,26 @@ public class Context { private static final Map, PropertyKey> properties = new HashMap<>(); private final Map, Properties> map = new HashMap<>(); private final AtomicReference list = new AtomicReference<>(new Properties[size.get()]); - + @SuppressWarnings("unchecked") public static PropertyKey create(Class clazz) { return (PropertyKey) properties.computeIfAbsent(clazz, c -> new PropertyKey<>(size.getAndIncrement(), clazz)); } - + @SuppressWarnings("unchecked") public T get(Class clazz) { return (T) map.computeIfAbsent(clazz, k -> { throw new IllegalArgumentException("No properties registered for class " + clazz.getCanonicalName()); }); } - + public Context put(Properties properties) { if(map.containsKey(properties.getClass())) throw new IllegalArgumentException( - "Property for class " + properties.getClass().getCanonicalName() + " already registered."); + "Property for class " + properties.getClass().getCanonicalName() + " already registered."); map.put(properties.getClass(), properties); return this; } - + public Context put(PropertyKey key, T properties) { list.updateAndGet(p -> { if(p.length == size.get()) return p; @@ -47,12 +47,12 @@ public class Context { })[key.key] = properties; return this; } - + @SuppressWarnings("unchecked") public T get(PropertyKey key) { return (T) list.get()[key.key]; } - + public boolean has(Class test) { return map.containsKey(test); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/properties/PropertyKey.java b/common/api/src/main/java/com/dfsek/terra/api/properties/PropertyKey.java index 9c2daefe2..d1eb83d9a 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/properties/PropertyKey.java +++ b/common/api/src/main/java/com/dfsek/terra/api/properties/PropertyKey.java @@ -3,12 +3,12 @@ package com.dfsek.terra.api.properties; public class PropertyKey { protected final int key; private final Class clazz; - + protected PropertyKey(int key, Class clazz) { this.key = key; this.clazz = clazz; } - + public Class getTypeClass() { return clazz; } diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/CheckedRegistry.java b/common/api/src/main/java/com/dfsek/terra/api/registry/CheckedRegistry.java index 823db21b1..20535a293 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/CheckedRegistry.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/CheckedRegistry.java @@ -24,7 +24,7 @@ public interface CheckedRegistry extends Registry { * @throws DuplicateEntryException If an entry with the same identifier is already present. */ void register(@NotNull RegistryKey identifier, @NotNull T value) throws DuplicateEntryException; - + @SuppressWarnings("unchecked") default void register(@NotNull Keyed value) throws DuplicateEntryException { register(value.getRegistryKey(), (T) value); diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/OpenRegistry.java b/common/api/src/main/java/com/dfsek/terra/api/registry/OpenRegistry.java index 2f46830ac..ababb389d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/OpenRegistry.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/OpenRegistry.java @@ -22,12 +22,12 @@ public interface OpenRegistry extends Registry { * @param value Value to register. */ boolean register(@NotNull RegistryKey identifier, @NotNull T value); - + @SuppressWarnings("unchecked") default boolean register(@NotNull Keyed value) { return register(value.getRegistryKey(), (T) value); } - + /** * Add a value to this registry, checking whether it is present first. * @@ -37,12 +37,12 @@ public interface OpenRegistry extends Registry { * @throws DuplicateEntryException If an entry with the same identifier is already present. */ void registerChecked(@NotNull RegistryKey identifier, @NotNull T value) throws DuplicateEntryException; - + @SuppressWarnings("unchecked") default void registerChecked(@NotNull Keyed value) { registerChecked(value.getRegistryKey(), (T) value); } - + /** * Clears all entries from the registry. */ diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/Registry.java b/common/api/src/main/java/com/dfsek/terra/api/registry/Registry.java index 2d3589a2b..33995a9f5 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/Registry.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/Registry.java @@ -33,7 +33,7 @@ public interface Registry extends TypeLoader { */ @Contract(pure = true) Optional get(@NotNull RegistryKey key); - + /** * Check if the registry contains a value. * @@ -43,21 +43,21 @@ public interface Registry extends TypeLoader { */ @Contract(pure = true) boolean contains(@NotNull RegistryKey key); - + /** * Perform the given action for every value in the registry. * * @param consumer Action to perform on value. */ void forEach(@NotNull Consumer consumer); - + /** * Perform an action for every key-value pair in the registry. * * @param consumer Action to perform on pair. */ void forEach(@NotNull BiConsumer consumer); - + /** * Get the entries of this registry as a {@link Set}. * @@ -66,7 +66,7 @@ public interface Registry extends TypeLoader { @NotNull @Contract(pure = true) Collection entries(); - + /** * Get all the keys in this registry. * @@ -75,13 +75,13 @@ public interface Registry extends TypeLoader { @NotNull @Contract(pure = true) Set keys(); - + TypeKey getType(); - + default Class getRawType() { return getType().getRawType(); } - + default Optional getByID(String id) { return getByID(id, map -> { if(map.isEmpty()) return Optional.empty(); @@ -89,19 +89,19 @@ public interface Registry extends TypeLoader { return map.values().stream().findFirst(); // only one value. } throw new IllegalArgumentException("ID \"" + id + "\" is ambiguous; matches: " + map - .keySet() - .stream() - .map(RegistryKey::toString) - .reduce("", (a, b) -> a + "\n - " + b)); + .keySet() + .stream() + .map(RegistryKey::toString) + .reduce("", (a, b) -> a + "\n - " + b)); }); } - + default Collection getAllWithID(String id) { return getMatches(id).values(); } - + Map getMatches(String id); - + default Optional getByID(String attempt, Function, Optional> reduction) { if(attempt.contains(":")) { return get(RegistryKey.parse(attempt)); diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/exception/DuplicateEntryException.java b/common/api/src/main/java/com/dfsek/terra/api/registry/exception/DuplicateEntryException.java index db4cee6e8..82afcda98 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/exception/DuplicateEntryException.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/exception/DuplicateEntryException.java @@ -16,11 +16,11 @@ import java.io.Serial; public class DuplicateEntryException extends RuntimeException { @Serial private static final long serialVersionUID = -7199021672428288780L; - + public DuplicateEntryException(String message) { super(message); } - + public DuplicateEntryException(String message, Throwable cause) { super(message, cause); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/exception/NoSuchEntryException.java b/common/api/src/main/java/com/dfsek/terra/api/registry/exception/NoSuchEntryException.java index ce39576c3..a1007a1ed 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/exception/NoSuchEntryException.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/exception/NoSuchEntryException.java @@ -4,5 +4,5 @@ public class NoSuchEntryException extends RuntimeException { public NoSuchEntryException(String message) { super(message); } - + } diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/key/Keyed.java b/common/api/src/main/java/com/dfsek/terra/api/registry/key/Keyed.java index 957226f52..3ab262ca6 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/key/Keyed.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/key/Keyed.java @@ -3,12 +3,12 @@ package com.dfsek.terra.api.registry.key; @SuppressWarnings("unused") public interface Keyed> extends Namespaced, StringIdentifiable { RegistryKey getRegistryKey(); - + @Override default String getNamespace() { return getRegistryKey().getNamespace(); } - + @Override default String getID() { return getRegistryKey().getID(); diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/key/Namespaced.java b/common/api/src/main/java/com/dfsek/terra/api/registry/key/Namespaced.java index 0c4e33c22..2e0f2f92c 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/key/Namespaced.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/key/Namespaced.java @@ -2,7 +2,7 @@ package com.dfsek.terra.api.registry.key; public interface Namespaced { String getNamespace(); - + default RegistryKey key(String id) { return RegistryKey.of(getNamespace(), id); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/key/RegistryKey.java b/common/api/src/main/java/com/dfsek/terra/api/registry/key/RegistryKey.java index 40398b81a..ebcf4b0a4 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/key/RegistryKey.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/key/RegistryKey.java @@ -8,53 +8,53 @@ public final class RegistryKey implements StringIdentifiable, Namespaced { private static final Pattern ID_PATTERN = Pattern.compile("^[a-zA-Z0-9_-]*$"); private final String namespace; private final String id; - + private RegistryKey(String namespace, String id) { if(!ID_PATTERN.matcher(namespace).matches()) { throw new IllegalArgumentException( - "Namespace must only contain alphanumeric characters, hyphens, and underscores. \"" + namespace + - "\" is not a valid namespace."); + "Namespace must only contain alphanumeric characters, hyphens, and underscores. \"" + namespace + + "\" is not a valid namespace."); } - + if(!ID_PATTERN.matcher(id).matches()) { throw new IllegalArgumentException( - "ID must only contain alphanumeric characters, hyphens, and underscores. \"" + id + - "\" is not a valid ID."); + "ID must only contain alphanumeric characters, hyphens, and underscores. \"" + id + + "\" is not a valid ID."); } - + this.namespace = namespace; this.id = id; } - + public static RegistryKey parse(String key) { if(key.chars().filter(c -> c == ':').count() != 1) { throw new IllegalArgumentException("Malformed RegistryKey: " + key); } String namespace = key.substring(0, key.indexOf(":")); String id = key.substring(key.indexOf(":") + 1); - + return new RegistryKey(namespace, id); } - + public static RegistryKey of(String namespace, String id) { return new RegistryKey(namespace, id); } - + @Override public String getNamespace() { return namespace; } - + @Override public String getID() { return id; } - + @Override public int hashCode() { return Objects.hash(namespace, id); } - + @Override public boolean equals(Object obj) { if(obj instanceof RegistryKey that) { @@ -62,7 +62,7 @@ public final class RegistryKey implements StringIdentifiable, Namespaced { } return false; } - + @Override public String toString() { return namespace + ":" + id; diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/meta/CheckedRegistryHolder.java b/common/api/src/main/java/com/dfsek/terra/api/registry/meta/CheckedRegistryHolder.java index 57d35e043..a55be5885 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/meta/CheckedRegistryHolder.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/meta/CheckedRegistryHolder.java @@ -10,10 +10,10 @@ public interface CheckedRegistryHolder extends RegistryHolder { default CheckedRegistry getCheckedRegistry(Class clazz) throws IllegalStateException { return getCheckedRegistry((Type) clazz); } - + default CheckedRegistry getCheckedRegistry(TypeKey type) throws IllegalStateException { return getCheckedRegistry(type.getType()); } - + CheckedRegistry getCheckedRegistry(Type type); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/meta/RegistryHolder.java b/common/api/src/main/java/com/dfsek/terra/api/registry/meta/RegistryHolder.java index fd765ebaa..b7a8b1530 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/meta/RegistryHolder.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/meta/RegistryHolder.java @@ -17,10 +17,10 @@ public interface RegistryHolder { default Registry getRegistry(Class clazz) { return getRegistry((Type) clazz); } - + default Registry getRegistry(TypeKey type) { return getRegistry(type.getType()); } - + Registry getRegistry(Type type); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/registry/meta/RegistryProvider.java b/common/api/src/main/java/com/dfsek/terra/api/registry/meta/RegistryProvider.java index b3acdfd20..32edc988d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/registry/meta/RegistryProvider.java +++ b/common/api/src/main/java/com/dfsek/terra/api/registry/meta/RegistryProvider.java @@ -8,6 +8,6 @@ public interface RegistryProvider { default CheckedRegistry getOrCreateRegistry(Class clazz) { return getOrCreateRegistry(TypeKey.of(clazz)); } - + CheckedRegistry getOrCreateRegistry(TypeKey type); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/structure/LootTable.java b/common/api/src/main/java/com/dfsek/terra/api/structure/LootTable.java index 44827a26d..3108dd1f3 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/structure/LootTable.java +++ b/common/api/src/main/java/com/dfsek/terra/api/structure/LootTable.java @@ -25,7 +25,7 @@ public interface LootTable { * @param r The The Random instance to use. */ void fillInventory(Inventory i, Random r); - + /** * Fetches a list of ItemStacks from the loot table using the given Random instance. * diff --git a/common/api/src/main/java/com/dfsek/terra/api/structure/configured/ConfiguredStructure.java b/common/api/src/main/java/com/dfsek/terra/api/structure/configured/ConfiguredStructure.java index c6280b570..37a03996f 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/structure/configured/ConfiguredStructure.java +++ b/common/api/src/main/java/com/dfsek/terra/api/structure/configured/ConfiguredStructure.java @@ -19,8 +19,8 @@ import com.dfsek.terra.api.util.collection.ProbabilityCollection; @Experimental public interface ConfiguredStructure extends StringIdentifiable { ProbabilityCollection getStructure(); - + Range getSpawnStart(); - + StructureSpawn getSpawn(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/BinaryColumn.java b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/BinaryColumn.java index a14777751..9a4baab54 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/BinaryColumn.java +++ b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/BinaryColumn.java @@ -24,7 +24,7 @@ public class BinaryColumn { private final int minY; private final int maxY; private final Lazy results; - + /** * Constructs a new {@link BinaryColumn} with all values initiated to {@code false} * @@ -44,7 +44,7 @@ public class BinaryColumn { if(maxY <= minY) throw new IllegalArgumentException("Max y must be greater than min y"); this.data = data; } - + public BinaryColumn(int minY, int maxY, boolean[] data) { this.minY = minY; this.maxY = maxY; @@ -52,15 +52,15 @@ public class BinaryColumn { if(maxY <= minY) throw new IllegalArgumentException("Max y must be greater than min y"); this.data = y -> data[y - minY]; } - + public BinaryColumn(Range y, IntToBooleanFunction data) { this(y.getMin(), y.getMax(), data); } - + public static BinaryColumn getNull() { return NULL; } - + /** * Get the value at a height. * @@ -71,12 +71,12 @@ public class BinaryColumn { public boolean get(int y) { return data.apply(y); } - - + + public boolean contains(int y) { return y >= minY && y < maxY; } - + /** * Perform an action for all heights which have been set. * @@ -90,7 +90,7 @@ public class BinaryColumn { } } } - + /** * Return a {@link BinaryColumn} of equal height with a boolean AND operation applied to each height. * @@ -103,12 +103,12 @@ public class BinaryColumn { public BinaryColumn and(BinaryColumn that) { int bigMinY = Math.max(this.minY, that.minY); // narrow new column, as areas outside will always be false. int smallMaxY = Math.min(this.maxY, that.maxY); - + if(bigMinY >= smallMaxY) return getNull(); - + return new BinaryColumn(bigMinY, smallMaxY, y -> this.get(y) && that.get(y)); } - + /** * Return a {@link BinaryColumn} of equal height with a boolean OR operation applied to each height. * @@ -121,18 +121,18 @@ public class BinaryColumn { public BinaryColumn or(BinaryColumn that) { return or(that, (a, b) -> a.getAsBoolean() || b.getAsBoolean()); } - + public BinaryColumn xor(BinaryColumn that) { return or(that, (a, b) -> a.getAsBoolean() ^ b.getAsBoolean()); } - + private BinaryColumn or(BinaryColumn that, BooleanBinaryOperator operator) { int smallMinY = Math.min(this.minY, that.minY); int bigMaxY = Math.max(this.maxY, that.maxY); - + return new BinaryColumn(smallMinY, bigMaxY, y -> operator.apply(() -> this.get(y), () -> that.get(y))); } - + private interface BooleanBinaryOperator { boolean apply(BooleanSupplier a, BooleanSupplier b); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Distributor.java b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Distributor.java index 799b45e92..7f2ec0a1b 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Distributor.java +++ b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Distributor.java @@ -11,21 +11,21 @@ public interface Distributor { static Distributor yes() { return (x, z, seed) -> true; } - + static Distributor no() { return (x, z, seed) -> false; } - + boolean matches(int x, int z, long seed); - + default Distributor and(Distributor other) { return (x, z, seed) -> this.matches(x, z, seed) && other.matches(x, z, seed); } - + default Distributor or(Distributor other) { return (x, z, seed) -> this.matches(x, z, seed) || other.matches(x, z, seed); } - + default Distributor xor(Distributor other) { return (x, z, seed) -> this.matches(x, z, seed) ^ other.matches(x, z, seed); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Feature.java b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Feature.java index 985e97321..5ce08b3dd 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Feature.java +++ b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Feature.java @@ -14,8 +14,8 @@ import com.dfsek.terra.api.world.WritableWorld; public interface Feature extends StringIdentifiable { Structure getStructure(WritableWorld world, int x, int y, int z); - + Distributor getDistributor(); - + Locator getLocator(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Locator.java b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Locator.java index 325ba10aa..ac0f4be3d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Locator.java +++ b/common/api/src/main/java/com/dfsek/terra/api/structure/feature/Locator.java @@ -14,14 +14,14 @@ public interface Locator { default Locator and(Locator that) { return column -> this.getSuitableCoordinates(column).and(that.getSuitableCoordinates(column)); } - + default Locator or(Locator that) { return column -> this.getSuitableCoordinates(column).or(that.getSuitableCoordinates(column)); } - + default Locator xor(Locator that) { return column -> this.getSuitableCoordinates(column).xor(that.getSuitableCoordinates(column)); } - + BinaryColumn getSuitableCoordinates(Column column); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/tectonic/ConfigLoadingDelegate.java b/common/api/src/main/java/com/dfsek/terra/api/tectonic/ConfigLoadingDelegate.java index 5756419a6..ce05d5ae1 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/tectonic/ConfigLoadingDelegate.java +++ b/common/api/src/main/java/com/dfsek/terra/api/tectonic/ConfigLoadingDelegate.java @@ -16,13 +16,13 @@ import java.util.function.Supplier; public interface ConfigLoadingDelegate { ConfigLoadingDelegate applyLoader(Type type, TypeLoader loader); - + default ConfigLoadingDelegate applyLoader(Class type, TypeLoader loader) { return applyLoader((Type) type, loader); } - + ConfigLoadingDelegate applyLoader(Type type, Supplier> loader); - + default ConfigLoadingDelegate applyLoader(Class type, Supplier> loader) { return applyLoader((Type) type, loader); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/transform/Validator.java b/common/api/src/main/java/com/dfsek/terra/api/transform/Validator.java index 70aaefcf6..430f3df3b 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/transform/Validator.java +++ b/common/api/src/main/java/com/dfsek/terra/api/transform/Validator.java @@ -17,6 +17,6 @@ public interface Validator { static Validator notNull() { return Objects::nonNull; } - + boolean validate(T value) throws TransformException; } diff --git a/common/api/src/main/java/com/dfsek/terra/api/transform/exception/AttemptsFailedException.java b/common/api/src/main/java/com/dfsek/terra/api/transform/exception/AttemptsFailedException.java index 2296dbab6..694df9fb5 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/transform/exception/AttemptsFailedException.java +++ b/common/api/src/main/java/com/dfsek/terra/api/transform/exception/AttemptsFailedException.java @@ -20,12 +20,12 @@ public class AttemptsFailedException extends RuntimeException { @Serial private static final long serialVersionUID = -1160459550006067137L; private final List causes; - + public AttemptsFailedException(String message, List causes) { super(message); this.causes = causes; } - + public List getCauses() { return new ArrayList<>(causes); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/transform/exception/TransformException.java b/common/api/src/main/java/com/dfsek/terra/api/transform/exception/TransformException.java index 32312311e..d0625a226 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/transform/exception/TransformException.java +++ b/common/api/src/main/java/com/dfsek/terra/api/transform/exception/TransformException.java @@ -13,19 +13,19 @@ import java.io.Serial; public class TransformException extends Exception { @Serial private static final long serialVersionUID = -6661338369581162084L; - + public TransformException() { super(); } - + public TransformException(String message) { super(message); } - + public TransformException(String message, Throwable cause) { super(message, cause); } - + public TransformException(Throwable cause) { super(cause); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/Column.java b/common/api/src/main/java/com/dfsek/terra/api/util/Column.java index 2b6264228..011796c1f 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/Column.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/Column.java @@ -10,45 +10,45 @@ import com.dfsek.terra.api.util.function.IntObjConsumer; public interface Column { int getMinY(); - + int getMaxY(); - + int getX(); - + int getZ(); - + T get(int y); - + default void forEach(Consumer consumer) { for(int y = getMinY(); y < getMaxY(); y++) { consumer.accept(get(y)); } } - + default void forEach(IntObjConsumer consumer) { for(int y = getMinY(); y < getMaxY(); y++) { consumer.accept(y, get(y)); } } - + default void forRanges(int resolution, IntIntObjConsumer consumer) { int min = getMinY(); - + int y = min; - + T runningObj = get(y); - + int runningMin = min; - + int max = getMaxY() - 1; - + while(true) { y += resolution; if(y > max) { break; } T current = get(y); - + if(!current.equals(runningObj)) { consumer.accept(runningMin, y, runningObj); runningMin = y; @@ -57,7 +57,7 @@ public interface Column { } consumer.accept(runningMin, getMaxY(), runningObj); } - + default List asList() { List list = new ArrayList<>(); forEach((Consumer) list::add); diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/ConstantRange.java b/common/api/src/main/java/com/dfsek/terra/api/util/ConstantRange.java index a5db22b4c..68b062d21 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/ConstantRange.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/ConstantRange.java @@ -16,30 +16,30 @@ import java.util.Random; public class ConstantRange implements Range { private int min; private int max; - + public ConstantRange(int min, int max) { if(min >= max) throw new IllegalArgumentException("Minimum must not be greater than or equal to maximum!"); this.max = max; this.min = min; } - + @Override public Range multiply(int mult) { min *= mult; max *= mult; return this; } - + @Override public Range reflect(int pt) { return new ConstantRange(2 * pt - this.getMax(), 2 * pt - this.getMin()); } - + @Override public int get(Random r) { return r.nextInt(min, max); } - + @Override public Range intersects(Range other) { try { @@ -48,91 +48,91 @@ public class ConstantRange implements Range { return null; } } - + @Override public Range add(int add) { this.min += add; this.max += add; return this; } - + @Override public Range sub(int sub) { this.min -= sub; this.max -= sub; return this; } - + @NotNull @Override public Iterator iterator() { return new RangeIterator(this); } - + @Override public boolean isInRange(int test) { return test >= min && test < max; } - + @Override public int getMax() { return max; } - + @Override public Range setMax(int max) { this.max = max; return this; } - + @Override public int getMin() { return min; } - + @Override public Range setMin(int min) { this.min = min; return this; } - + @Override public int getRange() { return max - min; } - + @Override public int hashCode() { return min * 31 + max; } - + @Override public boolean equals(Object obj) { if(!(obj instanceof ConstantRange)) return false; Range other = (Range) obj; return other.getMin() == this.getMin() && other.getMax() == this.getMax(); } - + @Override public String toString() { return "Min: " + getMin() + ", Max:" + getMax(); } - - + + private static class RangeIterator implements Iterator { private final Range m; private Integer current; - + public RangeIterator(Range m) { this.m = m; current = m.getMin(); } - + @Override public boolean hasNext() { return current < m.getMax(); } - + @Override public Integer next() { current++; diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/GeometryUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/GeometryUtil.java index 25984257f..3cecfbfbc 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/GeometryUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/GeometryUtil.java @@ -9,7 +9,7 @@ public final class GeometryUtil { private GeometryUtil() { } - + public static void sphere(Vector3Int origin, int radius, Consumer action) { for(int x = -radius; x <= radius; x++) { for(int y = -radius; y <= radius; y++) { @@ -21,7 +21,7 @@ public final class GeometryUtil { } } } - + public static void cube(Vector3Int origin, int radius, Consumer action) { for(int x = -radius; x <= radius; x++) { for(int y = -radius; y <= radius; y++) { diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java index d745f35e2..e57765f2e 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/MathUtil.java @@ -26,39 +26,39 @@ public final class MathUtil { SIN_BITS = 12; SIN_MASK = ~(-1 << SIN_BITS); SIN_COUNT = SIN_MASK + 1; - + radFull = Math.PI * 2.0; degFull = 360.0; radToIndex = SIN_COUNT / radFull; degToIndex = SIN_COUNT / degFull; - + sin = new double[SIN_COUNT]; cos = new double[SIN_COUNT]; - + for(int i = 0; i < SIN_COUNT; i++) { sin[i] = Math.sin((i + 0.5f) / SIN_COUNT * radFull); cos[i] = Math.cos((i + 0.5f) / SIN_COUNT * radFull); } - + // Four cardinal directions (credits: Nate) for(int i = 0; i < 360; i += 90) { sin[(int) (i * degToIndex) & SIN_MASK] = Math.sin(i * Math.PI / 180.0); cos[(int) (i * degToIndex) & SIN_MASK] = Math.cos(i * Math.PI / 180.0); } } - + public static double sin(double rad) { return sin[(int) (rad * radToIndex) & SIN_MASK]; } - + public static double cos(double rad) { return cos[(int) (rad * radToIndex) & SIN_MASK]; } - + public static double tan(double rad) { - return sin(rad)/cos(rad); + return sin(rad) / cos(rad); } - + public static double invSqrt(double x) { double halfX = 0.5d * x; long i = Double.doubleToLongBits(x); // evil floating point bit level hacking @@ -66,10 +66,10 @@ public final class MathUtil { double y = Double.longBitsToDouble(i); y *= (1.5d - halfX * y * y); // 1st newtonian iteration // y *= (1.5d - halfX * y * y); // 2nd newtonian iteration, this can be removed - + return y; } - + /** * Gets the standard deviation of an array of doubles. * @@ -80,20 +80,20 @@ public final class MathUtil { public static double standardDeviation(List numArray) { double sum = 0.0, standardDeviation = 0.0; int length = numArray.size(); - + for(Number num : numArray) { sum += num.doubleValue(); } - + double mean = sum / length; - + for(Number num : numArray) { standardDeviation += Math.pow(num.doubleValue() - mean, 2); } - + return Math.sqrt(standardDeviation / length); } - + public static long hashToLong(String s) { if(s == null) { return 0; @@ -104,7 +104,7 @@ public final class MathUtil { } return hash; } - + /** * Compare 2 floating-point values with epsilon to account for rounding errors * @@ -116,15 +116,15 @@ public final class MathUtil { public static boolean equals(double a, double b) { return a == b || Math.abs(a - b) < EPSILON; } - + public static int normalizeIndex(double val, int size) { return Math.max(Math.min((int) Math.floor(((val + 1D) / 2D) * size), size - 1), 0); } - + public static long squash(int first, int last) { return (((long) first) << 32) | (last & 0xffffffffL); } - + /** * Clamp value to range of [-1, 1] * @@ -135,11 +135,11 @@ public final class MathUtil { public static double clamp(double in) { return Math.min(Math.max(in, -1), 1); } - + public static int clamp(int min, int i, int max) { return Math.max(Math.min(i, max), min); } - + /** * Compute the value in a normally distributed data set that has probability p. * @@ -161,30 +161,30 @@ public final class MathUtil { if(sigma == 0) return mu; double q, r, val; - + q = p - 0.5; - + if(Math.abs(q) <= .425) { r = .180625 - q * q; val = - q * (((((((r * 2509.0809287301226727 + - 33430.575583588128105) * r + 67265.770927008700853) * r + - 45921.953931549871457) * r + 13731.693765509461125) * r + - 1971.5909503065514427) * r + 133.14166789178437745) * r + - 3.387132872796366608) - / (((((((r * 5226.495278852854561 + - 28729.085735721942674) * r + 39307.89580009271061) * r + - 21213.794301586595867) * r + 5394.1960214247511077) * r + - 687.1870074920579083) * r + 42.313330701600911252) * r + 1); + q * (((((((r * 2509.0809287301226727 + + 33430.575583588128105) * r + 67265.770927008700853) * r + + 45921.953931549871457) * r + 13731.693765509461125) * r + + 1971.5909503065514427) * r + 133.14166789178437745) * r + + 3.387132872796366608) + / (((((((r * 5226.495278852854561 + + 28729.085735721942674) * r + 39307.89580009271061) * r + + 21213.794301586595867) * r + 5394.1960214247511077) * r + + 687.1870074920579083) * r + 42.313330701600911252) * r + 1); } else { if(q > 0) { r = 1 - p; } else { r = p; } - + r = Math.sqrt(-Math.log(r)); - + if(r <= 5) { r -= 1.6; val = (((((((r * 7.7454501427834140764e-4 + @@ -214,15 +214,15 @@ public final class MathUtil { * r + .13692988092273580531) * r + .59983220655588793769) * r + 1); } - + if(q < 0.0) { val = -val; } } - + return mu + sigma * val; } - + /** * Murmur64 hashing function * @@ -238,7 +238,7 @@ public final class MathUtil { h ^= h >>> 33; return h; } - + /** * 1D Linear interpolation between 2 points 1 unit apart. * @@ -251,16 +251,16 @@ public final class MathUtil { public static double lerp(double t, double v0, double v1) { return v0 + t * (v1 - v0); } - + public static double cubicLerp(double a, double b, double c, double d, double t) { double p = (d - c) - (a - b); return t * t * t * p + t * t * ((a - b) - p) + t * (c - a) + b; } - + public static double interpHermite(double t) { return t * t * (3 - 2 * t); } - + public static double interpQuintic(double t) { return t * t * t * (t * (t * 6 - 15) + 10); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/PopulationUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/PopulationUtil.java index f16b45629..f3ea39f10 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/PopulationUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/PopulationUtil.java @@ -7,20 +7,20 @@ package com.dfsek.terra.api.util; -import com.dfsek.terra.api.world.chunk.Chunk; - import java.util.Random; +import com.dfsek.terra.api.world.chunk.Chunk; + public final class PopulationUtil { public static Random getRandom(Chunk c) { return getRandom(c, 0); } - + public static Random getRandom(Chunk c, long salt) { return new Random(getCarverChunkSeed(c.getX(), c.getZ(), c.getWorld().getSeed() + salt)); } - + /** * Gets the carver seed for a chunk. * diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/Range.java b/common/api/src/main/java/com/dfsek/terra/api/util/Range.java index 25f22aa79..f42bc174d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/Range.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/Range.java @@ -16,48 +16,48 @@ import java.util.function.Supplier; public interface Range extends Iterable { Range multiply(int mult); - + Range reflect(int pt); - + int get(Random r); - + Range intersects(Range other); - + Range add(int add); - + Range sub(int sub); - + @NotNull @Override Iterator iterator(); - + boolean isInRange(int test); - + int getMax(); - + Range setMax(int max); - + int getMin(); - + Range setMin(int min); - + int getRange(); - + default T ifInRange(int y, T inRange, T notInRange) { if(isInRange(y)) return inRange; return notInRange; } - + default T ifInRange(int y, Supplier inRange, Supplier notInRange) { if(isInRange(y)) return inRange.get(); return notInRange.get(); } - + default T ifInRange(int y, Supplier inRange, T notInRange) { if(isInRange(y)) return inRange.get(); return notInRange; } - + default T ifInRange(int y, T inRange, Supplier notInRange) { if(isInRange(y)) return inRange; return notInRange.get(); diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/Rotation.java b/common/api/src/main/java/com/dfsek/terra/api/util/Rotation.java index e12afaea7..6f0a17c71 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/Rotation.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/Rotation.java @@ -8,17 +8,17 @@ package com.dfsek.terra.api.util; public enum Rotation { - + CW_90(90), CW_180(180), CCW_90(270), NONE(0); private final int degrees; - + Rotation(int degrees) { this.degrees = degrees; } - + public static Rotation fromDegrees(int deg) { return switch(Math.floorMod(deg, 360)) { case 0 -> Rotation.NONE; @@ -28,7 +28,7 @@ public enum Rotation { default -> throw new IllegalArgumentException(); }; } - + public Rotation inverse() { return switch(this) { case NONE -> NONE; @@ -37,15 +37,15 @@ public enum Rotation { case CW_180 -> CW_180; }; } - + public Rotation rotate(Rotation rotation) { return fromDegrees(this.getDegrees() + rotation.getDegrees()); } - + public int getDegrees() { return degrees; } - + public enum Axis { X, Y, diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/RotationUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/RotationUtil.java index 4f951d0e0..96c968650 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/RotationUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/RotationUtil.java @@ -29,6 +29,6 @@ public final class RotationUtil { } return copy.immutable(); } - - + + } diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/collection/MaterialSet.java b/common/api/src/main/java/com/dfsek/terra/api/util/collection/MaterialSet.java index 1a13e836c..a0c28b1e1 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/collection/MaterialSet.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/collection/MaterialSet.java @@ -24,46 +24,46 @@ import com.dfsek.terra.api.block.state.BlockState; public class MaterialSet extends HashSet { @Serial private static final long serialVersionUID = 3056512763631017301L; - + public static MaterialSet singleton(BlockType material) { return new Singleton(material); } - + public static MaterialSet get(BlockType... materials) { MaterialSet set = new MaterialSet(); set.addAll(Arrays.asList(materials)); return set; } - + public static MaterialSet get(BlockState... materials) { MaterialSet set = new MaterialSet(); Arrays.stream(materials).forEach(set::add); return set; } - + public static MaterialSet empty() { return new MaterialSet(); } - + private void add(BlockState data) { add(data.getBlockType()); } - + private static final class Singleton extends MaterialSet { private final BlockType element; - + Singleton(BlockType e) { element = e; } - + public Iterator iterator() { return new Iterator<>() { private boolean hasNext = true; - + public boolean hasNext() { return hasNext; } - + public BlockType next() { if(hasNext) { hasNext = false; @@ -71,11 +71,11 @@ public class MaterialSet extends HashSet { } throw new NoSuchElementException(); } - + public void remove() { throw new UnsupportedOperationException(); } - + @Override public void forEachRemaining(Consumer action) { Objects.requireNonNull(action); @@ -86,31 +86,31 @@ public class MaterialSet extends HashSet { } }; } - + public int size() { return 1; } - + public boolean contains(Object o) { return Objects.equals(o, element); } - + // Override default methods for Collection @Override public void forEach(Consumer action) { action.accept(element); } - + @Override public Spliterator spliterator() { return new Spliterator<>() { long est = 1; - + @Override public Spliterator trySplit() { return null; } - + @Override public boolean tryAdvance(Consumer consumer) { Objects.requireNonNull(consumer); @@ -121,32 +121,32 @@ public class MaterialSet extends HashSet { } return false; } - + @Override public void forEachRemaining(Consumer consumer) { tryAdvance(consumer); } - + @Override public long estimateSize() { return est; } - + @Override public int characteristics() { int value = (element != null) ? Spliterator.NONNULL : 0; - + return value | Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.IMMUTABLE | Spliterator.DISTINCT | Spliterator.ORDERED; } }; } - + @Override public boolean removeIf(Predicate filter) { throw new UnsupportedOperationException(); } - + @Override public int hashCode() { return Objects.hashCode(element); diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java b/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java index 84c9041e5..4aad8b7e1 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/collection/ProbabilityCollection.java @@ -30,7 +30,7 @@ public class ProbabilityCollection implements Collection { protected final Map cont = new HashMap<>(); private Object[] array = new Object[0]; private int size; - + public ProbabilityCollection add(E item, int probability) { if(!cont.containsKey(item)) size++; cont.computeIfAbsent(item, i -> new MutableInteger(0)).increment(); @@ -41,94 +41,94 @@ public class ProbabilityCollection implements Collection { for(int i = oldLength; i < array.length; i++) array[i] = item; return this; } - + @SuppressWarnings("unchecked") public E get(Random r) { if(array.length == 0) return null; return (E) array[r.nextInt(array.length)]; } - + @SuppressWarnings("unchecked") public E get(NoiseSampler n, double x, double y, double z, long seed) { if(array.length == 0) return null; return (E) array[(int) MathUtil.normalizeIndex(n.noise(seed, x, y, z), array.length)]; } - + @SuppressWarnings("unchecked") public E get(NoiseSampler n, Vector3Int vector3Int, long seed) { if(array.length == 0) return null; return (E) array[(int) MathUtil.normalizeIndex(n.noise(seed, vector3Int.getX(), vector3Int.getY(), vector3Int.getZ()), - array.length)]; + array.length)]; } - + @SuppressWarnings("unchecked") public E get(NoiseSampler n, Vector3 vector3Int, long seed) { if(array.length == 0) return null; return (E) array[(int) MathUtil.normalizeIndex(n.noise(seed, vector3Int.getX(), vector3Int.getY(), vector3Int.getZ()), - array.length)]; + array.length)]; } - + @SuppressWarnings("unchecked") public E get(NoiseSampler n, double x, double z, long seed) { if(array.length == 0) return null; return (E) array[(int) MathUtil.normalizeIndex(n.noise(seed, x, z), array.length)]; } - + @SuppressWarnings("unchecked") public ProbabilityCollection map(Function mapper, boolean carryNull) { ProbabilityCollection newCollection = new ProbabilityCollection<>(); newCollection.array = new Object[array.length]; - + for(int i = 0; i < array.length; i++) { if(carryNull && array[i] == null) continue; newCollection.array[i] = mapper.apply((E) array[i]); } return newCollection; } - + @Override public String toString() { StringBuilder builder = new StringBuilder("["); - + cont.forEach((item, prob) -> builder.append(item).append(": ").append(prob).append(", ")); - + return builder.append("]").toString(); } - + @Override public int size() { return size; } - + @Override public boolean isEmpty() { return array.length == 0; } - + @Override public boolean contains(Object o) { return cont.containsKey(o); } - + @NotNull @Override public Iterator iterator() { return cont.keySet().iterator(); } - + @NotNull @Override public Object @NotNull [] toArray() { return cont.keySet().toArray(); } - + @SuppressWarnings("SuspiciousToArrayCall") @NotNull @Override public T @NotNull [] toArray(@NotNull T @NotNull [] a) { return cont.keySet().toArray(a); } - + /** * Adds an item with probability of 1. */ @@ -137,96 +137,96 @@ public class ProbabilityCollection implements Collection { add(e, 1); return true; // Since this adds the item with a probability, the collection will always have changed. } - + @Override public boolean remove(Object o) { throw new UnsupportedOperationException("Cannot remove item from ProbabilityCollection!"); } - + @Override public boolean containsAll(@NotNull Collection c) { return cont.keySet().containsAll(c); } - + @Override public boolean addAll(@NotNull Collection c) { c.forEach(this::add); return true; } - + @Override public boolean removeAll(@NotNull Collection c) { throw new UnsupportedOperationException("Cannot remove item from ProbabilityCollection!"); } - + @Override public boolean retainAll(@NotNull Collection c) { throw new UnsupportedOperationException("Cannot remove item from ProbabilityCollection!"); } - + @Override public void clear() { cont.clear(); array = new Object[0]; } - + public int getTotalProbability() { return array.length; } - + public int getProbability(E item) { MutableInteger integer = cont.get(item); return integer == null ? 0 : integer.get(); } - + public Set getContents() { return new HashSet<>(cont.keySet()); } - + public static final class Singleton extends ProbabilityCollection { private final T single; - + public Singleton(T single) { this.single = single; cont.put(single, new MutableInteger(1)); } - + @Override public ProbabilityCollection add(T item, int probability) { throw new UnsupportedOperationException(); } - + @Override public T get(Random r) { return single; } - + @Override public T get(NoiseSampler n, double x, double y, double z, long seed) { return single; } - + @Override public T get(NoiseSampler n, double x, double z, long seed) { return single; } - + @Override public ProbabilityCollection map(Function mapper, boolean carryNull) { if(carryNull && single == null) return new Singleton<>(null); return new Singleton<>(mapper.apply(single)); } - + @Override public int size() { return 1; } - + @Override public int getTotalProbability() { return 1; } - + @Override public Set getContents() { return Collections.singleton(single); diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/generic/Lazy.java b/common/api/src/main/java/com/dfsek/terra/api/util/generic/Lazy.java index ff45bfaa8..7a1a11831 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/generic/Lazy.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/generic/Lazy.java @@ -14,15 +14,15 @@ public final class Lazy { private final Supplier valueSupplier; private T value; private boolean got = false; - + private Lazy(Supplier valueSupplier) { this.valueSupplier = valueSupplier; } - + public static Lazy lazy(Supplier valueSupplier) { return new Lazy<>(valueSupplier); } - + public T value() { if(!got && value == null) { got = true; diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/generic/either/Either.java b/common/api/src/main/java/com/dfsek/terra/api/util/generic/either/Either.java index 56fdec9d7..b60a09ef4 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/generic/either/Either.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/generic/either/Either.java @@ -19,68 +19,68 @@ public final class Either { private final L left; private final R right; private final boolean leftPresent; - + private Either(L left, R right, boolean leftPresent) { this.left = left; this.right = right; this.leftPresent = leftPresent; } - + @NotNull @Contract("_ -> new") public static Either left(L1 left) { return new Either<>(Objects.requireNonNull(left), null, true); } - + @NotNull @Contract("_ -> new") public static Either right(R1 right) { return new Either<>(null, Objects.requireNonNull(right), false); } - + @NotNull @Contract("_ -> this") public Either ifLeft(Consumer action) { if(leftPresent) action.accept(left); return this; } - + @NotNull @Contract("_ -> this") public Either ifRight(Consumer action) { if(!leftPresent) action.accept(right); return this; } - + @NotNull public Optional getLeft() { if(leftPresent) return Optional.of(left); return Optional.empty(); } - + @NotNull public Optional getRight() { if(!leftPresent) return Optional.of(right); return Optional.empty(); } - + public boolean hasLeft() { return leftPresent; } - + public boolean hasRight() { return !leftPresent; } - + @Override public int hashCode() { return Objects.hash(left, right); } - + @Override public boolean equals(Object obj) { if(!(obj instanceof Either that)) return false; - + return (this.leftPresent && that.leftPresent && Objects.equals(this.left, that.left)) || (!this.leftPresent && !that.leftPresent && Objects.equals(this.right, that.right)); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/generic/pair/Pair.java b/common/api/src/main/java/com/dfsek/terra/api/util/generic/pair/Pair.java index 1eef92360..424d8bea0 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/generic/pair/Pair.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/generic/pair/Pair.java @@ -21,137 +21,137 @@ public final class Pair { private static final Pair NULL = new Pair<>(null, null); private final L left; private final R right; - + private Pair(L left, R right) { this.left = left; this.right = right; } - + public static Function, Pair> mapLeft(Function function) { return pair -> of(function.apply(pair.left), pair.right); } - + public static Function, Pair> mapRight(Function function) { return pair -> of(pair.left, function.apply(pair.right)); } - + public static Predicate> testLeft(Predicate predicate) { return pair -> predicate.test(pair.left); } - + public static Predicate> testRight(Predicate predicate) { return pair -> predicate.test(pair.right); } - + public static Consumer> consumeLeft(Consumer consumer) { return pair -> consumer.accept(pair.left); } - + public static Consumer> consumeRight(Consumer consumer) { return pair -> consumer.accept(pair.right); } - + public static Function, R> unwrapRight() { return pair -> pair.right; } - + public static Function, L> unwrapLeft() { return pair -> pair.left; } - + @Contract("_, _ -> new") public static Pair of(L1 left, R1 right) { return new Pair<>(left, right); } - + @Contract("-> new") @SuppressWarnings("unchecked") public static Pair ofNull() { return (Pair) NULL; } - + @NotNull @Contract("-> new") public Pair.Mutable mutable() { return Mutable.of(left, right); } - + public R getRight() { return right; } - + public L getLeft() { return left; } - + @Override public int hashCode() { return Objects.hash(left, right); } - + @Override public boolean equals(Object obj) { if(!(obj instanceof Pair that)) return false; - + return Objects.equals(this.left, that.left) && Objects.equals(this.right, that.right); } - + public Pair apply(BiConsumer consumer) { consumer.accept(this.left, this.right); return this; } - + @Override public String toString() { return String.format("{%s,%s}", left, right); } - - + + public static class Mutable { private L left; private R right; - + private Mutable(L left, R right) { this.left = left; this.right = right; } - + @NotNull @Contract("_, _ -> new") public static Pair.Mutable of(L1 left, R1 right) { return new Mutable<>(left, right); } - + @Contract("-> new") public Pair immutable() { return Pair.of(left, right); } - + public L getLeft() { return left; } - + public void setLeft(L left) { this.left = left; } - + public R getRight() { return right; } - + public void setRight(R right) { this.right = right; } - + @Override public int hashCode() { return Objects.hash(left, right); } - + @Override public boolean equals(Object obj) { if(!(obj instanceof Mutable that)) return false; - + return Objects.equals(this.left, that.left) && Objects.equals(this.right, that.right); } } diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableBoolean.java b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableBoolean.java index 0d666d110..6dfef1ca5 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableBoolean.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableBoolean.java @@ -12,30 +12,30 @@ import org.jetbrains.annotations.NotNull; public class MutableBoolean implements MutablePrimitive { private boolean value; - + public MutableBoolean() { this.value = false; } - + public MutableBoolean(boolean value) { this.value = value; } - + @Override public Boolean get() { return value; } - + @Override public void set(Boolean value) { this.value = value; } - + public boolean invert() { value = !value; return value; } - + @Override public int compareTo(@NotNull Boolean o) { return Boolean.compare(value, o); diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableDouble.java b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableDouble.java index f6cd874bb..91c21a9af 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableDouble.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableDouble.java @@ -15,41 +15,41 @@ import java.io.Serial; public class MutableDouble extends MutableNumber { @Serial private static final long serialVersionUID = -2218110876763640053L; - + public MutableDouble(Double value) { super(value); } - + @Override public void increment() { add(1d); } - + @Override public void decrement() { subtract(1d); } - + @Override public void add(Double add) { value += add; } - + @Override public void multiply(Double mul) { value *= mul; } - + @Override public void subtract(Double sub) { value -= sub; } - + @Override public void divide(Double divide) { value /= divide; } - + @Override public int compareTo(@NotNull Double o) { return Double.compare(value, o); diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableInteger.java b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableInteger.java index 437e399c7..e66bcff43 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableInteger.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableInteger.java @@ -15,43 +15,43 @@ import java.io.Serial; public class MutableInteger extends MutableNumber { @Serial private static final long serialVersionUID = -4427935901819632745L; - + public MutableInteger(Integer value) { super(value); } - + public void increment() { add(1); } - + public void decrement() { subtract(1); } - + @Override public void add(Integer add) { value += add; } - + @Override public void multiply(Integer mul) { value *= mul; } - + @Override public void subtract(Integer sub) { value -= sub; } - + @Override public void divide(Integer divide) { value /= divide; } - + public void add(int add) { value += add; } - + @Override public int compareTo(@NotNull Integer o) { return Integer.compare(value, o); diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableNumber.java b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableNumber.java index f2e739a9f..8ba43fac8 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableNumber.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutableNumber.java @@ -11,52 +11,52 @@ import java.io.Serial; public abstract class MutableNumber extends Number implements MutablePrimitive { - + @Serial private static final long serialVersionUID = 8619508342781664393L; protected T value; - + public MutableNumber(T value) { this.value = value; } - + public abstract void increment(); - + public abstract void decrement(); - + public abstract void add(T add); - + public abstract void multiply(T mul); - + public abstract void subtract(T sub); - + public abstract void divide(T divide); - + @Override public T get() { return value; } - + @Override public void set(T value) { this.value = value; } - + @Override public int intValue() { return value.intValue(); } - + @Override public long longValue() { return value.longValue(); } - + @Override public float floatValue() { return value.floatValue(); } - + @Override public double doubleValue() { return value.doubleValue(); diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutablePrimitive.java b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutablePrimitive.java index 5ed6cb095..f4c9fd65f 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutablePrimitive.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/mutable/MutablePrimitive.java @@ -9,6 +9,6 @@ package com.dfsek.terra.api.util.mutable; public interface MutablePrimitive extends Comparable { T get(); - + void set(T value); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/reflection/ReflectionUtil.java b/common/api/src/main/java/com/dfsek/terra/api/util/reflection/ReflectionUtil.java index 795ba8936..8e35c3f9f 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/reflection/ReflectionUtil.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/reflection/ReflectionUtil.java @@ -34,7 +34,7 @@ public final class ReflectionUtil { } return result; } - + public static Method[] getMethods(@NotNull Class type) { Method[] result = type.getDeclaredMethods(); Class parentClass = type.getSuperclass(); @@ -43,13 +43,13 @@ public final class ReflectionUtil { } return result; } - + public static void ifAnnotationPresent(AnnotatedElement element, Class annotation, Consumer operation) { T a = element.getAnnotation(annotation); if(a != null) operation.accept(a); } - + public static Class getRawType(Type type) { if(type instanceof Class) { return (Class) type; @@ -69,11 +69,11 @@ public final class ReflectionUtil { + "GenericArrayType, but <" + type + "> is of type " + className); } } - + public static String typeToString(Type type) { return type instanceof Class ? ((Class) type).getName() : type.toString(); } - + public static boolean equals(Type a, Type b) { if(a == b) { return true; @@ -83,7 +83,7 @@ public final class ReflectionUtil { if(!(b instanceof ParameterizedType pb)) { return false; } - + return Objects.equals(pa.getOwnerType(), pb.getOwnerType()) && pa.getRawType().equals(pb.getRawType()) && Arrays.equals(pa.getActualTypeArguments(), pb.getActualTypeArguments()); @@ -91,13 +91,13 @@ public final class ReflectionUtil { if(!(b instanceof GenericArrayType gb)) { return false; } - + return equals(ga.getGenericComponentType(), gb.getGenericComponentType()); } else if(a instanceof WildcardType wa) { if(!(b instanceof WildcardType wb)) { return false; } - + return Arrays.equals(wa.getUpperBounds(), wb.getUpperBounds()) && Arrays.equals(wa.getLowerBounds(), wb.getLowerBounds()); } else if(a instanceof TypeVariable va) { diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/reflection/TypeKey.java b/common/api/src/main/java/com/dfsek/terra/api/util/reflection/TypeKey.java index 19ff4259c..b5ae20265 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/reflection/TypeKey.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/reflection/TypeKey.java @@ -18,10 +18,10 @@ import java.lang.reflect.Type; public class TypeKey { final Class rawType; final Type type; - + final AnnotatedType annotatedType; final int hashCode; - + @SuppressWarnings("unchecked") protected TypeKey() { this.type = getSuperclassTypeParameter(getClass()); @@ -29,18 +29,18 @@ public class TypeKey { this.rawType = (Class) ReflectionUtil.getRawType(type); this.hashCode = type.hashCode(); } - + protected TypeKey(Class clazz) { this.type = clazz; this.rawType = clazz; this.annotatedType = new ClassAnnotatedTypeImpl(clazz); this.hashCode = type.hashCode(); } - + public static TypeKey of(Class clazz) { return new TypeKey<>(clazz); } - + private static Type getSuperclassTypeParameter(Class subclass) { Type superclass = subclass.getGenericSuperclass(); if(superclass instanceof Class) { @@ -49,7 +49,7 @@ public class TypeKey { ParameterizedType parameterized = (ParameterizedType) superclass; return parameterized.getActualTypeArguments()[0]; } - + private static AnnotatedType getAnnotatedSuperclassTypeParameter(Class subclass) { AnnotatedType superclass = subclass.getAnnotatedSuperclass(); if(superclass.getType() instanceof Class) { @@ -58,36 +58,36 @@ public class TypeKey { AnnotatedParameterizedType parameterized = (AnnotatedParameterizedType) superclass; return parameterized.getAnnotatedActualTypeArguments()[0]; } - + /** * Returns the raw (non-generic) type for this type. */ public final Class getRawType() { return rawType; } - + /** * Gets underlying {@code Type} instance. */ public final Type getType() { return type; } - + public final AnnotatedType getAnnotatedType() { return annotatedType; } - + @Override public final int hashCode() { return this.hashCode; } - + @Override public final boolean equals(Object o) { return o instanceof TypeKey && ReflectionUtil.equals(type, ((TypeKey) o).type); } - + @Override public final String toString() { return ReflectionUtil.typeToString(type); diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java index 7d8e45665..021e98122 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2.java @@ -17,7 +17,7 @@ public class Vector2 { private static final Vector2 ZERO = new Vector2(0, 0); private static final Vector2 UNIT = new Vector2(0, 1); protected double x, z; - + /** * Create a vector with a given X and Z component * @@ -28,20 +28,20 @@ public class Vector2 { this.x = x; this.z = z; } - + public static Vector2 zero() { return ZERO; } - + public static Vector2 unit() { return UNIT; } - + public static Vector2 of(double x, double z) { return new Vector2(x, z); } - - + + /** * Get the length of this Vector * @@ -50,7 +50,7 @@ public class Vector2 { public double length() { return Math.sqrt(lengthSquared()); } - + /** * Get the squared length of this Vector * @@ -59,7 +59,7 @@ public class Vector2 { public double lengthSquared() { return x * x + z * z; } - + /** * Get the distance from this vector to another. * @@ -70,7 +70,7 @@ public class Vector2 { public double distance(Vector2 other) { return Math.sqrt(distanceSquared(other)); } - + /** * Get the squared distance between 2 vectors. * @@ -83,11 +83,11 @@ public class Vector2 { double dz = other.getZ() - z; return dx * dx + dz * dz; } - + public Vector3 extrude(double y) { return Vector3.of(this.x, y, this.z); } - + /** * Get X component * @@ -96,8 +96,8 @@ public class Vector2 { public double getX() { return x; } - - + + /** * Get Z component * @@ -106,16 +106,16 @@ public class Vector2 { public double getZ() { return z; } - - + + public int getBlockX() { return (int) Math.floor(x); } - + public int getBlockZ() { return (int) Math.floor(z); } - + @Override public int hashCode() { int hash = 17; @@ -123,50 +123,50 @@ public class Vector2 { hash = 31 * hash + Double.hashCode(z); return hash; } - + public boolean equals(Object obj) { if(!(obj instanceof Vector2 other)) return false; return MathUtil.equals(this.x, other.x) && MathUtil.equals(this.z, other.z); } - + public Mutable mutable() { return new Mutable(x, z); } - + @Override public String toString() { return "(" + x + ", " + z + ")"; } - - + + public static class Mutable extends Vector2 { - + private Mutable(double x, double z) { super(x, z); } - + public double getX() { return x; } - + public Mutable setX(double x) { this.x = x; return this; } - + public double getZ() { return z; } - + public Mutable setZ(double z) { this.z = z; return this; } - + public Vector2 immutable() { return Vector2.of(x, z); } - + /** * Get the length of this Vector * @@ -175,7 +175,7 @@ public class Vector2 { public double length() { return Math.sqrt(lengthSquared()); } - + /** * Get the squared length of this Vector * @@ -184,13 +184,13 @@ public class Vector2 { public double lengthSquared() { return x * x + z * z; } - + public Mutable add(double x, double z) { this.x += x; this.z += z; return this; } - + /** * Multiply X and Z components by a value. * @@ -203,7 +203,7 @@ public class Vector2 { z *= m; return this; } - + /** * Add this vector to another. * @@ -216,7 +216,7 @@ public class Vector2 { z += other.getZ(); return this; } - + /** * Subtract a vector from this vector, * @@ -229,7 +229,7 @@ public class Vector2 { z -= other.getZ(); return this; } - + /** * Normalize this vector to length 1 * @@ -239,7 +239,7 @@ public class Vector2 { divide(length()); return this; } - + /** * Divide X and Z components by a value. * diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2Int.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2Int.java index 48e71562b..8f904dfcb 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2Int.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector2Int.java @@ -10,40 +10,40 @@ public class Vector2Int { private static final Vector2Int ZERO = new Vector2Int(0, 0); private static final Vector2Int UNIT = new Vector2Int(0, 1); protected int x, z; - + protected Vector2Int(int x, int z) { this.x = x; this.z = z; } - + public static Vector2Int zero() { return ZERO; } - + public static Vector2Int unit() { return UNIT; } - + public static Vector2Int of(int x, int z) { return new Vector2Int(x, z); } - + public int getX() { return x; } - + public int getZ() { return z; } - + public Vector3Int toVector3(int y) { return new Vector3Int(x, y, z); } - + public Mutable mutable() { return new Mutable(x, z); } - + public Vector2Int rotate(Rotation rotation) { return switch(rotation) { case CW_90 -> of(z, -x); @@ -52,12 +52,12 @@ public class Vector2Int { default -> this; }; } - + @Override public int hashCode() { return (31 * x) + z; } - + @Override public boolean equals(Object obj) { if(obj instanceof Vector2Int that) { @@ -65,30 +65,30 @@ public class Vector2Int { } return false; } - - + + public static class Mutable extends Vector2Int { - + protected Mutable(int x, int z) { super(x, z); } - + public int getZ() { return z; } - + public void setZ(int z) { this.z = z; } - + public int getX() { return x; } - + public void setX(int x) { this.x = x; } - + public Vector2Int immutable() { return new Vector2Int(x, z); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java index 2f649b3d6..d6d74c68a 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3.java @@ -16,37 +16,37 @@ public class Vector3 { private static final Vector3 ZERO = new Vector3(0, 0, 0); private static final Vector3 UNIT = new Vector3(0, 1, 0); protected double x, y, z; - + private Vector3(double x, double y, double z) { this.x = x; this.y = y; this.z = z; } - + public static Vector3 zero() { return ZERO; } - + public static Vector3 unit() { return UNIT; } - + public static Vector3 of(double x, double y, double z) { return new Vector3(x, y, z); } - + public double lengthSquared() { return x * x + y * y + z * z; } - + public double length() { return Math.sqrt(lengthSquared()); } - + public double inverseLength() { return MathUtil.invSqrt(lengthSquared()); } - + /** * Get the distance between this vector and another. The value of this * method is not cached and uses a costly square-root function, so do not @@ -61,7 +61,7 @@ public class Vector3 { public double distance(@NotNull Vector3 o) { return Math.sqrt(Math.pow(x - o.getX(), 2) + Math.pow(y - o.getY(), 2) + Math.pow(z - o.getZ(), 2)); } - + /** * Get the squared distance between this vector and another. * @@ -72,7 +72,7 @@ public class Vector3 { public double distanceSquared(@NotNull Vector3 o) { return Math.pow(x - o.getX(), 2) + Math.pow(y - o.getY(), 2) + Math.pow(z - o.getZ(), 2); } - + /** * Calculates the dot product of this vector with another. The dot product * is defined as x1*x2+y1*y2+z1*z2. The returned value is a scalar. @@ -84,34 +84,34 @@ public class Vector3 { public double dot(@NotNull Vector3 other) { return x * other.getX() + y * other.getY() + z * other.getZ(); } - + public double getZ() { return z; } - - + + public double getX() { return x; } - - + + public double getY() { return y; } - - + + public int getBlockX() { return (int) Math.floor(x); } - + public int getBlockY() { return (int) Math.floor(y); } - + public int getBlockZ() { return (int) Math.floor(z); } - + /** * Returns if a vector is normalized * @@ -120,7 +120,7 @@ public class Vector3 { public boolean isNormalized() { return MathUtil.equals(this.lengthSquared(), 1); } - + /** * Returns a hash code for this vector * @@ -129,13 +129,13 @@ public class Vector3 { @Override public int hashCode() { int hash = 7; - + hash = 79 * hash + (int) (Double.doubleToLongBits(this.x) ^ (Double.doubleToLongBits(this.x) >>> 32)); hash = 79 * hash + (int) (Double.doubleToLongBits(this.y) ^ (Double.doubleToLongBits(this.y) >>> 32)); hash = 79 * hash + (int) (Double.doubleToLongBits(this.z) ^ (Double.doubleToLongBits(this.z) >>> 32)); return hash; } - + /** * Checks to see if two objects are equal. *

@@ -148,84 +148,84 @@ public class Vector3 { if(!(obj instanceof Vector3 other)) return false; return MathUtil.equals(x, other.getX()) && MathUtil.equals(y, other.getY()) && MathUtil.equals(z, other.getZ()); } - + public Vector3Int toInt() { return Vector3Int.of(getBlockX(), getBlockY(), getBlockZ()); } - + public Mutable mutable() { return new Mutable(x, y, z); } - + @Override public String toString() { return "(" + getX() + ", " + getY() + ", " + getZ() + ")"; } - - + + public static class Mutable extends Vector3 { private Mutable(double x, double y, double z) { super(x, y, z); } - + public static Mutable of(double x, double y, double z) { return new Mutable(x, y, z); } - + public Vector3 immutable() { return Vector3.of(x, y, z); } - + public double getZ() { return z; } - + public Mutable setZ(double z) { this.z = z; return this; } - + public double getX() { return x; } - + public Mutable setX(double x) { this.x = x; return this; } - + public double getY() { return y; } - + public Mutable setY(double y) { this.y = y; return this; } - + public double lengthSquared() { return x * x + y * y + z * z; } - + public double length() { return Math.sqrt(lengthSquared()); } - + public double inverseLength() { return MathUtil.invSqrt(lengthSquared()); } - + public Mutable normalize() { return this.multiply(this.inverseLength()); } - + public Mutable subtract(int x, int y, int z) { this.x -= x; this.y -= y; this.z -= z; return this; } - + /** * Calculates the dot product of this vector with another. The dot product * is defined as x1*x2+y1*y2+z1*z2. The returned value is a scalar. @@ -237,48 +237,48 @@ public class Vector3 { public double dot(@NotNull Vector3 other) { return x * other.getX() + y * other.getY() + z * other.getZ(); } - + public Mutable subtract(Vector3 end) { x -= end.getX(); y -= end.getY(); z -= end.getZ(); return this; } - + public Mutable multiply(double m) { x *= m; y *= m; z *= m; return this; } - + public Mutable add(double x, double y, double z) { this.x += x; this.y += y; this.z += z; return this; } - + public Mutable add(Vector3 other) { this.x += other.getX(); this.y += other.getY(); this.z += other.getZ(); return this; } - + public Mutable add(Vector3Int other) { this.x += other.getX(); this.y += other.getY(); this.z += other.getZ(); return this; } - + public Mutable add(Vector2 other) { this.x += other.getX(); this.z += other.getZ(); return this; } - + /** * Rotates the vector around a given arbitrary axis in 3 dimensional space. * @@ -304,7 +304,7 @@ public class Vector3 { public Mutable rotateAroundAxis(@NotNull Vector3 axis, double angle) throws IllegalArgumentException { return rotateAroundNonUnitAxis(axis.isNormalized() ? axis : axis.mutable().normalize().immutable(), angle); } - + /** * Rotates the vector around a given arbitrary axis in 3 dimensional space. * @@ -329,11 +329,11 @@ public class Vector3 { public Mutable rotateAroundNonUnitAxis(@NotNull Vector3 axis, double angle) throws IllegalArgumentException { double x = getX(), y = getY(), z = getZ(); double x2 = axis.getX(), y2 = axis.getY(), z2 = axis.getZ(); - + double cosTheta = MathUtil.cos(angle); double sinTheta = MathUtil.sin(angle); double dotProduct = this.dot(axis); - + double xPrime = x2 * dotProduct * (1d - cosTheta) + x * cosTheta + (-z2 * y + y2 * z) * sinTheta; @@ -343,10 +343,10 @@ public class Vector3 { double zPrime = z2 * dotProduct * (1d - cosTheta) + z * cosTheta + (-y2 * x + x2 * y) * sinTheta; - + return setX(xPrime).setY(yPrime).setZ(zPrime); } - + /** * Rotates the vector around the x axis. *

@@ -364,12 +364,12 @@ public class Vector3 { public Mutable rotateAroundX(double angle) { double angleCos = MathUtil.cos(angle); double angleSin = MathUtil.sin(angle); - + double y = angleCos * getY() - angleSin * getZ(); double z = angleSin * getY() + angleCos * getZ(); return setY(y).setZ(z); } - + /** * Rotates the vector around the y axis. *

@@ -387,12 +387,12 @@ public class Vector3 { public Mutable rotateAroundY(double angle) { double angleCos = MathUtil.cos(angle); double angleSin = MathUtil.sin(angle); - + double x = angleCos * getX() + angleSin * getZ(); double z = -angleSin * getX() + angleCos * getZ(); return setX(x).setZ(z); } - + /** * Rotates the vector around the z axis *

@@ -410,30 +410,30 @@ public class Vector3 { public Mutable rotateAroundZ(double angle) { double angleCos = MathUtil.cos(angle); double angleSin = MathUtil.sin(angle); - + double x = angleCos * getX() - angleSin * getY(); double y = angleSin * getX() + angleCos * getY(); return setX(x).setY(y); } - + @Override public int hashCode() { int hash = 13; - + hash = 79 * hash + (int) (Double.doubleToLongBits(this.x) ^ (Double.doubleToLongBits(this.x) >>> 32)); hash = 79 * hash + (int) (Double.doubleToLongBits(this.y) ^ (Double.doubleToLongBits(this.y) >>> 32)); hash = 79 * hash + (int) (Double.doubleToLongBits(this.z) ^ (Double.doubleToLongBits(this.z) >>> 32)); return hash; } - + public int getBlockX() { return (int) Math.floor(x); } - + public int getBlockY() { return (int) Math.floor(y); } - + public int getBlockZ() { return (int) Math.floor(z); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3Int.java b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3Int.java index ad79cec14..ff9e3fc0f 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3Int.java +++ b/common/api/src/main/java/com/dfsek/terra/api/util/vector/Vector3Int.java @@ -5,93 +5,93 @@ public class Vector3Int { private static final Vector3Int ZERO = new Vector3Int(0, 0, 0); private static final Vector3Int UNIT = new Vector3Int(0, 1, 0); protected int x, y, z; - + protected Vector3Int(int x, int y, int z) { this.x = x; this.y = y; this.z = z; } - + public static Vector3Int unit() { return UNIT; } - + public static Vector3Int zero() { return ZERO; } - + public static Vector3Int of(int x, int y, int z) { return new Vector3Int(x, y, z); } - + public static Vector3Int of(Vector3Int origin, int x, int y, int z) { return new Vector3Int(origin.x + x, origin.y + y, origin.z + z); } - + public int getX() { return x; } - + public int getY() { return y; } - + public int getZ() { return z; } - + public Mutable mutable() { return new Mutable(x, y, z); } - + public Vector3 toVector3() { return Vector3.of(x, y, z); } - + public Vector3.Mutable toVector3Mutable() { return Vector3.Mutable.of(x, y, z); } - + public static class Mutable extends Vector3Int { protected Mutable(int x, int y, int z) { super(x, y, z); } - + public int getX() { return x; } - + public void setX(int x) { this.x = x; } - + public int getY() { return y; } - + public void setY(int y) { this.y = y; } - + public int getZ() { return z; } - + public void setZ(int z) { this.z = z; } - + public Vector3Int immutable() { return Vector3Int.of(x, y, z); } - + public Mutable add(int x, int y, int z) { this.x += x; this.y += y; this.z += z; return this; } - + public Vector3 toVector3() { return Vector3.of(x, y, z); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/BufferedWorld.java b/common/api/src/main/java/com/dfsek/terra/api/world/BufferedWorld.java index aba5d9cfa..086feed7a 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/BufferedWorld.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/BufferedWorld.java @@ -22,80 +22,80 @@ import com.dfsek.terra.api.world.util.WriteInterceptor; public class BufferedWorld implements WritableWorld { private final WritableWorld delegate; private final int offsetX, offsetY, offsetZ; - + private final ReadInterceptor readInterceptor; private final WriteInterceptor writeInterceptor; - + protected BufferedWorld(WritableWorld delegate, int offsetX, int offsetY, int offsetZ, ReadInterceptor readInterceptor, WriteInterceptor writeInterceptor) { this.delegate = delegate; this.offsetX = offsetX; - + this.offsetY = offsetY; this.offsetZ = offsetZ; this.readInterceptor = readInterceptor; this.writeInterceptor = writeInterceptor; } - + protected static Builder builder(WritableWorld world) { return new Builder(world); } - + @Override public Object getHandle() { return delegate.getHandle(); } - + @Override public BlockState getBlockState(int x, int y, int z) { return readInterceptor.read(x + offsetX, y + offsetY, z + offsetZ, delegate); } - + @Override public BlockEntity getBlockEntity(int x, int y, int z) { return delegate.getBlockEntity(x + offsetX, y + offsetY, z + offsetZ); } - + @Override public long getSeed() { return delegate.getSeed(); } - + @Override public int getMaxHeight() { return delegate.getMaxHeight(); } - + @Override public int getMinHeight() { return delegate.getMinHeight(); } - + @Override public ChunkGenerator getGenerator() { return delegate.getGenerator(); } - + @Override public BiomeProvider getBiomeProvider() { return delegate.getBiomeProvider(); } - + @Override public ConfigPack getPack() { return delegate.getPack(); } - + @Override public void setBlockState(int x, int y, int z, BlockState data, boolean physics) { writeInterceptor.write(x + offsetX, y + offsetY, z + offsetZ, data, delegate, physics); } - + @Override public Entity spawnEntity(double x, double y, double z, EntityType entityType) { return delegate.spawnEntity(x + offsetX, y + offsetY, z + offsetZ, entityType); } - + /** * Get the world this {@link BufferedWorld} delegates to. * @@ -104,60 +104,60 @@ public class BufferedWorld implements WritableWorld { public WritableWorld getDelegate() { return delegate; } - - + + public static final class Builder { private final WritableWorld delegate; private ReadInterceptor readInterceptor; private WriteInterceptor writeInterceptor; - + private int x = 0; private int y = 0; private int z = 0; - + private Builder(WritableWorld delegate) { this.delegate = delegate; } - + public Builder read(ReadInterceptor interceptor) { this.readInterceptor = interceptor; return this; } - + public Builder write(WriteInterceptor interceptor) { this.writeInterceptor = interceptor; return this; } - + public Builder offsetX(int x) { this.x = x; return this; } - + public Builder offsetY(int y) { this.y = y; return this; } - + public Builder offsetZ(int z) { this.z = z; return this; } - + public Builder offset(Vector3Int vector) { this.x = vector.getX(); this.y = vector.getY(); this.z = vector.getZ(); return this; } - + public BufferedWorld build() { return new BufferedWorld(delegate, - this.x, - this.y, - this.z, - Objects.requireNonNullElse(readInterceptor, Interceptors.readThrough()), - Objects.requireNonNullElse(writeInterceptor, Interceptors.writeThrough())); + this.x, + this.y, + this.z, + Objects.requireNonNullElse(readInterceptor, Interceptors.readThrough()), + Objects.requireNonNullElse(writeInterceptor, Interceptors.writeThrough())); } } } diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/ReadableWorld.java b/common/api/src/main/java/com/dfsek/terra/api/world/ReadableWorld.java index 931f599d2..4ea52661d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/ReadableWorld.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/ReadableWorld.java @@ -20,7 +20,7 @@ public interface ReadableWorld extends World { * @return {@link BlockState} at coordinates. */ BlockState getBlockState(int x, int y, int z); - + /** * Get the {@link BlockState} at a location. * @@ -31,7 +31,7 @@ public interface ReadableWorld extends World { default BlockState getBlockState(Vector3 position) { return getBlockState(position.getBlockX(), position.getBlockY(), position.getBlockZ()); } - + /** * Get the {@link BlockState} at a location. * @@ -42,13 +42,13 @@ public interface ReadableWorld extends World { default BlockState getBlockState(Vector3Int position) { return getBlockState(position.getX(), position.getY(), position.getZ()); } - + BlockEntity getBlockEntity(int x, int y, int z); - + default BlockEntity getBlockEntity(Vector3 position) { return getBlockEntity(position.getBlockX(), position.getBlockY(), position.getBlockZ()); } - + default BlockEntity getBlockEntity(Vector3Int position) { return getBlockEntity(position.getX(), position.getY(), position.getZ()); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/ServerWorld.java b/common/api/src/main/java/com/dfsek/terra/api/world/ServerWorld.java index ba3e16196..be30a3f33 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/ServerWorld.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/ServerWorld.java @@ -13,7 +13,7 @@ import com.dfsek.terra.api.world.chunk.Chunk; public interface ServerWorld extends WritableWorld { Chunk getChunkAt(int x, int z); - + default Chunk getChunkAt(Vector3 location) { return getChunkAt(location.getBlockX() >> 4, location.getBlockZ() >> 4); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/World.java b/common/api/src/main/java/com/dfsek/terra/api/world/World.java index 938f7ed58..4ebc30ee6 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/World.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/World.java @@ -16,14 +16,14 @@ public interface World extends WorldProperties { * @return Chunk generator. */ ChunkGenerator getGenerator(); - + /** * Get the {@link BiomeProvider} this world uses. * * @return Biome provider. */ BiomeProvider getBiomeProvider(); - + /** * Get the {@link ConfigPack} this world uses. * diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/WritableWorld.java b/common/api/src/main/java/com/dfsek/terra/api/world/WritableWorld.java index ef4ca89bb..6b528a040 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/WritableWorld.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/WritableWorld.java @@ -12,61 +12,61 @@ public interface WritableWorld extends ReadableWorld { default void setBlockState(Vector3 position, BlockState data, boolean physics) { setBlockState(position.getBlockX(), position.getBlockY(), position.getBlockZ(), data, physics); } - + default void setBlockState(Vector3.Mutable position, BlockState data, boolean physics) { setBlockState(position.getBlockX(), position.getBlockY(), position.getBlockZ(), data, physics); } - + default void setBlockState(Vector3Int position, BlockState data, boolean physics) { setBlockState(position.getX(), position.getY(), position.getZ(), data, physics); } - + default void setBlockState(Vector3Int.Mutable position, BlockState data, boolean physics) { setBlockState(position.getX(), position.getY(), position.getZ(), data, physics); } - + default void setBlockState(Vector3 position, BlockState data) { setBlockState(position, data, false); } - + default void setBlockState(Vector3.Mutable position, BlockState data) { setBlockState(position, data, false); } - + default void setBlockState(Vector3Int position, BlockState data) { setBlockState(position, data, false); } - + default void setBlockState(Vector3Int.Mutable position, BlockState data) { setBlockState(position, data, false); } - + default void setBlockState(int x, int y, int z, BlockState data) { setBlockState(x, y, z, data, false); } - + void setBlockState(int x, int y, int z, BlockState data, boolean physics); - - + + default Entity spawnEntity(Vector3 location, EntityType entityType) { return spawnEntity(location.getX(), location.getY(), location.getZ(), entityType); } - + Entity spawnEntity(double x, double y, double z, EntityType entityType); - + default BufferedWorld buffer(int offsetX, int offsetY, int offsetZ) { return BufferedWorld - .builder(this) - .offsetX(offsetX) - .offsetY(offsetY) - .offsetZ(offsetZ) - .build(); + .builder(this) + .offsetX(offsetX) + .offsetY(offsetY) + .offsetZ(offsetZ) + .build(); } - + default BufferedWorld.Builder buffer() { return BufferedWorld.builder(this); } - + default Column column(int x, int z) { return new Column<>(x, z, this); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/biome/Biome.java b/common/api/src/main/java/com/dfsek/terra/api/world/biome/Biome.java index 417dea9cd..af52720a4 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/biome/Biome.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/biome/Biome.java @@ -8,31 +8,31 @@ package com.dfsek.terra.api.world.biome; +import java.util.Set; + import com.dfsek.terra.api.properties.PropertyHolder; import com.dfsek.terra.api.registry.key.StringIdentifiable; -import java.util.Set; - /** * Represents a Terra biome */ public interface Biome extends PropertyHolder, StringIdentifiable { - + /** * Gets the platform biome this custom biome delegates to. * * @return The platform biome. */ PlatformBiome getPlatformBiome(); - + /** * Get the color of this biome. * * @return ARGB color of this biome */ int getColor(); - + /** * Get the tags this biome holds * diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/BiomeColumn.java b/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/BiomeColumn.java index addec2110..429be78a1 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/BiomeColumn.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/BiomeColumn.java @@ -8,11 +8,11 @@ class BiomeColumn implements Column { private final BiomeProvider biomeProvider; private final int min; private final int max; - + private final int x; private final int z; private final long seed; - + protected BiomeColumn(BiomeProvider biomeProvider, int min, int max, int x, int z, long seed) { this.biomeProvider = biomeProvider; this.min = min; @@ -21,27 +21,27 @@ class BiomeColumn implements Column { this.z = z; this.seed = seed; } - + @Override public int getMinY() { return min; } - + @Override public int getMaxY() { return max; } - + @Override public int getX() { return x; } - + @Override public int getZ() { return z; } - + @Override public Biome get(int y) { return biomeProvider.getBiome(x, y, z, seed); diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/BiomeProvider.java b/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/BiomeProvider.java index 1fb7c5c92..d049cd43b 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/BiomeProvider.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/BiomeProvider.java @@ -36,7 +36,7 @@ public interface BiomeProvider { */ @Contract(pure = true) Biome getBiome(int x, int y, int z, long seed); - + /** * Get the biome at a location. * @@ -49,7 +49,7 @@ public interface BiomeProvider { default Biome getBiome(Vector3 vector3, long seed) { return getBiome(vector3.getBlockX(), vector3.getBlockY(), vector3.getBlockZ(), seed); } - + /** * Get the biome at a location. * @@ -62,20 +62,20 @@ public interface BiomeProvider { default Biome getBiome(Vector3Int vector3, long seed) { return getBiome(vector3.getX(), vector3.getY(), vector3.getZ(), seed); } - + default Optional getBaseBiome(int x, int z, long seed) { return Optional.empty(); } - - + + default Column getColumn(int x, int z, WorldProperties properties) { return getColumn(x, z, properties.getSeed(), properties.getMinHeight(), properties.getMaxHeight()); } - + default Column getColumn(int x, int z, long seed, int min, int max) { return new BiomeColumn(this, min, max, x, z, seed); } - + /** * Get all biomes this {@link BiomeProvider} is capable of generating in the world. *

@@ -85,20 +85,20 @@ public interface BiomeProvider { */ @Contract(pure = true) Iterable getBiomes(); - + @Contract(pure = true) default Stream stream() { return StreamSupport.stream(getBiomes().spliterator(), false); } - + default CachingBiomeProvider caching() { if(this instanceof CachingBiomeProvider cachingBiomeProvider) { return cachingBiomeProvider; } return new CachingBiomeProvider(this); } - - + + default int resolution() { return 1; } diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/CachingBiomeProvider.java b/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/CachingBiomeProvider.java index 37aeed63b..a07e9efd9 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/CachingBiomeProvider.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/biome/generation/CachingBiomeProvider.java @@ -20,49 +20,49 @@ public class CachingBiomeProvider implements BiomeProvider, Handle { private final int res; private final LoadingCache cache; private final LoadingCache> baseCache; - + protected CachingBiomeProvider(BiomeProvider delegate) { this.delegate = delegate; this.res = delegate.resolution(); this.cache = Caffeine - .newBuilder() - .scheduler(Scheduler.disabledScheduler()) - .initialCapacity(98304) - .maximumSize(98304) // 1 full chunk (high res) - .build(vec -> delegate.getBiome(vec.x * res, vec.y * res, vec.z * res, vec.seed)); - + .newBuilder() + .scheduler(Scheduler.disabledScheduler()) + .initialCapacity(98304) + .maximumSize(98304) // 1 full chunk (high res) + .build(vec -> delegate.getBiome(vec.x * res, vec.y * res, vec.z * res, vec.seed)); + this.baseCache = Caffeine - .newBuilder() - .maximumSize(256) // 1 full chunk (high res) - .build(vec -> delegate.getBaseBiome(vec.x * res, vec.z * res, vec.seed)); - + .newBuilder() + .maximumSize(256) // 1 full chunk (high res) + .build(vec -> delegate.getBaseBiome(vec.x * res, vec.z * res, vec.seed)); + } - + @Override public BiomeProvider getHandle() { return delegate; } - + @Override public Biome getBiome(int x, int y, int z, long seed) { return cache.get(new SeededVector3(x / res, y / res, z / res, seed)); } - + @Override public Optional getBaseBiome(int x, int z, long seed) { return baseCache.get(new SeededVector2(x / res, z / res, seed)); } - + @Override public Iterable getBiomes() { return delegate.getBiomes(); } - + @Override public int resolution() { return delegate.resolution(); } - + private record SeededVector3(int x, int y, int z, long seed) { @Override public boolean equals(Object obj) { @@ -71,7 +71,7 @@ public class CachingBiomeProvider implements BiomeProvider, Handle { } return false; } - + @Override public int hashCode() { int code = x; @@ -80,8 +80,8 @@ public class CachingBiomeProvider implements BiomeProvider, Handle { return 31 * code + ((int) (seed ^ (seed >>> 32))); } } - - + + private record SeededVector2(int x, int z, long seed) { @Override public boolean equals(Object obj) { @@ -90,7 +90,7 @@ public class CachingBiomeProvider implements BiomeProvider, Handle { } return false; } - + @Override public int hashCode() { int code = x; diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/Chunk.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/Chunk.java index 6482df935..b1d532631 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/Chunk.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/Chunk.java @@ -15,16 +15,16 @@ import com.dfsek.terra.api.world.ServerWorld; public interface Chunk extends ChunkAccess { void setBlock(int x, int y, int z, BlockState data, boolean physics); - + default void setBlock(int x, int y, int z, @NotNull BlockState data) { setBlock(x, y, z, data, false); } - + @NotNull BlockState getBlock(int x, int y, int z); - + int getX(); - + int getZ(); - + ServerWorld getWorld(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/ChunkAccess.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/ChunkAccess.java index ca88b131c..a98d0e42e 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/ChunkAccess.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/ChunkAccess.java @@ -25,7 +25,7 @@ public interface ChunkAccess extends Handle { * @param blockState the type to set the block to */ void setBlock(int x, int y, int z, @NotNull BlockState blockState); - + /** * Get the type and data of the block at x, y, z. *

diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ChunkGenerator.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ChunkGenerator.java index 133077c91..0bf8d753d 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ChunkGenerator.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ChunkGenerator.java @@ -20,16 +20,16 @@ import com.dfsek.terra.api.world.info.WorldProperties; public interface ChunkGenerator { void generateChunkData(@NotNull ProtoChunk chunk, @NotNull WorldProperties world, @NotNull BiomeProvider biomeProvider, int chunkX, int chunkZ); - + BlockState getBlock(WorldProperties world, int x, int y, int z, BiomeProvider biomeProvider); - + default BlockState getBlock(WorldProperties world, Vector3 vector3, BiomeProvider biomeProvider) { return getBlock(world, vector3.getBlockX(), vector3.getBlockY(), vector3.getBlockZ(), biomeProvider); } - + default BlockState getBlock(WorldProperties world, Vector3Int vector3, BiomeProvider biomeProvider) { return getBlock(world, vector3.getX(), vector3.getY(), vector3.getZ(), biomeProvider); } - + Palette getPalette(int x, int y, int z, WorldProperties world, BiomeProvider biomeProvider); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ProtoWorld.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ProtoWorld.java index dd484d6fc..4a0f2f758 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ProtoWorld.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/ProtoWorld.java @@ -6,9 +6,9 @@ import com.dfsek.terra.api.world.WritableWorld; public interface ProtoWorld extends WritableWorld { int centerChunkX(); - + int centerChunkZ(); - + /** * Get the world object this ProtoWorld represents * diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/Column.java b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/Column.java index 658ec303f..d41d17237 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/Column.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/chunk/generation/util/Column.java @@ -26,11 +26,11 @@ public class Column { private final int min; private final int max; private final T world; - + public Column(int x, int z, T world) { this(x, z, world, world.getMinHeight(), world.getMaxHeight()); } - + public Column(int x, int z, T world, int min, int max) { this.x = x; this.z = z; @@ -38,70 +38,70 @@ public class Column { this.max = max; this.min = min; } - - + + public int getX() { return x; } - + public int getZ() { return z; } - + public BlockState getBlock(int y) { return world.getBlockState(x, y, z); } - + public T getWorld() { return world; } - + public int getMinY() { return min; } - + public int getMaxY() { return max; } - + public void forEach(IntConsumer function) { for(int y = world.getMinHeight(); y < world.getMaxHeight(); y++) { function.accept(y); } } - + public Column clamp(int min, int max) { if(min >= max) throw new IllegalArgumentException("Min greater than or equal to max: " + min + ", " + max); return new Column<>(x, z, world, min, max); } - + public BinaryColumn newBinaryColumn(IntToBooleanFunction function) { return new BinaryColumn(getMinY(), getMaxY(), function); } - + public BinaryColumnBuilder newBinaryColumn() { return new BinaryColumnBuilder(this); } - + @SuppressWarnings("unchecked") public Column adjacent(int offsetX, int offsetZ) { return (Column) world.column(x + offsetX, z + offsetZ); } - - + + public static class BinaryColumnBuilder { private final boolean[] arr; private final Column column; - + public BinaryColumnBuilder(Column column) { this.column = column; arr = new boolean[column.getMaxY() - column.getMinY()]; } - + public BinaryColumn build() { return new BinaryColumn(column.getMinY(), column.getMaxY(), arr); } - + public BinaryColumnBuilder set(int y) { arr[y - column.getMinY()] = true; return this; diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/info/WorldProperties.java b/common/api/src/main/java/com/dfsek/terra/api/world/info/WorldProperties.java index d9db43ef6..53c4d5ffd 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/info/WorldProperties.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/info/WorldProperties.java @@ -5,8 +5,8 @@ import com.dfsek.terra.api.Handle; public interface WorldProperties extends Handle { long getSeed(); - + int getMaxHeight(); - + int getMinHeight(); } diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/util/Interceptors.java b/common/api/src/main/java/com/dfsek/terra/api/world/util/Interceptors.java index 4b98c8b34..d57a89808 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/util/Interceptors.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/util/Interceptors.java @@ -3,16 +3,16 @@ package com.dfsek.terra.api.world.util; public final class Interceptors { private static final ReadInterceptor READ_THROUGH = ((x, y, z, world) -> world.getBlockState(x, y, z)); private static final WriteInterceptor WRITE_THROUGH = ((x, y, z, block, world, physics) -> world.setBlockState(x, y, z, block, - physics)); - + physics)); + private Interceptors() { - + } - + public static ReadInterceptor readThrough() { return READ_THROUGH; } - + public static WriteInterceptor writeThrough() { return WRITE_THROUGH; } diff --git a/common/api/src/main/java/com/dfsek/terra/api/world/util/WriteInterceptor.java b/common/api/src/main/java/com/dfsek/terra/api/world/util/WriteInterceptor.java index 27f4bcbe1..07e2300d3 100644 --- a/common/api/src/main/java/com/dfsek/terra/api/world/util/WriteInterceptor.java +++ b/common/api/src/main/java/com/dfsek/terra/api/world/util/WriteInterceptor.java @@ -8,6 +8,6 @@ public interface WriteInterceptor { default void write(int x, int y, int z, BlockState block, WritableWorld world) { write(x, y, z, block, world, false); } - + void write(int x, int y, int z, BlockState block, WritableWorld world, boolean physics); } diff --git a/common/api/src/test/java/util/ColumnTest.java b/common/api/src/test/java/util/ColumnTest.java index c6bff5035..a39d3d086 100644 --- a/common/api/src/test/java/util/ColumnTest.java +++ b/common/api/src/test/java/util/ColumnTest.java @@ -19,9 +19,9 @@ import static org.junit.jupiter.api.Assertions.*; public class ColumnTest { private final Column returnY = new ColumnImpl<>(-10, 10, Function.identity()); private final Column returnPositive = new ColumnImpl<>(-10, 10, i -> i >= 0); - + private final Column returnTrue = new ColumnImpl<>(-10, 10, i -> true); - + @Test public void testForEach() { returnY.forEach(Assertions::assertEquals); @@ -32,71 +32,71 @@ public class ColumnTest { }); assertEquals(returnY.getMaxY(), test.get()); } - + @Test public void testForRanges() { List, Boolean>> list = new ArrayList<>(); - + returnPositive.forRanges(1, (min, max, p) -> list.add(Pair.of(Pair.of(min, max), p))); - + assertEquals(List.of( - Pair.of(Pair.of(-10, 0), false), - Pair.of(Pair.of(0, 10), true) - ), - list); + Pair.of(Pair.of(-10, 0), false), + Pair.of(Pair.of(0, 10), true) + ), + list); } - + @Test public void testForRangesIndividual() { List, Integer>> list = new ArrayList<>(); - + returnY.forRanges(1, (min, max, p) -> list.add(Pair.of(Pair.of(min, max), p))); - + assertEquals(IntStream.range(-10, 10).mapToObj(i -> Pair.of(Pair.of(i, i + 1), i)).collect(Collectors.toList()), - list); + list); } - + @Test public void testForRangesContiguous() { List, Boolean>> list = new ArrayList<>(); - + returnTrue.forRanges(1, (min, max, p) -> list.add(Pair.of(Pair.of(min, max), p))); - + assertEquals(List.of(Pair.of(Pair.of(-10, 10), true)), - list); + list); } - + static class ColumnImpl implements Column { private final int min; private final int max; private final Function p; - + ColumnImpl(int min, int max, Function p) { this.min = min; this.max = max; this.p = p; } - + @Override public int getMinY() { return min; } - + @Override public int getMaxY() { return max; } - + @Override public int getX() { return 0; } - + @Override public int getZ() { return 0; } - + @Override public T get(int y) { return p.apply(y); diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/AbstractPlatform.java b/common/implementation/base/src/main/java/com/dfsek/terra/AbstractPlatform.java index 84ef39437..86d22bc2a 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/AbstractPlatform.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/AbstractPlatform.java @@ -81,41 +81,41 @@ import com.dfsek.terra.registry.master.ConfigRegistry; */ public abstract class AbstractPlatform implements Platform { private static final Logger logger = LoggerFactory.getLogger(AbstractPlatform.class); - + private static final MutableBoolean LOADED = new MutableBoolean(false); private final EventManager eventManager = new EventManagerImpl(); private final ConfigRegistry configRegistry = new ConfigRegistry(); - + private final CheckedRegistry checkedConfigRegistry = new CheckedRegistryImpl<>(configRegistry); - + private final Profiler profiler = new ProfilerImpl(); - + private final GenericLoaders loaders = new GenericLoaders(this); - + private final PluginConfigImpl config = new PluginConfigImpl(); - + private final CheckedRegistry addonRegistry = new CheckedRegistryImpl<>(new OpenRegistryImpl<>(TypeKey.of(BaseAddon.class))); - + private final Registry lockedAddonRegistry = new LockedRegistryImpl<>(addonRegistry); - + public ConfigRegistry getRawConfigRegistry() { return configRegistry; } - + protected Iterable platformAddon() { return Collections.emptySet(); } - + protected void load() { if(LOADED.get()) { throw new IllegalStateException( - "Someone tried to initialize Terra, but Terra has already initialized. This is most likely due to a broken platform " + - "implementation, or a misbehaving mod."); + "Someone tried to initialize Terra, but Terra has already initialized. This is most likely due to a broken platform " + + "implementation, or a misbehaving mod."); } LOADED.set(true); - + logger.info("Initializing Terra..."); - + try(InputStream stream = getClass().getResourceAsStream("/config.yml")) { logger.info("Loading config.yml"); File configFile = new File(getDataFolder(), "config.yml"); @@ -130,79 +130,79 @@ public abstract class AbstractPlatform implements Platform { } catch(IOException e) { logger.error("Error loading config.yml resource from jar", e); } - + config.load(this); // load config.yml - + if(config.dumpDefaultConfig()) { dumpResources(); } else { logger.info("Skipping resource dumping."); } - + if(config.isDebugProfiler()) { // if debug.profiler is enabled, start profiling profiler.start(); } - + InternalAddon internalAddon = loadAddons(); - + eventManager.getHandler(FunctionalEventHandler.class) - .register(internalAddon, PlatformInitializationEvent.class) - .then(event -> { - logger.info("Loading config packs..."); - configRegistry.loadAll(this); - logger.info("Loaded packs."); - }) - .global(); - - + .register(internalAddon, PlatformInitializationEvent.class) + .then(event -> { + logger.info("Loading config packs..."); + configRegistry.loadAll(this); + logger.info("Loaded packs."); + }) + .global(); + + logger.info("Terra addons successfully loaded."); logger.info("Finished initialization."); } - + protected InternalAddon loadAddons() { List addonList = new ArrayList<>(); - + InternalAddon internalAddon = new InternalAddon(); - + addonList.add(internalAddon); - + platformAddon().forEach(addonList::add); - + BootstrapAddonLoader bootstrapAddonLoader = new BootstrapAddonLoader(); - + Path addonsFolder = getDataFolder().toPath().resolve("addons"); - + Injector platformInjector = new InjectorImpl<>(this); platformInjector.addExplicitTarget(Platform.class); - + BootstrapAddonClassLoader bootstrapAddonClassLoader = new BootstrapAddonClassLoader(new URL[]{ }, getClass().getClassLoader()); - + bootstrapAddonLoader.loadAddons(addonsFolder, bootstrapAddonClassLoader) - .forEach(bootstrapAddon -> { - platformInjector.inject(bootstrapAddon); - - bootstrapAddon.loadAddons(addonsFolder, bootstrapAddonClassLoader) - .forEach(addonList::add); - }); - + .forEach(bootstrapAddon -> { + platformInjector.inject(bootstrapAddon); + + bootstrapAddon.loadAddons(addonsFolder, bootstrapAddonClassLoader) + .forEach(addonList::add); + }); + addonList.sort(Comparator.comparing(StringIdentifiable::getID)); if(logger.isInfoEnabled()) { StringBuilder builder = new StringBuilder(); builder.append("Loading ") - .append(addonList.size()) - .append(" Terra addons:"); - + .append(addonList.size()) + .append(" Terra addons:"); + for(BaseAddon addon : addonList) { builder.append("\n ") - .append("- ") - .append(addon.getID()) - .append("@") - .append(addon.getVersion().getFormatted()); + .append("- ") + .append(addon.getID()) + .append("@") + .append(addon.getVersion().getFormatted()); } - + logger.info(builder.toString()); } - + DependencySorter sorter = new DependencySorter(); addonList.forEach(sorter::add); sorter.sort().forEach(addon -> { @@ -212,48 +212,48 @@ public abstract class AbstractPlatform implements Platform { addonRegistry.register(addon.key(addon.getID()), addon); } }); - + return internalAddon; } - + protected void dumpResources() { try(InputStream resourcesConfig = getClass().getResourceAsStream("/resources.yml")) { if(resourcesConfig == null) { logger.info("No resources config found. Skipping resource dumping."); return; } - + Path data = getDataFolder().toPath(); - + Path addonsPath = data.resolve("addons"); Files.createDirectories(addonsPath); Set> paths = Files - .walk(addonsPath) - .map(path -> Pair.of(path, data.relativize(path).toString())) - - .map(Pair.mapRight(s -> { - if(s.contains("+")) { // remove commit hash - return s.substring(0, s.lastIndexOf('+')); - } - return s; - })) - - .filter(Pair.testRight(s -> s.contains("."))) // remove patch version - .map(Pair.mapRight(s -> s.substring(0, s.lastIndexOf('.')))) - - .filter(Pair.testRight(s -> s.contains("."))) // remove minor version - .map(Pair.mapRight(s -> s.substring(0, s.lastIndexOf('.')))) - - .collect(Collectors.toSet()); - + .walk(addonsPath) + .map(path -> Pair.of(path, data.relativize(path).toString())) + + .map(Pair.mapRight(s -> { + if(s.contains("+")) { // remove commit hash + return s.substring(0, s.lastIndexOf('+')); + } + return s; + })) + + .filter(Pair.testRight(s -> s.contains("."))) // remove patch version + .map(Pair.mapRight(s -> s.substring(0, s.lastIndexOf('.')))) + + .filter(Pair.testRight(s -> s.contains("."))) // remove minor version + .map(Pair.mapRight(s -> s.substring(0, s.lastIndexOf('.')))) + + .collect(Collectors.toSet()); + Set pathsNoMajor = paths - .stream() - .filter(Pair.testRight(s -> s.contains("."))) - .map(Pair.mapRight(s -> s.substring(0, s.lastIndexOf('.')))) // remove major version - .map(Pair.unwrapRight()) - .collect(Collectors.toSet()); - - + .stream() + .filter(Pair.testRight(s -> s.contains("."))) + .map(Pair.mapRight(s -> s.substring(0, s.lastIndexOf('.')))) // remove major version + .map(Pair.unwrapRight()) + .collect(Collectors.toSet()); + + String resourceYaml = IOUtils.toString(resourcesConfig, StandardCharsets.UTF_8); Map> resources = new Yaml().load(resourceYaml); resources.forEach((dir, entries) -> entries.forEach(entry -> { @@ -262,39 +262,39 @@ public abstract class AbstractPlatform implements Platform { File resource = new File(getDataFolder(), resourcePath); if(resource.exists()) return; // dont overwrite - + try(InputStream is = getClass().getResourceAsStream("/" + resourceClassPath)) { if(is == null) { logger.error("Resource {} doesn't exist on the classpath!", resourcePath); return; } - + paths - .stream() - .filter(Pair.testRight(resourcePath::startsWith)) - .forEach(Pair.consumeLeft(path -> { - logger.info("Removing outdated resource {}, replacing with {}", path, resourcePath); - try { - Files.delete(path); - } catch(IOException e) { - throw new UncheckedIOException(e); - } - })); - + .stream() + .filter(Pair.testRight(resourcePath::startsWith)) + .forEach(Pair.consumeLeft(path -> { + logger.info("Removing outdated resource {}, replacing with {}", path, resourcePath); + try { + Files.delete(path); + } catch(IOException e) { + throw new UncheckedIOException(e); + } + })); + if(pathsNoMajor - .stream() - .anyMatch(resourcePath::startsWith) && // if any share name + .stream() + .anyMatch(resourcePath::startsWith) && // if any share name paths - .stream() - .map(Pair.unwrapRight()) - .noneMatch(resourcePath::startsWith)) { // but dont share major version + .stream() + .map(Pair.unwrapRight()) + .noneMatch(resourcePath::startsWith)) { // but dont share major version logger.warn( - "Addon {} has a new major version available. It will not be automatically updated; you will need to " + - "ensure " + - "compatibility and update manually.", - resourcePath); + "Addon {} has a new major version available. It will not be automatically updated; you will need to " + + "ensure " + + "compatibility and update manually.", + resourcePath); } - + logger.info("Dumping resource {}...", resource.getAbsolutePath()); resource.getParentFile().mkdirs(); resource.createNewFile(); @@ -309,32 +309,32 @@ public abstract class AbstractPlatform implements Platform { logger.error("Error while dumping resources...", e); } } - + @Override public void register(TypeRegistry registry) { loaders.register(registry); } - + @Override public @NotNull PluginConfig getTerraConfig() { return config; } - + @Override public @NotNull CheckedRegistry getConfigRegistry() { return checkedConfigRegistry; } - + @Override public @NotNull Registry getAddons() { return lockedAddonRegistry; } - + @Override public @NotNull EventManager getEventManager() { return eventManager; } - + @Override public @NotNull Profiler getProfiler() { return profiler; diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/addon/DependencySorter.java b/common/implementation/base/src/main/java/com/dfsek/terra/addon/DependencySorter.java index 5b1402c44..36b0a1faf 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/addon/DependencySorter.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/addon/DependencySorter.java @@ -31,35 +31,35 @@ import com.dfsek.terra.api.addon.BaseAddon; public class DependencySorter { private final Map addons = new HashMap<>(); private final Map visited = new HashMap<>(); - + private final List addonList = new ArrayList<>(); - + public void add(BaseAddon addon) { addons.put(addon.getID(), addon); visited.put(addon.getID(), false); addonList.add(addon); } - + private void sortDependencies(BaseAddon addon, List sort) { addon.getDependencies().forEach((id, range) -> { BaseAddon dependency = get(id, addon); - + if(!range.isSatisfiedBy(dependency.getVersion())) { throw new DependencyVersionException( - "Addon " + addon.getID() + " specifies dependency on " + id + ", versions " + range.getFormatted() + - ", but non-matching version " + dependency.getVersion().getFormatted() + " is installed."); + "Addon " + addon.getID() + " specifies dependency on " + id + ", versions " + range.getFormatted() + + ", but non-matching version " + dependency.getVersion().getFormatted() + " is installed."); } - + if(!visited.get(dependency.getID())) { // if we've not visited it yet visited.put(dependency.getID(), true); // we've visited it now - + sortDependencies(dependency, sort); - + sort.add(dependency); // add it to the list. } }); } - + private BaseAddon get(String id, BaseAddon addon) { if(!addons.containsKey(id)) { throw new DependencyException("Addon " + addon.getID() + " specifies dependency on " + id + ", versions " + @@ -68,38 +68,38 @@ public class DependencySorter { } return addons.get(id); } - + private void checkDependencies(BaseAddon base, BaseAddon current) { current.getDependencies().forEach((id, range) -> { BaseAddon dependency = get(id, current); if(dependency.getID().equals(base.getID())) { throw new CircularDependencyException( - "Addon " + base.getID() + " has circular dependency beginning with " + dependency.getID()); + "Addon " + base.getID() + " has circular dependency beginning with " + dependency.getID()); } checkDependencies(base, dependency); }); } - + public List sort() { List sorted = new ArrayList<>(); - + for(int i = addonList.size() - 1; i >= 0; i--) { BaseAddon addon = addonList.get(i); - + checkDependencies(addon, addon); - + addonList.remove(i); - + if(!visited.get(addon.getID())) { sortDependencies(addon, sorted); } - + if(!visited.get(addon.getID())) { sorted.add(addon); visited.put(addon.getID(), true); } } - + return sorted; } } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/addon/EphemeralAddon.java b/common/implementation/base/src/main/java/com/dfsek/terra/addon/EphemeralAddon.java index 8d269241d..cdc73a654 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/addon/EphemeralAddon.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/addon/EphemeralAddon.java @@ -8,17 +8,17 @@ import com.dfsek.terra.api.addon.BaseAddon; public class EphemeralAddon implements BaseAddon { private final Version version; private final String id; - + public EphemeralAddon(Version version, String id) { this.version = version; this.id = id; } - + @Override public Version getVersion() { return version; } - + @Override public String getID() { return id; diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/addon/InternalAddon.java b/common/implementation/base/src/main/java/com/dfsek/terra/addon/InternalAddon.java index 0a63af2db..1e013e870 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/addon/InternalAddon.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/addon/InternalAddon.java @@ -25,16 +25,16 @@ import com.dfsek.terra.api.addon.BaseAddon; public class InternalAddon implements BaseAddon { private static final Version VERSION = Versions.getVersion(1, 0, 0); - + public InternalAddon() { } - + @Override public String getID() { return "terra"; } - + @Override public Version getVersion() { return VERSION; diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/addon/dependency/CircularDependencyException.java b/common/implementation/base/src/main/java/com/dfsek/terra/addon/dependency/CircularDependencyException.java index 0c646d94f..9dae3fee0 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/addon/dependency/CircularDependencyException.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/addon/dependency/CircularDependencyException.java @@ -23,11 +23,11 @@ import java.io.Serial; public class CircularDependencyException extends DependencyException { @Serial private static final long serialVersionUID = -6098780459461482651L; - + public CircularDependencyException(String message) { super(message); } - + public CircularDependencyException(String message, Throwable cause) { super(message, cause); } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/addon/dependency/DependencyException.java b/common/implementation/base/src/main/java/com/dfsek/terra/addon/dependency/DependencyException.java index 1b6ded135..884f7c20c 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/addon/dependency/DependencyException.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/addon/dependency/DependencyException.java @@ -24,11 +24,11 @@ import java.io.Serial; public class DependencyException extends RuntimeException { @Serial private static final long serialVersionUID = 4864727433635612759L; - + public DependencyException(String message) { super(message); } - + public DependencyException(String message, Throwable cause) { super(message, cause); } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/addon/dependency/DependencyVersionException.java b/common/implementation/base/src/main/java/com/dfsek/terra/addon/dependency/DependencyVersionException.java index 007968451..929615570 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/addon/dependency/DependencyVersionException.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/addon/dependency/DependencyVersionException.java @@ -23,11 +23,11 @@ import java.io.Serial; public class DependencyVersionException extends DependencyException { @Serial private static final long serialVersionUID = 3564288935278878135L; - + public DependencyVersionException(String message) { super(message); } - + public DependencyVersionException(String message, Throwable cause) { super(message, cause); } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/GenericLoaders.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/GenericLoaders.java index f4f5c6cfd..948db5f18 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/GenericLoaders.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/GenericLoaders.java @@ -41,26 +41,26 @@ import com.dfsek.terra.config.loaders.VersionRangeLoader; public class GenericLoaders implements LoaderRegistrar { private final Platform platform; - + public GenericLoaders(Platform platform) { this.platform = platform; } - + @Override public void register(TypeRegistry registry) { registry.registerLoader(ProbabilityCollection.class, new ProbabilityCollectionLoader()) - .registerLoader(Range.class, new RangeLoader()) - .registerLoader(Version.class, new VersionLoader()) - .registerLoader(MaterialSet.class, new MaterialSetLoader()) - .registerLoader(VersionRange.class, new VersionRangeLoader()) - .registerLoader(LinkedHashMap.class, new LinkedHashMapLoader()); - + .registerLoader(Range.class, new RangeLoader()) + .registerLoader(Version.class, new VersionLoader()) + .registerLoader(MaterialSet.class, new MaterialSetLoader()) + .registerLoader(VersionRange.class, new VersionRangeLoader()) + .registerLoader(LinkedHashMap.class, new LinkedHashMapLoader()); + if(platform != null) { registry.registerLoader(BaseAddon.class, platform.getAddons()) - .registerLoader(BlockType.class, (type, object, configLoader, depthTracker) -> platform - .getWorldHandle().createBlockState((String) object).getBlockType()) - .registerLoader(BlockState.class, (type, object, configLoader, depthTracker) -> platform - .getWorldHandle().createBlockState((String) object)); + .registerLoader(BlockType.class, (type, object, configLoader, depthTracker) -> platform + .getWorldHandle().createBlockState((String) object).getBlockType()) + .registerLoader(BlockState.class, (type, object, configLoader, depthTracker) -> platform + .getWorldHandle().createBlockState((String) object)); } } } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/PluginConfigImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/PluginConfigImpl.java index 810206513..d22c2945f 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/PluginConfigImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/PluginConfigImpl.java @@ -38,47 +38,47 @@ import com.dfsek.terra.api.config.PluginConfig; @SuppressWarnings("FieldMayBeFinal") public class PluginConfigImpl implements ConfigTemplate, PluginConfig { private static final Logger logger = LoggerFactory.getLogger(PluginConfigImpl.class); - + @Value("debug.commands") @Default private boolean debugCommands = false; - + @Value("debug.profiler") @Default private boolean debugProfiler = false; - + @Value("debug.script") @Default private boolean debugScript = false; - + @Value("debug.log") @Default private boolean debugLog = false; - + @Value("biome-search-resolution") @Default private int biomeSearch = 4; - + @Value("cache.structure") @Default private int structureCache = 32; - + @Value("cache.sampler") @Default private int samplerCache = 1024; - + @Value("cache.biome-provider") @Default private int providerCache = 32; - + @Value("dump-default") @Default private boolean dumpDefaultData = true; - + @Value("script.max-recursion") @Default private int maxRecursion = 1000; - + @Override public void load(Platform platform) { logger.info("Loading config values from config.yml"); @@ -88,7 +88,7 @@ public class PluginConfigImpl implements ConfigTemplate, PluginConfig { } catch(ConfigException | IOException | UncheckedIOException e) { logger.error("Failed to load config", e); } - + if(debugCommands) logger.info("Debug commands enabled."); if(debugProfiler) @@ -98,52 +98,52 @@ public class PluginConfigImpl implements ConfigTemplate, PluginConfig { if(debugLog) logger.info("Debug logging enabled."); } - + @Override public boolean dumpDefaultConfig() { return dumpDefaultData; } - + @Override public boolean isDebugCommands() { return debugCommands; } - + @Override public boolean isDebugProfiler() { return debugProfiler; } - + @Override public boolean isDebugScript() { return debugScript; } - + @Override public boolean isDebugLog() { return debugLog; } - + @Override public int getBiomeSearchResolution() { return biomeSearch; } - + @Override public int getStructureCache() { return structureCache; } - + @Override public int getSamplerCache() { return samplerCache; } - + @Override public int getMaxRecursion() { return maxRecursion; } - + @Override public int getProviderCache() { return providerCache; diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/fileloaders/FolderLoader.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/fileloaders/FolderLoader.java index e9e44c412..fb236f6d7 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/fileloaders/FolderLoader.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/fileloaders/FolderLoader.java @@ -35,18 +35,18 @@ import java.util.stream.Stream; */ public class FolderLoader extends LoaderImpl { private static final Logger logger = LoggerFactory.getLogger(FolderLoader.class); - + private final Path path; - + public FolderLoader(Path path) { this.path = path; } - + @Override public InputStream get(String singleFile) throws IOException { return new FileInputStream(new File(path.toFile(), singleFile)); } - + protected void load(String directory, String extension) { File newPath = new File(path.toFile(), directory); newPath.mkdirs(); diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/fileloaders/LoaderImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/fileloaders/LoaderImpl.java index 00637240b..b1cfe97c6 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/fileloaders/LoaderImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/fileloaders/LoaderImpl.java @@ -35,21 +35,21 @@ import com.dfsek.terra.api.config.Loader; public abstract class LoaderImpl implements Loader { private static final Logger logger = LoggerFactory.getLogger(LoaderImpl.class); - + protected final Map streams = new HashMap<>(); - + @Override public Loader thenNames(Consumer> consumer) throws ConfigException { consumer.accept(new ArrayList<>(streams.keySet())); return this; } - + @Override public Loader thenEntries(Consumer>> consumer) throws ConfigException { consumer.accept(streams.entrySet()); return this; } - + /** * Open a subdirectory. * @@ -62,7 +62,7 @@ public abstract class LoaderImpl implements Loader { load(directory, extension); return this; } - + /** * Close all InputStreams opened. */ @@ -78,6 +78,6 @@ public abstract class LoaderImpl implements Loader { streams.clear(); return this; } - + protected abstract void load(String directory, String extension); } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/fileloaders/ZIPLoader.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/fileloaders/ZIPLoader.java index 2b68580d9..9bcd5962c 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/fileloaders/ZIPLoader.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/fileloaders/ZIPLoader.java @@ -29,13 +29,13 @@ import java.util.zip.ZipFile; public class ZIPLoader extends LoaderImpl { private static final Logger logger = LoggerFactory.getLogger(ZIPLoader.class); - + private final ZipFile file; - + public ZIPLoader(ZipFile file) { this.file = file; } - + @Override public InputStream get(String singleFile) throws IOException { Enumeration entries = file.entries(); @@ -45,7 +45,7 @@ public class ZIPLoader extends LoaderImpl { } throw new IllegalArgumentException("No such file: " + singleFile); } - + protected void load(String directory, String extension) { Enumeration entries = file.entries(); while(entries.hasMoreElements()) { diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/GenericTemplateSupplierLoader.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/GenericTemplateSupplierLoader.java index 0c24524fb..5a23e54b8 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/GenericTemplateSupplierLoader.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/GenericTemplateSupplierLoader.java @@ -34,20 +34,20 @@ import com.dfsek.terra.api.registry.Registry; public class GenericTemplateSupplierLoader implements TypeLoader { private final Registry>> registry; - + public GenericTemplateSupplierLoader(Registry>> registry) { this.registry = registry; } - + @SuppressWarnings("unchecked") @Override public T load(@NotNull AnnotatedType t, @NotNull Object c, ConfigLoader loader, DepthTracker depthTracker) throws LoadException { Map map = (Map) c; String type = (String) map.get("type"); return loader - .load(registry.getByID(type) - .orElseThrow(() -> new LoadException("No such entry: " + map.get("type"), depthTracker)) - .get(), new MapConfiguration(map), depthTracker.intrinsic("With type \"" + type + "\"")).get(); - + .load(registry.getByID(type) + .orElseThrow(() -> new LoadException("No such entry: " + map.get("type"), depthTracker)) + .get(), new MapConfiguration(map), depthTracker.intrinsic("With type \"" + type + "\"")).get(); + } } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/LinkedHashMapLoader.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/LinkedHashMapLoader.java index a79d6418b..d014469f6 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/LinkedHashMapLoader.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/LinkedHashMapLoader.java @@ -41,10 +41,10 @@ public class LinkedHashMapLoader implements TypeLoader entry : config.entrySet()) { map.put(loader.loadType(key, entry.getKey(), depthTracker.entry(entry.getKey())), - loader.loadType(value, entry.getValue(), depthTracker.entry(entry.getKey()))); + loader.loadType(value, entry.getValue(), depthTracker.entry(entry.getKey()))); } } else throw new LoadException("Unable to load config", depthTracker); - + return map; } } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/MaterialSetLoader.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/MaterialSetLoader.java index 1debeb906..8d2f0fb5f 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/MaterialSetLoader.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/MaterialSetLoader.java @@ -36,13 +36,13 @@ public class MaterialSetLoader implements TypeLoader { public MaterialSet load(@NotNull AnnotatedType type, @NotNull Object o, @NotNull ConfigLoader configLoader, DepthTracker depthTracker) throws LoadException { List stringData = (List) o; - + if(stringData.size() == 1) { return MaterialSet.singleton(configLoader.loadType(BlockType.class, stringData.get(0), depthTracker)); } - + MaterialSet set = new MaterialSet(); - + for(String string : stringData) { try { set.add(configLoader.loadType(BlockType.class, string, depthTracker)); @@ -50,7 +50,7 @@ public class MaterialSetLoader implements TypeLoader { throw new LoadException("Invalid data identifier \"" + string + "\"", e, depthTracker); } } - + return set; } } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/ProbabilityCollectionLoader.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/ProbabilityCollectionLoader.java index 902bc16d4..6a9e10bd0 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/ProbabilityCollectionLoader.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/ProbabilityCollectionLoader.java @@ -38,14 +38,14 @@ public class ProbabilityCollectionLoader implements TypeLoader load(@NotNull AnnotatedType type, @NotNull Object o, @NotNull ConfigLoader configLoader, DepthTracker depthTracker) throws LoadException { ProbabilityCollection collection = new ProbabilityCollection<>(); - + if(type instanceof AnnotatedParameterizedType pType) { AnnotatedType generic = pType.getAnnotatedActualTypeArguments()[0]; if(o instanceof Map) { Map map = (Map) o; for(Map.Entry entry : map.entrySet()) { collection.add(configLoader.loadType(generic, entry.getKey(), depthTracker.entry((String) entry.getKey())), - configLoader.loadType(Integer.class, entry.getValue(), depthTracker.entry((String) entry.getKey()))); + configLoader.loadType(Integer.class, entry.getValue(), depthTracker.entry((String) entry.getKey()))); } } else if(o instanceof List) { List> map = (List>) o; @@ -61,10 +61,10 @@ public class ProbabilityCollectionLoader implements TypeLoader l = map.get(i); for(Entry entry : l.entrySet()) { if(entry.getValue() == null) throw new LoadException("No probability defined for entry \"" + entry.getKey() + "\"", - depthTracker); + depthTracker); Object val = configLoader.loadType(generic, entry.getKey(), depthTracker.index(i).entry((String) entry.getKey())); collection.add(val, - configLoader.loadType(Integer.class, entry.getValue(), depthTracker.entry((String) entry.getKey()))); + configLoader.loadType(Integer.class, entry.getValue(), depthTracker.entry((String) entry.getKey()))); } } } else if(o instanceof String) { @@ -73,9 +73,9 @@ public class ProbabilityCollectionLoader implements TypeLoader { return new ConstantRange(h, h + 1); } } - + /* * Template needed so keys can be meta annotated, otherwise the loader could just grab keys directly from the object */ private static class RangeMapTemplate implements ObjectTemplate { @Value("min") private @Meta int min; - + @Value("max") private @Meta int max; - + @Override public Range get() { return new ConstantRange(min, max); diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/config/BufferedImageLoader.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/config/BufferedImageLoader.java index 057eba98e..078e62e87 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/config/BufferedImageLoader.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/config/BufferedImageLoader.java @@ -40,16 +40,16 @@ import com.dfsek.terra.api.properties.Properties; @Deprecated public class BufferedImageLoader implements TypeLoader { private final Loader files; - + private final ConfigPack pack; - + public BufferedImageLoader(Loader files, ConfigPack pack) { this.files = files; this.pack = pack; if(!pack.getContext().has(ImageCache.class)) pack.getContext().put(new ImageCache(new ConcurrentHashMap<>())); } - + @Override public BufferedImage load(@NotNull AnnotatedType t, @NotNull Object c, @NotNull ConfigLoader loader, DepthTracker depthTracker) throws LoadException { @@ -61,7 +61,7 @@ public class BufferedImageLoader implements TypeLoader { } }); } - + /* * Cache prevents configs from loading the same image multiple times into memory */ diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackAddonsTemplate.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackAddonsTemplate.java index 004a961c9..1900ba753 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackAddonsTemplate.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackAddonsTemplate.java @@ -33,8 +33,8 @@ public class ConfigPackAddonsTemplate implements ConfigTemplate { @Value("addons") @Default private Map addons = new HashMap<>(); - - + + public Map getAddons() { return addons; } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackImpl.java index 611539c41..82ec7d95b 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackImpl.java @@ -103,24 +103,24 @@ public class ConfigPackImpl implements ConfigPack { private static final Logger logger = LoggerFactory.getLogger(ConfigPackImpl.class); private final Context context = new Context(); private final ConfigPackTemplate template = new ConfigPackTemplate(); - + private final AbstractConfigLoader abstractConfigLoader = new AbstractConfigLoader(); private final ConfigLoader selfLoader = new ConfigLoader(); private final Platform platform; private final Loader loader; - + private final Map addons; - + private final BiomeProvider seededBiomeProvider; - + private final Map> registryMap = new HashMap<>(); private final Map> shortcuts = new HashMap<>(); - + private final OpenRegistry> configTypeRegistry; private final TreeMap>>> configTypes = new TreeMap<>(); - + private final RegistryKey key; - + public ConfigPackImpl(File folder, Platform platform) { this(new FolderLoader(folder.toPath()), Construct.construct(() -> { try { @@ -130,7 +130,7 @@ public class ConfigPackImpl implements ConfigPack { } }), platform); } - + public ConfigPackImpl(ZipFile file, Platform platform) { this(new ZIPLoader(file), Construct.construct(() -> { ZipEntry pack = null; @@ -139,9 +139,9 @@ public class ConfigPackImpl implements ConfigPack { ZipEntry entry = entries.nextElement(); if(entry.getName().equals("pack.yml")) pack = entry; } - + if(pack == null) throw new IllegalArgumentException("No pack.yml file found in " + file.getName()); - + try { return new YamlConfiguration(file.getInputStream(pack), "pack.yml"); } catch(IOException e) { @@ -149,33 +149,33 @@ public class ConfigPackImpl implements ConfigPack { } }), platform); } - + @SuppressWarnings({ "rawtypes", "unchecked" }) private ConfigPackImpl(Loader loader, Configuration packManifest, Platform platform) { long start = System.nanoTime(); - + this.loader = loader; this.platform = platform; this.configTypeRegistry = createConfigRegistry(); - + register(selfLoader); platform.register(selfLoader); - + register(abstractConfigLoader); platform.register(abstractConfigLoader); - + ConfigPackAddonsTemplate addonsTemplate = new ConfigPackAddonsTemplate(); selfLoader.load(addonsTemplate, packManifest); this.addons = addonsTemplate.getAddons(); - + Map configurations = discoverConfigurations(); registerMeta(configurations); - + platform.getEventManager().callEvent( - new ConfigPackPreLoadEvent(this, template -> selfLoader.load(template, packManifest))); - + new ConfigPackPreLoadEvent(this, template -> selfLoader.load(template, packManifest))); + selfLoader.load(template, packManifest); - + String namespace; String id; if(template.getID().contains(":")) { @@ -185,109 +185,109 @@ public class ConfigPackImpl implements ConfigPack { id = template.getID(); namespace = template.getID(); } - + this.key = RegistryKey.of(namespace, id); - + logger.info("Loading config pack \"{}:{}\"", id, namespace); - + configTypes.values().forEach(list -> list.forEach(pair -> configTypeRegistry.register(pair.getLeft(), pair.getRight()))); - + ListMultimap, Configuration> multimap = configurations.values().parallelStream().collect( - () -> Multimaps.newListMultimap(new ConcurrentHashMap<>(), ArrayList::new), (configs, configuration) -> { - if(configuration.contains("type")) { // Only sort configs with type key - ProtoConfig config = new ProtoConfig(); - selfLoader.load(config, configuration); - configs.put(config.getType(), configuration); - } - }, ListMultimap::putAll); - + () -> Multimaps.newListMultimap(new ConcurrentHashMap<>(), ArrayList::new), (configs, configuration) -> { + if(configuration.contains("type")) { // Only sort configs with type key + ProtoConfig config = new ProtoConfig(); + selfLoader.load(config, configuration); + configs.put(config.getType(), configuration); + } + }, ListMultimap::putAll); + configTypeRegistry.forEach(configType -> { CheckedRegistry registry = getCheckedRegistry(configType.getTypeKey()); abstractConfigLoader - .loadConfigs(multimap.get(configType)) - .stream() - .parallel() - .map(configuration -> { - logger.debug("Loading abstract config {}", configuration.getID()); - Object loaded = ((ConfigFactory) configType.getFactory()).build( - selfLoader.load(configType.getTemplate(this, platform), configuration), platform); - platform.getEventManager().callEvent(new ConfigurationLoadEvent(this, - configuration, - template -> selfLoader.load(template, - configuration), - configType, - loaded)); - return Pair.of(configuration.getID(), loaded); - }) - .toList() - .forEach(pair -> registry.register(key(pair.getLeft()), pair.getRight())); + .loadConfigs(multimap.get(configType)) + .stream() + .parallel() + .map(configuration -> { + logger.debug("Loading abstract config {}", configuration.getID()); + Object loaded = ((ConfigFactory) configType.getFactory()).build( + selfLoader.load(configType.getTemplate(this, platform), configuration), platform); + platform.getEventManager().callEvent(new ConfigurationLoadEvent(this, + configuration, + template -> selfLoader.load(template, + configuration), + configType, + loaded)); + return Pair.of(configuration.getID(), loaded); + }) + .toList() + .forEach(pair -> registry.register(key(pair.getLeft()), pair.getRight())); platform.getEventManager().callEvent(new ConfigTypePostLoadEvent(configType, registry, this)); }); - + platform.getEventManager().callEvent(new ConfigPackPostLoadEvent(this, template -> selfLoader.load(template, packManifest))); logger.info("Loaded config pack \"{}:{}\" v{} by {} in {}ms.", - namespace, id, getVersion().getFormatted(), template.getAuthor(), (System.nanoTime() - start) / 1000000.0D); - - + namespace, id, getVersion().getFormatted(), template.getAuthor(), (System.nanoTime() - start) / 1000000.0D); + + ConfigPackPostTemplate packPostTemplate = new ConfigPackPostTemplate(); selfLoader.load(packPostTemplate, packManifest); seededBiomeProvider = - template.getBiomeCache() ? packPostTemplate.getProviderBuilder().caching() : packPostTemplate.getProviderBuilder(); + template.getBiomeCache() ? packPostTemplate.getProviderBuilder().caching() : packPostTemplate.getProviderBuilder(); checkDeadEntries(); } - + private Map discoverConfigurations() { Map configurations = new HashMap<>(); platform.getEventManager().callEvent(new ConfigurationDiscoveryEvent(this, loader, - (s, c) -> configurations.put(s.replace("\\", "/"), - c))); // Create all the configs. + (s, c) -> configurations.put(s.replace("\\", "/"), + c))); // Create all the configs. return configurations; } - + private void registerMeta(Map configurations) { MetaStringPreprocessor stringPreprocessor = new MetaStringPreprocessor(configurations); selfLoader.registerPreprocessor(Meta.class, stringPreprocessor); abstractConfigLoader.registerPreprocessor(Meta.class, stringPreprocessor); - + MetaListLikePreprocessor listPreprocessor = new MetaListLikePreprocessor(configurations); selfLoader.registerPreprocessor(Meta.class, listPreprocessor); abstractConfigLoader.registerPreprocessor(Meta.class, listPreprocessor); - + MetaMapPreprocessor mapPreprocessor = new MetaMapPreprocessor(configurations); selfLoader.registerPreprocessor(Meta.class, mapPreprocessor); abstractConfigLoader.registerPreprocessor(Meta.class, mapPreprocessor); - + MetaValuePreprocessor valuePreprocessor = new MetaValuePreprocessor(configurations); selfLoader.registerPreprocessor(Meta.class, valuePreprocessor); abstractConfigLoader.registerPreprocessor(Meta.class, valuePreprocessor); - + MetaNumberPreprocessor numberPreprocessor = new MetaNumberPreprocessor(configurations); selfLoader.registerPreprocessor(Meta.class, numberPreprocessor); abstractConfigLoader.registerPreprocessor(Meta.class, numberPreprocessor); } - + @Override public ConfigPackImpl applyLoader(Type type, TypeLoader loader) { abstractConfigLoader.registerLoader(type, loader); selfLoader.registerLoader(type, loader); return this; } - + @Override public ConfigPackImpl applyLoader(Type type, Supplier> loader) { abstractConfigLoader.registerLoader(type, loader); selfLoader.registerLoader(type, loader); return this; } - + @Override public void register(TypeRegistry registry) { registry.registerLoader(ConfigType.class, configTypeRegistry) - .registerLoader(BufferedImage.class, new BufferedImageLoader(loader, this)); + .registerLoader(BufferedImage.class, new BufferedImageLoader(loader, this)); registryMap.forEach(registry::registerLoader); shortcuts.forEach(registry::registerLoader); // overwrite with delegated shortcuts if present } - + @Override public ConfigPack registerConfigType(ConfigType type, RegistryKey key, int priority) { Set contained = new HashSet<>(); @@ -298,17 +298,17 @@ public class ConfigPackImpl implements ConfigPack { configTypes.computeIfAbsent(priority, p -> new ArrayList<>()).add(Pair.of(key, type)); return this; } - + @Override public Map addons() { return addons; } - + @Override public BiomeProvider getBiomeProvider() { return seededBiomeProvider; } - + @SuppressWarnings("unchecked") @Override public CheckedRegistry getOrCreateRegistry(TypeKey typeKey) { @@ -317,7 +317,7 @@ public class ConfigPackImpl implements ConfigPack { selfLoader.registerLoader(c, registry); abstractConfigLoader.registerLoader(c, registry); logger.debug("Registered loader for registry of class {}", ReflectionUtil.typeToString(c)); - + if(typeKey.getType() instanceof ParameterizedType param) { Type base = param.getRawType(); if(base instanceof Class // should always be true but we'll check anyways @@ -329,7 +329,7 @@ public class ConfigPackImpl implements ConfigPack { && ObjectTemplate.class.isAssignableFrom((Class) suppliedBase)) { Type templateType = suppliedParam.getActualTypeArguments()[0]; GenericTemplateSupplierLoader loader = new GenericTemplateSupplierLoader<>( - (Registry>>>>) registry); + (Registry>>>>) registry); selfLoader.registerLoader(templateType, loader); abstractConfigLoader.registerLoader(templateType, loader); logger.debug("Registered template loader for registry of class {}", ReflectionUtil.typeToString(templateType)); @@ -337,54 +337,54 @@ public class ConfigPackImpl implements ConfigPack { } } } - + return new CheckedRegistryImpl<>(registry); }); } - + @Override public List getStages() { return template.getStages(); } - + @Override public Loader getLoader() { return loader; } - + @Override public String getAuthor() { return template.getAuthor(); } - + @Override public Version getVersion() { return template.getVersion(); } - + @SuppressWarnings("unchecked,rawtypes") @Override public ConfigPack registerShortcut(TypeKey clazz, String shortcut, ShortcutLoader loader) { ShortcutHolder holder = shortcuts - .computeIfAbsent(clazz.getType(), c -> new ShortcutHolder<>(getOrCreateRegistry(clazz))) - .register(shortcut, (ShortcutLoader) loader); + .computeIfAbsent(clazz.getType(), c -> new ShortcutHolder<>(getOrCreateRegistry(clazz))) + .register(shortcut, (ShortcutLoader) loader); selfLoader.registerLoader(clazz.getType(), holder); abstractConfigLoader.registerLoader(clazz.getType(), holder); return this; } - + @Override public ChunkGeneratorProvider getGeneratorProvider() { return template.getGeneratorProvider(); } - + private OpenRegistry> createConfigRegistry() { return new OpenRegistryImpl<>(new LinkedHashMap<>(), CONFIG_TYPE_TYPE_KEY) { @Override public boolean register(@NotNull RegistryKey key, @NotNull ConfigType value) { if(!registryMap - .containsKey(value.getTypeKey() - .getType())) { + .containsKey(value.getTypeKey() + .getType())) { OpenRegistry openRegistry = new OpenRegistryImpl<>(value.getTypeKey()); selfLoader.registerLoader(value.getTypeKey().getType(), openRegistry); abstractConfigLoader.registerLoader(value.getTypeKey().getType(), openRegistry); @@ -394,34 +394,34 @@ public class ConfigPackImpl implements ConfigPack { } }; } - + private void checkDeadEntries() { registryMap.forEach((clazz, pair) -> ((OpenRegistryImpl) pair.getRegistry()) - .getDeadEntries() - .forEach((id, value) -> logger.debug("Dead entry in '{}' registry: '{}'", ReflectionUtil.typeToString(clazz), id))); + .getDeadEntries() + .forEach((id, value) -> logger.debug("Dead entry in '{}' registry: '{}'", ReflectionUtil.typeToString(clazz), id))); } - + public ConfigPackTemplate getTemplate() { return template; } - + @Override @SuppressWarnings("unchecked") public CheckedRegistry getRegistry(Type type) { return (CheckedRegistry) registryMap.get(type); } - + @SuppressWarnings("unchecked") @Override public CheckedRegistry getCheckedRegistry(Type type) throws IllegalStateException { return (CheckedRegistry) registryMap.get(type); } - + @Override public RegistryKey getRegistryKey() { return key; } - + @Override public Context getContext() { return context; diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackPostTemplate.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackPostTemplate.java index cfa166a40..e0e2259bc 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackPostTemplate.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackPostTemplate.java @@ -27,7 +27,7 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider; public class ConfigPackPostTemplate implements ConfigTemplate { @Value("biomes") private @Meta BiomeProvider providerBuilder; - + public BiomeProvider getProviderBuilder() { return providerBuilder; } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackTemplate.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackTemplate.java index 3aa0a8c27..0276f1fa4 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackTemplate.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackTemplate.java @@ -36,157 +36,157 @@ import com.dfsek.terra.api.world.chunk.generation.util.provider.ChunkGeneratorPr public class ConfigPackTemplate implements ConfigTemplate { @Value("id") private String id; - + @Value("variables") @Default private @Meta Map variables = new HashMap<>(); - + @Value("beta.carving") @Default private @Meta boolean betaCarvers = false; - + @Value("structures.locatable") @Default private @Meta Map<@Meta String, @Meta String> locatable = new HashMap<>(); - + @Value("blend.terrain.elevation") @Default private @Meta int elevationBlend = 4; - + @Value("vanilla.mobs") @Default private @Meta boolean vanillaMobs = true; - + @Value("vanilla.caves") @Default private @Meta boolean vanillaCaves = false; - + @Value("vanilla.decorations") @Default private @Meta boolean vanillaDecorations = false; - + @Value("vanilla.structures") @Default private @Meta boolean vanillaStructures = false; - + @Value("author") @Default private String author = "Anon Y. Mous"; - + @Value("disable.sapling") @Default private @Meta boolean disableSaplings = false; - + @Value("stages") @Default private @Meta List<@Meta GenerationStage> stages = Collections.emptyList(); - + @Value("version") private Version version; - + @Value("disable.carvers") @Default private @Meta boolean disableCarvers = false; - + @Value("disable.structures") @Default private @Meta boolean disableStructures = false; - + @Value("disable.ores") @Default private @Meta boolean disableOres = false; - + @Value("disable.trees") @Default private @Meta boolean disableTrees = false; - + @Value("disable.flora") @Default private @Meta boolean disableFlora = false; - + @Value("generator") private @Meta ChunkGeneratorProvider generatorProvider; - + @Value("cache.biome.enable") @Default private boolean biomeCache = false; - + public boolean disableCarvers() { return disableCarvers; } - + public boolean disableFlora() { return disableFlora; } - + public boolean disableOres() { return disableOres; } - + public boolean disableStructures() { return disableStructures; } - + public boolean disableTrees() { return disableTrees; } - + public boolean vanillaMobs() { return vanillaMobs; } - + public boolean vanillaCaves() { return vanillaCaves; } - + public boolean vanillaDecorations() { return vanillaDecorations; } - + public boolean vanillaStructures() { return vanillaStructures; } - + public boolean doBetaCarvers() { return betaCarvers; } - + public ChunkGeneratorProvider getGeneratorProvider() { return generatorProvider; } - + public List getStages() { return stages; } - + public Version getVersion() { return version; } - + public boolean isDisableSaplings() { return disableSaplings; } - + public String getID() { return id; } - + public String getAuthor() { return author; } - + public Map getVariables() { return variables; } - + public int getElevationBlend() { return elevationBlend; } - + public Map getLocatable() { return locatable; } - + public boolean getBiomeCache() { return biomeCache; } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaListLikePreprocessor.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaListLikePreprocessor.java index db868690b..2e6707c9d 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaListLikePreprocessor.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaListLikePreprocessor.java @@ -41,43 +41,43 @@ public class MetaListLikePreprocessor extends MetaPreprocessor { public MetaListLikePreprocessor(Map configs) { super(configs); } - + @SuppressWarnings("unchecked") @Override public @NotNull Result process(AnnotatedType t, T c, ConfigLoader loader, Meta annotation, DepthTracker depthTracker) { if(t.getType() instanceof ParameterizedType parameterizedType) { if(parameterizedType.getRawType() instanceof Class baseClass) { // Should always be true but we check anyways - + if((List.class.isAssignableFrom(baseClass) || Set.class.isAssignableFrom(baseClass)) && c instanceof List) { // List or set metaconfig List list = (List) c; - + int offset = 0; List newList = new ArrayList<>((List) c); - + for(int i = 0; i < list.size(); i++) { Object o = list.get(i); if(!(o instanceof String)) continue; String s = ((String) o).trim(); if(!s.startsWith("<< ")) continue; String meta = s.substring(3); - - + + Pair pair = getMetaValue(meta, depthTracker); Object metaValue = pair.getRight(); - + if(!(metaValue instanceof List)) { throw new LoadException( - "Meta list / set injection (via <<) must point to a list. '" + meta + "' points to type " + - metaValue.getClass().getCanonicalName(), - depthTracker); + "Meta list / set injection (via <<) must point to a list. '" + meta + "' points to type " + + metaValue.getClass().getCanonicalName(), + depthTracker); } - + List metaList = (List) metaValue; - + newList.remove(i + offset); // Remove placeholder newList.addAll(i + offset, metaList); // Add metalist values where placeholder was - + int begin = i + offset; offset += metaList.size() - 1; // add metalist size to offset, subtract one to account for placeholder. int end = i + offset; @@ -96,12 +96,12 @@ public class MetaListLikePreprocessor extends MetaPreprocessor { return Optional.empty(); }); } - + return (Result) Result.overwrite(newList, depthTracker); } } } - + return Result.noOp(); } } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaMapPreprocessor.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaMapPreprocessor.java index f90544e9c..3a05e8112 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaMapPreprocessor.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaMapPreprocessor.java @@ -23,11 +23,6 @@ import com.dfsek.tectonic.api.depth.EntryLevel; import com.dfsek.tectonic.api.exception.LoadException; import com.dfsek.tectonic.api.loader.ConfigLoader; import com.dfsek.tectonic.api.preprocessor.Result; - -import com.dfsek.terra.api.config.meta.Meta; -import com.dfsek.terra.api.util.generic.pair.Pair; -import com.dfsek.terra.api.util.reflection.TypeKey; - import org.jetbrains.annotations.NotNull; import java.lang.reflect.AnnotatedType; @@ -37,45 +32,49 @@ import java.util.List; import java.util.Map; import java.util.Optional; +import com.dfsek.terra.api.config.meta.Meta; +import com.dfsek.terra.api.util.generic.pair.Pair; +import com.dfsek.terra.api.util.reflection.TypeKey; + public class MetaMapPreprocessor extends MetaPreprocessor { private static final TypeKey> STRING_LIST = new TypeKey<>() { }; - + public MetaMapPreprocessor(Map configs) { super(configs); } - + @SuppressWarnings("unchecked") @Override public @NotNull Result process(AnnotatedType t, T c, ConfigLoader loader, Meta annotation, DepthTracker depthTracker) { if(t.getType() instanceof ParameterizedType parameterizedType) { if(parameterizedType.getRawType() instanceof Class baseClass) { // Should always be true but we check anyways - + if(Map.class.isAssignableFrom(baseClass) && c instanceof Map) { // Map metaconfig Map map = (Map) c; - + if(map.containsKey("<<")) { Map newMap = new HashMap<>(map); - + List keys = (List) loader.loadType(STRING_LIST.getAnnotatedType(), map.get("<<"), depthTracker); keys.forEach(key -> { Pair pair = getMetaValue(key, depthTracker); Object meta = pair.getRight(); if(!(meta instanceof Map)) { throw new LoadException( - "MetaMap injection candidate must be list, is type " + meta.getClass().getCanonicalName(), - depthTracker); + "MetaMap injection candidate must be list, is type " + meta.getClass().getCanonicalName(), + depthTracker); } newMap.putAll((Map) meta); - + String configName; if(pair.getLeft().getName() == null) { configName = "Anonymous Configuration"; } else { configName = pair.getLeft().getName(); } - + depthTracker.addIntrinsicLevel(level -> { if(level instanceof EntryLevel entryLevel && ((Map) meta).containsKey(entryLevel.getName())) { return Optional.of("From configuration \"" + configName + "\""); @@ -90,7 +89,7 @@ public class MetaMapPreprocessor extends MetaPreprocessor { } } } - + return Result.noOp(); } } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaNumberPreprocessor.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaNumberPreprocessor.java index 543e2b862..9197adeb1 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaNumberPreprocessor.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaNumberPreprocessor.java @@ -36,11 +36,11 @@ import com.dfsek.terra.api.util.reflection.TypeKey; public class MetaNumberPreprocessor extends MetaPreprocessor { public static final TypeKey META_STRING_KEY = new TypeKey<@Meta String>() { }; - + public MetaNumberPreprocessor(Map configs) { super(configs); } - + private static boolean isNumber(Class clazz) { return Number.class.isAssignableFrom(clazz) || byte.class.equals(clazz) @@ -49,7 +49,7 @@ public class MetaNumberPreprocessor extends MetaPreprocessor { || float.class.equals(clazz) || double.class.equals(clazz); } - + @SuppressWarnings("unchecked") @Override public @NotNull Result process(AnnotatedType t, T c, ConfigLoader loader, Meta annotation, DepthTracker depthTracker) { diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaPreprocessor.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaPreprocessor.java index 5ed605845..2f4b0d231 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaPreprocessor.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaPreprocessor.java @@ -30,24 +30,24 @@ import com.dfsek.terra.api.util.generic.pair.Pair; public abstract class MetaPreprocessor implements ValuePreprocessor { private final Map configs; - + public MetaPreprocessor(Map configs) { this.configs = configs; } - + protected Pair getMetaValue(String meta, DepthTracker depthTracker) { int sep = meta.indexOf(':'); String file = meta.substring(0, sep); String key = meta.substring(sep + 1); - + if(!configs.containsKey(file)) throw new LoadException("Cannot fetch metavalue: No such config: " + file, depthTracker); - + Configuration config = configs.get(file); - + if(!config.contains(key)) { throw new LoadException("Cannot fetch metavalue: No such key " + key + " in configuration " + config.getName(), depthTracker); } - + return Pair.of(config, config.get(key)); } } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaStringPreprocessor.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaStringPreprocessor.java index c23bbb287..8869a0228 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaStringPreprocessor.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaStringPreprocessor.java @@ -35,7 +35,7 @@ public class MetaStringPreprocessor extends MetaPreprocessor { public MetaStringPreprocessor(Map configs) { super(configs); } - + @SuppressWarnings("unchecked") @Override public @NotNull Result process(AnnotatedType t, T c, ConfigLoader loader, Meta annotation, DepthTracker depthTracker) { @@ -52,6 +52,6 @@ public class MetaStringPreprocessor extends MetaPreprocessor { } return Result.noOp(); } - - + + } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaValuePreprocessor.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaValuePreprocessor.java index 94997ca5b..ff0a50afc 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaValuePreprocessor.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaValuePreprocessor.java @@ -31,11 +31,11 @@ import com.dfsek.terra.api.util.generic.pair.Pair; public class MetaValuePreprocessor extends MetaPreprocessor { - + public MetaValuePreprocessor(Map configs) { super(configs); } - + @SuppressWarnings("unchecked") @Override public @NotNull Result process(AnnotatedType t, T c, ConfigLoader configLoader, Meta annotation, DepthTracker depthTracker) { @@ -44,14 +44,14 @@ public class MetaValuePreprocessor extends MetaPreprocessor { if(value.startsWith("$") // it's a meta value. && !value.startsWith("${")) { // it's not a meta string template. Pair pair = getMetaValue(value.substring(1), depthTracker); - + String configName; if(pair.getLeft().getName() == null) { configName = "Anonymous Configuration"; } else { configName = pair.getLeft().getName(); } - + return (Result) Result.overwrite(pair.getRight(), depthTracker.intrinsic("From configuration \"" + configName + "\"")); } } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/prototype/ProtoConfig.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/prototype/ProtoConfig.java index 928aaaf72..699e1982b 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/prototype/ProtoConfig.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/prototype/ProtoConfig.java @@ -26,15 +26,15 @@ import com.dfsek.terra.api.config.ConfigType; public class ProtoConfig implements ConfigTemplate { @Value("id") private String id; - + @Value("type") private ConfigType type; - - + + public String getId() { return id; } - + public ConfigType getType() { return type; } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/event/EventContextImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/event/EventContextImpl.java index 891102e2b..08be1e54e 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/event/EventContextImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/event/EventContextImpl.java @@ -39,63 +39,63 @@ public class EventContextImpl implements EventContext, Compa private int priority; private boolean failThrough = false; private boolean global = false; - + public EventContextImpl(BaseAddon addon, Type eventType, FunctionalEventHandlerImpl parent) { this.addon = addon; this.eventType = eventType; this.parent = parent; } - + public void handle(T event) { actions.forEach(action -> action.accept(event)); } - + @Override public EventContext then(Consumer action) { actions.add(action); return this; } - + @Override public EventContext priority(int priority) { this.priority = priority; parent.recomputePriorities(eventType); return this; } - + @Override public EventContext failThrough() { if(!FailThroughEvent.class.isAssignableFrom(ReflectionUtil.getRawType(eventType))) { throw new IllegalStateException( - "Cannot fail-through on event which does not implement FailThroughEvent: " + ReflectionUtil.typeToString(eventType)); + "Cannot fail-through on event which does not implement FailThroughEvent: " + ReflectionUtil.typeToString(eventType)); } this.failThrough = true; return this; } - + @Override public EventContext global() { this.global = true; return this; } - + @Override public int compareTo(@NotNull EventContextImpl o) { return this.priority - o.priority; } - + public boolean isGlobal() { return global; } - + public int getPriority() { return priority; } - + public BaseAddon getAddon() { return addon; } - + public boolean isFailThrough() { return failThrough; } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/event/EventManagerImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/event/EventManagerImpl.java index 80a50785f..879f91a68 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/event/EventManagerImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/event/EventManagerImpl.java @@ -28,22 +28,22 @@ import com.dfsek.terra.api.event.functional.FunctionalEventHandler; public class EventManagerImpl implements EventManager { private final Map, EventHandler> handlers = new HashMap<>(); - + public EventManagerImpl() { registerHandler(FunctionalEventHandler.class, new FunctionalEventHandlerImpl()); // default handler } - + @Override public T callEvent(T event) { handlers.values().forEach(handler -> handler.handle(event)); return event; } - + @Override public void registerHandler(Class clazz, T handler) { handlers.put(clazz, handler); } - + @SuppressWarnings("unchecked") @Override public T getHandler(Class clazz) { diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/event/FunctionalEventHandlerImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/event/FunctionalEventHandlerImpl.java index 3ba854a3e..67f984646 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/event/FunctionalEventHandlerImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/event/FunctionalEventHandlerImpl.java @@ -39,9 +39,9 @@ import com.dfsek.terra.api.util.reflection.TypeKey; public class FunctionalEventHandlerImpl implements FunctionalEventHandler { private static final Logger logger = LoggerFactory.getLogger(FunctionalEventHandlerImpl.class); - + private final Map>> contextMap = new HashMap<>(); - + @SuppressWarnings("unchecked") @Override public void handle(Event event) { @@ -59,25 +59,25 @@ public class FunctionalEventHandlerImpl implements FunctionalEventHandler { throw e; // Rethrow if it's fail-through. // else warn logger.warn("Exception occurred during event handling. Report this to the maintainers of {}@{}", - context.getAddon().getID(), context.getAddon().getVersion().getFormatted(), e); + context.getAddon().getID(), context.getAddon().getVersion().getFormatted(), e); } }); } - + @Override public EventContext register(BaseAddon addon, Class clazz) { EventContextImpl eventContext = new EventContextImpl<>(addon, clazz, this); contextMap.computeIfAbsent(clazz, c -> new ArrayList<>()).add(eventContext); return eventContext; } - + @Override public EventContext register(BaseAddon addon, TypeKey clazz) { EventContextImpl eventContext = new EventContextImpl<>(addon, clazz.getType(), this); contextMap.computeIfAbsent(clazz.getType(), c -> new ArrayList<>()).add(eventContext); return eventContext; } - + public void recomputePriorities(Type target) { contextMap.get(target).sort(Comparator.naturalOrder()); } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/profiler/Frame.java b/common/implementation/base/src/main/java/com/dfsek/terra/profiler/Frame.java index 0b4d2dae5..22141e63b 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/profiler/Frame.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/profiler/Frame.java @@ -20,21 +20,21 @@ package com.dfsek.terra.profiler; public class Frame { private final String id; private final long start; - + public Frame(String id) { this.id = id; this.start = System.nanoTime(); } - + @Override public String toString() { return id; } - + public String getId() { return id; } - + public long getStart() { return start; } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/profiler/ProfilerImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/profiler/ProfilerImpl.java index 7da799e68..4e419f883 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/profiler/ProfilerImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/profiler/ProfilerImpl.java @@ -34,7 +34,7 @@ import com.dfsek.terra.profiler.exception.MalformedStackException; public class ProfilerImpl implements Profiler { private static final Logger logger = LoggerFactory.getLogger(ProfilerImpl.class); - + private static final ThreadLocal> THREAD_STACK = ThreadLocal.withInitial(Stack::new); private static final ThreadLocal>> TIMINGS = ThreadLocal.withInitial(HashMap::new); private static final ThreadLocal SAFE = ThreadLocal.withInitial(() -> false); @@ -42,13 +42,13 @@ public class ProfilerImpl implements Profiler { private static boolean instantiated = false; private final List>> accessibleThreadMaps = new ArrayList<>(); private volatile boolean running = false; - + public ProfilerImpl() { if(instantiated) throw new IllegalStateException("Only one instance of Profiler may exist!"); instantiated = true; } - + @Override public void push(String frame) { if(running) { @@ -59,7 +59,7 @@ public class ProfilerImpl implements Profiler { } else SAFE.set(false); } else SAFE.set(false); } - + @Override public void pop(String frame) { if(running) { @@ -68,45 +68,45 @@ public class ProfilerImpl implements Profiler { if(SAFE.get()) { long time = System.nanoTime(); Stack stack = THREAD_STACK.get(); - + Map> timingsMap = TIMINGS.get(); - + if(timingsMap.isEmpty()) { synchronized(accessibleThreadMaps) { accessibleThreadMaps.add(timingsMap); } } - + Frame top = stack.pop(); if(!stack.isEmpty() ? !top.getId().endsWith("." + frame) : !top.getId().equals(frame)) throw new MalformedStackException("Expected " + frame + ", found " + top); - + List timings = timingsMap.computeIfAbsent(top.getId(), id -> new ArrayList<>()); - + timings.add(time - top.getStart()); } if(size.get() == 0) SAFE.set(true); } } - + @Override public void start() { logger.info("Starting Terra profiler"); running = true; } - + @Override public void stop() { logger.info("Stopping Terra profiler"); running = false; } - + @Override public void reset() { logger.info("Resetting Terra profiler"); accessibleThreadMaps.forEach(Map::clear); } - + @Override public Map getTimings() { Map map = new HashMap<>(); diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/profiler/exception/MalformedStackException.java b/common/implementation/base/src/main/java/com/dfsek/terra/profiler/exception/MalformedStackException.java index 3578d80e0..095b43c09 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/profiler/exception/MalformedStackException.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/profiler/exception/MalformedStackException.java @@ -23,15 +23,15 @@ import java.io.Serial; public class MalformedStackException extends ProfilerException { @Serial private static final long serialVersionUID = -3009539681021691054L; - + public MalformedStackException(String message) { super(message); } - + public MalformedStackException(String message, Throwable cause) { super(message, cause); } - + public MalformedStackException(Throwable cause) { super(cause); } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/profiler/exception/ProfilerException.java b/common/implementation/base/src/main/java/com/dfsek/terra/profiler/exception/ProfilerException.java index 8a839249f..798d319e9 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/profiler/exception/ProfilerException.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/profiler/exception/ProfilerException.java @@ -23,15 +23,15 @@ import java.io.Serial; public class ProfilerException extends RuntimeException { @Serial private static final long serialVersionUID = 8206737998791649002L; - + public ProfilerException(String message) { super(message); } - + public ProfilerException(String message, Throwable cause) { super(message, cause); } - + public ProfilerException(Throwable cause) { super(cause); } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/registry/CheckedRegistryImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/registry/CheckedRegistryImpl.java index 13e849675..52b22e634 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/registry/CheckedRegistryImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/registry/CheckedRegistryImpl.java @@ -45,61 +45,61 @@ import com.dfsek.terra.api.util.reflection.TypeKey; */ public class CheckedRegistryImpl implements CheckedRegistry { private final OpenRegistry registry; - + public CheckedRegistryImpl(OpenRegistry registry) { this.registry = registry; } - + @Internal public OpenRegistry getRegistry() { return registry; } - + @Override public void register(@NotNull RegistryKey identifier, @NotNull T value) throws DuplicateEntryException { registry.registerChecked(identifier, value); } - + @Override public Optional get(@NotNull RegistryKey key) { return registry.get(key); } - + @Override public boolean contains(@NotNull RegistryKey key) { return registry.contains(key); } - + @Override public void forEach(@NotNull Consumer consumer) { registry.forEach(consumer); } - + @Override public void forEach(@NotNull BiConsumer consumer) { registry.forEach(consumer); } - + @Override public @NotNull Collection entries() { return registry.entries(); } - + @Override public @NotNull Set keys() { return registry.keys(); } - + @Override public TypeKey getType() { return registry.getType(); } - + @Override public Map getMatches(String id) { return registry.getMatches(id); } - + @Override public T load(@NotNull AnnotatedType t, @NotNull Object c, @NotNull ConfigLoader loader, DepthTracker depthTracker) throws LoadException { diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/registry/LockedRegistryImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/registry/LockedRegistryImpl.java index 977979148..153f3792a 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/registry/LockedRegistryImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/registry/LockedRegistryImpl.java @@ -42,51 +42,51 @@ import com.dfsek.terra.api.util.reflection.TypeKey; */ public class LockedRegistryImpl implements Registry { private final Registry registry; - + public LockedRegistryImpl(Registry registry) { this.registry = registry; } - + @Override public Optional get(@NotNull RegistryKey key) { return registry.get(key); } - + @Override public boolean contains(@NotNull RegistryKey key) { return registry.contains(key); } - + @Override public void forEach(@NotNull Consumer consumer) { registry.forEach(consumer); } - + @Override public void forEach(@NotNull BiConsumer consumer) { registry.forEach(consumer); } - + @Override public @NotNull Collection entries() { return registry.entries(); } - + @Override public @NotNull Set keys() { return registry.keys(); } - + @Override public TypeKey getType() { return registry.getType(); } - + @Override public Map getMatches(String id) { return registry.getMatches(id); } - + @Override public T load(@NotNull AnnotatedType t, @NotNull Object c, @NotNull ConfigLoader loader, DepthTracker depthTracker) throws LoadException { diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/registry/OpenRegistryImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/registry/OpenRegistryImpl.java index d02ba1172..fe80bd15b 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/registry/OpenRegistryImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/registry/OpenRegistryImpl.java @@ -53,16 +53,16 @@ public class OpenRegistryImpl implements OpenRegistry { private final Map> objects; private final ListMultimap>> objectIDs = Multimaps.newListMultimap(new HashMap<>(), ArrayList::new); private final TypeKey typeKey; - + public OpenRegistryImpl(TypeKey typeKey) { this(new HashMap<>(), typeKey); } - + protected OpenRegistryImpl(Map> init, TypeKey typeKey) { this.objects = init; this.typeKey = typeKey; } - + @Override public T load(@NotNull AnnotatedType type, @NotNull Object o, @NotNull ConfigLoader configLoader, DepthTracker depthTracker) throws LoadException { @@ -70,88 +70,88 @@ public class OpenRegistryImpl implements OpenRegistry { "\" was found in this registry. Registry contains items: " + getItemsFormatted(), depthTracker)); } - + private String getItemsFormatted() { if(objects.isEmpty()) { return "[ ]"; } return objects - .keySet() - .stream() - .map(RegistryKey::toString) - .sorted() - .reduce("", (a, b) -> a + "\n - " + b); + .keySet() + .stream() + .map(RegistryKey::toString) + .sorted() + .reduce("", (a, b) -> a + "\n - " + b); } - + @Override public boolean register(@NotNull RegistryKey identifier, @NotNull T value) { return register(identifier, new Entry<>(value)); } - + @Override public void registerChecked(@NotNull RegistryKey identifier, @NotNull T value) throws DuplicateEntryException { if(objects.containsKey(identifier)) throw new DuplicateEntryException("Value with identifier \"" + identifier + "\" is already defined in registry."); register(identifier, value); } - + @Override public void clear() { objects.clear(); objectIDs.clear(); } - + private boolean register(RegistryKey identifier, Entry value) { boolean exists = objects.containsKey(identifier); objects.put(identifier, value); objectIDs.put(identifier.getID(), Pair.of(identifier, value)); return exists; } - + @SuppressWarnings("unchecked") @Override public Optional get(@NotNull RegistryKey key) { return Optional.ofNullable(objects.getOrDefault(key, (Entry) NULL).getValue()); } - + @Override public boolean contains(@NotNull RegistryKey key) { return objects.containsKey(key); } - + @Override public void forEach(@NotNull Consumer consumer) { objects.forEach((id, obj) -> consumer.accept(obj.getRaw())); } - + @Override public void forEach(@NotNull BiConsumer consumer) { objects.forEach((id, entry) -> consumer.accept(id, entry.getRaw())); } - + @Override public @NotNull Collection entries() { return objects.values().stream().map(Entry::getRaw).collect(Collectors.toList()); } - + @Override public @NotNull Set keys() { return objects.keySet(); } - + @Override public TypeKey getType() { return typeKey; } - + @Override public Map getMatches(String id) { return objectIDs - .get(id) - .stream() - .collect(HashMap::new, (map, pair) -> map.put(pair.getLeft(), pair.getRight().getValue()), Map::putAll); + .get(id) + .stream() + .collect(HashMap::new, (map, pair) -> map.put(pair.getLeft(), pair.getRight().getValue()), Map::putAll); } - + public Map getDeadEntries() { Map dead = new HashMap<>(); objects.forEach((id, entry) -> { @@ -159,25 +159,25 @@ public class OpenRegistryImpl implements OpenRegistry { }); return dead; } - - + + private static final class Entry { private final T value; private final AtomicInteger access = new AtomicInteger(0); - + public Entry(T value) { this.value = value; } - + public boolean dead() { return access.get() == 0; } - + public T getValue() { access.incrementAndGet(); return value; } - + private T getRaw() { return value; } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/registry/ShortcutHolder.java b/common/implementation/base/src/main/java/com/dfsek/terra/registry/ShortcutHolder.java index 5261ce76b..6678b053e 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/registry/ShortcutHolder.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/registry/ShortcutHolder.java @@ -4,36 +4,35 @@ import com.dfsek.tectonic.api.depth.DepthTracker; import com.dfsek.tectonic.api.exception.LoadException; import com.dfsek.tectonic.api.loader.ConfigLoader; import com.dfsek.tectonic.api.loader.type.TypeLoader; - -import com.dfsek.terra.api.registry.Registry; -import com.dfsek.terra.api.tectonic.ShortcutLoader; - import org.jetbrains.annotations.NotNull; import java.lang.reflect.AnnotatedType; import java.util.HashMap; import java.util.Map; +import com.dfsek.terra.api.registry.Registry; +import com.dfsek.terra.api.tectonic.ShortcutLoader; + public class ShortcutHolder implements TypeLoader { private final Map> shortcuts = new HashMap<>(); private final Registry back; - + public ShortcutHolder(Registry back) { this.back = back; } - + public ShortcutHolder register(String id, ShortcutLoader loader) { if(shortcuts.containsKey(id)) { throw new IllegalArgumentException( - "Attempted to register duplicate shortcut " + id + ", previously registered to " + shortcuts.get(id) - .getClass() - .getCanonicalName()); + "Attempted to register duplicate shortcut " + id + ", previously registered to " + shortcuts.get(id) + .getClass() + .getCanonicalName()); } shortcuts.put(id, loader); return this; } - + @Override public T load(@NotNull AnnotatedType annotatedType, @NotNull Object o, @NotNull ConfigLoader configLoader, DepthTracker depthTracker) throws LoadException { @@ -42,7 +41,7 @@ public class ShortcutHolder implements TypeLoader { String shortcut = id.substring(0, id.indexOf(":")); if(shortcuts.containsKey(shortcut)) { return shortcuts.get(shortcut).load(configLoader, id.substring(id.indexOf(":") + 1), - depthTracker.intrinsic("Using shortcut \"" + shortcut + "\"")); + depthTracker.intrinsic("Using shortcut \"" + shortcut + "\"")); } throw new LoadException("Shortcut \"" + shortcut + "\" is not defined.", depthTracker); } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/registry/master/ConfigRegistry.java b/common/implementation/base/src/main/java/com/dfsek/terra/registry/master/ConfigRegistry.java index b4ba6dc40..28886b354 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/registry/master/ConfigRegistry.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/registry/master/ConfigRegistry.java @@ -38,16 +38,16 @@ import com.dfsek.terra.registry.OpenRegistryImpl; */ public class ConfigRegistry extends OpenRegistryImpl { private static final Logger logger = LoggerFactory.getLogger(ConfigRegistry.class); - + public ConfigRegistry() { super(TypeKey.of(ConfigPack.class)); } - + public void load(File folder, Platform platform) throws ConfigException { ConfigPack pack = new ConfigPackImpl(folder, platform); registerChecked(pack.getRegistryKey(), pack); } - + public boolean loadAll(Platform platform) { boolean valid = true; File packsFolder = new File(platform.getDataFolder(), "packs"); @@ -61,7 +61,7 @@ public class ConfigRegistry extends OpenRegistryImpl { } } for(File zip : Objects.requireNonNull( - packsFolder.listFiles(file -> file.getName().endsWith(".zip") || file.getName().endsWith(".terra")))) { + packsFolder.listFiles(file -> file.getName().endsWith(".zip") || file.getName().endsWith(".terra")))) { try { logger.info("Loading ZIP archive: {}", zip.getName()); load(new ZipFile(zip), platform); @@ -72,7 +72,7 @@ public class ConfigRegistry extends OpenRegistryImpl { } return valid; } - + public void load(ZipFile file, Platform platform) throws ConfigException { ConfigPackImpl pack = new ConfigPackImpl(file, platform); registerChecked(pack.getRegistryKey(), pack); diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/transform/MapTransform.java b/common/implementation/base/src/main/java/com/dfsek/terra/transform/MapTransform.java index 7bc2ab6d9..8576a32ac 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/transform/MapTransform.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/transform/MapTransform.java @@ -26,25 +26,25 @@ import com.dfsek.terra.api.transform.exception.TransformException; public class MapTransform implements Transform { private final Map map; - + public MapTransform(Map map) { this.map = map; } - + public MapTransform() { this.map = new HashMap<>(); } - + public MapTransform add(F from, T to) { map.put(from, to); return this; } - + public MapTransform remove(F from) { map.remove(from); return this; } - + @Override public T transform(F input) throws TransformException { if(!map.containsKey(input)) throw new TransformException("No key matching " + input.toString() + " found in map."); diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/transform/TransformerImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/transform/TransformerImpl.java index 9875a5e65..4f736bba7 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/transform/TransformerImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/transform/TransformerImpl.java @@ -38,11 +38,11 @@ import com.dfsek.terra.api.transform.exception.TransformException; */ public class TransformerImpl implements Transformer { private final LinkedHashMap, List>> transformers; - + private TransformerImpl(LinkedHashMap, List>> transformer) { this.transformers = transformer; } - + @Override public T translate(F from) { List exceptions = new ArrayList<>(); @@ -61,7 +61,7 @@ public class TransformerImpl implements Transformer { } throw new AttemptsFailedException("Could not transform input; all attempts failed: " + from.toString() + "\n", exceptions); } - + /** * Builder pattern for building Transformers * @@ -70,14 +70,14 @@ public class TransformerImpl implements Transformer { */ public static final class Builder { private final LinkedHashMap, List>> transforms = new LinkedHashMap<>(); - + @SafeVarargs @SuppressWarnings("varargs") public final Builder addTransform(Transform transform, Validator... validators) { transforms.put(transform, Arrays.asList(validators)); return this; } - + public TransformerImpl build() { return new TransformerImpl<>(transforms); } diff --git a/common/implementation/base/src/test/java/MetaTest.java b/common/implementation/base/src/test/java/MetaTest.java index 81a90544b..92ad15de1 100644 --- a/common/implementation/base/src/test/java/MetaTest.java +++ b/common/implementation/base/src/test/java/MetaTest.java @@ -22,111 +22,111 @@ public class MetaTest { public void testMetaList() { Configuration meta = new YamlConfiguration(MetaTest.class.getResourceAsStream("/meta.yml"), "meta.yml"); Configuration metaTarget = new YamlConfiguration(MetaTest.class.getResourceAsStream("/metaTarget.yml"), "metaTarget.yml"); - + Map configurationMap = new HashMap<>(); - + configurationMap.put(meta.getName(), meta); configurationMap.put(metaTarget.getName(), metaTarget); - + ConfigLoader loader = new ConfigLoader(); loader.registerPreprocessor(Meta.class, new MetaStringPreprocessor(configurationMap)); loader.registerPreprocessor(Meta.class, new MetaListLikePreprocessor(configurationMap)); loader.registerPreprocessor(Meta.class, new MetaMapPreprocessor(configurationMap)); loader.registerPreprocessor(Meta.class, new MetaNumberPreprocessor(configurationMap)); - + loader.registerPreprocessor(Meta.class, new MetaValuePreprocessor(configurationMap)); - + loader.load(new MetaListConfig(), meta).list.forEach(System.out::println); } - + @Test public void testMetaMap() { Configuration meta = new YamlConfiguration(MetaTest.class.getResourceAsStream("/meta.yml"), "meta.yml"); Configuration metaTarget = new YamlConfiguration(MetaTest.class.getResourceAsStream("/metaTarget.yml"), "metaTarget.yml"); - + Map configurationMap = new HashMap<>(); - + configurationMap.put(meta.getName(), meta); configurationMap.put(metaTarget.getName(), metaTarget); - + ConfigLoader loader = new ConfigLoader(); loader.registerPreprocessor(Meta.class, new MetaStringPreprocessor(configurationMap)); loader.registerPreprocessor(Meta.class, new MetaListLikePreprocessor(configurationMap)); loader.registerPreprocessor(Meta.class, new MetaMapPreprocessor(configurationMap)); loader.registerPreprocessor(Meta.class, new MetaNumberPreprocessor(configurationMap)); - + loader.registerPreprocessor(Meta.class, new MetaValuePreprocessor(configurationMap)); - + loader.load(new MetaMapConfig(), meta).map.forEach((k, v) -> System.out.println(k + ": " + v)); } - + @Test public void testMetaString() { Configuration meta = new YamlConfiguration(MetaTest.class.getResourceAsStream("/meta.yml"), "meta.yml"); Configuration metaTarget = new YamlConfiguration(MetaTest.class.getResourceAsStream("/metaTarget.yml"), "metaTarget.yml"); - + Map configurationMap = new HashMap<>(); - + configurationMap.put(meta.getName(), meta); configurationMap.put(metaTarget.getName(), metaTarget); - + ConfigLoader loader = new ConfigLoader(); - + loader.registerPreprocessor(Meta.class, new MetaStringPreprocessor(configurationMap)); loader.registerPreprocessor(Meta.class, new MetaListLikePreprocessor(configurationMap)); loader.registerPreprocessor(Meta.class, new MetaMapPreprocessor(configurationMap)); loader.registerPreprocessor(Meta.class, new MetaNumberPreprocessor(configurationMap)); - + loader.registerPreprocessor(Meta.class, new MetaValuePreprocessor(configurationMap)); - + System.out.println(loader.load(new MetaStringConfig(), meta).string); } - + @Test public void testMetaNumber() { Configuration meta = new YamlConfiguration(MetaTest.class.getResourceAsStream("/meta.yml"), "meta.yml"); Configuration metaTarget = new YamlConfiguration(MetaTest.class.getResourceAsStream("/metaTarget.yml"), "metaTarget.yml"); - + Map configurationMap = new HashMap<>(); - + configurationMap.put(meta.getName(), meta); configurationMap.put(metaTarget.getName(), metaTarget); - + ConfigLoader loader = new ConfigLoader(); loader.registerPreprocessor(Meta.class, new MetaStringPreprocessor(configurationMap)); loader.registerPreprocessor(Meta.class, new MetaListLikePreprocessor(configurationMap)); loader.registerPreprocessor(Meta.class, new MetaMapPreprocessor(configurationMap)); loader.registerPreprocessor(Meta.class, new MetaNumberPreprocessor(configurationMap)); - + loader.registerPreprocessor(Meta.class, new MetaValuePreprocessor(configurationMap)); - + System.out.println("int: " + loader.load(new MetaNumberConfig(), meta).integer); System.out.println("double: " + loader.load(new MetaNumberConfig(), meta).aDouble); } - - + + private static final class MetaListConfig implements ConfigTemplate { @Value("list") private @Meta List<@Meta String> list; } - - + + private static final class MetaMapConfig implements ConfigTemplate { @Value("map") private @Meta Map<@Meta String, @Meta String> map; } - - + + private static final class MetaStringConfig implements ConfigTemplate { @Value("string") private @Meta String string; } - - + + private static final class MetaNumberConfig implements ConfigTemplate { @Value("int") private @Meta int integer; - + @Value("double") private @Meta double aDouble; } diff --git a/common/implementation/base/src/test/java/profiler/ProfilerTest.java b/common/implementation/base/src/test/java/profiler/ProfilerTest.java index 1986f4633..6c3ae486e 100644 --- a/common/implementation/base/src/test/java/profiler/ProfilerTest.java +++ b/common/implementation/base/src/test/java/profiler/ProfilerTest.java @@ -25,7 +25,7 @@ import com.dfsek.terra.profiler.ProfilerImpl; public class ProfilerTest { private static final Profiler PROFILER = new ProfilerImpl(); - + private static void doThing() throws InterruptedException { PROFILER.push("thing"); Thread.sleep(1); @@ -33,7 +33,7 @@ public class ProfilerTest { thing4(); PROFILER.pop("thing"); } - + private static void doOtherThing() throws InterruptedException { PROFILER.push("thing2"); Thread.sleep(2); @@ -41,30 +41,30 @@ public class ProfilerTest { thing4(); PROFILER.pop("thing2"); } - + private static void doThirdOtherThing() throws InterruptedException { PROFILER.push("thing3"); Thread.sleep(2); PROFILER.pop("thing3"); } - + private static void thing4() throws InterruptedException { PROFILER.push("thing4"); Thread.sleep(2); PROFILER.pop("thing4"); } - + @Test public void testProfiler() throws InterruptedException { //PROFILER.start(); for(int i = 0; i < 100; i++) { doThing(); } - + for(int i = 0; i < 100; i++) { doThirdOtherThing(); } - + for(int i = 0; i < 100; i++) { doOtherThing(); } @@ -76,7 +76,7 @@ public class ProfilerTest { PROFILER.pop("thing"); PROFILER.push("thing4"); PROFILER.pop("thing4"); - + PROFILER.getTimings().forEach((id, timings) -> System.out.println(id + ": " + timings.toString())); } } diff --git a/common/implementation/base/src/test/java/registry/RegistryTest.java b/common/implementation/base/src/test/java/registry/RegistryTest.java index b11e123b6..4ea1326fe 100644 --- a/common/implementation/base/src/test/java/registry/RegistryTest.java +++ b/common/implementation/base/src/test/java/registry/RegistryTest.java @@ -34,63 +34,63 @@ public class RegistryTest { @Test public void openRegistry() { OpenRegistry test = new OpenRegistryImpl<>(TypeKey.of(String.class)); - + test.register(RegistryKey.parse("test:test"), "bazinga"); - + assertEquals(test.get(RegistryKey.parse("test:test")).orElseThrow(), "bazinga"); } - + @Test public void openRegistryChecked() { OpenRegistry test = new OpenRegistryImpl<>(TypeKey.of(String.class)); - + test.registerChecked(RegistryKey.parse("test:test"), "bazinga"); - + try { test.registerChecked(RegistryKey.parse("test:test"), "bazinga2"); fail("Shouldn't be able to re-register with #registerChecked!"); } catch(DuplicateEntryException ignore) { - + } } - + @Test public void checkedRegistry() { CheckedRegistry test = new CheckedRegistryImpl<>(new OpenRegistryImpl<>(TypeKey.of(String.class))); - + test.register(RegistryKey.parse("test:test"), "bazinga"); - + assertEquals(test.get(RegistryKey.parse("test:test")).orElseThrow(), "bazinga"); - + try { test.register(RegistryKey.parse("test:test"), "bazinga2"); fail("Shouldn't be able to re-register in CheckedRegistry!"); } catch(DuplicateEntryException ignore) { - + } } - + @Test public void getID() { OpenRegistry test = new OpenRegistryImpl<>(TypeKey.of(String.class)); - + test.register(RegistryKey.parse("test:test"), "bazinga"); - + assertEquals(test.getByID("test").orElseThrow(), "bazinga"); } - + @Test public void getIDAmbiguous() { OpenRegistry test = new OpenRegistryImpl<>(TypeKey.of(String.class)); - + test.registerChecked(RegistryKey.parse("test:test"), "bazinga"); test.registerChecked(RegistryKey.parse("test2:test"), "bazinga"); - + try { test.getByID("test"); fail("Shouldn't be able to get with ambiguous ID!"); } catch(IllegalArgumentException ignore) { - + } } } diff --git a/common/implementation/bootstrap-addon-loader/src/main/java/com/dfsek/terra/addon/BootstrapAddonLoader.java b/common/implementation/bootstrap-addon-loader/src/main/java/com/dfsek/terra/addon/BootstrapAddonLoader.java index 874e8047c..98bdc8a4b 100644 --- a/common/implementation/bootstrap-addon-loader/src/main/java/com/dfsek/terra/addon/BootstrapAddonLoader.java +++ b/common/implementation/bootstrap-addon-loader/src/main/java/com/dfsek/terra/addon/BootstrapAddonLoader.java @@ -40,30 +40,30 @@ import com.dfsek.terra.api.addon.bootstrap.BootstrapBaseAddon; public class BootstrapAddonLoader implements BootstrapBaseAddon> { private static final Logger logger = LoggerFactory.getLogger(BootstrapAddonLoader.class); private static final Version VERSION = Versions.getVersion(1, 0, 0); - + public BootstrapAddonLoader() { } - + private BootstrapBaseAddon loadAddon(Path addonPath, BootstrapAddonClassLoader parent) { logger.debug("Loading bootstrap addon from JAR {}", addonPath); try(JarFile jar = new JarFile(addonPath.toFile())) { String entry = jar.getManifest().getMainAttributes().getValue("Terra-Bootstrap-Addon-Entry-Point"); - + if(entry == null) { throw new AddonLoadException("No Terra-Bootstrap-Addon-Entry-Point attribute defined in addon's MANIFEST.MF."); } - + //noinspection NestedTryStatement try { parent.addURL(addonPath.toUri().toURL()); Object addonObject = parent.loadClass(entry).getConstructor().newInstance(); - + if(!(addonObject instanceof BootstrapBaseAddon addon)) { throw new AddonLoadException( - addonObject.getClass() + " does not extend " + BootstrapBaseAddon.class); + addonObject.getClass() + " does not extend " + BootstrapBaseAddon.class); } - + logger.debug("Loaded bootstrap addon {}@{} with entry point {}", - addon.getID(), addon.getVersion().getFormatted(), addonObject.getClass()); + addon.getID(), addon.getVersion().getFormatted(), addonObject.getClass()); return addon; } catch(InvocationTargetException e) { throw new AddonLoadException("Exception occurred while instantiating addon", e); @@ -72,36 +72,36 @@ public class BootstrapAddonLoader implements BootstrapBaseAddon> loadAddons(Path addonsFolder, BootstrapAddonClassLoader parent) { try { Path bootstrapFolder = addonsFolder.resolve("bootstrap"); Files.createDirectories(bootstrapFolder); logger.debug("Loading bootstrap addons from {}", bootstrapFolder); - + try(Stream bootstrapAddons = Files.walk(bootstrapFolder, 1, FileVisitOption.FOLLOW_LINKS)) { return bootstrapAddons.filter(path -> path.toFile().isFile()) - .filter(path -> path.toFile().canRead()) - .filter(path -> path.toString().endsWith(".jar")) - .map(path -> loadAddon(path, parent)) - .collect(Collectors.toList()); + .filter(path -> path.toFile().canRead()) + .filter(path -> path.toString().endsWith(".jar")) + .map(path -> loadAddon(path, parent)) + .collect(Collectors.toList()); } } catch(IOException e) { throw new UncheckedIOException(e); } } - + @Override public String getID() { return "BOOTSTRAP"; } - + @Override public Version getVersion() { return VERSION; diff --git a/common/implementation/bootstrap-addon-loader/src/main/java/com/dfsek/terra/addon/exception/AddonLoadException.java b/common/implementation/bootstrap-addon-loader/src/main/java/com/dfsek/terra/addon/exception/AddonLoadException.java index 8f4eac420..f29c52261 100644 --- a/common/implementation/bootstrap-addon-loader/src/main/java/com/dfsek/terra/addon/exception/AddonLoadException.java +++ b/common/implementation/bootstrap-addon-loader/src/main/java/com/dfsek/terra/addon/exception/AddonLoadException.java @@ -23,11 +23,11 @@ import java.io.Serial; public class AddonLoadException extends RuntimeException { @Serial private static final long serialVersionUID = -4949084729296580176L; - + public AddonLoadException(String message) { super(message); } - + public AddonLoadException(String message, Throwable cause) { super(message, cause); } diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitAddon.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitAddon.java index 6c9dca4b2..c8a59100d 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitAddon.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitAddon.java @@ -14,37 +14,37 @@ import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; public class BukkitAddon implements BaseAddon { private static final Version VERSION = Versions.getVersion(1, 0, 0); - + private final PlatformImpl terraBukkitPlugin; - + public BukkitAddon(PlatformImpl terraBukkitPlugin) { this.terraBukkitPlugin = terraBukkitPlugin; } - + @Override public void initialize() { terraBukkitPlugin.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(this, ConfigPackPreLoadEvent.class) - .then(event -> event.getPack().getContext().put(event.loadTemplate(new PreLoadCompatibilityOptions()))) - .global(); - + .getHandler(FunctionalEventHandler.class) + .register(this, ConfigPackPreLoadEvent.class) + .then(event -> event.getPack().getContext().put(event.loadTemplate(new PreLoadCompatibilityOptions()))) + .global(); + terraBukkitPlugin.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(this, ConfigurationLoadEvent.class) - .then(event -> { - if(event.is(Biome.class)) { - event.getLoadedObject(Biome.class).getContext().put(event.load(new VanillaBiomeProperties())); - } - }) - .global(); + .getHandler(FunctionalEventHandler.class) + .register(this, ConfigurationLoadEvent.class) + .then(event -> { + if(event.is(Biome.class)) { + event.getLoadedObject(Biome.class).getContext().put(event.load(new VanillaBiomeProperties())); + } + }) + .global(); } - + @Override public Version getVersion() { return VERSION; } - + @Override public String getID() { return "terra-bukkit"; diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitCommandSender.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitCommandSender.java index af1627c93..3f7cfd696 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitCommandSender.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitCommandSender.java @@ -29,16 +29,16 @@ import com.dfsek.terra.bukkit.world.BukkitAdapter; public class BukkitCommandSender implements CommandSender { private final org.bukkit.command.CommandSender delegate; - + public BukkitCommandSender(org.bukkit.command.CommandSender delegate) { this.delegate = delegate; } - + @Override public void sendMessage(String message) { delegate.sendMessage(ChatColor.translateAlternateColorCodes('&', message)); } - + @Override public Optional getEntity() { if(delegate instanceof org.bukkit.entity.Entity entity) { @@ -46,7 +46,7 @@ public class BukkitCommandSender implements CommandSender { } return Optional.empty(); } - + @Override public Optional getPlayer() { if(delegate instanceof org.bukkit.entity.Player player) { @@ -54,7 +54,7 @@ public class BukkitCommandSender implements CommandSender { } return Optional.empty(); } - + @Override public org.bukkit.command.CommandSender getHandle() { return delegate; diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitEntity.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitEntity.java index aa404ff67..6df268180 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitEntity.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitEntity.java @@ -17,44 +17,44 @@ package com.dfsek.terra.bukkit; +import io.papermc.lib.PaperLib; +import org.bukkit.Location; + import com.dfsek.terra.api.entity.Entity; import com.dfsek.terra.api.util.vector.Vector3; import com.dfsek.terra.api.world.ServerWorld; import com.dfsek.terra.bukkit.world.BukkitAdapter; -import io.papermc.lib.PaperLib; -import org.bukkit.Location; - public class BukkitEntity implements Entity { private final org.bukkit.entity.Entity entity; - + public BukkitEntity(org.bukkit.entity.Entity entity) { this.entity = entity; } - + @Override public org.bukkit.entity.Entity getHandle() { return entity; } - + @Override public Vector3 position() { return BukkitAdapter.adapt(entity.getLocation().toVector()); } - + @Override public void position(Vector3 location) { PaperLib.teleportAsync(entity, BukkitAdapter.adapt(location).toLocation(entity.getWorld())); } - + @Override public void world(ServerWorld world) { Location newLoc = entity.getLocation().clone(); newLoc.setWorld(BukkitAdapter.adapt(world)); PaperLib.teleportAsync(entity, newLoc); } - + @Override public ServerWorld world() { return BukkitAdapter.adapt(entity.getWorld()); diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitPlayer.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitPlayer.java index c2958d44c..5bccd678b 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitPlayer.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitPlayer.java @@ -28,34 +28,34 @@ import com.dfsek.terra.bukkit.world.BukkitAdapter; public class BukkitPlayer implements Player { private final org.bukkit.entity.Player delegate; - + public BukkitPlayer(org.bukkit.entity.Player delegate) { this.delegate = delegate; } - + @Override public org.bukkit.entity.Player getHandle() { return delegate; } - + @Override public Vector3 position() { org.bukkit.Location bukkit = delegate.getLocation(); return Vector3.of(bukkit.getX(), bukkit.getY(), bukkit.getZ()); } - + @Override public void position(Vector3 location) { PaperLib.teleportAsync(delegate, BukkitAdapter.adapt(location).toLocation(delegate.getWorld())); } - + @Override public void world(ServerWorld world) { Location newLoc = delegate.getLocation().clone(); newLoc.setWorld(BukkitAdapter.adapt(world)); PaperLib.teleportAsync(delegate, newLoc); } - + @Override public ServerWorld world() { return BukkitAdapter.adapt(delegate.getWorld()); diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/PlatformImpl.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/PlatformImpl.java index ea09cd217..0ef6164d8 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/PlatformImpl.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/PlatformImpl.java @@ -44,28 +44,28 @@ import com.dfsek.terra.bukkit.world.BukkitPlatformBiome; public class PlatformImpl extends AbstractPlatform { private static final Logger LOGGER = LoggerFactory.getLogger(PlatformImpl.class); - + private final ItemHandle itemHandle = new BukkitItemHandle(); - + private final WorldHandle handle = new BukkitWorldHandle(); - + private final TerraBukkitPlugin plugin; - + public PlatformImpl(TerraBukkitPlugin plugin) { this.plugin = plugin; load(); } - + public TerraBukkitPlugin getPlugin() { return plugin; } - + @Override public boolean reload() { getTerraConfig().load(this); getRawConfigRegistry().clear(); boolean succeed = getRawConfigRegistry().loadAll(this); - + Bukkit.getWorlds().forEach(world -> { if(world.getGenerator() instanceof BukkitChunkGeneratorWrapper wrapper) { getConfigRegistry().get(wrapper.getPack().getRegistryKey()).ifPresent(pack -> { @@ -74,49 +74,49 @@ public class PlatformImpl extends AbstractPlatform { }); } }); - + return succeed; } - + @Override public @NotNull String platformName() { return "Bukkit"; } - + @Override public void runPossiblyUnsafeTask(@NotNull Runnable task) { plugin.getFoliaLib().getImpl().runAsync(task); } - + @Override protected Iterable platformAddon() { return List.of(new BukkitAddon(this)); } - + @Override public @NotNull WorldHandle getWorldHandle() { return handle; } - + @Override public @NotNull File getDataFolder() { return plugin.getDataFolder(); } - + @Override public @NotNull ItemHandle getItemHandle() { return itemHandle; } - + @Override public void register(TypeRegistry registry) { super.register(registry); registry.registerLoader(BlockState.class, (type, o, loader, depthTracker) -> handle.createBlockState((String) o)) - .registerLoader(PlatformBiome.class, (type, o, loader, depthTracker) -> parseBiome((String) o, depthTracker)) - .registerLoader(EntityType.class, (type, o, loader, depthTracker) -> EntityType.valueOf((String) o)); - + .registerLoader(PlatformBiome.class, (type, o, loader, depthTracker) -> parseBiome((String) o, depthTracker)) + .registerLoader(EntityType.class, (type, o, loader, depthTracker) -> EntityType.valueOf((String) o)); + } - + private BukkitPlatformBiome parseBiome(String id, DepthTracker depthTracker) throws LoadException { if(!id.startsWith("minecraft:")) throw new LoadException("Invalid biome identifier " + id, depthTracker); return new BukkitPlatformBiome(org.bukkit.block.Biome.valueOf(id.toUpperCase(Locale.ROOT).substring(10))); diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java index 2d3c2e0ee..dd910d48c 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java @@ -47,26 +47,26 @@ import com.dfsek.terra.bukkit.world.BukkitAdapter; public class TerraBukkitPlugin extends JavaPlugin { private static final Logger logger = LoggerFactory.getLogger(TerraBukkitPlugin.class); - + private final PlatformImpl platform = new PlatformImpl(this); private final Map generatorMap = new HashMap<>(); - + private final FoliaLib foliaLib = new FoliaLib(this); - + @Override public void onEnable() { if(!doVersionCheck()) { return; } - + platform.getEventManager().callEvent(new PlatformInitializationEvent()); - - + + try { PaperCommandManager commandManager = getCommandSenderPaperCommandManager(); - + platform.getEventManager().callEvent(new CommandRegistrationEvent(commandManager)); - + } catch(Exception e) { // This should never happen. logger.error(""" TERRA HAS BEEN DISABLED @@ -77,19 +77,19 @@ public class TerraBukkitPlugin extends JavaPlugin { Bukkit.getPluginManager().disablePlugin(this); return; } - + Bukkit.getPluginManager().registerEvents(new CommonListener(), this); // Register master event listener PaperUtil.checkPaper(this); - + Initializer.init(platform); } - + @NotNull private PaperCommandManager getCommandSenderPaperCommandManager() throws Exception { PaperCommandManager commandManager = new PaperCommandManager<>(this, - CommandExecutionCoordinator.simpleCoordinator(), - BukkitAdapter::adapt, - BukkitAdapter::adapt); + CommandExecutionCoordinator.simpleCoordinator(), + BukkitAdapter::adapt, + BukkitAdapter::adapt); if(commandManager.hasCapability(CloudBukkitCapabilities.NATIVE_BRIGADIER)) { commandManager.registerBrigadier(); final CloudBrigadierManager brigManager = commandManager.brigadierManager(); @@ -97,25 +97,25 @@ public class TerraBukkitPlugin extends JavaPlugin { brigManager.setNativeNumberSuggestions(false); } } - + if(commandManager.hasCapability(CloudBukkitCapabilities.ASYNCHRONOUS_COMPLETION)) { commandManager.registerAsynchronousCompletions(); } return commandManager; } - + public PlatformImpl getPlatform() { return platform; } - + @SuppressWarnings({ "deprecation", "AccessOfSystemProperties" }) private boolean doVersionCheck() { logger.info("Running on Minecraft version {} with server implementation {}.", VersionUtil.getMinecraftVersionInfo(), - Bukkit.getServer().getName()); - + Bukkit.getServer().getName()); + if(!VersionUtil.getSpigotVersionInfo().isSpigot()) logger.error("YOU ARE RUNNING A CRAFTBUKKIT OR BUKKIT SERVER. PLEASE UPGRADE TO PAPER."); - + if(VersionUtil.getSpigotVersionInfo().isMohist()) { if(System.getProperty("IKnowMohistCausesLotsOfIssuesButIWillUseItAnyways") == null) { Runnable runnable = () -> { // scary big block of text @@ -176,17 +176,17 @@ public class TerraBukkitPlugin extends JavaPlugin { } return true; } - + @Override public @Nullable ChunkGenerator getDefaultWorldGenerator(@NotNull String worldName, String id) { return new BukkitChunkGeneratorWrapper(generatorMap.computeIfAbsent(worldName, name -> { ConfigPack pack = platform.getConfigRegistry().getByID(id).orElseThrow( - () -> new IllegalArgumentException("No such config pack \"" + id + "\"")); + () -> new IllegalArgumentException("No such config pack \"" + id + "\"")); return pack.getGeneratorProvider().newInstance(pack); }), platform.getRawConfigRegistry().getByID(id).orElseThrow(), platform.getWorldHandle().air()); } - + public FoliaLib getFoliaLib() { return foliaLib; } diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/config/PreLoadCompatibilityOptions.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/config/PreLoadCompatibilityOptions.java index c9c4de3f4..7a48c05cc 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/config/PreLoadCompatibilityOptions.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/config/PreLoadCompatibilityOptions.java @@ -29,31 +29,31 @@ public class PreLoadCompatibilityOptions implements ConfigTemplate, Properties { @Value("minecraft.use-vanilla-biomes") @Default private boolean vanillaBiomes = false; - + @Value("minecraft.beard.enable") @Default private boolean beard = true; - + @Value("minecraft.beard.threshold") @Default private double beardThreshold = 0.5; - + @Value("minecraft.beard.air-threshold") @Default private double airThreshold = -0.5; - + public boolean useVanillaBiomes() { return vanillaBiomes; } - + public boolean isBeard() { return beard; } - + public double getBeardThreshold() { return beardThreshold; } - + public double getAirThreshold() { return airThreshold; } diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/config/VanillaBiomeProperties.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/config/VanillaBiomeProperties.java index 8b2d77e50..628f329d5 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/config/VanillaBiomeProperties.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/config/VanillaBiomeProperties.java @@ -11,47 +11,47 @@ public class VanillaBiomeProperties implements ConfigTemplate, Properties { @Value("colors.grass") @Default private Integer grassColor = null; - + @Value("colors.fog") @Default private Integer fogColor = null; - + @Value("colors.water") @Default private Integer waterColor = null; - + @Value("colors.water-fog") @Default private Integer waterFogColor = null; - + @Value("colors.foliage") @Default private Integer foliageColor = null; - + @Value("colors.sky") @Default private Integer skyColor = null; - + public Integer getFogColor() { return fogColor; } - + public Integer getFoliageColor() { return foliageColor; } - + public Integer getGrassColor() { return grassColor; } - + public Integer getWaterColor() { return waterColor; } - + public Integer getWaterFogColor() { return waterFogColor; } - + public Integer getSkyColor() { return skyColor; } diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitBiomeProvider.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitBiomeProvider.java index dfff71ccc..cb59ca8d5 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitBiomeProvider.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitBiomeProvider.java @@ -14,22 +14,22 @@ import com.dfsek.terra.api.world.biome.Biome; public class BukkitBiomeProvider extends BiomeProvider implements Handle { private final com.dfsek.terra.api.world.biome.generation.BiomeProvider delegate; - + public BukkitBiomeProvider(com.dfsek.terra.api.world.biome.generation.BiomeProvider delegate) { this.delegate = delegate; } - + @Override public @NotNull org.bukkit.block.Biome getBiome(@NotNull WorldInfo worldInfo, int x, int y, int z) { Biome biome = delegate.getBiome(x, y, z, worldInfo.getSeed()); return (org.bukkit.block.Biome) biome.getPlatformBiome().getHandle(); } - + @Override public @NotNull List getBiomes(@NotNull WorldInfo worldInfo) { return StreamSupport.stream(delegate.getBiomes().spliterator(), false) - .map(terraBiome -> (org.bukkit.block.Biome) terraBiome.getPlatformBiome().getHandle()) - .collect(Collectors.toList()); + .map(terraBiome -> (org.bukkit.block.Biome) terraBiome.getPlatformBiome().getHandle()) + .collect(Collectors.toList()); } - + @Override public Object getHandle() { return delegate; diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitBlockPopulator.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitBlockPopulator.java index 51dc63300..27f52de47 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitBlockPopulator.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitBlockPopulator.java @@ -15,20 +15,20 @@ import com.dfsek.terra.bukkit.world.BukkitProtoWorld; public class BukkitBlockPopulator extends BlockPopulator { private final BlockState air; private ConfigPack pack; - + public BukkitBlockPopulator(ConfigPack pack, BlockState air) { this.pack = pack; this.air = air; } - + public void setPack(ConfigPack pack) { this.pack = pack; } - + @Override public void populate(@NotNull WorldInfo worldInfo, @NotNull Random random, int chunkX, int chunkZ, @NotNull LimitedRegion limitedRegion) { pack.getStages().forEach( - generationStage -> generationStage.populate(new BukkitProtoWorld(limitedRegion, air, pack.getBiomeProvider()))); + generationStage -> generationStage.populate(new BukkitProtoWorld(limitedRegion, air, pack.getBiomeProvider()))); } } diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGeneratorWrapper.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGeneratorWrapper.java index 171b9e9eb..bd6796bad 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGeneratorWrapper.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGeneratorWrapper.java @@ -43,71 +43,71 @@ public class BukkitChunkGeneratorWrapper extends org.bukkit.generator.ChunkGener private final BukkitBlockPopulator blockPopulator; private ChunkGenerator delegate; private ConfigPack pack; - - + + public BukkitChunkGeneratorWrapper(ChunkGenerator delegate, ConfigPack pack, BlockState air) { this.delegate = delegate; this.pack = pack; this.air = air; this.blockPopulator = new BukkitBlockPopulator(pack, air); } - + public void setDelegate(ChunkGenerator delegate) { this.delegate = delegate; } - + @Override public @Nullable BiomeProvider getDefaultBiomeProvider(@NotNull WorldInfo worldInfo) { return new BukkitBiomeProvider(pack.getBiomeProvider()); } - + @Override public void generateNoise(@NotNull WorldInfo worldInfo, @NotNull Random random, int x, int z, @NotNull ChunkData chunkData) { BukkitWorldProperties properties = new BukkitWorldProperties(worldInfo); delegate.generateChunkData(new BukkitProtoChunk(chunkData), properties, pack.getBiomeProvider(), x, z); } - + @Override public @NotNull List getDefaultPopulators(@NotNull World world) { return List.of(blockPopulator); } - + @Override public boolean shouldGenerateCaves() { return false; //return pack.vanillaCaves(); } - + @Override public boolean shouldGenerateDecorations() { return true; } - + @Override public boolean shouldGenerateMobs() { return true; } - + @Override public boolean shouldGenerateStructures() { return true; } - + public ConfigPack getPack() { return pack; } - + public void setPack(ConfigPack pack) { this.pack = pack; setDelegate(pack.getGeneratorProvider().newInstance(pack)); } - + @Override public ChunkGenerator getHandle() { return delegate; } - - + + private record SeededVector(int x, int z, WorldProperties worldProperties) { @Override public boolean equals(Object obj) { @@ -116,7 +116,7 @@ public class BukkitChunkGeneratorWrapper extends org.bukkit.generator.ChunkGener } return false; } - + @Override public int hashCode() { int code = x; diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitProtoChunk.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitProtoChunk.java index 666d0ab52..e723ddbc3 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitProtoChunk.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/generator/BukkitProtoChunk.java @@ -26,30 +26,30 @@ import com.dfsek.terra.bukkit.world.block.data.BukkitBlockState; public class BukkitProtoChunk implements ProtoChunk { - + private final ChunkGenerator.ChunkData delegate; - + public BukkitProtoChunk(ChunkGenerator.ChunkData delegate) { this.delegate = delegate; } - + @Override public ChunkGenerator.ChunkData getHandle() { return delegate; } - + @Override public int getMaxHeight() { return delegate.getMaxHeight(); } - - + + @Override public void setBlock(int x, int y, int z, @NotNull BlockState blockState) { delegate.setBlock(x, y, z, ((BukkitBlockState) blockState).getHandle()); } - - + + @Override public @NotNull BlockState getBlock(int x, int y, int z) { return BukkitBlockState.newInstance(delegate.getBlockData(x, y, z)); diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/handles/BukkitItemHandle.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/handles/BukkitItemHandle.java index b4e7bc18c..35b99a0fc 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/handles/BukkitItemHandle.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/handles/BukkitItemHandle.java @@ -32,18 +32,18 @@ import com.dfsek.terra.bukkit.world.BukkitAdapter; public class BukkitItemHandle implements ItemHandle { - + @Override public Item createItem(String data) { return BukkitAdapter.adapt(Material.matchMaterial(data)); } - + @Override public Enchantment getEnchantment(String id) { return BukkitAdapter.adapt( - org.bukkit.enchantments.Enchantment.getByKey(NamespacedKey.minecraft(MinecraftUtils.stripMinecraftNamespace(id)))); + org.bukkit.enchantments.Enchantment.getByKey(NamespacedKey.minecraft(MinecraftUtils.stripMinecraftNamespace(id)))); } - + @Override public Set getEnchantments() { return Arrays.stream(org.bukkit.enchantments.Enchantment.values()).map(BukkitAdapter::adapt).collect(Collectors.toSet()); diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/handles/BukkitWorldHandle.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/handles/BukkitWorldHandle.java index e292fb0f2..d28798518 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/handles/BukkitWorldHandle.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/handles/BukkitWorldHandle.java @@ -32,32 +32,32 @@ import com.dfsek.terra.bukkit.world.entity.BukkitEntityType; public class BukkitWorldHandle implements WorldHandle { private final BlockState air; - + public BukkitWorldHandle() { this.air = BukkitBlockState.newInstance(Material.AIR.createBlockData()); } - + @Override public synchronized @NotNull BlockState createBlockState(@NotNull String data) { org.bukkit.block.data.BlockData bukkitData = Bukkit.createBlockData( - data); // somehow bukkit managed to make this not thread safe! :) + data); // somehow bukkit managed to make this not thread safe! :) return BukkitBlockState.newInstance(bukkitData); } - + @Override public @NotNull BlockState air() { return air; } - + @Override public @NotNull EntityType getEntity(@NotNull String id) { if(!id.startsWith("minecraft:")) throw new IllegalArgumentException("Invalid entity identifier " + id); String entityID = id.toUpperCase(Locale.ROOT).substring(10); - + return new BukkitEntityType(switch(entityID) { case "END_CRYSTAL" -> org.bukkit.entity.EntityType.ENDER_CRYSTAL; case "ENDER_CRYSTAL" -> throw new IllegalArgumentException( - "Invalid entity identifier " + id); // make sure this issue can't happen the other way around. + "Invalid entity identifier " + id); // make sure this issue can't happen the other way around. default -> org.bukkit.entity.EntityType.valueOf(entityID); }); } diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/listeners/SpigotListener.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/listeners/SpigotListener.java index 796053e82..a72379959 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/listeners/SpigotListener.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/listeners/SpigotListener.java @@ -39,11 +39,11 @@ import com.dfsek.terra.api.Platform; public class SpigotListener implements Listener { private static final Logger logger = LoggerFactory.getLogger(SpigotListener.class); private final Platform platform; - + public SpigotListener(Platform platform) { this.platform = platform; } - + @EventHandler(priority = EventPriority.NORMAL) public void onEnderEye(EntitySpawnEvent e) { /* @@ -68,7 +68,7 @@ public class SpigotListener implements Listener { } */ } - + @EventHandler public void onCartographerChange(VillagerAcquireTradeEvent e) { if(!(e.getEntity() instanceof Villager)) @@ -85,7 +85,7 @@ public class SpigotListener implements Listener { e.setCancelled(true); // Cancel leveling if the villager is a Cartographer, to prevent crashing server. } } - + @EventHandler public void onCartographerLevel(VillagerCareerChangeEvent e) { if(e.getProfession() == Villager.Profession.CARTOGRAPHER) { diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/nms/Initializer.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/nms/Initializer.java index 2c8f1c211..d2ae2f04b 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/nms/Initializer.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/nms/Initializer.java @@ -10,7 +10,7 @@ import com.dfsek.terra.bukkit.PlatformImpl; public interface Initializer { String NMS = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3]; String TERRA_PACKAGE = Initializer.class.getPackageName(); - + static void init(PlatformImpl platform) { Logger logger = LoggerFactory.getLogger(Initializer.class); try { @@ -35,6 +35,6 @@ public interface Initializer { logger.error("This is usually due to running Terra on an unsupported Minecraft version."); } } - + void initialize(PlatformImpl plugin); } diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/VersionUtil.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/VersionUtil.java index 469582bf2..6bc06a437 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/VersionUtil.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/util/VersionUtil.java @@ -12,12 +12,12 @@ import java.util.regex.Pattern; public final class VersionUtil { public static final SpigotVersionInfo SPIGOT_VERSION_INFO; public static final MinecraftVersionInfo MINECRAFT_VERSION_INFO; - + private static final Logger logger = LoggerFactory.getLogger(VersionUtil.class); - + static { SPIGOT_VERSION_INFO = new SpigotVersionInfo(); - + MinecraftVersionInfo mcVersionInfo; try { mcVersionInfo = new MinecraftVersionInfo(); @@ -27,28 +27,28 @@ public final class VersionUtil { } MINECRAFT_VERSION_INFO = mcVersionInfo; } - + public static MinecraftVersionInfo getMinecraftVersionInfo() { return MINECRAFT_VERSION_INFO; } - + public static SpigotVersionInfo getSpigotVersionInfo() { return SPIGOT_VERSION_INFO; } - + public static final class SpigotVersionInfo { private final boolean spigot; private final boolean paper; private final boolean mohist; - - + + public SpigotVersionInfo() { logger.debug("Parsing spigot version info..."); - + paper = PaperLib.isPaper(); spigot = PaperLib.isSpigot(); - - + + boolean isMohist = false; try { Class.forName("com.mohistmc.MohistMC"); @@ -56,42 +56,42 @@ public final class VersionUtil { isMohist = true; } catch(ClassNotFoundException ignore) { } this.mohist = isMohist; - + logger.debug("Spigot version info parsed successfully."); } - + public boolean isPaper() { return paper; } - + public boolean isMohist() { return mohist; } - + public boolean isSpigot() { return spigot; } } - - + + public static final class MinecraftVersionInfo { private static final Logger logger = LoggerFactory.getLogger(MinecraftVersionInfo.class); - + private static final Pattern VERSION_PATTERN = Pattern.compile("v?(\\d+)_(\\d+)_R(\\d+)"); private final int major; private final int minor; private final int patch; - + private MinecraftVersionInfo() { this(Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3]); } - + private MinecraftVersionInfo(int major, int minor, int patch) { this.major = major; this.minor = minor; this.patch = patch; } - + private MinecraftVersionInfo(String versionString) { Matcher versionMatcher = VERSION_PATTERN.matcher(versionString); if(versionMatcher.find()) { @@ -100,29 +100,29 @@ public final class VersionUtil { patch = Integer.parseInt(versionMatcher.group(3)); } else { logger.warn("Error while parsing minecraft version info. Continuing launch, but setting all versions to -1."); - + major = -1; minor = -1; patch = -1; } } - + @Override public String toString() { if(major == -1 && minor == -1 && patch == -1) return "Unknown"; - + return String.format("v%d.%d.%d", major, minor, patch); } - + public int getMajor() { return major; } - + public int getMinor() { return minor; } - + public int getPatch() { return patch; } diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitAdapter.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitAdapter.java index e517129f2..f2d446de7 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitAdapter.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitAdapter.java @@ -55,26 +55,26 @@ import com.dfsek.terra.transform.TransformerImpl; */ public final class BukkitAdapter { public static TransformerImpl TREE_TRANSFORMER = new TransformerImpl.Builder() - .addTransform(new MapTransform() - .add(TreeType.COCOA_TREE, "JUNGLE_COCOA") - .add(TreeType.BIG_TREE, "LARGE_OAK") - .add(TreeType.TALL_REDWOOD, "LARGE_SPRUCE") - .add(TreeType.REDWOOD, "SPRUCE") - .add(TreeType.TREE, "OAK") - .add(TreeType.MEGA_REDWOOD, "MEGA_SPRUCE") - .add(TreeType.SWAMP, "SWAMP_OAK")) - .addTransform(TreeType::toString) - .build(); - - + .addTransform(new MapTransform() + .add(TreeType.COCOA_TREE, "JUNGLE_COCOA") + .add(TreeType.BIG_TREE, "LARGE_OAK") + .add(TreeType.TALL_REDWOOD, "LARGE_SPRUCE") + .add(TreeType.REDWOOD, "SPRUCE") + .add(TreeType.TREE, "OAK") + .add(TreeType.MEGA_REDWOOD, "MEGA_SPRUCE") + .add(TreeType.SWAMP, "SWAMP_OAK")) + .addTransform(TreeType::toString) + .build(); + + public static BlockState adapt(org.bukkit.block.data.BlockData data) { return BukkitBlockState.newInstance(data); } - + public static org.bukkit.block.data.BlockData adapt(BlockState data) { return ((BukkitBlockState) data).getHandle(); } - + public static Axis adapt(org.bukkit.Axis axis) { return switch(axis) { case X -> Axis.X; @@ -82,22 +82,22 @@ public final class BukkitAdapter { case Z -> Axis.Z; }; } - + public static WorldProperties adapt(WorldInfo worldInfo) { return new BukkitWorldProperties(worldInfo); } - + public static WorldInfo adapt(WorldProperties properties) { return (WorldInfo) properties.getHandle(); } - + public static Half adapt(org.bukkit.block.data.Bisected.Half half) { return switch(half) { case BOTTOM -> Half.BOTTOM; case TOP -> Half.TOP; }; } - + public static RedstoneConnection adapt(org.bukkit.block.data.type.RedstoneWire.Connection connection) { return switch(connection) { case NONE -> RedstoneConnection.NONE; @@ -105,7 +105,7 @@ public final class BukkitAdapter { case SIDE -> RedstoneConnection.SIDE; }; } - + public static org.bukkit.block.data.type.RedstoneWire.Connection adapt(RedstoneConnection connection) { return switch(connection) { case SIDE -> org.bukkit.block.data.type.RedstoneWire.Connection.SIDE; @@ -113,7 +113,7 @@ public final class BukkitAdapter { case NONE -> org.bukkit.block.data.type.RedstoneWire.Connection.NONE; }; } - + public static RailShape adapt(org.bukkit.block.data.Rail.Shape shape) { return switch(shape) { case SOUTH_WEST -> RailShape.SOUTH_WEST; @@ -128,7 +128,7 @@ public final class BukkitAdapter { case EAST_WEST -> RailShape.EAST_WEST; }; } - + public static org.bukkit.block.data.Rail.Shape adapt(RailShape shape) { return switch(shape) { case EAST_WEST -> org.bukkit.block.data.Rail.Shape.EAST_WEST; @@ -143,8 +143,8 @@ public final class BukkitAdapter { case SOUTH_WEST -> org.bukkit.block.data.Rail.Shape.SOUTH_WEST; }; } - - + + public static org.bukkit.block.data.Bisected.Half adapt(Half half) { return switch(half) { case TOP -> org.bukkit.block.data.Bisected.Half.TOP; @@ -152,7 +152,7 @@ public final class BukkitAdapter { default -> throw new IllegalStateException(); }; } - + public static org.bukkit.Axis adapt(Axis axis) { return switch(axis) { case Z -> org.bukkit.Axis.Z; @@ -160,75 +160,75 @@ public final class BukkitAdapter { case X -> org.bukkit.Axis.X; }; } - + public static Vector3 adapt(Location location) { return Vector3.of(location.getX(), location.getY(), location.getZ()); } - + public static Vector adapt(Vector3 vector3) { return new Vector(vector3.getX(), vector3.getY(), vector3.getZ()); } - + public static Vector3 adapt(Vector vector) { return Vector3.of(vector.getX(), vector.getY(), vector.getZ()); } - + public static CommandSender adapt(org.bukkit.command.CommandSender sender) { return new BukkitCommandSender(sender); } - + public static Entity adapt(org.bukkit.entity.Entity entity) { return new BukkitEntity(entity); } - + public static org.bukkit.command.CommandSender adapt(CommandSender sender) { return ((BukkitCommandSender) sender).getHandle(); } - + public static ServerWorld adapt(org.bukkit.World world) { return new BukkitServerWorld(world); } - + public static org.bukkit.World adapt(ServerWorld world) { return (org.bukkit.World) world.getHandle(); } - + public static Chunk adapt(org.bukkit.Chunk chunk) { return new BukkitChunk(chunk); } - + public static org.bukkit.Chunk adapt(Chunk chunk) { return (org.bukkit.Chunk) chunk.getHandle(); } - + public static Enchantment adapt(org.bukkit.enchantments.Enchantment enchantment) { return new BukkitEnchantment(enchantment); } - + public static org.bukkit.enchantments.Enchantment adapt(Enchantment enchantment) { return ((BukkitEnchantment) enchantment).getHandle(); } - + public static Player adapt(com.dfsek.terra.api.entity.Player player) { return ((BukkitPlayer) player).getHandle(); } - + public static com.dfsek.terra.api.entity.Player adapt(Player player) { return new BukkitPlayer(player); } - + public static BukkitBlockTypeAndItem adapt(Material material) { return new BukkitBlockTypeAndItem(material); } - + public static Material adapt(BlockType type) { return ((BukkitBlockTypeAndItem) type).getHandle(); } - + public static ItemStack adapt(org.bukkit.inventory.ItemStack in) { return new BukkitItemStack(in); } - + public static org.bukkit.inventory.ItemStack adapt(ItemStack in) { return ((BukkitItemStack) in).getHandle(); } diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitChunk.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitChunk.java index a7ce8c62b..a8f43d5d2 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitChunk.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitChunk.java @@ -26,41 +26,41 @@ import com.dfsek.terra.api.world.chunk.Chunk; public class BukkitChunk implements Chunk { private final org.bukkit.Chunk delegate; - + public BukkitChunk(org.bukkit.Chunk delegate) { this.delegate = delegate; } - + @Override public org.bukkit.Chunk getHandle() { return delegate; } - + @Override public void setBlock(int x, int y, int z, BlockState data, boolean physics) { delegate.getBlock(x, y, z).setBlockData(BukkitAdapter.adapt(data), physics); } - + @Override public void setBlock(int x, int y, int z, @NotNull BlockState blockState) { delegate.getBlock(x, y, z).setBlockData(BukkitAdapter.adapt(blockState)); } - + @Override public @NotNull BlockState getBlock(int x, int y, int z) { return BukkitAdapter.adapt(delegate.getBlock(x, y, z).getBlockData()); } - + @Override public int getX() { return delegate.getX(); } - + @Override public int getZ() { return delegate.getZ(); } - + @Override public ServerWorld getWorld() { return BukkitAdapter.adapt(delegate.getWorld()); diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitPlatformBiome.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitPlatformBiome.java index aff5773fa..9af8e9db5 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitPlatformBiome.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitPlatformBiome.java @@ -25,16 +25,16 @@ import com.dfsek.terra.api.world.biome.PlatformBiome; public class BukkitPlatformBiome implements PlatformBiome, PropertyHolder { private final org.bukkit.block.Biome biome; private final Context context = new Context(); - + public BukkitPlatformBiome(org.bukkit.block.Biome biome) { this.biome = biome; } - + @Override public org.bukkit.block.Biome getHandle() { return biome; } - + @Override public Context getContext() { return context; diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java index dfe81ca06..3de237bb3 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitProtoWorld.java @@ -32,20 +32,20 @@ public class BukkitProtoWorld implements ProtoWorld { private static final AtomicBoolean warn = new AtomicBoolean(true); private final LimitedRegion delegate; private final BlockState air; - + private final BiomeProvider biomeProvider; - + public BukkitProtoWorld(LimitedRegion delegate, BlockState air, BiomeProvider provider) { this.delegate = delegate; this.air = air; this.biomeProvider = provider; } - + @Override public LimitedRegion getHandle() { return delegate; } - + @Override public void setBlockState(int x, int y, int z, BlockState data, boolean physics) { access(x, y, z, () -> { @@ -60,91 +60,91 @@ public class BukkitProtoWorld implements ProtoWorld { } }); } - + @Override public long getSeed() { return delegate.getWorld().getSeed(); } - + @Override public int getMaxHeight() { return delegate.getWorld().getMaxHeight(); } - + @Override public BlockState getBlockState(int x, int y, int z) { return access(x, y, z, () -> BukkitBlockState.newInstance(delegate.getBlockData(x, y, z))).orElse(air); } - + @Override public BlockEntity getBlockEntity(int x, int y, int z) { return access(x, y, z, () -> BukkitBlockEntity.newInstance(delegate.getBlockState(x, y, z))).orElse(null); } - + @Override public int getMinHeight() { return delegate.getWorld().getMinHeight(); } - + @Override public Entity spawnEntity(double x, double y, double z, EntityType entityType) { return access((int) x, (int) y, (int) z, () -> new BukkitEntity( - delegate.spawnEntity(new Location(delegate.getWorld(), x, y, z), ((BukkitEntityType) entityType).getHandle()))).orElse( - null); + delegate.spawnEntity(new Location(delegate.getWorld(), x, y, z), ((BukkitEntityType) entityType).getHandle()))).orElse( + null); } - + @Override public ChunkGenerator getGenerator() { return ((BukkitChunkGeneratorWrapper) delegate.getWorld().getGenerator()).getHandle(); } - + @Override public BiomeProvider getBiomeProvider() { return biomeProvider; } - + @Override public ConfigPack getPack() { return ((BukkitChunkGeneratorWrapper) delegate.getWorld().getGenerator()).getPack(); } - + @Override public int centerChunkX() { return delegate.getCenterChunkX(); } - + @Override public int centerChunkZ() { return delegate.getCenterChunkZ(); } - + @Override public ServerWorld getWorld() { return new BukkitServerWorld(delegate.getWorld()); } - + private Optional access(int x, int y, int z, Supplier action) { if(delegate.isInRegion(x, y, z)) { return Optional.of(action.get()); } else if(warn.getAndSet(false)) { LOGGER.warn("Detected world access at coordinates out of bounds: ({}, {}, {}) accessed for region [{}, {}]", x, y, z, - delegate.getCenterChunkX(), delegate.getCenterChunkZ()); + delegate.getCenterChunkX(), delegate.getCenterChunkZ()); } else { LOGGER.debug("Detected world access at coordinates out of bounds: ({}, {}, {}) accessed for region [{}, {}]", x, y, z, - delegate.getCenterChunkX(), delegate.getCenterChunkZ()); + delegate.getCenterChunkX(), delegate.getCenterChunkZ()); } return Optional.empty(); } - + private void access(int x, int y, int z, Runnable action) { if(delegate.isInRegion(x, y, z)) { action.run(); } else if(warn.getAndSet(false)) { LOGGER.warn("Detected world access at coordinates out of bounds: ({}, {}, {}) accessed for region [{}, {}]", x, y, z, - delegate.getCenterChunkX(), delegate.getCenterChunkZ()); + delegate.getCenterChunkX(), delegate.getCenterChunkZ()); } else { LOGGER.debug("Detected world access at coordinates out of bounds: ({}, {}, {}) accessed for region [{}, {}]", x, y, z, - delegate.getCenterChunkX(), delegate.getCenterChunkZ()); + delegate.getCenterChunkX(), delegate.getCenterChunkZ()); } } } diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitServerWorld.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitServerWorld.java index b7923ee26..9ddf8ae87 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitServerWorld.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitServerWorld.java @@ -36,83 +36,83 @@ import com.dfsek.terra.bukkit.world.entity.BukkitEntityType; public class BukkitServerWorld implements ServerWorld { private final org.bukkit.World delegate; - + public BukkitServerWorld(org.bukkit.World delegate) { this.delegate = delegate; } - + @Override public Entity spawnEntity(double x, double y, double z, EntityType entityType) { return new BukkitEntity( - delegate.spawnEntity(new Location(delegate, x, y, z), ((BukkitEntityType) entityType).getHandle())); + delegate.spawnEntity(new Location(delegate, x, y, z), ((BukkitEntityType) entityType).getHandle())); } - + @Override public void setBlockState(int x, int y, int z, BlockState data, boolean physics) { delegate.getBlockAt(x, y, z).setBlockData(BukkitAdapter.adapt(data), physics); } - + @Override public long getSeed() { return delegate.getSeed(); } - + @Override public int getMaxHeight() { return delegate.getMaxHeight(); } - + @Override public Chunk getChunkAt(int x, int z) { return BukkitAdapter.adapt(delegate.getChunkAt(x, z)); } - + @Override public BlockState getBlockState(int x, int y, int z) { return BukkitAdapter.adapt(delegate.getBlockAt(x, y, z).getBlockData()); } - + @Override public BlockEntity getBlockEntity(int x, int y, int z) { return BukkitBlockEntity.newInstance(delegate.getBlockAt(x, y, z).getState()); } - + @Override public int getMinHeight() { return delegate.getMinHeight(); } - + @Override public ChunkGenerator getGenerator() { return ((BukkitChunkGeneratorWrapper) delegate.getGenerator()).getHandle(); } - + @Override public BiomeProvider getBiomeProvider() { return ((BukkitChunkGeneratorWrapper) delegate.getGenerator()).getPack().getBiomeProvider(); } - + @Override public ConfigPack getPack() { return ((BukkitChunkGeneratorWrapper) delegate.getGenerator()).getPack(); } - + @Override public org.bukkit.World getHandle() { return delegate; } - + @Override public int hashCode() { return delegate.hashCode(); } - + @Override public boolean equals(Object obj) { if(!(obj instanceof BukkitServerWorld other)) return false; return other.getHandle().equals(delegate); } - + @Override public String toString() { return delegate.toString(); diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitWorldProperties.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitWorldProperties.java index 7bd4106c6..f9763df90 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitWorldProperties.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitWorldProperties.java @@ -7,36 +7,36 @@ import com.dfsek.terra.api.world.info.WorldProperties; public class BukkitWorldProperties implements WorldProperties { private final WorldInfo delegate; - + public BukkitWorldProperties(WorldInfo delegate) { this.delegate = delegate; } - + @Override public Object getHandle() { return delegate; } - + @Override public long getSeed() { return delegate.getSeed(); } - + @Override public int getMaxHeight() { return delegate.getMaxHeight(); } - + @Override public int getMinHeight() { return delegate.getMinHeight(); } - + @Override public int hashCode() { return delegate.hashCode(); } - + @Override public boolean equals(Object obj) { if(obj instanceof WorldProperties that) { diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/BukkitBlockTypeAndItem.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/BukkitBlockTypeAndItem.java index 8c03645b0..6d442343b 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/BukkitBlockTypeAndItem.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/BukkitBlockTypeAndItem.java @@ -28,46 +28,46 @@ import com.dfsek.terra.bukkit.world.BukkitAdapter; public class BukkitBlockTypeAndItem implements BlockType, Item { private final Material delegate; - + public BukkitBlockTypeAndItem(Material delegate) { this.delegate = delegate; } - + @Override public Material getHandle() { return delegate; } - + @Override public BlockState getDefaultState() { return BukkitAdapter.adapt(delegate.createBlockData()); } - + @Override public boolean isSolid() { return delegate.isOccluding(); } - + @Override public boolean isWater() { return delegate == Material.WATER; } - + @Override public ItemStack newItemStack(int amount) { return BukkitAdapter.adapt(new org.bukkit.inventory.ItemStack(delegate, amount)); } - + @Override public double getMaxDurability() { return delegate.getMaxDurability(); } - + @Override public int hashCode() { return delegate.hashCode(); } - + @Override public boolean equals(Object obj) { if(!(obj instanceof BukkitBlockTypeAndItem)) return false; diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitBlockState.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitBlockState.java index 4a6716826..492f53193 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitBlockState.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitBlockState.java @@ -25,51 +25,51 @@ import com.dfsek.terra.bukkit.world.BukkitAdapter; public class BukkitBlockState implements BlockState { private final org.bukkit.block.data.BlockData delegate; - + protected BukkitBlockState(org.bukkit.block.data.BlockData delegate) { this.delegate = delegate; } - + public static BlockState newInstance(org.bukkit.block.data.BlockData bukkitData) { return new BukkitBlockState(bukkitData); } - - + + @Override public org.bukkit.block.data.BlockData getHandle() { return delegate; } - + @Override public boolean matches(BlockState data) { return delegate.getMaterial() == ((BukkitBlockState) data).getHandle().getMaterial(); } - + @Override public > boolean has(Property property) { return false; } - + @Override public > T get(Property property) { return null; } - + @Override public > BlockState set(Property property, T value) { return null; } - + @Override public BlockType getBlockType() { return BukkitAdapter.adapt(delegate.getMaterial()); } - + @Override public String getAsString(boolean properties) { return delegate.getAsString(!properties); } - + @Override public boolean isAir() { return delegate.getMaterial().isAir(); diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitBlockEntity.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitBlockEntity.java index 57bb052e2..0b0f0410c 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitBlockEntity.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitBlockEntity.java @@ -30,48 +30,48 @@ import com.dfsek.terra.bukkit.world.block.data.BukkitBlockState; public class BukkitBlockEntity implements BlockEntity { private final org.bukkit.block.BlockState delegate; - + protected BukkitBlockEntity(org.bukkit.block.BlockState block) { this.delegate = block; } - + public static BukkitBlockEntity newInstance(org.bukkit.block.BlockState block) { if(block instanceof Container) return new BukkitContainer((Container) block); if(block instanceof Sign) return new BukkitSign((Sign) block); if(block instanceof CreatureSpawner) return new BukkitMobSpawner((CreatureSpawner) block); return new BukkitBlockEntity(block); } - + @Override public org.bukkit.block.BlockState getHandle() { return delegate; } - + @Override public boolean update(boolean applyPhysics) { return delegate.update(true, applyPhysics); } - + @Override public Vector3 getPosition() { return BukkitAdapter.adapt(delegate.getBlock().getLocation().toVector()); } - + @Override public int getX() { return delegate.getX(); } - + @Override public int getY() { return delegate.getY(); } - + @Override public int getZ() { return delegate.getZ(); } - + @Override public BlockState getBlockState() { return BukkitBlockState.newInstance(delegate.getBlockData()); diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitContainer.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitContainer.java index ecde57209..65e9d44da 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitContainer.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitContainer.java @@ -23,16 +23,16 @@ import com.dfsek.terra.bukkit.world.inventory.BukkitInventory; public class BukkitContainer extends BukkitBlockEntity implements Container { - + protected BukkitContainer(org.bukkit.block.Container block) { super(block); } - + @Override public Inventory getInventory() { return new BukkitInventory(((org.bukkit.block.Container) getHandle()).getInventory()); } - + @Override public boolean update(boolean applyPhysics) { return false; // This clears the inventory. we don't want that. diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitMobSpawner.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitMobSpawner.java index 71485ea13..7bdc75d96 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitMobSpawner.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitMobSpawner.java @@ -30,87 +30,87 @@ public class BukkitMobSpawner extends BukkitBlockEntity implements MobSpawner { protected BukkitMobSpawner(CreatureSpawner block) { super(block); } - + @Override public EntityType getSpawnedType() { return new BukkitEntityType(((CreatureSpawner) getHandle()).getSpawnedType()); } - + @Override public void setSpawnedType(@NotNull EntityType creatureType) { ((CreatureSpawner) getHandle()).setSpawnedType(((BukkitEntityType) creatureType).getHandle()); } - + @Override public int getDelay() { return ((CreatureSpawner) getHandle()).getDelay(); } - + @Override public void setDelay(int delay) { ((CreatureSpawner) getHandle()).setDelay(delay); } - + @Override public int getMinSpawnDelay() { return ((CreatureSpawner) getHandle()).getMinSpawnDelay(); } - + @Override public void setMinSpawnDelay(int delay) { ((CreatureSpawner) getHandle()).setMinSpawnDelay(delay); } - + @Override public int getMaxSpawnDelay() { return ((CreatureSpawner) getHandle()).getMaxSpawnDelay(); } - + @Override public void setMaxSpawnDelay(int delay) { ((CreatureSpawner) getHandle()).setMaxSpawnDelay(delay); } - + @Override public int getSpawnCount() { return ((CreatureSpawner) getHandle()).getSpawnCount(); } - + @Override public void setSpawnCount(int spawnCount) { ((CreatureSpawner) getHandle()).setSpawnCount(spawnCount); } - + @Override public int getMaxNearbyEntities() { return ((CreatureSpawner) getHandle()).getMaxNearbyEntities(); } - + @Override public void setMaxNearbyEntities(int maxNearbyEntities) { ((CreatureSpawner) getHandle()).setMaxNearbyEntities(maxNearbyEntities); } - + @Override public int getRequiredPlayerRange() { return ((CreatureSpawner) getHandle()).getRequiredPlayerRange(); } - + @Override public void setRequiredPlayerRange(int requiredPlayerRange) { ((CreatureSpawner) getHandle()).setRequiredPlayerRange(requiredPlayerRange); } - + @Override public int getSpawnRange() { return ((CreatureSpawner) getHandle()).getSpawnRange(); } - + @Override public void setSpawnRange(int spawnRange) { ((CreatureSpawner) getHandle()).setSpawnRange(spawnRange); } - + @Override public void applyState(String state) { SerialState.parse(state).forEach((k, v) -> { diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitSign.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitSign.java index 65c6f303f..2ed7ea8e0 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitSign.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/block/state/BukkitSign.java @@ -28,22 +28,22 @@ public class BukkitSign extends BukkitBlockEntity implements Sign { protected BukkitSign(org.bukkit.block.Sign block) { super(block); } - + @Override public void setLine(int index, @NotNull String line) throws IndexOutOfBoundsException { ((org.bukkit.block.Sign) getHandle()).setLine(index, line); } - + @Override public @NotNull String[] getLines() { return ((org.bukkit.block.Sign) getHandle()).getLines(); } - + @Override public @NotNull String getLine(int index) throws IndexOutOfBoundsException { return ((org.bukkit.block.Sign) getHandle()).getLine(index); } - + @Override public void applyState(String state) { SerialState.parse(state).forEach((k, v) -> { diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/entity/BukkitEntityType.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/entity/BukkitEntityType.java index 8f8786867..963217d48 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/entity/BukkitEntityType.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/entity/BukkitEntityType.java @@ -22,11 +22,11 @@ import com.dfsek.terra.api.entity.EntityType; public class BukkitEntityType implements EntityType { private final org.bukkit.entity.EntityType delegate; - + public BukkitEntityType(org.bukkit.entity.EntityType delegate) { this.delegate = delegate; } - + @Override public org.bukkit.entity.EntityType getHandle() { return delegate; diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/BukkitInventory.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/BukkitInventory.java index d4c5039b5..afb9ecc28 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/BukkitInventory.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/BukkitInventory.java @@ -23,27 +23,27 @@ import com.dfsek.terra.api.inventory.ItemStack; public class BukkitInventory implements Inventory { private final org.bukkit.inventory.Inventory delegate; - + public BukkitInventory(org.bukkit.inventory.Inventory delegate) { this.delegate = delegate; } - + @Override public void setItem(int slot, ItemStack newStack) { delegate.setItem(slot, ((BukkitItemStack) newStack).getHandle()); } - + @Override public int getSize() { return delegate.getSize(); } - + @Override public ItemStack getItem(int slot) { org.bukkit.inventory.ItemStack itemStack = delegate.getItem(slot); return itemStack == null ? null : new BukkitItemStack(itemStack); } - + @Override public org.bukkit.inventory.Inventory getHandle() { return delegate; diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/BukkitItemMeta.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/BukkitItemMeta.java index 3aaa8a382..2588140f4 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/BukkitItemMeta.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/BukkitItemMeta.java @@ -31,26 +31,26 @@ import com.dfsek.terra.bukkit.world.inventory.meta.BukkitEnchantment; public class BukkitItemMeta implements ItemMeta { private final org.bukkit.inventory.meta.ItemMeta delegate; - + protected BukkitItemMeta(org.bukkit.inventory.meta.ItemMeta delegate) { this.delegate = delegate; } - + public static BukkitItemMeta newInstance(org.bukkit.inventory.meta.ItemMeta delegate) { if(delegate instanceof Damageable) return new BukkitDamageable((Damageable) delegate); return new BukkitItemMeta(delegate); } - + @Override public org.bukkit.inventory.meta.ItemMeta getHandle() { return delegate; } - + @Override public void addEnchantment(Enchantment enchantment, int level) { delegate.addEnchant(((BukkitEnchantment) enchantment).getHandle(), level, true); } - + @Override public Map getEnchantments() { Map map = new HashMap<>(); diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/BukkitItemStack.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/BukkitItemStack.java index a3a9557cd..6fdf4c4ea 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/BukkitItemStack.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/BukkitItemStack.java @@ -25,36 +25,36 @@ import com.dfsek.terra.bukkit.world.BukkitAdapter; public class BukkitItemStack implements ItemStack { private final org.bukkit.inventory.ItemStack delegate; - + public BukkitItemStack(org.bukkit.inventory.ItemStack delegate) { this.delegate = delegate; } - + @Override public int getAmount() { return delegate.getAmount(); } - + @Override public void setAmount(int i) { delegate.setAmount(i); } - + @Override public Item getType() { return BukkitAdapter.adapt(delegate.getType()); } - + @Override public ItemMeta getItemMeta() { return BukkitItemMeta.newInstance(delegate.getItemMeta()); } - + @Override public void setItemMeta(ItemMeta meta) { delegate.setItemMeta(((BukkitItemMeta) meta).getHandle()); } - + @Override public org.bukkit.inventory.ItemStack getHandle() { return delegate; diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/meta/BukkitDamageable.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/meta/BukkitDamageable.java index 461806112..fafb11fd7 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/meta/BukkitDamageable.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/meta/BukkitDamageable.java @@ -25,17 +25,17 @@ public class BukkitDamageable extends BukkitItemMeta implements Damageable { public BukkitDamageable(org.bukkit.inventory.meta.Damageable delegate) { super(delegate); } - + @Override public int getDamage() { return ((org.bukkit.inventory.meta.Damageable) getHandle()).getDamage(); } - + @Override public void setDamage(int damage) { ((org.bukkit.inventory.meta.Damageable) getHandle()).setDamage(damage); } - + @Override public boolean hasDamage() { return ((org.bukkit.inventory.meta.Damageable) getHandle()).hasDamage(); diff --git a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/meta/BukkitEnchantment.java b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/meta/BukkitEnchantment.java index 13fc3b690..087ff12cb 100644 --- a/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/meta/BukkitEnchantment.java +++ b/platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/inventory/meta/BukkitEnchantment.java @@ -24,31 +24,31 @@ import com.dfsek.terra.bukkit.world.inventory.BukkitItemStack; public class BukkitEnchantment implements Enchantment { private final org.bukkit.enchantments.Enchantment delegate; - + public BukkitEnchantment(org.bukkit.enchantments.Enchantment delegate) { this.delegate = delegate; } - + @Override public org.bukkit.enchantments.Enchantment getHandle() { return delegate; } - + @Override public boolean canEnchantItem(ItemStack itemStack) { return delegate.canEnchantItem(((BukkitItemStack) itemStack).getHandle()); } - + @Override public boolean conflictsWith(Enchantment other) { return delegate.conflictsWith(((BukkitEnchantment) other).getHandle()); } - + @Override public String getID() { return delegate.getKey().toString(); } - + @Override public int getMaxLevel() { return delegate.getMaxLevel(); diff --git a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/AwfulBukkitHacks.java b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/AwfulBukkitHacks.java index 02ac1b5c8..bbfae8b2c 100644 --- a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/AwfulBukkitHacks.java +++ b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/AwfulBukkitHacks.java @@ -27,87 +27,87 @@ import com.dfsek.terra.registry.master.ConfigRegistry; public class AwfulBukkitHacks { private static final Logger LOGGER = LoggerFactory.getLogger(NMSBiomeInjector.class); private static final Map> terraBiomeMap = new HashMap<>(); - - + + public static void registerBiomes(ConfigRegistry configRegistry) { try { LOGGER.info("Hacking biome registry..."); WritableRegistry biomeRegistry = (WritableRegistry) Registries.biomeRegistry(); - + Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry) biomeRegistry, false); - + configRegistry.forEach(pack -> pack.getRegistry(com.dfsek.terra.api.world.biome.Biome.class).forEach((key, biome) -> { try { BukkitPlatformBiome platformBiome = (BukkitPlatformBiome) biome.getPlatformBiome(); NamespacedKey vanillaBukkitKey = platformBiome.getHandle().getKey(); ResourceLocation vanillaMinecraftKey = new ResourceLocation(vanillaBukkitKey.getNamespace(), vanillaBukkitKey.getKey()); Biome platform = NMSBiomeInjector.createBiome( - biome, - biomeRegistry.get(vanillaMinecraftKey) // get - ); - + biome, + biomeRegistry.get(vanillaMinecraftKey) // get + ); + ResourceKey delegateKey = ResourceKey.create(Registry.BIOME_REGISTRY, new ResourceLocation("terra", - NMSBiomeInjector.createBiomeID( - pack, key))); - + NMSBiomeInjector.createBiomeID( + pack, key))); + BuiltinRegistries.register(BuiltinRegistries.BIOME, delegateKey, platform); biomeRegistry.register(delegateKey, platform, Lifecycle.stable()); platformBiome.getContext().put(new NMSBiomeInfo(delegateKey)); - + terraBiomeMap.computeIfAbsent(vanillaMinecraftKey, i -> new ArrayList<>()).add(delegateKey.location()); - + LOGGER.debug("Registered biome: " + delegateKey); } catch(NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) { throw new RuntimeException(e); } })); - + Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry) biomeRegistry, true); // freeze registry again :) - + LOGGER.info("Doing tag garbage...."); Map, List>> collect = biomeRegistry - .getTags() // streamKeysAndEntries - .collect(HashMap::new, - (map, pair) -> - map.put(pair.getFirst(), new ArrayList<>(pair.getSecond().stream().toList())), - HashMap::putAll); - + .getTags() // streamKeysAndEntries + .collect(HashMap::new, + (map, pair) -> + map.put(pair.getFirst(), new ArrayList<>(pair.getSecond().stream().toList())), + HashMap::putAll); + terraBiomeMap - .forEach((vb, terraBiomes) -> - NMSBiomeInjector.getEntry(biomeRegistry, vb) - .ifPresentOrElse( - vanilla -> terraBiomes - .forEach(tb -> NMSBiomeInjector.getEntry(biomeRegistry, tb) - .ifPresentOrElse( - terra -> { - LOGGER.debug( - vanilla.unwrapKey() - .orElseThrow() - .location() + - " (vanilla for " + - terra.unwrapKey() - .orElseThrow() - .location() + - ": " + - vanilla.tags() - .toList()); - - vanilla.tags() - .forEach( - tag -> collect - .computeIfAbsent( - tag, - t -> new ArrayList<>()) - .add(terra)); - }, - () -> LOGGER.error( - "No such biome: {}", - tb))), - () -> LOGGER.error("No vanilla biome: {}", vb))); - + .forEach((vb, terraBiomes) -> + NMSBiomeInjector.getEntry(biomeRegistry, vb) + .ifPresentOrElse( + vanilla -> terraBiomes + .forEach(tb -> NMSBiomeInjector.getEntry(biomeRegistry, tb) + .ifPresentOrElse( + terra -> { + LOGGER.debug( + vanilla.unwrapKey() + .orElseThrow() + .location() + + " (vanilla for " + + terra.unwrapKey() + .orElseThrow() + .location() + + ": " + + vanilla.tags() + .toList()); + + vanilla.tags() + .forEach( + tag -> collect + .computeIfAbsent( + tag, + t -> new ArrayList<>()) + .add(terra)); + }, + () -> LOGGER.error( + "No such biome: {}", + tb))), + () -> LOGGER.error("No vanilla biome: {}", vb))); + biomeRegistry.resetTags(); // clearTags biomeRegistry.bindTags(ImmutableMap.copyOf(collect)); // populateTags - + } catch(SecurityException | IllegalArgumentException exception) { throw new RuntimeException(exception); } diff --git a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSBiomeInjector.java index 1e8245b4c..f56c32b5b 100644 --- a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSBiomeInjector.java @@ -15,63 +15,63 @@ import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; public class NMSBiomeInjector { - + public static Optional> getEntry(Registry registry, ResourceLocation identifier) { return registry.getOptional(identifier) - .flatMap(registry::getResourceKey) - .map(registry::getOrCreateHolder); + .flatMap(registry::getResourceKey) + .map(registry::getOrCreateHolder); } - + public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { Biome.BiomeBuilder builder = new Biome.BiomeBuilder(); // Builder - - + + builder.biomeCategory(Reflection.BIOME.getBiomeCategory(vanilla)) - .precipitation(vanilla.getPrecipitation()) // getPrecipitation - .mobSpawnSettings(vanilla.getMobSettings()) - .generationSettings(vanilla.getGenerationSettings()) - .temperature(vanilla.getBaseTemperature()) - .downfall(vanilla.getDownfall()); - - + .precipitation(vanilla.getPrecipitation()) // getPrecipitation + .mobSpawnSettings(vanilla.getMobSettings()) + .generationSettings(vanilla.getGenerationSettings()) + .temperature(vanilla.getBaseTemperature()) + .downfall(vanilla.getDownfall()); + + BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder(); - + effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier()); - + VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); - + effects.fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor())) - - .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) - - .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) - - .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); - + + .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) + + .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) + + .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); + if(vanillaBiomeProperties.getFoliageColor() == null) { vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride); } else { effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor()); } - + if(vanillaBiomeProperties.getGrassColor() == null) { vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride); } else { effects.grassColorOverride(vanillaBiomeProperties.getGrassColor()); } - + vanilla.getAmbientLoop().ifPresent(effects::ambientLoopSound); vanilla.getAmbientAdditions().ifPresent(effects::ambientAdditionsSound); vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound); vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic); vanilla.getAmbientParticle().ifPresent(effects::ambientParticle); - + builder.specialEffects(effects.build()); - + return builder.build(); // build() } - + public static String createBiomeID(ConfigPack pack, com.dfsek.terra.api.registry.key.RegistryKey biomeID) { return pack.getID() .toLowerCase() + "/" + biomeID.getNamespace().toLowerCase(Locale.ROOT) + "/" + biomeID.getID().toLowerCase(Locale.ROOT); diff --git a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSBiomeProvider.java b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSBiomeProvider.java index 111b2802b..9fb99f13f 100644 --- a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSBiomeProvider.java +++ b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSBiomeProvider.java @@ -17,33 +17,33 @@ public class NMSBiomeProvider extends BiomeSource { private final BiomeSource vanilla; private final long seed; private final Registry biomeRegistry = Registries.biomeRegistry(); - + public NMSBiomeProvider(BiomeProvider delegate, BiomeSource vanilla, long seed) { super(delegate.stream() - .map(biome -> Registries.biomeRegistry() - .getOrCreateHolder(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() - .get(NMSBiomeInfo.class) - .biomeKey()))); + .map(biome -> Registries.biomeRegistry() + .getOrCreateHolder(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey()))); this.delegate = delegate; this.vanilla = vanilla; this.seed = seed; } - + @Override protected Codec codec() { return BiomeSource.CODEC; } - + @Override public @NotNull BiomeSource withSeed(long seed) { return new NMSBiomeProvider(delegate, vanilla, seed); } - + @Override public @NotNull Holder getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) { return biomeRegistry.getOrCreateHolder(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed).getPlatformBiome()) - .getContext() - .get(NMSBiomeInfo.class) - .biomeKey()); + .getContext() + .get(NMSBiomeInfo.class) + .biomeKey()); } } diff --git a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSChunkGeneratorDelegate.java index 284eff2b1..905867b62 100644 --- a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSChunkGeneratorDelegate.java +++ b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSChunkGeneratorDelegate.java @@ -58,7 +58,7 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { private final long seed; private final Map>> ringPositions = new Object2ObjectArrayMap<>(); private volatile boolean rings = false; - + public NMSChunkGeneratorDelegate(ChunkGenerator vanilla, ConfigPack pack, NMSBiomeProvider biomeProvider, long seed) { super(Registries.structureSet(), Optional.empty(), biomeProvider, biomeProvider, seed); this.delegate = pack.getGeneratorProvider().newInstance(pack); @@ -67,42 +67,42 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { this.pack = pack; this.seed = seed; } - + @Override public void applyCarvers(@NotNull WorldGenRegion chunkRegion, long seed, @NotNull BiomeManager biomeAccess, @NotNull StructureFeatureManager structureAccessor, @NotNull ChunkAccess chunk, GenerationStep.@NotNull Carving generationStep) { // no-op } - + @Override public void applyBiomeDecoration(@NotNull WorldGenLevel world, @NotNull ChunkAccess chunk, @NotNull StructureFeatureManager structureAccessor) { vanilla.applyBiomeDecoration(world, chunk, structureAccessor); } - + @Override public int getSeaLevel() { return vanilla.getSeaLevel(); } - + @Override public @NotNull CompletableFuture fillFromNoise(@NotNull Executor executor, @NotNull Blender blender, @NotNull StructureFeatureManager structureAccessor, @NotNull ChunkAccess chunk) { return vanilla.fillFromNoise(executor, blender, structureAccessor, chunk); } - + @Override public void buildSurface(@NotNull WorldGenRegion region, @NotNull StructureFeatureManager structures, @NotNull ChunkAccess chunk) { // no-op } - + @Override protected @NotNull Codec codec() { return ChunkGenerator.CODEC; } - + @Override public @NotNull NoiseColumn getBaseColumn(int x, int z, LevelHeightAccessor height) { /* @@ -117,51 +117,51 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { */ return vanilla.getBaseColumn(x, z, height); } - + @Override // withSeed public @NotNull ChunkGenerator withSeed(long seed) { return new NMSChunkGeneratorDelegate(vanilla, pack, biomeSource, seed); } - + @Override public void spawnOriginalMobs(@NotNull WorldGenRegion regionlimitedworldaccess) { vanilla.spawnOriginalMobs(regionlimitedworldaccess); } - + @Override public int getGenDepth() { return vanilla.getGenDepth(); } - + @Override public @NotNull Sampler climateSampler() { return Climate.empty(); } - + @Override public int getMinY() { return vanilla.getMinY(); } - + @Override public int getBaseHeight(int x, int z, Heightmap.@NotNull Types heightmap, @NotNull LevelHeightAccessor world) { WorldProperties properties = new NMSWorldProperties(seed, world); int y = properties.getMaxHeight(); BiomeProvider biomeProvider = pack.getBiomeProvider(); while(y >= getMinY() && !heightmap.isOpaque().test( - ((CraftBlockData) delegate.getBlock(properties, x, y - 1, z, biomeProvider).getHandle()).getState())) { + ((CraftBlockData) delegate.getBlock(properties, x, y - 1, z, biomeProvider).getHandle()).getState())) { y--; } return y; } - + @Nullable @Override public List getRingPositionsFor(@NotNull ConcentricRingsStructurePlacement concentricringsstructureplacement) { ensureStructuresGenerated(); return ringPositions.getOrDefault(concentricringsstructureplacement, EMPTY).value(); } - + @Override public synchronized void ensureStructuresGenerated() { if(!this.rings) { @@ -170,7 +170,7 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { this.rings = true; } } - + private void populateStrongholdData() { LOGGER.info("Generating safe stronghold data. This may take up to a minute."); Set> set = this.runtimeBiomeSource.possibleBiomes(); @@ -179,29 +179,29 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { if(structureplacement instanceof ConcentricRingsStructurePlacement concentricringsstructureplacement) { if(holder.structures().stream().anyMatch((structureset_a1) -> structureset_a1.generatesInMatchingBiome(set::contains))) { this.ringPositions.put(concentricringsstructureplacement, - Lazy.lazy(() -> this.generateRingPositions(holder, concentricringsstructureplacement))); + Lazy.lazy(() -> this.generateRingPositions(holder, concentricringsstructureplacement))); } } }); } - + private List generateRingPositions(StructureSet holder, ConcentricRingsStructurePlacement concentricringsstructureplacement) { // Spigot if(concentricringsstructureplacement.count() == 0) { return List.of(); } - + List list = new ArrayList<>(); Set> set = holder - .structures() - .stream() - .flatMap((structureset_a) -> structureset_a.structure().value().biomes().stream()) - .collect(Collectors.toSet()); + .structures() + .stream() + .flatMap((structureset_a) -> structureset_a.structure().value().biomes().stream()) + .collect(Collectors.toSet()); int i = concentricringsstructureplacement.distance(); int j = concentricringsstructureplacement.count(); int k = concentricringsstructureplacement.spread(); Random random = new Random(); - + // Paper start if(this.conf.strongholdSeed != null && this.structureSets.getResourceKey(holder).orElse(null) == net.minecraft.world.level.levelgen.structure.BuiltinStructureSets.STRONGHOLDS) { @@ -213,25 +213,25 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { double d0 = random.nextDouble() * 3.141592653589793D * 2.0D; int l = 0; int i1 = 0; - + for(int j1 = 0; j1 < j; ++j1) { double d1 = (double) (4 * i + i * i1 * 6) + (random.nextDouble() - 0.5D) * (double) i * 2.5D; int k1 = (int) Math.round(MathUtil.cos(d0) * d1); int l1 = (int) Math.round(MathUtil.sin(d0) * d1); int i2 = SectionPos.sectionToBlockCoord(k1, 8); int j2 = SectionPos.sectionToBlockCoord(l1, 8); - + Objects.requireNonNull(set); Pair> pair = this.biomeSource.findBiomeHorizontal(i2, 0, j2, 112, set::contains, random, - this.climateSampler()); - + this.climateSampler()); + if(pair != null) { BlockPos blockposition = pair.getFirst(); - + k1 = SectionPos.blockToSectionCoord(blockposition.getX()); l1 = SectionPos.blockToSectionCoord(blockposition.getZ()); } - + list.add(new ChunkPos(k1, l1)); d0 += 6.283185307179586D / (double) k; ++l; @@ -243,12 +243,12 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { d0 += random.nextDouble() * 3.141592653589793D * 2.0D; } } - + return list; } - + @Override public void addDebugScreenInfo(@NotNull List arg0, @NotNull BlockPos arg1) { - + } } diff --git a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSInjectListener.java b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSInjectListener.java index 55408a136..9e055524a 100644 --- a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSInjectListener.java +++ b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSInjectListener.java @@ -22,7 +22,7 @@ public class NMSInjectListener implements Listener { private static final Logger LOGGER = LoggerFactory.getLogger(NMSInjectListener.class); private static final Set INJECTED = new HashSet<>(); private static final ReentrantLock INJECT_LOCK = new ReentrantLock(); - + @EventHandler public void onWorldInit(WorldInitEvent event) { if(!INJECTED.contains(event.getWorld()) && @@ -32,21 +32,21 @@ public class NMSInjectListener implements Listener { LOGGER.info("Preparing to take over the world: {}", event.getWorld().getName()); CraftWorld craftWorld = (CraftWorld) event.getWorld(); ServerLevel serverWorld = craftWorld.getHandle(); - + ConfigPack pack = bukkitChunkGeneratorWrapper.getPack(); - + ChunkGenerator vanilla = serverWorld.getChunkSource().getGenerator(); NMSBiomeProvider provider = new NMSBiomeProvider(pack.getBiomeProvider(), vanilla.getBiomeSource(), craftWorld.getSeed()); NMSChunkGeneratorDelegate custom = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed()); - + custom.conf = vanilla.conf; // world config from Spigot - + serverWorld.getChunkSource().chunkMap.generator = custom; - + LOGGER.info("Successfully injected into world."); - + serverWorld.getChunkSource().chunkMap.generator.ensureStructuresGenerated(); // generate stronghold data now - + INJECT_LOCK.unlock(); } } diff --git a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSWorldProperties.java b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSWorldProperties.java index 73b009fc4..875dc0330 100644 --- a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSWorldProperties.java +++ b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSWorldProperties.java @@ -8,27 +8,27 @@ import com.dfsek.terra.api.world.info.WorldProperties; public class NMSWorldProperties implements WorldProperties { private final long seed; private final LevelHeightAccessor height; - + public NMSWorldProperties(long seed, LevelHeightAccessor height) { this.seed = seed; this.height = height; } - + @Override public Object getHandle() { return height; } - + @Override public long getSeed() { return seed; } - + @Override public int getMaxHeight() { return height.getMaxBuildHeight(); } - + @Override public int getMinHeight() { return height.getMinBuildHeight(); diff --git a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/Reflection.java b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/Reflection.java index 793637395..c6e3351a1 100644 --- a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/Reflection.java +++ b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/Reflection.java @@ -12,24 +12,24 @@ import xyz.jpenilla.reflectionremapper.proxy.annotation.Proxies; public class Reflection { public static final MappedRegistryProxy MAPPED_REGISTRY; public static final BiomeProxy BIOME; - + static { ReflectionRemapper reflectionRemapper = ReflectionRemapper.forReobfMappingsInPaperJar(); ReflectionProxyFactory reflectionProxyFactory = ReflectionProxyFactory.create(reflectionRemapper, - Reflection.class.getClassLoader()); - + Reflection.class.getClassLoader()); + MAPPED_REGISTRY = reflectionProxyFactory.reflectionProxy(MappedRegistryProxy.class); BIOME = reflectionProxyFactory.reflectionProxy(BiomeProxy.class); } - - + + @Proxies(MappedRegistry.class) public interface MappedRegistryProxy { @FieldSetter("frozen") void setFrozen(MappedRegistry instance, boolean frozen); } - - + + @Proxies(Biome.class) public interface BiomeProxy { @FieldGetter("biomeCategory") diff --git a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/Registries.java b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/Registries.java index 3902b61d3..652d77cab 100644 --- a/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/Registries.java +++ b/platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/Registries.java @@ -14,16 +14,16 @@ public class Registries { CraftServer craftserver = (CraftServer) Bukkit.getServer(); DedicatedServer dedicatedserver = craftserver.getServer(); return dedicatedserver - .registryAccess() - .registryOrThrow( // getRegistry - key - ); + .registryAccess() + .registryOrThrow( // getRegistry + key + ); } - + public static Registry biomeRegistry() { return getRegistry(Registry.BIOME_REGISTRY); } - + public static Registry structureSet() { return getRegistry(Registry.STRUCTURE_SET_REGISTRY); } diff --git a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/AwfulBukkitHacks.java b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/AwfulBukkitHacks.java index d4f934f36..92506d834 100644 --- a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/AwfulBukkitHacks.java +++ b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/AwfulBukkitHacks.java @@ -27,88 +27,88 @@ import com.dfsek.terra.registry.master.ConfigRegistry; public class AwfulBukkitHacks { private static final Logger LOGGER = LoggerFactory.getLogger(AwfulBukkitHacks.class); - + private static final Map> terraBiomeMap = new HashMap<>(); - + public static void registerBiomes(ConfigRegistry configRegistry) { try { LOGGER.info("Hacking biome registry..."); WritableRegistry biomeRegistry = (WritableRegistry) Registries.biomeRegistry(); - + Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry) biomeRegistry, false); - + configRegistry.forEach(pack -> pack.getRegistry(com.dfsek.terra.api.world.biome.Biome.class).forEach((key, biome) -> { try { BukkitPlatformBiome platformBiome = (BukkitPlatformBiome) biome.getPlatformBiome(); NamespacedKey vanillaBukkitKey = platformBiome.getHandle().getKey(); ResourceLocation vanillaMinecraftKey = new ResourceLocation(vanillaBukkitKey.getNamespace(), vanillaBukkitKey.getKey()); Biome platform = NMSBiomeInjector.createBiome( - biome, - Objects.requireNonNull(biomeRegistry.get(vanillaMinecraftKey)) // get - ); - + biome, + Objects.requireNonNull(biomeRegistry.get(vanillaMinecraftKey)) // get + ); + ResourceKey delegateKey = ResourceKey.create(Registry.BIOME_REGISTRY, - new ResourceLocation("terra", - NMSBiomeInjector.createBiomeID(pack, key))); - + new ResourceLocation("terra", + NMSBiomeInjector.createBiomeID(pack, key))); + BuiltinRegistries.register(BuiltinRegistries.BIOME, delegateKey, platform); biomeRegistry.register(delegateKey, platform, Lifecycle.stable()); platformBiome.getContext().put(new NMSBiomeInfo(delegateKey)); - + terraBiomeMap.computeIfAbsent(vanillaMinecraftKey, i -> new ArrayList<>()).add(delegateKey.location()); - + LOGGER.debug("Registered biome: " + delegateKey); } catch(NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) { throw new RuntimeException(e); } })); - + Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry) biomeRegistry, true); // freeze registry again :) - + LOGGER.info("Doing tag garbage...."); Map, List>> collect = biomeRegistry - .getTags() // streamKeysAndEntries - .collect(HashMap::new, - (map, pair) -> - map.put(pair.getFirst(), new ArrayList<>(pair.getSecond().stream().toList())), - HashMap::putAll); - + .getTags() // streamKeysAndEntries + .collect(HashMap::new, + (map, pair) -> + map.put(pair.getFirst(), new ArrayList<>(pair.getSecond().stream().toList())), + HashMap::putAll); + terraBiomeMap - .forEach((vb, terraBiomes) -> - NMSBiomeInjector.getEntry(biomeRegistry, vb) - .ifPresentOrElse( - vanilla -> terraBiomes - .forEach(tb -> NMSBiomeInjector.getEntry(biomeRegistry, tb) - .ifPresentOrElse( - terra -> { - LOGGER.debug( - vanilla.unwrapKey() - .orElseThrow() - .location() + - " (vanilla for " + - terra.unwrapKey() - .orElseThrow() - .location() + - ": " + - vanilla.tags() - .toList()); - - vanilla.tags() - .forEach( - tag -> collect - .computeIfAbsent( - tag, - t -> new ArrayList<>()) - .add(terra)); - }, - () -> LOGGER.error( - "No such biome: {}", - tb))), - () -> LOGGER.error("No vanilla biome: {}", vb))); - + .forEach((vb, terraBiomes) -> + NMSBiomeInjector.getEntry(biomeRegistry, vb) + .ifPresentOrElse( + vanilla -> terraBiomes + .forEach(tb -> NMSBiomeInjector.getEntry(biomeRegistry, tb) + .ifPresentOrElse( + terra -> { + LOGGER.debug( + vanilla.unwrapKey() + .orElseThrow() + .location() + + " (vanilla for " + + terra.unwrapKey() + .orElseThrow() + .location() + + ": " + + vanilla.tags() + .toList()); + + vanilla.tags() + .forEach( + tag -> collect + .computeIfAbsent( + tag, + t -> new ArrayList<>()) + .add(terra)); + }, + () -> LOGGER.error( + "No such biome: {}", + tb))), + () -> LOGGER.error("No vanilla biome: {}", vb))); + biomeRegistry.resetTags(); biomeRegistry.bindTags(ImmutableMap.copyOf(collect)); - + } catch(SecurityException | IllegalArgumentException exception) { throw new RuntimeException(exception); } diff --git a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeInjector.java index 61acffc74..39a66e468 100644 --- a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeInjector.java @@ -15,63 +15,63 @@ import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; public class NMSBiomeInjector { - + public static Optional> getEntry(Registry registry, ResourceLocation identifier) { return registry.getOptional(identifier) - .flatMap(registry::getResourceKey) - .map(registry::getOrCreateHolderOrThrow); + .flatMap(registry::getResourceKey) + .map(registry::getOrCreateHolderOrThrow); } - + public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { Biome.BiomeBuilder builder = new Biome.BiomeBuilder(); - + builder - .precipitation(vanilla.getPrecipitation()) - .downfall(vanilla.getDownfall()) - .temperature(vanilla.getBaseTemperature()) - .mobSpawnSettings(vanilla.getMobSettings()) - .generationSettings(vanilla.getGenerationSettings()); - - + .precipitation(vanilla.getPrecipitation()) + .downfall(vanilla.getDownfall()) + .temperature(vanilla.getBaseTemperature()) + .mobSpawnSettings(vanilla.getMobSettings()) + .generationSettings(vanilla.getGenerationSettings()); + + BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder(); - + effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier()); - + VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); - + effects.fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor())) - - .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) - - .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) - - .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); - + + .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) + + .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) + + .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); + if(vanillaBiomeProperties.getFoliageColor() == null) { vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride); } else { effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor()); } - + if(vanillaBiomeProperties.getGrassColor() == null) { vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride); } else { // grass effects.grassColorOverride(vanillaBiomeProperties.getGrassColor()); } - + vanilla.getAmbientLoop().ifPresent(effects::ambientLoopSound); vanilla.getAmbientAdditions().ifPresent(effects::ambientAdditionsSound); vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound); vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic); vanilla.getAmbientParticle().ifPresent(effects::ambientParticle); - + builder.specialEffects(effects.build()); - + return builder.build(); } - + public static String createBiomeID(ConfigPack pack, com.dfsek.terra.api.registry.key.RegistryKey biomeID) { return pack.getID() .toLowerCase() + "/" + biomeID.getNamespace().toLowerCase(Locale.ROOT) + "/" + biomeID.getID().toLowerCase(Locale.ROOT); diff --git a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeProvider.java b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeProvider.java index 0c5a8ef06..ee7a05443 100644 --- a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeProvider.java +++ b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeProvider.java @@ -16,27 +16,27 @@ public class NMSBiomeProvider extends BiomeSource { private final BiomeProvider delegate; private final long seed; private final Registry biomeRegistry = Registries.biomeRegistry(); - + public NMSBiomeProvider(BiomeProvider delegate, long seed) { super(delegate.stream() - .map(biome -> Registries.biomeRegistry() - .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() - .get(NMSBiomeInfo.class) - .biomeKey()))); + .map(biome -> Registries.biomeRegistry() + .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey()))); this.delegate = delegate; this.seed = seed; } - + @Override protected @NotNull Codec codec() { return BiomeSource.CODEC; } - + @Override public @NotNull Holder getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) { return biomeRegistry.getHolderOrThrow(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed) - .getPlatformBiome()).getContext() - .get(NMSBiomeInfo.class) - .biomeKey()); + .getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey()); } } diff --git a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSChunkGeneratorDelegate.java index 5eecb9325..6e374ff8b 100644 --- a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSChunkGeneratorDelegate.java +++ b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSChunkGeneratorDelegate.java @@ -58,14 +58,14 @@ import com.dfsek.terra.bukkit.world.block.data.BukkitBlockState; public class NMSChunkGeneratorDelegate extends ChunkGenerator { private static final Logger LOGGER = LoggerFactory.getLogger(NMSChunkGeneratorDelegate.class); private final com.dfsek.terra.api.world.chunk.generation.ChunkGenerator delegate; - + private final ChunkGenerator vanilla; private final ConfigPack pack; - + private final long seed; private final Map>> ringPositions = new Object2ObjectArrayMap<>(); private volatile boolean rings = false; - + public NMSChunkGeneratorDelegate(ChunkGenerator vanilla, ConfigPack pack, NMSBiomeProvider biomeProvider, long seed) { super(Registries.structureSet(), Optional.empty(), biomeProvider); this.delegate = pack.getGeneratorProvider().newInstance(pack); @@ -73,57 +73,57 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { this.pack = pack; this.seed = seed; } - + @Override protected @NotNull Codec codec() { return ChunkGenerator.CODEC; } - + @Override public void applyCarvers(@NotNull WorldGenRegion chunkRegion, long seed, @NotNull RandomState noiseConfig, @NotNull BiomeManager world, @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk, @NotNull Carving carverStep) { // no-op } - + @Override public void buildSurface(@NotNull WorldGenRegion region, @NotNull StructureManager structures, @NotNull RandomState noiseConfig, @NotNull ChunkAccess chunk) { // no-op } - + @Override public void applyBiomeDecoration(@NotNull WorldGenLevel world, @NotNull ChunkAccess chunk, @NotNull StructureManager structureAccessor) { vanilla.applyBiomeDecoration(world, chunk, structureAccessor); } - + @Override public void spawnOriginalMobs(@NotNull WorldGenRegion region) { vanilla.spawnOriginalMobs(region); } - + @Override public int getGenDepth() { return vanilla.getGenDepth(); } - + @Override public @NotNull CompletableFuture fillFromNoise(@NotNull Executor executor, @NotNull Blender blender, @NotNull RandomState noiseConfig, @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) { return vanilla.fillFromNoise(executor, blender, noiseConfig, structureAccessor, chunk) - .thenApply(c -> { - LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); - BiomeProvider biomeProvider = pack.getBiomeProvider(); - PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); - if(compatibilityOptions.isBeard()) { - beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), - biomeProvider, compatibilityOptions); - } - return c; - }); + .thenApply(c -> { + LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); + BiomeProvider biomeProvider = pack.getBiomeProvider(); + PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); + if(compatibilityOptions.isBeard()) { + beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), + biomeProvider, compatibilityOptions); + } + return c; + }); } - + private void beard(StructureManager structureAccessor, ChunkAccess chunk, WorldProperties world, BiomeProvider biomeProvider, PreLoadCompatibilityOptions compatibilityOptions) { Beardifier structureWeightSampler = Beardifier.forStructuresInChunk(structureAccessor, chunk.getPos()); @@ -138,8 +138,8 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { double noise = structureWeightSampler.compute(new SinglePointContext(x + xi, y, z + zi)); if(noise > threshold) { chunk.setBlockState(new BlockPos(x, y, z), ((CraftBlockData) ((BukkitBlockState) delegate - .getPalette(x + xi, y, z + zi, world, biomeProvider) - .get(depth, x + xi, y, z + zi, world.getSeed())).getHandle()).getState(), false); + .getPalette(x + xi, y, z + zi, world, biomeProvider) + .get(depth, x + xi, y, z + zi, world.getSeed())).getHandle()).getState(), false); depth++; } else if(noise < airThreshold) { chunk.setBlockState(new BlockPos(x, y, z), Blocks.AIR.defaultBlockState(), false); @@ -150,29 +150,29 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { } } } - + @Override public int getSeaLevel() { return vanilla.getSeaLevel(); } - + @Override public int getMinY() { return vanilla.getMinY(); } - + @Override public int getBaseHeight(int x, int z, @NotNull Types heightmap, @NotNull LevelHeightAccessor world, @NotNull RandomState noiseConfig) { WorldProperties properties = new NMSWorldProperties(seed, world); int y = properties.getMaxHeight(); BiomeProvider biomeProvider = pack.getBiomeProvider(); while(y >= getMinY() && !heightmap.isOpaque().test( - ((CraftBlockData) delegate.getBlock(properties, x, y - 1, z, biomeProvider).getHandle()).getState())) { + ((CraftBlockData) delegate.getBlock(properties, x, y - 1, z, biomeProvider).getHandle()).getState())) { y--; } return y; } - + @Override public @NotNull NoiseColumn getBaseColumn(int x, int z, @NotNull LevelHeightAccessor world, @NotNull RandomState noiseConfig) { /* @@ -188,12 +188,12 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { */ return vanilla.getBaseColumn(x, z, world, noiseConfig); } - + @Override public void addDebugScreenInfo(@NotNull List text, @NotNull RandomState noiseConfig, @NotNull BlockPos pos) { - + } - + @Override public void ensureStructuresGenerated(@NotNull RandomState noiseConfig) { if(!this.rings) { @@ -201,16 +201,16 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { this.populateStrongholdData(noiseConfig); this.rings = true; } - + } - + @Override public List getRingPositionsFor(@NotNull ConcentricRingsStructurePlacement structurePlacement, @NotNull RandomState noiseConfig) { ensureStructuresGenerated(noiseConfig); return ringPositions.get(structurePlacement).value(); } - + private void populateStrongholdData(RandomState noiseConfig) { LOGGER.info("Generating safe stronghold data. This may take up to a minute."); Set> set = this.biomeSource.possibleBiomes(); @@ -223,29 +223,29 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { match = true; } } - + if(match) { if(holder.placement() instanceof ConcentricRingsStructurePlacement concentricringsstructureplacement) { this.ringPositions.put(concentricringsstructureplacement, Lazy.lazy( - () -> this.generateRingPositions(holder, noiseConfig, concentricringsstructureplacement))); + () -> this.generateRingPositions(holder, noiseConfig, concentricringsstructureplacement))); } } }); } - + private List generateRingPositions(StructureSet holder, RandomState randomstate, ConcentricRingsStructurePlacement concentricringsstructureplacement) { // Spigot if(concentricringsstructureplacement.count() == 0) { return List.of(); } - + List list = new ArrayList<>(); int i = concentricringsstructureplacement.distance(); int j = concentricringsstructureplacement.count(); int k = concentricringsstructureplacement.spread(); HolderSet holderset = concentricringsstructureplacement.preferredBiomes(); RandomSource randomsource = RandomSource.create(); - + if(this.conf.strongholdSeed != null && this.structureSets.getResourceKey(holder).orElse(null) == net.minecraft.world.level.levelgen.structure.BuiltinStructureSets.STRONGHOLDS) { randomsource.setSeed(this.conf.strongholdSeed); @@ -255,25 +255,25 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { double d0 = randomsource.nextDouble() * 3.141592653589793D * 2.0D; int l = 0; int i1 = 0; - + for(int j1 = 0; j1 < j; ++j1) { double d1 = (double) (4 * i + i * i1 * 6) + (randomsource.nextDouble() - 0.5D) * (double) i * 2.5D; int k1 = (int) Math.round(MathUtil.cos(d0) * d1); int l1 = (int) Math.round(MathUtil.sin(d0) * d1); int i2 = SectionPos.sectionToBlockCoord(k1, 8); int j2 = SectionPos.sectionToBlockCoord(l1, 8); - + Objects.requireNonNull(holderset); Pair> pair = this.biomeSource.findBiomeHorizontal(i2, 0, j2, 112, holderset::contains, randomsource, - randomstate.sampler()); - + randomstate.sampler()); + if(pair != null) { BlockPos blockposition = pair.getFirst(); - + k1 = SectionPos.blockToSectionCoord(blockposition.getX()); l1 = SectionPos.blockToSectionCoord(blockposition.getZ()); } - + list.add(new ChunkPos(k1, l1)); d0 += 6.283185307179586D / (double) k; ++l; @@ -285,7 +285,7 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { d0 += randomsource.nextDouble() * 3.141592653589793D * 2.0D; } } - + return list; } } diff --git a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSInjectListener.java b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSInjectListener.java index d57689a9b..0f11f700d 100644 --- a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSInjectListener.java +++ b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSInjectListener.java @@ -22,7 +22,7 @@ public class NMSInjectListener implements Listener { private static final Logger LOGGER = LoggerFactory.getLogger(NMSInjectListener.class); private static final Set INJECTED = new HashSet<>(); private static final ReentrantLock INJECT_LOCK = new ReentrantLock(); - + @EventHandler public void onWorldInit(WorldInitEvent event) { if(!INJECTED.contains(event.getWorld()) && @@ -32,19 +32,19 @@ public class NMSInjectListener implements Listener { LOGGER.info("Preparing to take over the world: {}", event.getWorld().getName()); CraftWorld craftWorld = (CraftWorld) event.getWorld(); ServerLevel serverWorld = craftWorld.getHandle(); - + ConfigPack pack = bukkitChunkGeneratorWrapper.getPack(); - + ChunkGenerator vanilla = serverWorld.getChunkSource().getGenerator(); NMSBiomeProvider provider = new NMSBiomeProvider(pack.getBiomeProvider(), craftWorld.getSeed()); NMSChunkGeneratorDelegate custom = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed()); - + custom.conf = vanilla.conf; // world config from Spigot - + serverWorld.getChunkSource().chunkMap.generator = custom; - + LOGGER.info("Successfully injected into world."); - + INJECT_LOCK.unlock(); } } diff --git a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSWorldProperties.java b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSWorldProperties.java index b068231f8..9348ca047 100644 --- a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSWorldProperties.java +++ b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSWorldProperties.java @@ -8,27 +8,27 @@ import com.dfsek.terra.api.world.info.WorldProperties; public class NMSWorldProperties implements WorldProperties { private final long seed; private final LevelHeightAccessor height; - + public NMSWorldProperties(long seed, LevelHeightAccessor height) { this.seed = seed; this.height = height; } - + @Override public Object getHandle() { return height; } - + @Override public long getSeed() { return seed; } - + @Override public int getMaxHeight() { return height.getMaxBuildHeight(); } - + @Override public int getMinHeight() { return height.getMinBuildHeight(); diff --git a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/Reflection.java b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/Reflection.java index 58062c5a5..84263a667 100644 --- a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/Reflection.java +++ b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/Reflection.java @@ -13,24 +13,24 @@ import xyz.jpenilla.reflectionremapper.proxy.annotation.Proxies; public class Reflection { public static final MappedRegistryProxy MAPPED_REGISTRY; public static final StructureManagerProxy STRUCTURE_MANAGER; - + static { ReflectionRemapper reflectionRemapper = ReflectionRemapper.forReobfMappingsInPaperJar(); ReflectionProxyFactory reflectionProxyFactory = ReflectionProxyFactory.create(reflectionRemapper, - Reflection.class.getClassLoader()); - + Reflection.class.getClassLoader()); + MAPPED_REGISTRY = reflectionProxyFactory.reflectionProxy(MappedRegistryProxy.class); STRUCTURE_MANAGER = reflectionProxyFactory.reflectionProxy(StructureManagerProxy.class); } - - + + @Proxies(MappedRegistry.class) public interface MappedRegistryProxy { @FieldSetter("frozen") void setFrozen(MappedRegistry instance, boolean frozen); } - - + + @Proxies(StructureManager.class) public interface StructureManagerProxy { @FieldGetter("level") diff --git a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/Registries.java b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/Registries.java index f1cdc645e..1ff964106 100644 --- a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/Registries.java +++ b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/Registries.java @@ -14,16 +14,16 @@ public class Registries { CraftServer craftserver = (CraftServer) Bukkit.getServer(); DedicatedServer dedicatedserver = craftserver.getServer(); return dedicatedserver - .registryAccess() - .registryOrThrow( // getRegistry - key - ); + .registryAccess() + .registryOrThrow( // getRegistry + key + ); } - + public static Registry biomeRegistry() { return getRegistry(Registry.BIOME_REGISTRY); } - + public static Registry structureSet() { return getRegistry(Registry.STRUCTURE_SET_REGISTRY); } diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/AwfulBukkitHacks.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/AwfulBukkitHacks.java index f7da9c45d..725f2fb1a 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/AwfulBukkitHacks.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/AwfulBukkitHacks.java @@ -27,72 +27,72 @@ import com.dfsek.terra.registry.master.ConfigRegistry; public class AwfulBukkitHacks { private static final Logger LOGGER = LoggerFactory.getLogger(AwfulBukkitHacks.class); - + private static final Map> terraBiomeMap = new HashMap<>(); - + public static void registerBiomes(ConfigRegistry configRegistry) { try { LOGGER.info("Hacking biome registry..."); WritableRegistry biomeRegistry = (WritableRegistry) RegistryFetcher.biomeRegistry(); - + Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry) biomeRegistry, false); - + configRegistry.forEach(pack -> pack.getRegistry(com.dfsek.terra.api.world.biome.Biome.class).forEach((key, biome) -> { try { BukkitPlatformBiome platformBiome = (BukkitPlatformBiome) biome.getPlatformBiome(); NamespacedKey vanillaBukkitKey = platformBiome.getHandle().getKey(); ResourceLocation vanillaMinecraftKey = new ResourceLocation(vanillaBukkitKey.getNamespace(), vanillaBukkitKey.getKey()); Biome platform = NMSBiomeInjector.createBiome(biome, Objects.requireNonNull(biomeRegistry.get(vanillaMinecraftKey))); - + ResourceKey delegateKey = ResourceKey.create( - Registries.BIOME, - new ResourceLocation("terra", NMSBiomeInjector.createBiomeID(pack, key)) - ); - + Registries.BIOME, + new ResourceLocation("terra", NMSBiomeInjector.createBiomeID(pack, key)) + ); + Reference holder = biomeRegistry.register(delegateKey, platform, Lifecycle.stable()); Reflection.REFERENCE.invokeBindValue(holder, platform); // IMPORTANT: bind holder. - + platformBiome.getContext().put(new NMSBiomeInfo(delegateKey)); - + terraBiomeMap.computeIfAbsent(vanillaMinecraftKey, i -> new ArrayList<>()).add(delegateKey.location()); - + LOGGER.debug("Registered biome: " + delegateKey); } catch(NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) { throw new RuntimeException(e); } })); - + Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry) biomeRegistry, true); // freeze registry again :) - + LOGGER.info("Doing tag garbage...."); Map, List>> collect = biomeRegistry - .getTags() // streamKeysAndEntries - .collect(HashMap::new, - (map, pair) -> - map.put(pair.getFirst(), new ArrayList<>(pair.getSecond().stream().toList())), - HashMap::putAll); - + .getTags() // streamKeysAndEntries + .collect(HashMap::new, + (map, pair) -> + map.put(pair.getFirst(), new ArrayList<>(pair.getSecond().stream().toList())), + HashMap::putAll); + terraBiomeMap - .forEach((vb, terraBiomes) -> - NMSBiomeInjector.getEntry(biomeRegistry, vb).ifPresentOrElse( - vanilla -> terraBiomes.forEach( - tb -> NMSBiomeInjector.getEntry(biomeRegistry, tb).ifPresentOrElse( - terra -> { - LOGGER.debug("{} (vanilla for {}): {}", - vanilla.unwrapKey().orElseThrow().location(), - terra.unwrapKey().orElseThrow().location(), - vanilla.tags().toList()); - vanilla.tags() - .forEach(tag -> collect - .computeIfAbsent(tag, t -> new ArrayList<>()) - .add(terra)); - }, - () -> LOGGER.error("No such biome: {}", tb))), - () -> LOGGER.error("No vanilla biome: {}", vb))); - + .forEach((vb, terraBiomes) -> + NMSBiomeInjector.getEntry(biomeRegistry, vb).ifPresentOrElse( + vanilla -> terraBiomes.forEach( + tb -> NMSBiomeInjector.getEntry(biomeRegistry, tb).ifPresentOrElse( + terra -> { + LOGGER.debug("{} (vanilla for {}): {}", + vanilla.unwrapKey().orElseThrow().location(), + terra.unwrapKey().orElseThrow().location(), + vanilla.tags().toList()); + vanilla.tags() + .forEach(tag -> collect + .computeIfAbsent(tag, t -> new ArrayList<>()) + .add(terra)); + }, + () -> LOGGER.error("No such biome: {}", tb))), + () -> LOGGER.error("No vanilla biome: {}", vb))); + biomeRegistry.resetTags(); biomeRegistry.bindTags(ImmutableMap.copyOf(collect)); - + } catch(SecurityException | IllegalArgumentException exception) { throw new RuntimeException(exception); } diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeInjector.java index 7067437dd..0b8c36a50 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeInjector.java @@ -15,63 +15,63 @@ import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; public class NMSBiomeInjector { - + public static Optional> getEntry(Registry registry, ResourceLocation identifier) { return registry.getOptional(identifier) - .flatMap(registry::getResourceKey) - .flatMap(registry::getHolder); + .flatMap(registry::getResourceKey) + .flatMap(registry::getHolder); } - + public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { Biome.BiomeBuilder builder = new Biome.BiomeBuilder(); - + builder - .precipitation(vanilla.getPrecipitation()) - .downfall(vanilla.getDownfall()) - .temperature(vanilla.getBaseTemperature()) - .mobSpawnSettings(vanilla.getMobSettings()) - .generationSettings(vanilla.getGenerationSettings()); - - + .precipitation(vanilla.getPrecipitation()) + .downfall(vanilla.getDownfall()) + .temperature(vanilla.getBaseTemperature()) + .mobSpawnSettings(vanilla.getMobSettings()) + .generationSettings(vanilla.getGenerationSettings()); + + BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder(); - + effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier()); - + VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); - + effects.fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor())) - - .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) - - .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) - - .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); - + + .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) + + .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) + + .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); + if(vanillaBiomeProperties.getFoliageColor() == null) { vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride); } else { effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor()); } - + if(vanillaBiomeProperties.getGrassColor() == null) { vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride); } else { // grass effects.grassColorOverride(vanillaBiomeProperties.getGrassColor()); } - + vanilla.getAmbientLoop().ifPresent(effects::ambientLoopSound); vanilla.getAmbientAdditions().ifPresent(effects::ambientAdditionsSound); vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound); vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic); vanilla.getAmbientParticle().ifPresent(effects::ambientParticle); - + builder.specialEffects(effects.build()); - + return builder.build(); } - + public static String createBiomeID(ConfigPack pack, com.dfsek.terra.api.registry.key.RegistryKey biomeID) { return pack.getID() .toLowerCase() + "/" + biomeID.getNamespace().toLowerCase(Locale.ROOT) + "/" + biomeID.getID().toLowerCase(Locale.ROOT); diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeProvider.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeProvider.java index 7c3820aad..4e4b9f1c5 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeProvider.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeProvider.java @@ -16,27 +16,27 @@ public class NMSBiomeProvider extends BiomeSource { private final BiomeProvider delegate; private final long seed; private final Registry biomeRegistry = RegistryFetcher.biomeRegistry(); - + public NMSBiomeProvider(BiomeProvider delegate, long seed) { super(delegate.stream() - .map(biome -> RegistryFetcher.biomeRegistry() - .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() - .get(NMSBiomeInfo.class) - .biomeKey()))); + .map(biome -> RegistryFetcher.biomeRegistry() + .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey()))); this.delegate = delegate; this.seed = seed; } - + @Override protected @NotNull Codec codec() { return BiomeSource.CODEC; } - + @Override public @NotNull Holder getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) { return biomeRegistry.getHolderOrThrow(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed) - .getPlatformBiome()).getContext() - .get(NMSBiomeInfo.class) - .biomeKey()); + .getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey()); } } diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSChunkGeneratorDelegate.java index b057b808a..9059326ca 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSChunkGeneratorDelegate.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSChunkGeneratorDelegate.java @@ -38,12 +38,12 @@ import com.dfsek.terra.bukkit.world.block.data.BukkitBlockState; public class NMSChunkGeneratorDelegate extends ChunkGenerator { private static final Logger LOGGER = LoggerFactory.getLogger(NMSChunkGeneratorDelegate.class); private final com.dfsek.terra.api.world.chunk.generation.ChunkGenerator delegate; - + private final ChunkGenerator vanilla; private final ConfigPack pack; - + private final long seed; - + public NMSChunkGeneratorDelegate(ChunkGenerator vanilla, ConfigPack pack, NMSBiomeProvider biomeProvider, long seed) { super(biomeProvider); this.delegate = pack.getGeneratorProvider().newInstance(pack); @@ -51,57 +51,57 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { this.pack = pack; this.seed = seed; } - + @Override protected @NotNull Codec codec() { return ChunkGenerator.CODEC; } - + @Override public void applyCarvers(@NotNull WorldGenRegion chunkRegion, long seed, @NotNull RandomState noiseConfig, @NotNull BiomeManager world, @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk, @NotNull Carving carverStep) { // no-op } - + @Override public void buildSurface(@NotNull WorldGenRegion region, @NotNull StructureManager structures, @NotNull RandomState noiseConfig, @NotNull ChunkAccess chunk) { // no-op } - + @Override public void applyBiomeDecoration(@NotNull WorldGenLevel world, @NotNull ChunkAccess chunk, @NotNull StructureManager structureAccessor) { vanilla.applyBiomeDecoration(world, chunk, structureAccessor); } - + @Override public void spawnOriginalMobs(@NotNull WorldGenRegion region) { vanilla.spawnOriginalMobs(region); } - + @Override public int getGenDepth() { return vanilla.getGenDepth(); } - + @Override public @NotNull CompletableFuture fillFromNoise(@NotNull Executor executor, @NotNull Blender blender, @NotNull RandomState noiseConfig, @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) { return vanilla.fillFromNoise(executor, blender, noiseConfig, structureAccessor, chunk) - .thenApply(c -> { - LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); - BiomeProvider biomeProvider = pack.getBiomeProvider(); - PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); - if(compatibilityOptions.isBeard()) { - beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), - biomeProvider, compatibilityOptions); - } - return c; - }); + .thenApply(c -> { + LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); + BiomeProvider biomeProvider = pack.getBiomeProvider(); + PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); + if(compatibilityOptions.isBeard()) { + beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), + biomeProvider, compatibilityOptions); + } + return c; + }); } - + private void beard(StructureManager structureAccessor, ChunkAccess chunk, WorldProperties world, BiomeProvider biomeProvider, PreLoadCompatibilityOptions compatibilityOptions) { Beardifier structureWeightSampler = Beardifier.forStructuresInChunk(structureAccessor, chunk.getPos()); @@ -116,8 +116,8 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { double noise = structureWeightSampler.compute(new SinglePointContext(x + xi, y, z + zi)); if(noise > threshold) { chunk.setBlockState(new BlockPos(x, y, z), ((CraftBlockData) ((BukkitBlockState) delegate - .getPalette(x + xi, y, z + zi, world, biomeProvider) - .get(depth, x + xi, y, z + zi, world.getSeed())).getHandle()).getState(), false); + .getPalette(x + xi, y, z + zi, world, biomeProvider) + .get(depth, x + xi, y, z + zi, world.getSeed())).getHandle()).getState(), false); depth++; } else if(noise < airThreshold) { chunk.setBlockState(new BlockPos(x, y, z), Blocks.AIR.defaultBlockState(), false); @@ -128,29 +128,29 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { } } } - + @Override public int getSeaLevel() { return vanilla.getSeaLevel(); } - + @Override public int getMinY() { return vanilla.getMinY(); } - + @Override public int getBaseHeight(int x, int z, @NotNull Types heightmap, @NotNull LevelHeightAccessor world, @NotNull RandomState noiseConfig) { WorldProperties properties = new NMSWorldProperties(seed, world); int y = properties.getMaxHeight(); BiomeProvider biomeProvider = pack.getBiomeProvider(); while(y >= getMinY() && !heightmap.isOpaque().test( - ((CraftBlockData) delegate.getBlock(properties, x, y - 1, z, biomeProvider).getHandle()).getState())) { + ((CraftBlockData) delegate.getBlock(properties, x, y - 1, z, biomeProvider).getHandle()).getState())) { y--; } return y; } - + @Override public @NotNull NoiseColumn getBaseColumn(int x, int z, @NotNull LevelHeightAccessor world, @NotNull RandomState noiseConfig) { /* @@ -166,9 +166,9 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { */ return vanilla.getBaseColumn(x, z, world, noiseConfig); } - + @Override public void addDebugScreenInfo(@NotNull List text, @NotNull RandomState noiseConfig, @NotNull BlockPos pos) { - + } } diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSInjectListener.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSInjectListener.java index b805bfd61..6ce184da0 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSInjectListener.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSInjectListener.java @@ -22,7 +22,7 @@ public class NMSInjectListener implements Listener { private static final Logger LOGGER = LoggerFactory.getLogger(NMSInjectListener.class); private static final Set INJECTED = new HashSet<>(); private static final ReentrantLock INJECT_LOCK = new ReentrantLock(); - + @EventHandler public void onWorldInit(WorldInitEvent event) { if(!INJECTED.contains(event.getWorld()) && @@ -32,16 +32,16 @@ public class NMSInjectListener implements Listener { LOGGER.info("Preparing to take over the world: {}", event.getWorld().getName()); CraftWorld craftWorld = (CraftWorld) event.getWorld(); ServerLevel serverWorld = craftWorld.getHandle(); - + ConfigPack pack = bukkitChunkGeneratorWrapper.getPack(); - + ChunkGenerator vanilla = serverWorld.getChunkSource().getGenerator(); NMSBiomeProvider provider = new NMSBiomeProvider(pack.getBiomeProvider(), craftWorld.getSeed()); - + serverWorld.getChunkSource().chunkMap.generator = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed()); - + LOGGER.info("Successfully injected into world."); - + INJECT_LOCK.unlock(); } } diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSWorldProperties.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSWorldProperties.java index cee2284d0..9e1989451 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSWorldProperties.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSWorldProperties.java @@ -8,27 +8,27 @@ import com.dfsek.terra.api.world.info.WorldProperties; public class NMSWorldProperties implements WorldProperties { private final long seed; private final LevelHeightAccessor height; - + public NMSWorldProperties(long seed, LevelHeightAccessor height) { this.seed = seed; this.height = height; } - + @Override public Object getHandle() { return height; } - + @Override public long getSeed() { return seed; } - + @Override public int getMaxHeight() { return height.getMaxBuildHeight(); } - + @Override public int getMinHeight() { return height.getMinBuildHeight(); diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/Reflection.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/Reflection.java index fd602468e..d0f933258 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/Reflection.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/Reflection.java @@ -16,34 +16,34 @@ import xyz.jpenilla.reflectionremapper.proxy.annotation.Proxies; public class Reflection { public static final MappedRegistryProxy MAPPED_REGISTRY; public static final StructureManagerProxy STRUCTURE_MANAGER; - + public static final ReferenceProxy REFERENCE; - + static { ReflectionRemapper reflectionRemapper = ReflectionRemapper.forReobfMappingsInPaperJar(); ReflectionProxyFactory reflectionProxyFactory = ReflectionProxyFactory.create(reflectionRemapper, - Reflection.class.getClassLoader()); - + Reflection.class.getClassLoader()); + MAPPED_REGISTRY = reflectionProxyFactory.reflectionProxy(MappedRegistryProxy.class); STRUCTURE_MANAGER = reflectionProxyFactory.reflectionProxy(StructureManagerProxy.class); REFERENCE = reflectionProxyFactory.reflectionProxy(ReferenceProxy.class); } - - + + @Proxies(MappedRegistry.class) public interface MappedRegistryProxy { @FieldSetter("frozen") void setFrozen(MappedRegistry instance, boolean frozen); } - - + + @Proxies(StructureManager.class) public interface StructureManagerProxy { @FieldGetter("level") LevelAccessor getLevel(StructureManager instance); } - - + + @Proxies(Holder.Reference.class) public interface ReferenceProxy { @MethodName("bindValue") diff --git a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/RegistryFetcher.java b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/RegistryFetcher.java index 904fba60b..ed353eafc 100644 --- a/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/RegistryFetcher.java +++ b/platforms/bukkit/nms/v1_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/RegistryFetcher.java @@ -14,10 +14,10 @@ public class RegistryFetcher { CraftServer craftserver = (CraftServer) Bukkit.getServer(); DedicatedServer dedicatedserver = craftserver.getServer(); return dedicatedserver - .registryAccess() - .registryOrThrow(key); + .registryAccess() + .registryOrThrow(key); } - + public static Registry biomeRegistry() { return getRegistry(Registries.BIOME); } diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/AwfulBukkitHacks.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/AwfulBukkitHacks.java index 6ce0cc9a5..b2ac9d28b 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/AwfulBukkitHacks.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/AwfulBukkitHacks.java @@ -27,72 +27,72 @@ import com.dfsek.terra.registry.master.ConfigRegistry; public class AwfulBukkitHacks { private static final Logger LOGGER = LoggerFactory.getLogger(AwfulBukkitHacks.class); - + private static final Map> terraBiomeMap = new HashMap<>(); - + public static void registerBiomes(ConfigRegistry configRegistry) { try { LOGGER.info("Hacking biome registry..."); WritableRegistry biomeRegistry = (WritableRegistry) RegistryFetcher.biomeRegistry(); - + Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry) biomeRegistry, false); - + configRegistry.forEach(pack -> pack.getRegistry(com.dfsek.terra.api.world.biome.Biome.class).forEach((key, biome) -> { try { BukkitPlatformBiome platformBiome = (BukkitPlatformBiome) biome.getPlatformBiome(); NamespacedKey vanillaBukkitKey = platformBiome.getHandle().getKey(); ResourceLocation vanillaMinecraftKey = new ResourceLocation(vanillaBukkitKey.getNamespace(), vanillaBukkitKey.getKey()); Biome platform = NMSBiomeInjector.createBiome(biome, Objects.requireNonNull(biomeRegistry.get(vanillaMinecraftKey))); - + ResourceKey delegateKey = ResourceKey.create( - Registries.BIOME, - new ResourceLocation("terra", NMSBiomeInjector.createBiomeID(pack, key)) - ); - + Registries.BIOME, + new ResourceLocation("terra", NMSBiomeInjector.createBiomeID(pack, key)) + ); + Reference holder = biomeRegistry.register(delegateKey, platform, Lifecycle.stable()); Reflection.REFERENCE.invokeBindValue(holder, platform); // IMPORTANT: bind holder. - + platformBiome.getContext().put(new NMSBiomeInfo(delegateKey)); - + terraBiomeMap.computeIfAbsent(vanillaMinecraftKey, i -> new ArrayList<>()).add(delegateKey.location()); - + LOGGER.debug("Registered biome: " + delegateKey); } catch(NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) { throw new RuntimeException(e); } })); - + Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry) biomeRegistry, true); // freeze registry again :) - + LOGGER.info("Doing tag garbage...."); Map, List>> collect = biomeRegistry - .getTags() // streamKeysAndEntries - .collect(HashMap::new, - (map, pair) -> - map.put(pair.getFirst(), new ArrayList<>(pair.getSecond().stream().toList())), - HashMap::putAll); - + .getTags() // streamKeysAndEntries + .collect(HashMap::new, + (map, pair) -> + map.put(pair.getFirst(), new ArrayList<>(pair.getSecond().stream().toList())), + HashMap::putAll); + terraBiomeMap - .forEach((vb, terraBiomes) -> - NMSBiomeInjector.getEntry(biomeRegistry, vb).ifPresentOrElse( - vanilla -> terraBiomes.forEach( - tb -> NMSBiomeInjector.getEntry(biomeRegistry, tb).ifPresentOrElse( - terra -> { - LOGGER.debug("{} (vanilla for {}): {}", - vanilla.unwrapKey().orElseThrow().location(), - terra.unwrapKey().orElseThrow().location(), - vanilla.tags().toList()); - vanilla.tags() - .forEach(tag -> collect - .computeIfAbsent(tag, t -> new ArrayList<>()) - .add(terra)); - }, - () -> LOGGER.error("No such biome: {}", tb))), - () -> LOGGER.error("No vanilla biome: {}", vb))); - + .forEach((vb, terraBiomes) -> + NMSBiomeInjector.getEntry(biomeRegistry, vb).ifPresentOrElse( + vanilla -> terraBiomes.forEach( + tb -> NMSBiomeInjector.getEntry(biomeRegistry, tb).ifPresentOrElse( + terra -> { + LOGGER.debug("{} (vanilla for {}): {}", + vanilla.unwrapKey().orElseThrow().location(), + terra.unwrapKey().orElseThrow().location(), + vanilla.tags().toList()); + vanilla.tags() + .forEach(tag -> collect + .computeIfAbsent(tag, t -> new ArrayList<>()) + .add(terra)); + }, + () -> LOGGER.error("No such biome: {}", tb))), + () -> LOGGER.error("No vanilla biome: {}", vb))); + biomeRegistry.resetTags(); biomeRegistry.bindTags(ImmutableMap.copyOf(collect)); - + } catch(SecurityException | IllegalArgumentException exception) { throw new RuntimeException(exception); } diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeInjector.java index 71c81d511..733fd38f4 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeInjector.java @@ -15,62 +15,62 @@ import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; public class NMSBiomeInjector { - + public static Optional> getEntry(Registry registry, ResourceLocation identifier) { return registry.getOptional(identifier) - .flatMap(registry::getResourceKey) - .flatMap(registry::getHolder); + .flatMap(registry::getResourceKey) + .flatMap(registry::getHolder); } - + public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { Biome.BiomeBuilder builder = new Biome.BiomeBuilder(); - + builder - .downfall(vanilla.climateSettings.downfall()) - .temperature(vanilla.getBaseTemperature()) - .mobSpawnSettings(vanilla.getMobSettings()) - .generationSettings(vanilla.getGenerationSettings()); - - + .downfall(vanilla.climateSettings.downfall()) + .temperature(vanilla.getBaseTemperature()) + .mobSpawnSettings(vanilla.getMobSettings()) + .generationSettings(vanilla.getGenerationSettings()); + + BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder(); - + effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier()); - + VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); - + effects.fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor())) - - .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) - - .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) - - .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); - + + .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) + + .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) + + .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); + if(vanillaBiomeProperties.getFoliageColor() == null) { vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride); } else { effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor()); } - + if(vanillaBiomeProperties.getGrassColor() == null) { vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride); } else { // grass effects.grassColorOverride(vanillaBiomeProperties.getGrassColor()); } - + vanilla.getAmbientLoop().ifPresent(effects::ambientLoopSound); vanilla.getAmbientAdditions().ifPresent(effects::ambientAdditionsSound); vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound); vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic); vanilla.getAmbientParticle().ifPresent(effects::ambientParticle); - + builder.specialEffects(effects.build()); - + return builder.build(); } - + public static String createBiomeID(ConfigPack pack, com.dfsek.terra.api.registry.key.RegistryKey biomeID) { return pack.getID() .toLowerCase() + "/" + biomeID.getNamespace().toLowerCase(Locale.ROOT) + "/" + biomeID.getID().toLowerCase(Locale.ROOT); diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeProvider.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeProvider.java index 60a82f58e..ed5ea1589 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeProvider.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeProvider.java @@ -18,32 +18,32 @@ public class NMSBiomeProvider extends BiomeSource { private final BiomeProvider delegate; private final long seed; private final Registry biomeRegistry = RegistryFetcher.biomeRegistry(); - + public NMSBiomeProvider(BiomeProvider delegate, long seed) { super(); this.delegate = delegate; this.seed = seed; } - + @Override protected Stream> collectPossibleBiomes() { return delegate.stream() - .map(biome -> RegistryFetcher.biomeRegistry() - .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() - .get(NMSBiomeInfo.class) - .biomeKey())); + .map(biome -> RegistryFetcher.biomeRegistry() + .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey())); } - + @Override protected @NotNull Codec codec() { return BiomeSource.CODEC; } - + @Override public @NotNull Holder getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) { return biomeRegistry.getHolderOrThrow(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed) - .getPlatformBiome()).getContext() - .get(NMSBiomeInfo.class) - .biomeKey()); + .getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey()); } } diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSChunkGeneratorDelegate.java index 97eba7114..c697bd0c1 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSChunkGeneratorDelegate.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSChunkGeneratorDelegate.java @@ -39,12 +39,12 @@ import com.dfsek.terra.bukkit.world.block.data.BukkitBlockState; public class NMSChunkGeneratorDelegate extends ChunkGenerator { private static final Logger LOGGER = LoggerFactory.getLogger(NMSChunkGeneratorDelegate.class); private final com.dfsek.terra.api.world.chunk.generation.ChunkGenerator delegate; - + private final ChunkGenerator vanilla; private final ConfigPack pack; - + private final long seed; - + public NMSChunkGeneratorDelegate(ChunkGenerator vanilla, ConfigPack pack, NMSBiomeProvider biomeProvider, long seed) { super(biomeProvider); this.delegate = pack.getGeneratorProvider().newInstance(pack); @@ -52,57 +52,57 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { this.pack = pack; this.seed = seed; } - + @Override protected @NotNull Codec codec() { return ChunkGenerator.CODEC; } - + @Override public void applyCarvers(@NotNull WorldGenRegion chunkRegion, long seed, @NotNull RandomState noiseConfig, @NotNull BiomeManager world, @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk, @NotNull Carving carverStep) { // no-op } - + @Override public void buildSurface(@NotNull WorldGenRegion region, @NotNull StructureManager structures, @NotNull RandomState noiseConfig, @NotNull ChunkAccess chunk) { // no-op } - + @Override public void applyBiomeDecoration(@NotNull WorldGenLevel world, @NotNull ChunkAccess chunk, @NotNull StructureManager structureAccessor) { vanilla.applyBiomeDecoration(world, chunk, structureAccessor); } - + @Override public void spawnOriginalMobs(@NotNull WorldGenRegion region) { vanilla.spawnOriginalMobs(region); } - + @Override public int getGenDepth() { return vanilla.getGenDepth(); } - + @Override public @NotNull CompletableFuture fillFromNoise(@NotNull Executor executor, @NotNull Blender blender, @NotNull RandomState noiseConfig, @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) { return vanilla.fillFromNoise(executor, blender, noiseConfig, structureAccessor, chunk) - .thenApply(c -> { - LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); - BiomeProvider biomeProvider = pack.getBiomeProvider(); - PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); - if(compatibilityOptions.isBeard()) { - beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), - biomeProvider, compatibilityOptions); - } - return c; - }); + .thenApply(c -> { + LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); + BiomeProvider biomeProvider = pack.getBiomeProvider(); + PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); + if(compatibilityOptions.isBeard()) { + beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), + biomeProvider, compatibilityOptions); + } + return c; + }); } - + private void beard(StructureManager structureAccessor, ChunkAccess chunk, WorldProperties world, BiomeProvider biomeProvider, PreLoadCompatibilityOptions compatibilityOptions) { Beardifier structureWeightSampler = Beardifier.forStructuresInChunk(structureAccessor, chunk.getPos()); @@ -117,8 +117,8 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { double noise = structureWeightSampler.compute(new SinglePointContext(x + xi, y, z + zi)); if(noise > threshold) { chunk.setBlockState(new BlockPos(x, y, z), ((CraftBlockData) ((BukkitBlockState) delegate - .getPalette(x + xi, y, z + zi, world, biomeProvider) - .get(depth, x + xi, y, z + zi, world.getSeed())).getHandle()).getState(), false); + .getPalette(x + xi, y, z + zi, world, biomeProvider) + .get(depth, x + xi, y, z + zi, world.getSeed())).getHandle()).getState(), false); depth++; } else if(noise < airThreshold) { chunk.setBlockState(new BlockPos(x, y, z), Blocks.AIR.defaultBlockState(), false); @@ -129,29 +129,29 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { } } } - + @Override public int getSeaLevel() { return vanilla.getSeaLevel(); } - + @Override public int getMinY() { return vanilla.getMinY(); } - + @Override public int getBaseHeight(int x, int z, @NotNull Types heightmap, @NotNull LevelHeightAccessor world, @NotNull RandomState noiseConfig) { WorldProperties properties = new NMSWorldProperties(seed, world); int y = properties.getMaxHeight(); BiomeProvider biomeProvider = pack.getBiomeProvider(); while(y >= getMinY() && !heightmap.isOpaque().test( - ((CraftBlockData) delegate.getBlock(properties, x, y - 1, z, biomeProvider).getHandle()).getState())) { + ((CraftBlockData) delegate.getBlock(properties, x, y - 1, z, biomeProvider).getHandle()).getState())) { y--; } return y; } - + @Override public @NotNull NoiseColumn getBaseColumn(int x, int z, @NotNull LevelHeightAccessor world, @NotNull RandomState noiseConfig) { BlockState[] array = new BlockState[world.getHeight()]; @@ -159,13 +159,13 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { BiomeProvider biomeProvider = pack.getBiomeProvider(); for(int y = properties.getMaxHeight() - 1; y >= properties.getMinHeight(); y--) { array[y - properties.getMinHeight()] = ((CraftBlockData) delegate.getBlock(properties, x, y, z, biomeProvider) - .getHandle()).getState(); + .getHandle()).getState(); } return new NoiseColumn(getMinY(), array); } - + @Override public void addDebugScreenInfo(@NotNull List text, @NotNull RandomState noiseConfig, @NotNull BlockPos pos) { - + } } diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInitializer.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInitializer.java index a5e286f00..99797e8ab 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInitializer.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInitializer.java @@ -1,10 +1,10 @@ package com.dfsek.terra.bukkit.nms.v1_19_R3; +import org.bukkit.Bukkit; + import com.dfsek.terra.bukkit.PlatformImpl; import com.dfsek.terra.bukkit.nms.Initializer; -import org.bukkit.Bukkit; - public class NMSInitializer implements Initializer { @Override diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInjectListener.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInjectListener.java index 2b8383b3d..78da74f65 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInjectListener.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInjectListener.java @@ -22,7 +22,7 @@ public class NMSInjectListener implements Listener { private static final Logger LOGGER = LoggerFactory.getLogger(NMSInjectListener.class); private static final Set INJECTED = new HashSet<>(); private static final ReentrantLock INJECT_LOCK = new ReentrantLock(); - + @EventHandler public void onWorldInit(WorldInitEvent event) { if(!INJECTED.contains(event.getWorld()) && @@ -32,16 +32,16 @@ public class NMSInjectListener implements Listener { LOGGER.info("Preparing to take over the world: {}", event.getWorld().getName()); CraftWorld craftWorld = (CraftWorld) event.getWorld(); ServerLevel serverWorld = craftWorld.getHandle(); - + ConfigPack pack = bukkitChunkGeneratorWrapper.getPack(); - + ChunkGenerator vanilla = serverWorld.getChunkSource().getGenerator(); NMSBiomeProvider provider = new NMSBiomeProvider(pack.getBiomeProvider(), craftWorld.getSeed()); - + serverWorld.getChunkSource().chunkMap.generator = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed()); - + LOGGER.info("Successfully injected into world."); - + INJECT_LOCK.unlock(); } } diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSWorldProperties.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSWorldProperties.java index 0c88eec33..2cda90452 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSWorldProperties.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSWorldProperties.java @@ -8,27 +8,27 @@ import com.dfsek.terra.api.world.info.WorldProperties; public class NMSWorldProperties implements WorldProperties { private final long seed; private final LevelHeightAccessor height; - + public NMSWorldProperties(long seed, LevelHeightAccessor height) { this.seed = seed; this.height = height; } - + @Override public Object getHandle() { return height; } - + @Override public long getSeed() { return seed; } - + @Override public int getMaxHeight() { return height.getMaxBuildHeight(); } - + @Override public int getMinHeight() { return height.getMinBuildHeight(); diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/Reflection.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/Reflection.java index c0c9136ae..43d362ee6 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/Reflection.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/Reflection.java @@ -16,34 +16,34 @@ import xyz.jpenilla.reflectionremapper.proxy.annotation.Proxies; public class Reflection { public static final MappedRegistryProxy MAPPED_REGISTRY; public static final StructureManagerProxy STRUCTURE_MANAGER; - + public static final ReferenceProxy REFERENCE; - + static { ReflectionRemapper reflectionRemapper = ReflectionRemapper.forReobfMappingsInPaperJar(); ReflectionProxyFactory reflectionProxyFactory = ReflectionProxyFactory.create(reflectionRemapper, - Reflection.class.getClassLoader()); - + Reflection.class.getClassLoader()); + MAPPED_REGISTRY = reflectionProxyFactory.reflectionProxy(MappedRegistryProxy.class); STRUCTURE_MANAGER = reflectionProxyFactory.reflectionProxy(StructureManagerProxy.class); REFERENCE = reflectionProxyFactory.reflectionProxy(ReferenceProxy.class); } - - + + @Proxies(MappedRegistry.class) public interface MappedRegistryProxy { @FieldSetter("frozen") void setFrozen(MappedRegistry instance, boolean frozen); } - - + + @Proxies(StructureManager.class) public interface StructureManagerProxy { @FieldGetter("level") LevelAccessor getLevel(StructureManager instance); } - - + + @Proxies(Holder.Reference.class) public interface ReferenceProxy { @MethodName("bindValue") diff --git a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/RegistryFetcher.java b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/RegistryFetcher.java index 5147eb360..e033491bb 100644 --- a/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/RegistryFetcher.java +++ b/platforms/bukkit/nms/v1_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/RegistryFetcher.java @@ -14,10 +14,10 @@ public class RegistryFetcher { CraftServer craftserver = (CraftServer) Bukkit.getServer(); DedicatedServer dedicatedserver = craftserver.getServer(); return dedicatedserver - .registryAccess() - .registryOrThrow(key); + .registryAccess() + .registryOrThrow(key); } - + public static Registry biomeRegistry() { return getRegistry(Registries.BIOME); } diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/AwfulBukkitHacks.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/AwfulBukkitHacks.java index c30882958..7994a0074 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/AwfulBukkitHacks.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/AwfulBukkitHacks.java @@ -27,72 +27,72 @@ import com.dfsek.terra.registry.master.ConfigRegistry; public class AwfulBukkitHacks { private static final Logger LOGGER = LoggerFactory.getLogger(AwfulBukkitHacks.class); - + private static final Map> terraBiomeMap = new HashMap<>(); - + public static void registerBiomes(ConfigRegistry configRegistry) { try { LOGGER.info("Hacking biome registry..."); WritableRegistry biomeRegistry = (WritableRegistry) RegistryFetcher.biomeRegistry(); - + Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry) biomeRegistry, false); - + configRegistry.forEach(pack -> pack.getRegistry(com.dfsek.terra.api.world.biome.Biome.class).forEach((key, biome) -> { try { BukkitPlatformBiome platformBiome = (BukkitPlatformBiome) biome.getPlatformBiome(); NamespacedKey vanillaBukkitKey = platformBiome.getHandle().getKey(); ResourceLocation vanillaMinecraftKey = new ResourceLocation(vanillaBukkitKey.getNamespace(), vanillaBukkitKey.getKey()); Biome platform = NMSBiomeInjector.createBiome(biome, Objects.requireNonNull(biomeRegistry.get(vanillaMinecraftKey))); - + ResourceKey delegateKey = ResourceKey.create( - Registries.BIOME, - new ResourceLocation("terra", NMSBiomeInjector.createBiomeID(pack, key)) - ); - + Registries.BIOME, + new ResourceLocation("terra", NMSBiomeInjector.createBiomeID(pack, key)) + ); + Reference holder = biomeRegistry.register(delegateKey, platform, Lifecycle.stable()); Reflection.REFERENCE.invokeBindValue(holder, platform); // IMPORTANT: bind holder. - + platformBiome.getContext().put(new NMSBiomeInfo(delegateKey)); - + terraBiomeMap.computeIfAbsent(vanillaMinecraftKey, i -> new ArrayList<>()).add(delegateKey.location()); - + LOGGER.debug("Registered biome: " + delegateKey); } catch(NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) { throw new RuntimeException(e); } })); - + Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry) biomeRegistry, true); // freeze registry again :) - + LOGGER.info("Doing tag garbage...."); Map, List>> collect = biomeRegistry - .getTags() // streamKeysAndEntries - .collect(HashMap::new, - (map, pair) -> - map.put(pair.getFirst(), new ArrayList<>(pair.getSecond().stream().toList())), - HashMap::putAll); - + .getTags() // streamKeysAndEntries + .collect(HashMap::new, + (map, pair) -> + map.put(pair.getFirst(), new ArrayList<>(pair.getSecond().stream().toList())), + HashMap::putAll); + terraBiomeMap - .forEach((vb, terraBiomes) -> - NMSBiomeInjector.getEntry(biomeRegistry, vb).ifPresentOrElse( - vanilla -> terraBiomes.forEach( - tb -> NMSBiomeInjector.getEntry(biomeRegistry, tb).ifPresentOrElse( - terra -> { - LOGGER.debug("{} (vanilla for {}): {}", - vanilla.unwrapKey().orElseThrow().location(), - terra.unwrapKey().orElseThrow().location(), - vanilla.tags().toList()); - vanilla.tags() - .forEach(tag -> collect - .computeIfAbsent(tag, t -> new ArrayList<>()) - .add(terra)); - }, - () -> LOGGER.error("No such biome: {}", tb))), - () -> LOGGER.error("No vanilla biome: {}", vb))); - + .forEach((vb, terraBiomes) -> + NMSBiomeInjector.getEntry(biomeRegistry, vb).ifPresentOrElse( + vanilla -> terraBiomes.forEach( + tb -> NMSBiomeInjector.getEntry(biomeRegistry, tb).ifPresentOrElse( + terra -> { + LOGGER.debug("{} (vanilla for {}): {}", + vanilla.unwrapKey().orElseThrow().location(), + terra.unwrapKey().orElseThrow().location(), + vanilla.tags().toList()); + vanilla.tags() + .forEach(tag -> collect + .computeIfAbsent(tag, t -> new ArrayList<>()) + .add(terra)); + }, + () -> LOGGER.error("No such biome: {}", tb))), + () -> LOGGER.error("No vanilla biome: {}", vb))); + biomeRegistry.resetTags(); biomeRegistry.bindTags(ImmutableMap.copyOf(collect)); - + } catch(SecurityException | IllegalArgumentException exception) { throw new RuntimeException(exception); } diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInfo.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInfo.java index 5978f935f..7d8203ce3 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInfo.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInfo.java @@ -1,10 +1,10 @@ package com.dfsek.terra.bukkit.nms.v1_20_R1; -import com.dfsek.terra.api.properties.Properties; - import net.minecraft.resources.ResourceKey; import net.minecraft.world.level.biome.Biome; +import com.dfsek.terra.api.properties.Properties; + public record NMSBiomeInfo(ResourceKey biomeKey) implements Properties { } diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java index a0245f021..8c13d05b1 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java @@ -15,62 +15,62 @@ import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; public class NMSBiomeInjector { - + public static Optional> getEntry(Registry registry, ResourceLocation identifier) { return registry.getOptional(identifier) - .flatMap(registry::getResourceKey) - .flatMap(registry::getHolder); + .flatMap(registry::getResourceKey) + .flatMap(registry::getHolder); } - + public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { Biome.BiomeBuilder builder = new Biome.BiomeBuilder(); - + builder - .downfall(vanilla.climateSettings.downfall()) - .temperature(vanilla.getBaseTemperature()) - .mobSpawnSettings(vanilla.getMobSettings()) - .generationSettings(vanilla.getGenerationSettings()); - - + .downfall(vanilla.climateSettings.downfall()) + .temperature(vanilla.getBaseTemperature()) + .mobSpawnSettings(vanilla.getMobSettings()) + .generationSettings(vanilla.getGenerationSettings()); + + BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder(); - + effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier()); - + VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); - + effects.fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor())) - - .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) - - .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) - - .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); - + + .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) + + .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) + + .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); + if(vanillaBiomeProperties.getFoliageColor() == null) { vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride); } else { effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor()); } - + if(vanillaBiomeProperties.getGrassColor() == null) { vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride); } else { // grass effects.grassColorOverride(vanillaBiomeProperties.getGrassColor()); } - + vanilla.getAmbientLoop().ifPresent(effects::ambientLoopSound); vanilla.getAmbientAdditions().ifPresent(effects::ambientAdditionsSound); vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound); vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic); vanilla.getAmbientParticle().ifPresent(effects::ambientParticle); - + builder.specialEffects(effects.build()); - + return builder.build(); } - + public static String createBiomeID(ConfigPack pack, com.dfsek.terra.api.registry.key.RegistryKey biomeID) { return pack.getID() .toLowerCase() + "/" + biomeID.getNamespace().toLowerCase(Locale.ROOT) + "/" + biomeID.getID().toLowerCase(Locale.ROOT); diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java index 17902f30c..48f048318 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java @@ -18,32 +18,32 @@ public class NMSBiomeProvider extends BiomeSource { private final BiomeProvider delegate; private final long seed; private final Registry biomeRegistry = RegistryFetcher.biomeRegistry(); - + public NMSBiomeProvider(BiomeProvider delegate, long seed) { super(); this.delegate = delegate; this.seed = seed; } - + @Override protected Stream> collectPossibleBiomes() { return delegate.stream() - .map(biome -> RegistryFetcher.biomeRegistry() - .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() - .get(NMSBiomeInfo.class) - .biomeKey())); + .map(biome -> RegistryFetcher.biomeRegistry() + .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey())); } - + @Override protected @NotNull Codec codec() { return BiomeSource.CODEC; } - + @Override public @NotNull Holder getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) { return biomeRegistry.getHolderOrThrow(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed) - .getPlatformBiome()).getContext() - .get(NMSBiomeInfo.class) - .biomeKey()); + .getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey()); } } diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java index fcdd63753..565d0cbc4 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSChunkGeneratorDelegate.java @@ -1,16 +1,13 @@ package com.dfsek.terra.bukkit.nms.v1_20_R1; -import com.dfsek.terra.api.config.ConfigPack; -import com.dfsek.terra.api.world.biome.generation.BiomeProvider; -import com.dfsek.terra.api.world.info.WorldProperties; -import com.dfsek.terra.bukkit.config.PreLoadCompatibilityOptions; -import com.dfsek.terra.bukkit.world.BukkitWorldProperties; -import com.dfsek.terra.bukkit.world.block.data.BukkitBlockState; - import com.mojang.serialization.Codec; import net.minecraft.core.BlockPos; import net.minecraft.server.level.WorldGenRegion; -import net.minecraft.world.level.*; +import net.minecraft.world.level.LevelAccessor; +import net.minecraft.world.level.LevelHeightAccessor; +import net.minecraft.world.level.NoiseColumn; +import net.minecraft.world.level.StructureManager; +import net.minecraft.world.level.WorldGenLevel; import net.minecraft.world.level.biome.BiomeManager; import net.minecraft.world.level.block.Blocks; import net.minecraft.world.level.block.state.BlockState; @@ -31,16 +28,23 @@ import java.util.List; import java.util.concurrent.CompletableFuture; import java.util.concurrent.Executor; +import com.dfsek.terra.api.config.ConfigPack; +import com.dfsek.terra.api.world.biome.generation.BiomeProvider; +import com.dfsek.terra.api.world.info.WorldProperties; +import com.dfsek.terra.bukkit.config.PreLoadCompatibilityOptions; +import com.dfsek.terra.bukkit.world.BukkitWorldProperties; +import com.dfsek.terra.bukkit.world.block.data.BukkitBlockState; + public class NMSChunkGeneratorDelegate extends ChunkGenerator { private static final Logger LOGGER = LoggerFactory.getLogger(NMSChunkGeneratorDelegate.class); private final com.dfsek.terra.api.world.chunk.generation.ChunkGenerator delegate; - + private final ChunkGenerator vanilla; private final ConfigPack pack; - + private final long seed; - + public NMSChunkGeneratorDelegate(ChunkGenerator vanilla, ConfigPack pack, NMSBiomeProvider biomeProvider, long seed) { super(biomeProvider); this.delegate = pack.getGeneratorProvider().newInstance(pack); @@ -48,57 +52,57 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { this.pack = pack; this.seed = seed; } - + @Override protected @NotNull Codec codec() { return ChunkGenerator.CODEC; } - + @Override public void applyCarvers(@NotNull WorldGenRegion chunkRegion, long seed, @NotNull RandomState noiseConfig, @NotNull BiomeManager world, @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk, @NotNull Carving carverStep) { // no-op } - + @Override public void buildSurface(@NotNull WorldGenRegion region, @NotNull StructureManager structures, @NotNull RandomState noiseConfig, @NotNull ChunkAccess chunk) { // no-op } - + @Override public void applyBiomeDecoration(@NotNull WorldGenLevel world, @NotNull ChunkAccess chunk, @NotNull StructureManager structureAccessor) { vanilla.applyBiomeDecoration(world, chunk, structureAccessor); } - + @Override public void spawnOriginalMobs(@NotNull WorldGenRegion region) { vanilla.spawnOriginalMobs(region); } - + @Override public int getGenDepth() { return vanilla.getGenDepth(); } - + @Override public @NotNull CompletableFuture fillFromNoise(@NotNull Executor executor, @NotNull Blender blender, @NotNull RandomState noiseConfig, @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) { return vanilla.fillFromNoise(executor, blender, noiseConfig, structureAccessor, chunk) - .thenApply(c -> { - LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); - BiomeProvider biomeProvider = pack.getBiomeProvider(); - PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); - if(compatibilityOptions.isBeard()) { - beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), - biomeProvider, compatibilityOptions); - } - return c; - }); + .thenApply(c -> { + LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); + BiomeProvider biomeProvider = pack.getBiomeProvider(); + PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); + if(compatibilityOptions.isBeard()) { + beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), + biomeProvider, compatibilityOptions); + } + return c; + }); } - + private void beard(StructureManager structureAccessor, ChunkAccess chunk, WorldProperties world, BiomeProvider biomeProvider, PreLoadCompatibilityOptions compatibilityOptions) { Beardifier structureWeightSampler = Beardifier.forStructuresInChunk(structureAccessor, chunk.getPos()); @@ -113,8 +117,8 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { double noise = structureWeightSampler.compute(new SinglePointContext(x + xi, y, z + zi)); if(noise > threshold) { chunk.setBlockState(new BlockPos(x, y, z), ((CraftBlockData) ((BukkitBlockState) delegate - .getPalette(x + xi, y, z + zi, world, biomeProvider) - .get(depth, x + xi, y, z + zi, world.getSeed())).getHandle()).getState(), false); + .getPalette(x + xi, y, z + zi, world, biomeProvider) + .get(depth, x + xi, y, z + zi, world.getSeed())).getHandle()).getState(), false); depth++; } else if(noise < airThreshold) { chunk.setBlockState(new BlockPos(x, y, z), Blocks.AIR.defaultBlockState(), false); @@ -125,29 +129,29 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { } } } - + @Override public int getSeaLevel() { return vanilla.getSeaLevel(); } - + @Override public int getMinY() { return vanilla.getMinY(); } - + @Override public int getBaseHeight(int x, int z, @NotNull Types heightmap, @NotNull LevelHeightAccessor world, @NotNull RandomState noiseConfig) { WorldProperties properties = new NMSWorldProperties(seed, world); int y = properties.getMaxHeight(); BiomeProvider biomeProvider = pack.getBiomeProvider(); while(y >= getMinY() && !heightmap.isOpaque().test( - ((CraftBlockData) delegate.getBlock(properties, x, y - 1, z, biomeProvider).getHandle()).getState())) { + ((CraftBlockData) delegate.getBlock(properties, x, y - 1, z, biomeProvider).getHandle()).getState())) { y--; } return y; } - + @Override public @NotNull NoiseColumn getBaseColumn(int x, int z, @NotNull LevelHeightAccessor world, @NotNull RandomState noiseConfig) { BlockState[] array = new BlockState[world.getHeight()]; @@ -155,13 +159,13 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { BiomeProvider biomeProvider = pack.getBiomeProvider(); for(int y = properties.getMaxHeight() - 1; y >= properties.getMinHeight(); y--) { array[y - properties.getMinHeight()] = ((CraftBlockData) delegate.getBlock(properties, x, y, z, biomeProvider) - .getHandle()).getState(); + .getHandle()).getState(); } return new NoiseColumn(getMinY(), array); } - + @Override public void addDebugScreenInfo(@NotNull List text, @NotNull RandomState noiseConfig, @NotNull BlockPos pos) { - + } } diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInjectListener.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInjectListener.java index 2d83d6c1b..3f7c9e060 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInjectListener.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInjectListener.java @@ -22,7 +22,7 @@ public class NMSInjectListener implements Listener { private static final Logger LOGGER = LoggerFactory.getLogger(NMSInjectListener.class); private static final Set INJECTED = new HashSet<>(); private static final ReentrantLock INJECT_LOCK = new ReentrantLock(); - + @EventHandler public void onWorldInit(WorldInitEvent event) { if(!INJECTED.contains(event.getWorld()) && @@ -32,16 +32,16 @@ public class NMSInjectListener implements Listener { LOGGER.info("Preparing to take over the world: {}", event.getWorld().getName()); CraftWorld craftWorld = (CraftWorld) event.getWorld(); ServerLevel serverWorld = craftWorld.getHandle(); - + ConfigPack pack = bukkitChunkGeneratorWrapper.getPack(); - + ChunkGenerator vanilla = serverWorld.getChunkSource().getGenerator(); NMSBiomeProvider provider = new NMSBiomeProvider(pack.getBiomeProvider(), craftWorld.getSeed()); - + serverWorld.getChunkSource().chunkMap.generator = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed()); - + LOGGER.info("Successfully injected into world."); - + INJECT_LOCK.unlock(); } } diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSWorldProperties.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSWorldProperties.java index 9754c7627..48effeb5f 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSWorldProperties.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSWorldProperties.java @@ -8,27 +8,27 @@ import com.dfsek.terra.api.world.info.WorldProperties; public class NMSWorldProperties implements WorldProperties { private final long seed; private final LevelHeightAccessor height; - + public NMSWorldProperties(long seed, LevelHeightAccessor height) { this.seed = seed; this.height = height; } - + @Override public Object getHandle() { return height; } - + @Override public long getSeed() { return seed; } - + @Override public int getMaxHeight() { return height.getMaxBuildHeight(); } - + @Override public int getMinHeight() { return height.getMinBuildHeight(); diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/Reflection.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/Reflection.java index f3f17b085..a11dd1b15 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/Reflection.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/Reflection.java @@ -16,34 +16,34 @@ import xyz.jpenilla.reflectionremapper.proxy.annotation.Proxies; public class Reflection { public static final MappedRegistryProxy MAPPED_REGISTRY; public static final StructureManagerProxy STRUCTURE_MANAGER; - + public static final ReferenceProxy REFERENCE; - + static { ReflectionRemapper reflectionRemapper = ReflectionRemapper.forReobfMappingsInPaperJar(); ReflectionProxyFactory reflectionProxyFactory = ReflectionProxyFactory.create(reflectionRemapper, - Reflection.class.getClassLoader()); - + Reflection.class.getClassLoader()); + MAPPED_REGISTRY = reflectionProxyFactory.reflectionProxy(MappedRegistryProxy.class); STRUCTURE_MANAGER = reflectionProxyFactory.reflectionProxy(StructureManagerProxy.class); REFERENCE = reflectionProxyFactory.reflectionProxy(ReferenceProxy.class); } - - + + @Proxies(MappedRegistry.class) public interface MappedRegistryProxy { @FieldSetter("frozen") void setFrozen(MappedRegistry instance, boolean frozen); } - - + + @Proxies(StructureManager.class) public interface StructureManagerProxy { @FieldGetter("level") LevelAccessor getLevel(StructureManager instance); } - - + + @Proxies(Holder.Reference.class) public interface ReferenceProxy { @MethodName("bindValue") diff --git a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/RegistryFetcher.java b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/RegistryFetcher.java index 9c7de5d8a..c7d77462d 100644 --- a/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/RegistryFetcher.java +++ b/platforms/bukkit/nms/v1_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/RegistryFetcher.java @@ -14,10 +14,10 @@ public class RegistryFetcher { CraftServer craftserver = (CraftServer) Bukkit.getServer(); DedicatedServer dedicatedserver = craftserver.getServer(); return dedicatedserver - .registryAccess() - .registryOrThrow(key); + .registryAccess() + .registryOrThrow(key); } - + public static Registry biomeRegistry() { return getRegistry(Registries.BIOME); } diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/AwfulBukkitHacks.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/AwfulBukkitHacks.java index 98d031de2..8023ae452 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/AwfulBukkitHacks.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/AwfulBukkitHacks.java @@ -27,72 +27,72 @@ import com.dfsek.terra.registry.master.ConfigRegistry; public class AwfulBukkitHacks { private static final Logger LOGGER = LoggerFactory.getLogger(AwfulBukkitHacks.class); - + private static final Map> terraBiomeMap = new HashMap<>(); - + public static void registerBiomes(ConfigRegistry configRegistry) { try { LOGGER.info("Hacking biome registry..."); WritableRegistry biomeRegistry = (WritableRegistry) RegistryFetcher.biomeRegistry(); - + Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry) biomeRegistry, false); - + configRegistry.forEach(pack -> pack.getRegistry(com.dfsek.terra.api.world.biome.Biome.class).forEach((key, biome) -> { try { BukkitPlatformBiome platformBiome = (BukkitPlatformBiome) biome.getPlatformBiome(); NamespacedKey vanillaBukkitKey = platformBiome.getHandle().getKey(); ResourceLocation vanillaMinecraftKey = new ResourceLocation(vanillaBukkitKey.getNamespace(), vanillaBukkitKey.getKey()); Biome platform = NMSBiomeInjector.createBiome(biome, Objects.requireNonNull(biomeRegistry.get(vanillaMinecraftKey))); - + ResourceKey delegateKey = ResourceKey.create( - Registries.BIOME, - new ResourceLocation("terra", NMSBiomeInjector.createBiomeID(pack, key)) - ); - + Registries.BIOME, + new ResourceLocation("terra", NMSBiomeInjector.createBiomeID(pack, key)) + ); + Reference holder = biomeRegistry.register(delegateKey, platform, Lifecycle.stable()); Reflection.REFERENCE.invokeBindValue(holder, platform); // IMPORTANT: bind holder. - + platformBiome.getContext().put(new NMSBiomeInfo(delegateKey)); - + terraBiomeMap.computeIfAbsent(vanillaMinecraftKey, i -> new ArrayList<>()).add(delegateKey.location()); - + LOGGER.debug("Registered biome: " + delegateKey); } catch(NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) { throw new RuntimeException(e); } })); - + Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry) biomeRegistry, true); // freeze registry again :) - + LOGGER.info("Doing tag garbage...."); Map, List>> collect = biomeRegistry - .getTags() // streamKeysAndEntries - .collect(HashMap::new, - (map, pair) -> - map.put(pair.getFirst(), new ArrayList<>(pair.getSecond().stream().toList())), - HashMap::putAll); - + .getTags() // streamKeysAndEntries + .collect(HashMap::new, + (map, pair) -> + map.put(pair.getFirst(), new ArrayList<>(pair.getSecond().stream().toList())), + HashMap::putAll); + terraBiomeMap - .forEach((vb, terraBiomes) -> - NMSBiomeInjector.getEntry(biomeRegistry, vb).ifPresentOrElse( - vanilla -> terraBiomes.forEach( - tb -> NMSBiomeInjector.getEntry(biomeRegistry, tb).ifPresentOrElse( - terra -> { - LOGGER.debug("{} (vanilla for {}): {}", - vanilla.unwrapKey().orElseThrow().location(), - terra.unwrapKey().orElseThrow().location(), - vanilla.tags().toList()); - vanilla.tags() - .forEach(tag -> collect - .computeIfAbsent(tag, t -> new ArrayList<>()) - .add(terra)); - }, - () -> LOGGER.error("No such biome: {}", tb))), - () -> LOGGER.error("No vanilla biome: {}", vb))); - + .forEach((vb, terraBiomes) -> + NMSBiomeInjector.getEntry(biomeRegistry, vb).ifPresentOrElse( + vanilla -> terraBiomes.forEach( + tb -> NMSBiomeInjector.getEntry(biomeRegistry, tb).ifPresentOrElse( + terra -> { + LOGGER.debug("{} (vanilla for {}): {}", + vanilla.unwrapKey().orElseThrow().location(), + terra.unwrapKey().orElseThrow().location(), + vanilla.tags().toList()); + vanilla.tags() + .forEach(tag -> collect + .computeIfAbsent(tag, t -> new ArrayList<>()) + .add(terra)); + }, + () -> LOGGER.error("No such biome: {}", tb))), + () -> LOGGER.error("No vanilla biome: {}", vb))); + biomeRegistry.resetTags(); biomeRegistry.bindTags(ImmutableMap.copyOf(collect)); - + } catch(SecurityException | IllegalArgumentException exception) { throw new RuntimeException(exception); } diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeInjector.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeInjector.java index a4972ce3f..b798ba4b8 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeInjector.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeInjector.java @@ -15,62 +15,62 @@ import com.dfsek.terra.bukkit.config.VanillaBiomeProperties; public class NMSBiomeInjector { - + public static Optional> getEntry(Registry registry, ResourceLocation identifier) { return registry.getOptional(identifier) - .flatMap(registry::getResourceKey) - .flatMap(registry::getHolder); + .flatMap(registry::getResourceKey) + .flatMap(registry::getHolder); } - + public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException { Biome.BiomeBuilder builder = new Biome.BiomeBuilder(); - + builder - .downfall(vanilla.climateSettings.downfall()) - .temperature(vanilla.getBaseTemperature()) - .mobSpawnSettings(vanilla.getMobSettings()) - .generationSettings(vanilla.getGenerationSettings()); - - + .downfall(vanilla.climateSettings.downfall()) + .temperature(vanilla.getBaseTemperature()) + .mobSpawnSettings(vanilla.getMobSettings()) + .generationSettings(vanilla.getGenerationSettings()); + + BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder(); - + effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier()); - + VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); - + effects.fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor())) - - .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) - - .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) - - .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); - + + .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) + + .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) + + .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())); + if(vanillaBiomeProperties.getFoliageColor() == null) { vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride); } else { effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor()); } - + if(vanillaBiomeProperties.getGrassColor() == null) { vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride); } else { // grass effects.grassColorOverride(vanillaBiomeProperties.getGrassColor()); } - + vanilla.getAmbientLoop().ifPresent(effects::ambientLoopSound); vanilla.getAmbientAdditions().ifPresent(effects::ambientAdditionsSound); vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound); vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic); vanilla.getAmbientParticle().ifPresent(effects::ambientParticle); - + builder.specialEffects(effects.build()); - + return builder.build(); } - + public static String createBiomeID(ConfigPack pack, com.dfsek.terra.api.registry.key.RegistryKey biomeID) { return pack.getID() .toLowerCase() + "/" + biomeID.getNamespace().toLowerCase(Locale.ROOT) + "/" + biomeID.getID().toLowerCase(Locale.ROOT); diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeProvider.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeProvider.java index baac766e4..1521a3582 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeProvider.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSBiomeProvider.java @@ -18,32 +18,32 @@ public class NMSBiomeProvider extends BiomeSource { private final BiomeProvider delegate; private final long seed; private final Registry biomeRegistry = RegistryFetcher.biomeRegistry(); - + public NMSBiomeProvider(BiomeProvider delegate, long seed) { super(); this.delegate = delegate; this.seed = seed; } - + @Override protected Stream> collectPossibleBiomes() { return delegate.stream() - .map(biome -> RegistryFetcher.biomeRegistry() - .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() - .get(NMSBiomeInfo.class) - .biomeKey())); + .map(biome -> RegistryFetcher.biomeRegistry() + .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey())); } - + @Override protected @NotNull Codec codec() { return BiomeSource.CODEC; } - + @Override public @NotNull Holder getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) { return biomeRegistry.getHolderOrThrow(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed) - .getPlatformBiome()).getContext() - .get(NMSBiomeInfo.class) - .biomeKey()); + .getPlatformBiome()).getContext() + .get(NMSBiomeInfo.class) + .biomeKey()); } } diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSChunkGeneratorDelegate.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSChunkGeneratorDelegate.java index a10376900..8ecc904ac 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSChunkGeneratorDelegate.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSChunkGeneratorDelegate.java @@ -39,12 +39,12 @@ import com.dfsek.terra.bukkit.world.block.data.BukkitBlockState; public class NMSChunkGeneratorDelegate extends ChunkGenerator { private static final Logger LOGGER = LoggerFactory.getLogger(NMSChunkGeneratorDelegate.class); private final com.dfsek.terra.api.world.chunk.generation.ChunkGenerator delegate; - + private final ChunkGenerator vanilla; private final ConfigPack pack; - + private final long seed; - + public NMSChunkGeneratorDelegate(ChunkGenerator vanilla, ConfigPack pack, NMSBiomeProvider biomeProvider, long seed) { super(biomeProvider); this.delegate = pack.getGeneratorProvider().newInstance(pack); @@ -52,57 +52,57 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { this.pack = pack; this.seed = seed; } - + @Override protected @NotNull Codec codec() { return ChunkGenerator.CODEC; } - + @Override public void applyCarvers(@NotNull WorldGenRegion chunkRegion, long seed, @NotNull RandomState noiseConfig, @NotNull BiomeManager world, @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk, @NotNull Carving carverStep) { // no-op } - + @Override public void buildSurface(@NotNull WorldGenRegion region, @NotNull StructureManager structures, @NotNull RandomState noiseConfig, @NotNull ChunkAccess chunk) { // no-op } - + @Override public void applyBiomeDecoration(@NotNull WorldGenLevel world, @NotNull ChunkAccess chunk, @NotNull StructureManager structureAccessor) { vanilla.applyBiomeDecoration(world, chunk, structureAccessor); } - + @Override public void spawnOriginalMobs(@NotNull WorldGenRegion region) { vanilla.spawnOriginalMobs(region); } - + @Override public int getGenDepth() { return vanilla.getGenDepth(); } - + @Override public @NotNull CompletableFuture fillFromNoise(@NotNull Executor executor, @NotNull Blender blender, @NotNull RandomState noiseConfig, @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) { return vanilla.fillFromNoise(executor, blender, noiseConfig, structureAccessor, chunk) - .thenApply(c -> { - LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); - BiomeProvider biomeProvider = pack.getBiomeProvider(); - PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); - if(compatibilityOptions.isBeard()) { - beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), - biomeProvider, compatibilityOptions); - } - return c; - }); + .thenApply(c -> { + LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor); + BiomeProvider biomeProvider = pack.getBiomeProvider(); + PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); + if(compatibilityOptions.isBeard()) { + beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()), + biomeProvider, compatibilityOptions); + } + return c; + }); } - + private void beard(StructureManager structureAccessor, ChunkAccess chunk, WorldProperties world, BiomeProvider biomeProvider, PreLoadCompatibilityOptions compatibilityOptions) { Beardifier structureWeightSampler = Beardifier.forStructuresInChunk(structureAccessor, chunk.getPos()); @@ -117,8 +117,8 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { double noise = structureWeightSampler.compute(new SinglePointContext(x + xi, y, z + zi)); if(noise > threshold) { chunk.setBlockState(new BlockPos(x, y, z), ((CraftBlockData) ((BukkitBlockState) delegate - .getPalette(x + xi, y, z + zi, world, biomeProvider) - .get(depth, x + xi, y, z + zi, world.getSeed())).getHandle()).getState(), false); + .getPalette(x + xi, y, z + zi, world, biomeProvider) + .get(depth, x + xi, y, z + zi, world.getSeed())).getHandle()).getState(), false); depth++; } else if(noise < airThreshold) { chunk.setBlockState(new BlockPos(x, y, z), Blocks.AIR.defaultBlockState(), false); @@ -129,29 +129,29 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { } } } - + @Override public int getSeaLevel() { return vanilla.getSeaLevel(); } - + @Override public int getMinY() { return vanilla.getMinY(); } - + @Override public int getBaseHeight(int x, int z, @NotNull Types heightmap, @NotNull LevelHeightAccessor world, @NotNull RandomState noiseConfig) { WorldProperties properties = new NMSWorldProperties(seed, world); int y = properties.getMaxHeight(); BiomeProvider biomeProvider = pack.getBiomeProvider(); while(y >= getMinY() && !heightmap.isOpaque().test( - ((CraftBlockData) delegate.getBlock(properties, x, y - 1, z, biomeProvider).getHandle()).getState())) { + ((CraftBlockData) delegate.getBlock(properties, x, y - 1, z, biomeProvider).getHandle()).getState())) { y--; } return y; } - + @Override public @NotNull NoiseColumn getBaseColumn(int x, int z, @NotNull LevelHeightAccessor world, @NotNull RandomState noiseConfig) { BlockState[] array = new BlockState[world.getHeight()]; @@ -159,13 +159,13 @@ public class NMSChunkGeneratorDelegate extends ChunkGenerator { BiomeProvider biomeProvider = pack.getBiomeProvider(); for(int y = properties.getMaxHeight() - 1; y >= properties.getMinHeight(); y--) { array[y - properties.getMinHeight()] = ((CraftBlockData) delegate.getBlock(properties, x, y, z, biomeProvider) - .getHandle()).getState(); + .getHandle()).getState(); } return new NoiseColumn(getMinY(), array); } - + @Override public void addDebugScreenInfo(@NotNull List text, @NotNull RandomState noiseConfig, @NotNull BlockPos pos) { - + } } diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSInjectListener.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSInjectListener.java index b3dd2c7d4..ace83ddc7 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSInjectListener.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSInjectListener.java @@ -22,7 +22,7 @@ public class NMSInjectListener implements Listener { private static final Logger LOGGER = LoggerFactory.getLogger(NMSInjectListener.class); private static final Set INJECTED = new HashSet<>(); private static final ReentrantLock INJECT_LOCK = new ReentrantLock(); - + @EventHandler public void onWorldInit(WorldInitEvent event) { if(!INJECTED.contains(event.getWorld()) && @@ -32,16 +32,16 @@ public class NMSInjectListener implements Listener { LOGGER.info("Preparing to take over the world: {}", event.getWorld().getName()); CraftWorld craftWorld = (CraftWorld) event.getWorld(); ServerLevel serverWorld = craftWorld.getHandle(); - + ConfigPack pack = bukkitChunkGeneratorWrapper.getPack(); - + ChunkGenerator vanilla = serverWorld.getChunkSource().getGenerator(); NMSBiomeProvider provider = new NMSBiomeProvider(pack.getBiomeProvider(), craftWorld.getSeed()); - + serverWorld.getChunkSource().chunkMap.generator = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed()); - + LOGGER.info("Successfully injected into world."); - + INJECT_LOCK.unlock(); } } diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSWorldProperties.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSWorldProperties.java index 117bda467..441a1847d 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSWorldProperties.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/NMSWorldProperties.java @@ -8,27 +8,27 @@ import com.dfsek.terra.api.world.info.WorldProperties; public class NMSWorldProperties implements WorldProperties { private final long seed; private final LevelHeightAccessor height; - + public NMSWorldProperties(long seed, LevelHeightAccessor height) { this.seed = seed; this.height = height; } - + @Override public Object getHandle() { return height; } - + @Override public long getSeed() { return seed; } - + @Override public int getMaxHeight() { return height.getMaxBuildHeight(); } - + @Override public int getMinHeight() { return height.getMinBuildHeight(); diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/Reflection.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/Reflection.java index 3432482d5..da7b5c01d 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/Reflection.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/Reflection.java @@ -16,34 +16,34 @@ import xyz.jpenilla.reflectionremapper.proxy.annotation.Proxies; public class Reflection { public static final MappedRegistryProxy MAPPED_REGISTRY; public static final StructureManagerProxy STRUCTURE_MANAGER; - + public static final ReferenceProxy REFERENCE; - + static { ReflectionRemapper reflectionRemapper = ReflectionRemapper.forReobfMappingsInPaperJar(); ReflectionProxyFactory reflectionProxyFactory = ReflectionProxyFactory.create(reflectionRemapper, - Reflection.class.getClassLoader()); - + Reflection.class.getClassLoader()); + MAPPED_REGISTRY = reflectionProxyFactory.reflectionProxy(MappedRegistryProxy.class); STRUCTURE_MANAGER = reflectionProxyFactory.reflectionProxy(StructureManagerProxy.class); REFERENCE = reflectionProxyFactory.reflectionProxy(ReferenceProxy.class); } - - + + @Proxies(MappedRegistry.class) public interface MappedRegistryProxy { @FieldSetter("frozen") void setFrozen(MappedRegistry instance, boolean frozen); } - - + + @Proxies(StructureManager.class) public interface StructureManagerProxy { @FieldGetter("level") LevelAccessor getLevel(StructureManager instance); } - - + + @Proxies(Holder.Reference.class) public interface ReferenceProxy { @MethodName("bindValue") diff --git a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/RegistryFetcher.java b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/RegistryFetcher.java index fb18b3e17..52bec1b1b 100644 --- a/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/RegistryFetcher.java +++ b/platforms/bukkit/nms/v1_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/RegistryFetcher.java @@ -14,10 +14,10 @@ public class RegistryFetcher { CraftServer craftserver = (CraftServer) Bukkit.getServer(); DedicatedServer dedicatedserver = craftserver.getServer(); return dedicatedserver - .registryAccess() - .registryOrThrow(key); + .registryAccess() + .registryOrThrow(key); } - + public static Registry biomeRegistry() { return getRegistry(Registries.BIOME); } diff --git a/platforms/cli/src/main/java/com/dfsek/terra/cli/CLIPlatform.java b/platforms/cli/src/main/java/com/dfsek/terra/cli/CLIPlatform.java index 4a73c53ee..ca58f1f5d 100644 --- a/platforms/cli/src/main/java/com/dfsek/terra/cli/CLIPlatform.java +++ b/platforms/cli/src/main/java/com/dfsek/terra/cli/CLIPlatform.java @@ -18,41 +18,41 @@ import com.dfsek.terra.cli.handle.CLIWorldHandle; public class CLIPlatform extends AbstractPlatform { private static final Logger LOGGER = LoggerFactory.getLogger(CLIPlatform.class); - + private final CLIWorldHandle worldHandle = new CLIWorldHandle(); private final CLIItemHandle itemHandle = new CLIItemHandle(); - + public CLIPlatform() { LOGGER.info("Root directory: {}", getDataFolder().getAbsoluteFile()); load(); LOGGER.info("Initialized Terra platform."); } - + @Override public boolean reload() { return false; } - + @Override public @NotNull String platformName() { return "CLI"; } - + @Override public @NotNull WorldHandle getWorldHandle() { return worldHandle; } - + @Override public @NotNull File getDataFolder() { return new File("./"); } - + @Override public @NotNull ItemHandle getItemHandle() { return itemHandle; } - + @Override public void register(TypeRegistry registry) { super.register(registry); diff --git a/platforms/cli/src/main/java/com/dfsek/terra/cli/TerraCLI.java b/platforms/cli/src/main/java/com/dfsek/terra/cli/TerraCLI.java index 39eaf59c6..8f62528bc 100644 --- a/platforms/cli/src/main/java/com/dfsek/terra/cli/TerraCLI.java +++ b/platforms/cli/src/main/java/com/dfsek/terra/cli/TerraCLI.java @@ -14,24 +14,24 @@ import com.dfsek.terra.cli.world.CLIWorld; public final class TerraCLI { private static final Logger LOGGER = LoggerFactory.getLogger(TerraCLI.class); - + public static void main(String... args) { LOGGER.info("Starting Terra CLI..."); - + CLIPlatform platform = new CLIPlatform(); platform.getEventManager().callEvent(new PlatformInitializationEvent()); - + ConfigPack generate = platform.getConfigRegistry().getByID("OVERWORLD").orElseThrow(); // TODO: make this a cli argument - + CLIWorld world = new CLIWorld(2, 2, 384, -64, generate); - + world.generate(); - + world.serialize().parallel().forEach(mcaFile -> { Vector2Int pos = mcaFile.getLeft(); String name = MCAUtil.createNameFromRegionLocation(pos.getX(), pos.getZ()); LOGGER.info("Writing region ({}, {}) to {}", pos.getX(), pos.getZ(), name); - + try { MCAUtil.write(mcaFile.getRight(), name); } catch(IOException e) { diff --git a/platforms/cli/src/main/java/com/dfsek/terra/cli/block/CLIBlockState.java b/platforms/cli/src/main/java/com/dfsek/terra/cli/block/CLIBlockState.java index 53cbc5e90..be21e7169 100644 --- a/platforms/cli/src/main/java/com/dfsek/terra/cli/block/CLIBlockState.java +++ b/platforms/cli/src/main/java/com/dfsek/terra/cli/block/CLIBlockState.java @@ -12,13 +12,13 @@ public class CLIBlockState implements BlockState { private final CLIBlockType type; private final boolean isAir; private final CompoundTag nbt; - + public CLIBlockState(String value) { this.value = value; if(value.contains("[")) { - + } else { - + } this.isAir = value.startsWith("minecraft:air"); this.nbt = new CompoundTag(); @@ -30,54 +30,54 @@ public class CLIBlockState implements BlockState { for(String property : props) { String name = property.substring(0, property.indexOf('=')); String val = property.substring(property.indexOf('=') + 1); - + pTag.putString(name, val); } this.nbt.put("Properties", pTag); } else this.type = new CLIBlockType(value); this.nbt.putString("Name", type.getHandle()); } - + @Override public Object getHandle() { return value; } - + @Override public boolean matches(BlockState other) { return false; } - + @Override public > boolean has(Property property) { return false; } - + @Override public > T get(Property property) { return null; } - + @Override public > BlockState set(Property property, T value) { return null; } - + @Override public BlockType getBlockType() { return type; } - + @Override public String getAsString(boolean properties) { return value; } - + @Override public boolean isAir() { return isAir; } - + public CompoundTag getNbt() { return nbt; } diff --git a/platforms/cli/src/main/java/com/dfsek/terra/cli/block/CLIBlockType.java b/platforms/cli/src/main/java/com/dfsek/terra/cli/block/CLIBlockType.java index 361a283da..9f2bd12eb 100644 --- a/platforms/cli/src/main/java/com/dfsek/terra/cli/block/CLIBlockType.java +++ b/platforms/cli/src/main/java/com/dfsek/terra/cli/block/CLIBlockType.java @@ -10,7 +10,7 @@ public class CLIBlockType implements BlockType { private final boolean solid; private final boolean water; private final Lazy defaultState; - + public CLIBlockType(String value) { if(value.contains("[")) throw new IllegalArgumentException("Block Type must not contain properties"); this.value = value; @@ -18,22 +18,22 @@ public class CLIBlockType implements BlockType { this.water = value.equals("minecraft:water"); this.defaultState = Lazy.lazy(() -> new CLIBlockState(value)); } - + @Override public String getHandle() { return value; } - + @Override public BlockState getDefaultState() { return defaultState.value(); } - + @Override public boolean isSolid() { return solid; } - + @Override public boolean isWater() { return water; diff --git a/platforms/cli/src/main/java/com/dfsek/terra/cli/handle/CLIItemHandle.java b/platforms/cli/src/main/java/com/dfsek/terra/cli/handle/CLIItemHandle.java index 3a183d006..535e23897 100644 --- a/platforms/cli/src/main/java/com/dfsek/terra/cli/handle/CLIItemHandle.java +++ b/platforms/cli/src/main/java/com/dfsek/terra/cli/handle/CLIItemHandle.java @@ -1,23 +1,23 @@ package com.dfsek.terra.cli.handle; +import java.util.Set; + import com.dfsek.terra.api.handle.ItemHandle; import com.dfsek.terra.api.inventory.Item; import com.dfsek.terra.api.inventory.item.Enchantment; -import java.util.Set; - public class CLIItemHandle implements ItemHandle { @Override public Item createItem(String data) { return null; } - + @Override public Enchantment getEnchantment(String id) { return null; } - + @Override public Set getEnchantments() { return null; diff --git a/platforms/cli/src/main/java/com/dfsek/terra/cli/handle/CLIWorldHandle.java b/platforms/cli/src/main/java/com/dfsek/terra/cli/handle/CLIWorldHandle.java index a6ec3a0e7..c52181e72 100644 --- a/platforms/cli/src/main/java/com/dfsek/terra/cli/handle/CLIWorldHandle.java +++ b/platforms/cli/src/main/java/com/dfsek/terra/cli/handle/CLIWorldHandle.java @@ -10,21 +10,21 @@ import com.dfsek.terra.cli.block.CLIBlockState; public class CLIWorldHandle implements WorldHandle { private static final CLIBlockState AIR = new CLIBlockState("minecraft:air"); - + public static CLIBlockState getAIR() { return AIR; } - + @Override public @NotNull BlockState createBlockState(@NotNull String data) { return new CLIBlockState(data); } - + @Override public @NotNull BlockState air() { return AIR; } - + @Override public @NotNull EntityType getEntity(@NotNull String id) { return null; diff --git a/platforms/cli/src/main/java/com/dfsek/terra/cli/world/CLIWorld.java b/platforms/cli/src/main/java/com/dfsek/terra/cli/world/CLIWorld.java index 00c5f17d3..a4af0d02e 100644 --- a/platforms/cli/src/main/java/com/dfsek/terra/cli/world/CLIWorld.java +++ b/platforms/cli/src/main/java/com/dfsek/terra/cli/world/CLIWorld.java @@ -44,9 +44,9 @@ public class CLIWorld implements ServerWorld, NBTSerializable> futures = new ArrayList<>(); @@ -101,7 +101,7 @@ public class CLIWorld implements ServerWorld, NBTSerializable future : futures) { try { future.get(); @@ -110,18 +110,18 @@ public class CLIWorld implements ServerWorld, NBTSerializable= 0) return regions[key]; else return negativeRegions[-key]; } - + @Override public long getSeed() { return seed; } - + @Override public int getMaxHeight() { return maxHeight; } - + @Override public int getMinHeight() { return minHeight; } - + @Override public ChunkGenerator getGenerator() { return chunkGenerator; } - + @Override public BiomeProvider getBiomeProvider() { return biomeProvider; } - + @Override public ConfigPack getPack() { return pack; } - + @Override public void setBlockState(int x, int y, int z, BlockState data, boolean physics) { getChunkAt(Math.floorDiv(x, 16), Math.floorDiv(z, 16)) - .setBlock(Math.floorMod(x, 16), y, Math.floorMod(z, 16), data, physics); + .setBlock(Math.floorMod(x, 16), y, Math.floorMod(z, 16), data, physics); } - + @Override public Entity spawnEntity(double x, double y, double z, EntityType entityType) { return null; } - + @Override public Stream> serialize() { return Streams - .concat(Arrays.stream(regions), Arrays.stream(negativeRegions)) - .map(region -> Pair.of(Vector2Int.of(region.getX(), region.getZ()), region.serialize())); + .concat(Arrays.stream(regions), Arrays.stream(negativeRegions)) + .map(region -> Pair.of(Vector2Int.of(region.getX(), region.getZ()), region.serialize())); } - + private static final class CLIProtoWorld implements ProtoWorld { private final CLIWorld delegate; private final BiomeProvider biomeProvider; private final int x, z; - + private CLIProtoWorld(CLIWorld delegate, BiomeProvider biomeProvider, int x, int z) { this.delegate = delegate; this.biomeProvider = biomeProvider; this.x = x; this.z = z; } - + @Override public Object getHandle() { return this; } - + @Override public BlockState getBlockState(int x, int y, int z) { return delegate.getBlockState(x, y, z); } - + @Override public BlockEntity getBlockEntity(int x, int y, int z) { return delegate.getBlockEntity(x, y, z); } - + @Override public long getSeed() { return delegate.seed; } - + @Override public int getMaxHeight() { return delegate.maxHeight; } - + @Override public int getMinHeight() { return delegate.minHeight; } - + @Override public ChunkGenerator getGenerator() { return delegate.chunkGenerator; } - + @Override public BiomeProvider getBiomeProvider() { return biomeProvider; } - + @Override public ConfigPack getPack() { return delegate.pack; } - + @Override public void setBlockState(int x, int y, int z, BlockState data, boolean physics) { delegate.setBlockState(x, y, z, data, physics); } - + @Override public Entity spawnEntity(double x, double y, double z, EntityType entityType) { return delegate.spawnEntity(x, y, z, entityType); } - + @Override public int centerChunkX() { return x; } - + @Override public int centerChunkZ() { return z; } - + @Override public ServerWorld getWorld() { return delegate; diff --git a/platforms/cli/src/main/java/com/dfsek/terra/cli/world/Region.java b/platforms/cli/src/main/java/com/dfsek/terra/cli/world/Region.java index 9d84ce197..508d820cf 100644 --- a/platforms/cli/src/main/java/com/dfsek/terra/cli/world/Region.java +++ b/platforms/cli/src/main/java/com/dfsek/terra/cli/world/Region.java @@ -10,14 +10,14 @@ public class Region implements NBTSerializable { private final CLIChunk[] chunks; private final int x, z; private final CLIWorld world; - + public Region(CLIWorld world, int x, int z) { this.x = x; this.z = z; this.world = world; this.chunks = new CLIChunk[32 * 32]; } - + public CLIChunk get(int x, int z) { int key = x + z * 32; CLIChunk chunk = chunks[key]; @@ -27,7 +27,7 @@ public class Region implements NBTSerializable { } return chunk; } - + @Override public MCAFile serialize() { MCAFile mcaFile = new MCAFile(x, z); @@ -46,11 +46,11 @@ public class Region implements NBTSerializable { } return mcaFile; } - + public int getX() { return x; } - + public int getZ() { return z; } diff --git a/platforms/cli/src/main/java/com/dfsek/terra/cli/world/chunk/CLIChunk.java b/platforms/cli/src/main/java/com/dfsek/terra/cli/world/chunk/CLIChunk.java index 7bf397bef..5a5669708 100644 --- a/platforms/cli/src/main/java/com/dfsek/terra/cli/world/chunk/CLIChunk.java +++ b/platforms/cli/src/main/java/com/dfsek/terra/cli/world/chunk/CLIChunk.java @@ -20,7 +20,7 @@ public class CLIChunk implements Chunk, ProtoChunk, NBTSerializable getPlatformMods() { return FabricLoader.getInstance().getAllMods().stream().flatMap( - mod -> parseModData(mod.getMetadata().getId(), mod.getMetadata().getVersion().getFriendlyString(), "fabric") - ).collect(Collectors.toList()); + mod -> parseModData(mod.getMetadata().getId(), mod.getMetadata().getVersion().getFriendlyString(), "fabric") + ).collect(Collectors.toList()); } - + @Override public @NotNull String platformName() { return "Fabric"; } - + @Override public @NotNull File getDataFolder() { return new File(FabricLoader.getInstance().getConfigDir().toFile(), "Terra"); } - + @Override public BaseAddon getPlatformAddon() { return new FabricAddon(this); diff --git a/platforms/forge/src/main/java/com/dfsek/terra/forge/AwfulForgeHacks.java b/platforms/forge/src/main/java/com/dfsek/terra/forge/AwfulForgeHacks.java index f37e5b1ee..d558e18ff 100644 --- a/platforms/forge/src/main/java/com/dfsek/terra/forge/AwfulForgeHacks.java +++ b/platforms/forge/src/main/java/com/dfsek/terra/forge/AwfulForgeHacks.java @@ -26,7 +26,7 @@ import com.dfsek.terra.api.addon.bootstrap.BootstrapAddonClassLoader; */ public final class AwfulForgeHacks { private static final Logger LOGGER = LoggerFactory.getLogger(AwfulForgeHacks.class); - + /** * Forge tampers with code source to make the *normal* way of getting the current JAR file useless, so this awful hack is * needed. @@ -42,114 +42,114 @@ public final class AwfulForgeHacks { public static JarFile getTerraJar() throws IOException { LOGGER.info("Scanning for Terra JAR..."); return Files.walk(Path.of(System.getProperty("user.dir"), "mods"), 1, FileVisitOption.FOLLOW_LINKS) - .filter(it -> it.getFileName().toString().endsWith(".jar")) - .peek(path -> LOGGER.info("Found mod: {}", path)) - .map(Path::toFile) - .flatMap(path -> { - try { - return Stream.of(new JarFile(path)); - } catch(IOException e) { - LOGGER.error("Malformed mod JAR: {}: {}", path, e); - return Stream.of(); - } - }) - .filter(jar -> jar - .stream() - .anyMatch(entry -> entry - .getName() - .equals(ForgeEntryPoint.class.getName().replace('.', '/') + ".class"))) - .findFirst() - .orElseThrow(() -> new IllegalStateException("Could not find Terra JAR")); + .filter(it -> it.getFileName().toString().endsWith(".jar")) + .peek(path -> LOGGER.info("Found mod: {}", path)) + .map(Path::toFile) + .flatMap(path -> { + try { + return Stream.of(new JarFile(path)); + } catch(IOException e) { + LOGGER.error("Malformed mod JAR: {}: {}", path, e); + return Stream.of(); + } + }) + .filter(jar -> jar + .stream() + .anyMatch(entry -> entry + .getName() + .equals(ForgeEntryPoint.class.getName().replace('.', '/') + ".class"))) + .findFirst() + .orElseThrow(() -> new IllegalStateException("Could not find Terra JAR")); } - + public static void loadAllTerraClasses() { if(FMLLoader.isProduction()) { try(JarFile jar = getTerraJar()) { jar.stream() - .forEach(jarEntry -> { - if(jarEntry.getName().startsWith("com/dfsek/terra/forge/mixin") - || jarEntry.getName().startsWith("com/dfsek/terra/mod/mixin")) { - return; - } - if(jarEntry.getName().endsWith(".class")) { - String name = jarEntry.getName().replace('/', '.'); - name = name.substring(0, name.length() - 6); - try { - Class.forName(name); - } catch(ClassNotFoundException | NoClassDefFoundError e) { - LOGGER.warn("Failed to load class {}: {}", name, e); - } - } - }); + .forEach(jarEntry -> { + if(jarEntry.getName().startsWith("com/dfsek/terra/forge/mixin") + || jarEntry.getName().startsWith("com/dfsek/terra/mod/mixin")) { + return; + } + if(jarEntry.getName().endsWith(".class")) { + String name = jarEntry.getName().replace('/', '.'); + name = name.substring(0, name.length() - 6); + try { + Class.forName(name); + } catch(ClassNotFoundException | NoClassDefFoundError e) { + LOGGER.warn("Failed to load class {}: {}", name, e); + } + } + }); } catch(IOException e) { throw new IllegalStateException("Could not load all Terra classes", e); } } else { // Forgive me for what I'm about to do... LOGGER.warn( - "I felt a great disturbance in the JVM, as if millions of class not found exceptions suddenly cried out in terror and" + - " were suddenly silenced."); + "I felt a great disturbance in the JVM, as if millions of class not found exceptions suddenly cried out in terror and" + + " were suddenly silenced."); ArrayList pathsToLoad = new ArrayList<>(); - + Path terraRoot = Path.of(System.getProperty("user.dir")).getParent().getParent().getParent(); Path commonRoot = terraRoot.resolve("common"); Path implementationRoot = commonRoot.resolve("implementation"); - + pathsToLoad.add(commonRoot.resolve("api")); pathsToLoad.add(implementationRoot.resolve("base")); pathsToLoad.add(implementationRoot.resolve("bootstrap-addon-loader")); for(Path path : pathsToLoad) { try { Path target = path.resolve("build").resolve("classes").resolve("java").resolve("main"); - + BootstrapAddonClassLoader cl = new BootstrapAddonClassLoader(new URL[]{ path.toUri().toURL() }); - + Classes.Loaders omegaCL = Classes.Loaders.create(); Files.walk(target, Integer.MAX_VALUE, FileVisitOption.FOLLOW_LINKS) - .filter(it -> it.getFileName().toString().endsWith(".class")) - .map(Path::toFile) - .forEach(it -> { - String name = it.getAbsolutePath().replace(target + "/", "").replace('\\', '.').replace('/', '.'); - name = name.substring(0, name.length() - 6); - LOGGER.info("Loading class {}", name); - try { - Class.forName(name); - } catch(ClassNotFoundException e) { - try { - String pathToJar = cl.loadClass(name) - .getProtectionDomain() - .getCodeSource() - .getLocation() - .toURI() - .getPath(); - - cl.addURL(new URL("jar:file:" + pathToJar + "!/")); - Class newClassLoad = Class.forName(name, true, cl); - omegaCL.loadOrDefine(newClassLoad, AbstractPlatform.class.getClassLoader()); - } catch(ClassNotFoundException | URISyntaxException | IOException ex) { - throw new RuntimeException(ex); - } - - } - }); + .filter(it -> it.getFileName().toString().endsWith(".class")) + .map(Path::toFile) + .forEach(it -> { + String name = it.getAbsolutePath().replace(target + "/", "").replace('\\', '.').replace('/', '.'); + name = name.substring(0, name.length() - 6); + LOGGER.info("Loading class {}", name); + try { + Class.forName(name); + } catch(ClassNotFoundException e) { + try { + String pathToJar = cl.loadClass(name) + .getProtectionDomain() + .getCodeSource() + .getLocation() + .toURI() + .getPath(); + + cl.addURL(new URL("jar:file:" + pathToJar + "!/")); + Class newClassLoad = Class.forName(name, true, cl); + omegaCL.loadOrDefine(newClassLoad, AbstractPlatform.class.getClassLoader()); + } catch(ClassNotFoundException | URISyntaxException | IOException ex) { + throw new RuntimeException(ex); + } + + } + }); } catch(IOException e) { throw new IllegalStateException("Could not load all Terra classes", e); } } } } - + public enum RegistryStep { BLOCK, BIOME, WORLD_TYPE, DONE } - - + + public static class RegistrySanityCheck { private final AtomicReference step = new AtomicReference<>(RegistryStep.BLOCK); - + public void progress(RegistryStep expected, Runnable action) { step.getAndUpdate(s -> { if(s != expected) { diff --git a/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgeAddon.java b/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgeAddon.java index e742610cf..d01b5cc32 100644 --- a/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgeAddon.java +++ b/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgeAddon.java @@ -5,11 +5,11 @@ import com.dfsek.terra.mod.ModPlatform; public class ForgeAddon extends MinecraftAddon { - + public ForgeAddon(ModPlatform modPlatform) { super(modPlatform); } - + @Override public String getID() { return "terra-forge"; diff --git a/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgeEntryPoint.java b/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgeEntryPoint.java index b761ea2ef..da1bae874 100644 --- a/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgeEntryPoint.java +++ b/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgeEntryPoint.java @@ -51,32 +51,32 @@ public class ForgeEntryPoint { TERRA_PLUGIN = new ForgePlatform(); } private final RegistrySanityCheck sanityCheck = new RegistrySanityCheck(); - + public ForgeEntryPoint() { IEventBus modEventBus = FMLJavaModLoadingContext.get().getModEventBus(); modEventBus.register(this); } - + public static ForgePlatform getPlatform() { return TERRA_PLUGIN; } - + public static void initialize(RegisterHelper helper) { getPlatform().getEventManager().callEvent( - new PlatformInitializationEvent()); + new PlatformInitializationEvent()); BiomeUtil.registerBiomes(helper); } - + @SubscribeEvent(priority = EventPriority.LOWEST) public void registerBiomes(RegisterEvent event) { event.register(Keys.BLOCKS, helper -> sanityCheck.progress(RegistryStep.BLOCK, () -> logger.debug("Block registration detected."))); event.register(Keys.BIOMES, helper -> sanityCheck.progress(RegistryStep.BIOME, () -> initialize(helper))); event.register(RegistryKeys.WORLD_PRESET, - helper -> sanityCheck.progress(RegistryStep.WORLD_TYPE, () -> TERRA_PLUGIN.registerWorldTypes(helper::register))); - - + helper -> sanityCheck.progress(RegistryStep.WORLD_TYPE, () -> TERRA_PLUGIN.registerWorldTypes(helper::register))); + + event.register(RegistryKeys.CHUNK_GENERATOR, - helper -> helper.register(new Identifier("terra:terra"), Codecs.MINECRAFT_CHUNK_GENERATOR_WRAPPER)); + helper -> helper.register(new Identifier("terra:terra"), Codecs.MINECRAFT_CHUNK_GENERATOR_WRAPPER)); event.register(RegistryKeys.BIOME_SOURCE, helper -> helper.register(new Identifier("terra:terra"), Codecs.TERRA_BIOME_SOURCE)); } } diff --git a/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgePlatform.java b/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgePlatform.java index aad562033..c07bde6f3 100644 --- a/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgePlatform.java +++ b/platforms/forge/src/main/java/com/dfsek/terra/forge/ForgePlatform.java @@ -48,25 +48,25 @@ import com.dfsek.terra.mod.generation.MinecraftChunkGeneratorWrapper; public class ForgePlatform extends ModPlatform { private static final Logger LOGGER = LoggerFactory.getLogger(ForgePlatform.class); private final Lazy dataFolder = Lazy.lazy(() -> new File("./config/Terra")); - + public ForgePlatform() { CommonPlatform.initialize(this); load(); } - + @Override public MinecraftServer getServer() { return ServerLifecycleHooks.getCurrentServer(); } - + @Override public boolean reload() { getTerraConfig().load(this); getRawConfigRegistry().clear(); boolean succeed = getRawConfigRegistry().loadAll(this); - + MinecraftServer server = getServer(); - + if(server != null) { server.reloadResources(server.getDataPackManager().getNames()).exceptionally(throwable -> { LOGGER.warn("Failed to execute reload", throwable); @@ -84,13 +84,13 @@ public class ForgePlatform extends ModPlatform { } return succeed; } - + @Override protected Iterable platformAddon() { List addons = new ArrayList<>(); - + super.platformAddon().forEach(addons::add); - + String mcVersion = MinecraftVersion.CURRENT.getName(); try { addons.add(new EphemeralAddon(Versions.parseVersion(mcVersion), "minecraft")); @@ -101,48 +101,48 @@ public class ForgePlatform extends ModPlatform { LOGGER.warn("Failed to parse Minecraft version", e); } } - + FMLLoader.getLoadingModList().getMods().forEach(mod -> { String id = mod.getModId(); if(id.equals("terra") || id.equals("minecraft") || id.equals("java")) return; Version version = Versions.getVersion(mod.getVersion().getMajorVersion(), mod.getVersion().getMinorVersion(), - mod.getVersion().getIncrementalVersion()); + mod.getVersion().getIncrementalVersion()); addons.add(new EphemeralAddon(version, "forge:" + id)); }); - + return addons; } - + @Override public @NotNull String platformName() { return "Forge"; } - + @Override public @NotNull File getDataFolder() { return dataFolder.value(); } - + @Override public BaseAddon getPlatformAddon() { return new ForgeAddon(this); } - + @Override public Registry dimensionTypeRegistry() { return null; } - + @Override public Registry biomeRegistry() { return null; } - + @Override public Registry chunkGeneratorSettingsRegistry() { return null; } - + @Override public Registry multiNoiseBiomeSourceParameterListRegistry() { return null; diff --git a/platforms/forge/src/main/java/com/dfsek/terra/forge/mixin/lifecycle/NoiseConfigMixin.java b/platforms/forge/src/main/java/com/dfsek/terra/forge/mixin/lifecycle/NoiseConfigMixin.java index c18791cb8..4b1b0ad78 100644 --- a/platforms/forge/src/main/java/com/dfsek/terra/forge/mixin/lifecycle/NoiseConfigMixin.java +++ b/platforms/forge/src/main/java/com/dfsek/terra/forge/mixin/lifecycle/NoiseConfigMixin.java @@ -23,7 +23,7 @@ public class NoiseConfigMixin { @Shadow @Final private MultiNoiseSampler multiNoiseSampler; - + @Inject(method = "(Lnet/minecraft/world/gen/chunk/ChunkGeneratorSettings;Lnet/minecraft/registry/RegistryEntryLookup;J)V", at = @At("TAIL")) private void mapMultiNoise(ChunkGeneratorSettings chunkGeneratorSettings, RegistryEntryLookup noiseParametersLookup, diff --git a/platforms/forge/src/main/java/com/dfsek/terra/forge/util/BiomeUtil.java b/platforms/forge/src/main/java/com/dfsek/terra/forge/util/BiomeUtil.java index 6114714b9..660c750af 100644 --- a/platforms/forge/src/main/java/com/dfsek/terra/forge/util/BiomeUtil.java +++ b/platforms/forge/src/main/java/com/dfsek/terra/forge/util/BiomeUtil.java @@ -26,13 +26,13 @@ import com.dfsek.terra.mod.util.MinecraftUtil; public final class BiomeUtil { private static final Logger logger = LoggerFactory.getLogger(BiomeUtil.class); - - + + private BiomeUtil() { - + } - - + + public static void registerBiomes(RegisterHelper helper) { logger.info("Registering biomes..."); ForgeEntryPoint.getPlatform().getConfigRegistry().forEach(pack -> { // Register all Terra biomes. @@ -41,7 +41,7 @@ public final class BiomeUtil { }); logger.info("Terra biomes registered."); } - + /** * Clones a Vanilla biome and injects Terra data to create a Terra-vanilla biome delegate. * @@ -52,39 +52,39 @@ public final class BiomeUtil { com.dfsek.terra.api.registry.key.RegistryKey id, RegisterHelper helper) { RegistryEntry - vanilla = ForgeRegistries.BIOMES.getHolder(((ProtoPlatformBiome) biome.getPlatformBiome()).getHandle()).orElseThrow(); - - + vanilla = ForgeRegistries.BIOMES.getHolder(((ProtoPlatformBiome) biome.getPlatformBiome()).getHandle()).orElseThrow(); + + if(pack.getContext().get(PreLoadCompatibilityOptions.class).useVanillaBiomes()) { ((ProtoPlatformBiome) biome.getPlatformBiome()).setDelegate(vanilla); } else { VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); - + net.minecraft.world.biome.Biome minecraftBiome = MinecraftUtil.createBiome(biome, - ForgeRegistries.BIOMES.getDelegateOrThrow( - vanilla.getKey().orElseThrow()) - .value(), - vanillaBiomeProperties); - + ForgeRegistries.BIOMES.getDelegateOrThrow( + vanilla.getKey().orElseThrow()) + .value(), + vanillaBiomeProperties); + Identifier identifier = new Identifier("terra", MinecraftUtil.createBiomeID(pack, id)); - + if(ForgeRegistries.BIOMES.containsKey(identifier)) { ((ProtoPlatformBiome) biome.getPlatformBiome()).setDelegate(ForgeRegistries.BIOMES.getHolder(identifier) - .orElseThrow()); + .orElseThrow()); } else { helper.register(MinecraftUtil.registerKey(identifier).getValue(), minecraftBiome); ((ProtoPlatformBiome) biome.getPlatformBiome()).setDelegate(ForgeRegistries.BIOMES.getHolder(identifier) - .orElseThrow()); + .orElseThrow()); } - + Map, VillagerType> villagerMap = VillagerTypeAccessor.getBiomeTypeToIdMap(); - + villagerMap.put(RegistryKey.of(RegistryKeys.BIOME, identifier), - Objects.requireNonNullElse(vanillaBiomeProperties.getVillagerType(), - villagerMap.getOrDefault(vanilla.getKey().orElseThrow(), VillagerType.PLAINS))); - + Objects.requireNonNullElse(vanillaBiomeProperties.getVillagerType(), + villagerMap.getOrDefault(vanilla.getKey().orElseThrow(), VillagerType.PLAINS))); + MinecraftUtil.TERRA_BIOME_MAP.computeIfAbsent(vanilla.getKey().orElseThrow().getValue(), i -> new ArrayList<>()).add( - identifier); + identifier); } } } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/CommonPlatform.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/CommonPlatform.java index 97534c8b1..809b56a33 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/CommonPlatform.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/CommonPlatform.java @@ -5,17 +5,17 @@ import java.util.concurrent.atomic.AtomicReference; public final class CommonPlatform { private static final AtomicReference platform = new AtomicReference<>(); - + public static ModPlatform get() { ModPlatform modPlatform = platform.get(); - + if(modPlatform == null) { throw new IllegalStateException("Platform is not yet initialised!"); } - + return modPlatform; } - + public static void initialize(ModPlatform modPlatform) { if(!platform.compareAndSet(null, modPlatform)) { throw new IllegalStateException("Platform has already been initialized to " + platform.get()); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/MinecraftAddon.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/MinecraftAddon.java index fa1214389..9d7dfdcae 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/MinecraftAddon.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/MinecraftAddon.java @@ -37,37 +37,37 @@ public abstract class MinecraftAddon implements BaseAddon { private static final Version VERSION = Versions.getVersion(1, 0, 0); private static final Logger logger = LoggerFactory.getLogger(MinecraftAddon.class); private final ModPlatform modPlatform; - + public MinecraftAddon(ModPlatform modPlatform) { this.modPlatform = modPlatform; } - + @Override public void initialize() { modPlatform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(this, ConfigPackPreLoadEvent.class) - .then(event -> event.getPack().getContext().put(event.loadTemplate(new PreLoadCompatibilityOptions()))) - .global(); - + .getHandler(FunctionalEventHandler.class) + .register(this, ConfigPackPreLoadEvent.class) + .then(event -> event.getPack().getContext().put(event.loadTemplate(new PreLoadCompatibilityOptions()))) + .global(); + modPlatform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(this, ConfigPackPostLoadEvent.class) - .then(event -> event.getPack().getContext().put(event.loadTemplate(new PostLoadCompatibilityOptions()))) - .priority(100) - .global(); - + .getHandler(FunctionalEventHandler.class) + .register(this, ConfigPackPostLoadEvent.class) + .then(event -> event.getPack().getContext().put(event.loadTemplate(new PostLoadCompatibilityOptions()))) + .priority(100) + .global(); + modPlatform.getEventManager() - .getHandler(FunctionalEventHandler.class) - .register(this, ConfigurationLoadEvent.class) - .then(event -> { - if(event.is(Biome.class)) { - event.getLoadedObject(Biome.class).getContext().put(event.load(new VanillaBiomeProperties())); - } - }) - .global(); + .getHandler(FunctionalEventHandler.class) + .register(this, ConfigurationLoadEvent.class) + .then(event -> { + if(event.is(Biome.class)) { + event.getLoadedObject(Biome.class).getContext().put(event.load(new VanillaBiomeProperties())); + } + }) + .global(); } - + @Override public Version getVersion() { return VERSION; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/ModPlatform.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/ModPlatform.java index 29cc8fed6..25c78c228 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/ModPlatform.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/ModPlatform.java @@ -56,72 +56,72 @@ import com.dfsek.terra.mod.util.PresetUtil; public abstract class ModPlatform extends AbstractPlatform { private final ItemHandle itemHandle = new MinecraftItemHandle(); private final WorldHandle worldHandle = new MinecraftWorldHandle(); - + public abstract MinecraftServer getServer(); - + public void registerWorldTypes(BiConsumer registerFunction) { getRawConfigRegistry() - .forEach(pack -> PresetUtil.createDefault(pack, this).apply(registerFunction)); + .forEach(pack -> PresetUtil.createDefault(pack, this).apply(registerFunction)); } - + @Override public void register(TypeRegistry registry) { super.register(registry); registry.registerLoader(PlatformBiome.class, (type, o, loader, depthTracker) -> parseBiome((String) o, depthTracker)) - .registerLoader(Identifier.class, (type, o, loader, depthTracker) -> { - Identifier identifier = Identifier.tryParse((String) o); - if(identifier == null) - throw new LoadException("Invalid identifier: " + o, depthTracker); - return identifier; - }) - .registerLoader(Precipitation.class, (type, o, loader, depthTracker) -> Precipitation.valueOf(((String) o).toUpperCase( - Locale.ROOT))) - .registerLoader(GrassColorModifier.class, - (type, o, loader, depthTracker) -> GrassColorModifier.valueOf(((String) o).toUpperCase( - Locale.ROOT))) - .registerLoader(GrassColorModifier.class, - (type, o, loader, depthTracker) -> TemperatureModifier.valueOf(((String) o).toUpperCase( - Locale.ROOT))) - .registerLoader(BiomeParticleConfig.class, BiomeParticleConfigTemplate::new) - .registerLoader(SoundEvent.class, SoundEventTemplate::new) - .registerLoader(BiomeMoodSound.class, BiomeMoodSoundTemplate::new) - .registerLoader(BiomeAdditionsSound.class, BiomeAdditionsSoundTemplate::new) - .registerLoader(MusicSound.class, MusicSoundTemplate::new) - .registerLoader(EntityType.class, EntityTypeTemplate::new) - .registerLoader(SpawnCostConfig.class, SpawnCostConfig::new) - .registerLoader(SpawnEntry.class, SpawnEntryTemplate::new) - .registerLoader(SpawnGroup.class, SpawnGroupTemplate::new) - .registerLoader(SpawnTypeConfig.class, SpawnTypeConfig::new) - .registerLoader(SpawnSettings.class, SpawnSettingsTemplate::new) - .registerLoader(VillagerType.class, VillagerTypeTemplate::new); + .registerLoader(Identifier.class, (type, o, loader, depthTracker) -> { + Identifier identifier = Identifier.tryParse((String) o); + if(identifier == null) + throw new LoadException("Invalid identifier: " + o, depthTracker); + return identifier; + }) + .registerLoader(Precipitation.class, (type, o, loader, depthTracker) -> Precipitation.valueOf(((String) o).toUpperCase( + Locale.ROOT))) + .registerLoader(GrassColorModifier.class, + (type, o, loader, depthTracker) -> GrassColorModifier.valueOf(((String) o).toUpperCase( + Locale.ROOT))) + .registerLoader(GrassColorModifier.class, + (type, o, loader, depthTracker) -> TemperatureModifier.valueOf(((String) o).toUpperCase( + Locale.ROOT))) + .registerLoader(BiomeParticleConfig.class, BiomeParticleConfigTemplate::new) + .registerLoader(SoundEvent.class, SoundEventTemplate::new) + .registerLoader(BiomeMoodSound.class, BiomeMoodSoundTemplate::new) + .registerLoader(BiomeAdditionsSound.class, BiomeAdditionsSoundTemplate::new) + .registerLoader(MusicSound.class, MusicSoundTemplate::new) + .registerLoader(EntityType.class, EntityTypeTemplate::new) + .registerLoader(SpawnCostConfig.class, SpawnCostConfig::new) + .registerLoader(SpawnEntry.class, SpawnEntryTemplate::new) + .registerLoader(SpawnGroup.class, SpawnGroupTemplate::new) + .registerLoader(SpawnTypeConfig.class, SpawnTypeConfig::new) + .registerLoader(SpawnSettings.class, SpawnSettingsTemplate::new) + .registerLoader(VillagerType.class, VillagerTypeTemplate::new); } - + private ProtoPlatformBiome parseBiome(String id, DepthTracker tracker) throws LoadException { Identifier identifier = Identifier.tryParse(id); if(!biomeRegistry().containsId(identifier)) throw new LoadException("Invalid Biome ID: " + identifier, tracker); // failure. return new ProtoPlatformBiome(identifier); } - + @Override protected Iterable platformAddon() { return List.of(getPlatformAddon()); } - + protected abstract BaseAddon getPlatformAddon(); - + public abstract Registry dimensionTypeRegistry(); - + public abstract Registry biomeRegistry(); - + public abstract Registry chunkGeneratorSettingsRegistry(); - + public abstract Registry multiNoiseBiomeSourceParameterListRegistry(); - + @Override public @NotNull WorldHandle getWorldHandle() { return worldHandle; } - + @Override public @NotNull ItemHandle getItemHandle() { return itemHandle; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/BiomeAdditionsSoundTemplate.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/BiomeAdditionsSoundTemplate.java index 4a66cf6e5..26896e959 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/BiomeAdditionsSoundTemplate.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/BiomeAdditionsSoundTemplate.java @@ -12,11 +12,11 @@ public class BiomeAdditionsSoundTemplate implements ObjectTemplate { @Value("sound") @Default private SoundEvent sound = null; - + @Value("cultivation-ticks") @Default private Integer soundCultivationTicks = null; - + @Value("spawn-range") @Default private Integer soundSpawnRange = null; - + @Value("extra-distance") @Default private Double soundExtraDistance = null; - + @Override public BiomeMoodSound get() { if(sound == null || soundCultivationTicks == null || soundSpawnRange == null || soundExtraDistance == null) { diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/BiomeParticleConfigTemplate.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/BiomeParticleConfigTemplate.java index 7139031d2..97c8c8ed7 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/BiomeParticleConfigTemplate.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/BiomeParticleConfigTemplate.java @@ -14,21 +14,21 @@ public class BiomeParticleConfigTemplate implements ObjectTemplate> { @Value("id") @Default private Identifier id = null; - + @Override public EntityType get() { return Registries.ENTITY_TYPE.get(id); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/MusicSoundTemplate.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/MusicSoundTemplate.java index b9f563621..83a2f20ec 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/MusicSoundTemplate.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/MusicSoundTemplate.java @@ -12,19 +12,19 @@ public class MusicSoundTemplate implements ObjectTemplate { @Value("sound") @Default private SoundEvent sound = null; - + @Value("min-delay") @Default private Integer minDelay = null; - + @Value("max-delay") @Default private Integer maxDelay = null; - + @Value("replace-current-music") @Default private Boolean replaceCurrentMusic = null; - + @Override public MusicSound get() { if(sound == null || minDelay == null || maxDelay == null || replaceCurrentMusic == null) { diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/PreLoadCompatibilityOptions.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/PreLoadCompatibilityOptions.java index 00825bc5f..7efd74015 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/PreLoadCompatibilityOptions.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/PreLoadCompatibilityOptions.java @@ -29,31 +29,31 @@ public class PreLoadCompatibilityOptions implements ConfigTemplate, Properties { @Value("minecraft.use-vanilla-biomes") @Default private boolean vanillaBiomes = false; - + @Value("minecraft.beard.enable") @Default private boolean beard = true; - + @Value("minecraft.beard.threshold") @Default private double beardThreshold = 0.5; - + @Value("minecraft.beard.air-threshold") @Default private double airThreshold = -0.5; - + public boolean useVanillaBiomes() { return vanillaBiomes; } - + public boolean isBeard() { return beard; } - + public double getBeardThreshold() { return beardThreshold; } - + public double getAirThreshold() { return airThreshold; } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/ProtoPlatformBiome.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/ProtoPlatformBiome.java index 30f19bac4..b05ba8236 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/ProtoPlatformBiome.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/ProtoPlatformBiome.java @@ -31,26 +31,26 @@ import com.dfsek.terra.mod.util.MinecraftUtil; public class ProtoPlatformBiome implements PlatformBiome { private final Identifier identifier; - + private RegistryEntry delegate; - + public ProtoPlatformBiome(Identifier identifier) { this.identifier = identifier; } - + public RegistryKey get(Registry registry) { return MinecraftUtil.getEntry(registry, identifier).orElseThrow().getKey().orElseThrow(); } - + @Override public Identifier getHandle() { return identifier; } - + public RegistryEntry getDelegate() { return delegate; } - + public void setDelegate(RegistryEntry delegate) { this.delegate = Objects.requireNonNull(delegate); } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SoundEventTemplate.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SoundEventTemplate.java index b5b7fe079..e794f99b0 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SoundEventTemplate.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SoundEventTemplate.java @@ -11,11 +11,11 @@ public class SoundEventTemplate implements ObjectTemplate { @Value("id") @Default private Identifier id = null; - + @Value("distance-to-travel") @Default private Float distanceToTravel = null; - + @Override public SoundEvent get() { if(id == null) { diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnCostConfig.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnCostConfig.java index 3af1ff1b1..98c1ed71f 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnCostConfig.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnCostConfig.java @@ -10,27 +10,27 @@ public class SpawnCostConfig implements ObjectTemplate { @Value("type") @Default private EntityType type = null; - + @Value("mass") @Default private Double mass = null; - + @Value("gravity") @Default private Double gravity = null; - + public EntityType getType() { return type; } - + public Double getMass() { return mass; } - + public Double getGravity() { return gravity; } - + @Override public SpawnCostConfig get() { return this; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnEntryTemplate.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnEntryTemplate.java index 7c203b62e..4fdf390d9 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnEntryTemplate.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnEntryTemplate.java @@ -11,19 +11,19 @@ public class SpawnEntryTemplate implements ObjectTemplate { @Value("type") @Default private EntityType type = null; - + @Value("weight") @Default private Integer weight = null; - + @Value("min-group-size") @Default private Integer minGroupSize = null; - + @Value("max-group-size") @Default private Integer maxGroupSize = null; - + @Override public SpawnEntry get() { return new SpawnEntry(type, weight, minGroupSize, maxGroupSize); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnGroupTemplate.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnGroupTemplate.java index e6a9143d1..0ae2047f2 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnGroupTemplate.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnGroupTemplate.java @@ -10,7 +10,7 @@ public class SpawnGroupTemplate implements ObjectTemplate { @Value("group") @Default private String group = null; - + @Override public SpawnGroup get() { return SpawnGroup.valueOf(group); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnSettingsTemplate.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnSettingsTemplate.java index 9b72e579c..9392e94e1 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnSettingsTemplate.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnSettingsTemplate.java @@ -12,15 +12,15 @@ public class SpawnSettingsTemplate implements ObjectTemplate { @Value("spawns") @Default private List spawns = null; - + @Value("costs") @Default private List costs = null; - + @Value("probability") @Default private Float probability = null; - + @Override public SpawnSettings get() { SpawnSettings.Builder builder = new SpawnSettings.Builder(); @@ -33,7 +33,7 @@ public class SpawnSettingsTemplate implements ObjectTemplate { if(probability != null) { builder.creatureSpawnProbability(probability); } - + return builder.build(); } } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnTypeConfig.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnTypeConfig.java index 0f1eff6b5..9384f991d 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnTypeConfig.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/SpawnTypeConfig.java @@ -11,19 +11,19 @@ public class SpawnTypeConfig implements ObjectTemplate { @Value("group") @Default private SpawnGroup group = null; - + @Value("entry") @Default private SpawnEntry entry = null; - + public SpawnGroup getGroup() { return group; } - + public SpawnEntry getEntry() { return entry; } - + @Override public SpawnTypeConfig get() { return this; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VanillaBiomeProperties.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VanillaBiomeProperties.java index 2015f7019..5c49c4d29 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VanillaBiomeProperties.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VanillaBiomeProperties.java @@ -20,143 +20,143 @@ public class VanillaBiomeProperties implements ConfigTemplate, Properties { @Value("colors.grass") @Default private Integer grassColor = null; - + @Value("colors.fog") @Default private Integer fogColor = null; - + @Value("colors.water") @Default private Integer waterColor = null; - + @Value("colors.water-fog") @Default private Integer waterFogColor = null; - + @Value("colors.foliage") @Default private Integer foliageColor = null; - + @Value("colors.sky") @Default private Integer skyColor = null; - + @Value("colors.modifier") @Default private GrassColorModifier grassColorModifier = null; - + @Value("particles") @Default private BiomeParticleConfig particleConfig = null; - + @Value("climate.precipitation") @Default private Boolean precipitation = true; - + @Value("climate.temperature") @Default private Float temperature = null; - + @Value("climate.temperature-modifier") @Default private TemperatureModifier temperatureModifier = null; - + @Value("climate.downfall") @Default private Float downfall = null; - + @Value("sound.loop-sound.sound") @Default private SoundEvent loopSound = null; - + @Value("sound.mood-sound") @Default private BiomeMoodSound moodSound = null; - + @Value("sound.additions-sound") @Default private BiomeAdditionsSound additionsSound = null; - + @Value("sound.music") @Default private MusicSound music = null; - + @Value("spawning") @Default private SpawnSettings spawnSettings = null; - + @Value("villager-type") @Default private VillagerType villagerType = null; - + public Integer getGrassColor() { return grassColor; } - + public Integer getFogColor() { return fogColor; } - + public Integer getWaterColor() { return waterColor; } - + public Integer getWaterFogColor() { return waterFogColor; } - + public Integer getFoliageColor() { return foliageColor; } - + public Integer getSkyColor() { return skyColor; } - + public GrassColorModifier getGrassColorModifier() { return grassColorModifier; } - + public BiomeParticleConfig getParticleConfig() { return particleConfig; } - + public Boolean getPrecipitation() { return precipitation; } - + public Float getTemperature() { return temperature; } - + public TemperatureModifier getTemperatureModifier() { return temperatureModifier; } - + public Float getDownfall() { return downfall; } - + public SoundEvent getLoopSound() { return loopSound; } - + public BiomeMoodSound getMoodSound() { return moodSound; } - + public BiomeAdditionsSound getAdditionsSound() { return additionsSound; } - + public MusicSound getMusic() { return music; } - + public SpawnSettings getSpawnSettings() { return spawnSettings; } - + public VillagerType getVillagerType() { return villagerType; } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VillagerTypeTemplate.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VillagerTypeTemplate.java index c998d8abf..68e7a518f 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VillagerTypeTemplate.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/config/VillagerTypeTemplate.java @@ -12,7 +12,7 @@ public class VillagerTypeTemplate implements ObjectTemplate { @Value("id") @Default private Identifier id = null; - + @Override public VillagerType get() { return Registries.VILLAGER_TYPE.get(id); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/data/Codecs.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/data/Codecs.java index 410a719fc..595f5ec5b 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/data/Codecs.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/data/Codecs.java @@ -13,45 +13,45 @@ import com.dfsek.terra.mod.generation.TerraBiomeSource; public final class Codecs { public static final Codec TERRA_REGISTRY_KEY = RecordCodecBuilder - .create(registryKey -> registryKey.group(Codec.STRING.fieldOf("namespace") - .stable() - .forGetter(RegistryKey::getNamespace), - Codec.STRING.fieldOf("id") - .stable() - .forGetter(RegistryKey::getID)) - .apply(registryKey, registryKey.stable(RegistryKey::of))); - + .create(registryKey -> registryKey.group(Codec.STRING.fieldOf("namespace") + .stable() + .forGetter(RegistryKey::getNamespace), + Codec.STRING.fieldOf("id") + .stable() + .forGetter(RegistryKey::getID)) + .apply(registryKey, registryKey.stable(RegistryKey::of))); + public static final Codec CONFIG_PACK = RecordCodecBuilder - .create(config -> config.group(TERRA_REGISTRY_KEY.fieldOf("pack") - .stable() - .forGetter(ConfigPack::getRegistryKey)) - .apply(config, config.stable(id -> CommonPlatform.get() - .getConfigRegistry() - .get(id) - .orElseThrow(() -> new IllegalArgumentException( - "No such config pack " + - id))))); - + .create(config -> config.group(TERRA_REGISTRY_KEY.fieldOf("pack") + .stable() + .forGetter(ConfigPack::getRegistryKey)) + .apply(config, config.stable(id -> CommonPlatform.get() + .getConfigRegistry() + .get(id) + .orElseThrow(() -> new IllegalArgumentException( + "No such config pack " + + id))))); + public static final Codec TERRA_BIOME_SOURCE = RecordCodecBuilder - .create(instance -> instance.group( - CONFIG_PACK.fieldOf("pack") - .stable() - .forGetter(TerraBiomeSource::getPack)) - .apply(instance, instance.stable(TerraBiomeSource::new))); - + .create(instance -> instance.group( + CONFIG_PACK.fieldOf("pack") + .stable() + .forGetter(TerraBiomeSource::getPack)) + .apply(instance, instance.stable(TerraBiomeSource::new))); + public static final Codec MINECRAFT_CHUNK_GENERATOR_WRAPPER = RecordCodecBuilder - .create( - instance -> instance.group( - TERRA_BIOME_SOURCE.fieldOf("biome_source") - .stable() - .forGetter(MinecraftChunkGeneratorWrapper::getBiomeSource), - CONFIG_PACK.fieldOf("pack") - .stable() - .forGetter(MinecraftChunkGeneratorWrapper::getPack), - ChunkGeneratorSettings.REGISTRY_CODEC.fieldOf("settings") - .stable() - .forGetter(MinecraftChunkGeneratorWrapper::getSettings) - ).apply(instance, instance.stable( - MinecraftChunkGeneratorWrapper::new)) - ); + .create( + instance -> instance.group( + TERRA_BIOME_SOURCE.fieldOf("biome_source") + .stable() + .forGetter(MinecraftChunkGeneratorWrapper::getBiomeSource), + CONFIG_PACK.fieldOf("pack") + .stable() + .forGetter(MinecraftChunkGeneratorWrapper::getPack), + ChunkGeneratorSettings.REGISTRY_CODEC.fieldOf("settings") + .stable() + .forGetter(MinecraftChunkGeneratorWrapper::getSettings) + ).apply(instance, instance.stable( + MinecraftChunkGeneratorWrapper::new)) + ); } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/MinecraftChunkGeneratorWrapper.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/MinecraftChunkGeneratorWrapper.java index fc1e0f54c..899b007f0 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/MinecraftChunkGeneratorWrapper.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/MinecraftChunkGeneratorWrapper.java @@ -67,33 +67,33 @@ import com.dfsek.terra.mod.util.SeedHack; public class MinecraftChunkGeneratorWrapper extends net.minecraft.world.gen.chunk.ChunkGenerator implements GeneratorWrapper { private static final Logger logger = LoggerFactory.getLogger(MinecraftChunkGeneratorWrapper.class); - + private final TerraBiomeSource biomeSource; private final RegistryEntry settings; private ChunkGenerator delegate; private ConfigPack pack; - + public MinecraftChunkGeneratorWrapper(TerraBiomeSource biomeSource, ConfigPack configPack, RegistryEntry settingsSupplier) { super(biomeSource); this.pack = configPack; this.settings = settingsSupplier; - + this.delegate = pack.getGeneratorProvider().newInstance(pack); logger.info("Loading world with config pack {}", pack.getID()); this.biomeSource = biomeSource; } - + @Override protected Codec getCodec() { return Codecs.MINECRAFT_CHUNK_GENERATOR_WRAPPER; } - + @Override public void buildSurface(ChunkRegion region, StructureAccessor structures, NoiseConfig noiseConfig, Chunk chunk) { // no op } - + @Override public void populateEntities(ChunkRegion region) { if(!this.settings.value().mobGenerationDisabled()) { @@ -104,13 +104,13 @@ public class MinecraftChunkGeneratorWrapper extends net.minecraft.world.gen.chun SpawnHelper.populateEntities(region, registryEntry, chunkPos, chunkRandom); } } - + @Override public int getWorldHeight() { return settings.value().generationShapeConfig().height(); } - - + + @Override public CompletableFuture populateNoise(Executor executor, Blender blender, NoiseConfig noiseConfig, StructureAccessor structureAccessor, Chunk chunk) { @@ -118,7 +118,7 @@ public class MinecraftChunkGeneratorWrapper extends net.minecraft.world.gen.chun ProtoWorld world = (ProtoWorld) ((StructureAccessorAccessor) structureAccessor).getWorld(); BiomeProvider biomeProvider = pack.getBiomeProvider(); delegate.generateChunkData((ProtoChunk) chunk, world, biomeProvider, chunk.getPos().x, chunk.getPos().z); - + PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class); if(compatibilityOptions.isBeard()) { beard(structureAccessor, chunk, world, biomeProvider, compatibilityOptions); @@ -126,11 +126,11 @@ public class MinecraftChunkGeneratorWrapper extends net.minecraft.world.gen.chun return chunk; }, Util.getMainWorkerExecutor()); } - + private void beard(StructureAccessor structureAccessor, Chunk chunk, WorldProperties world, BiomeProvider biomeProvider, PreLoadCompatibilityOptions compatibilityOptions) { StructureWeightSampler structureWeightSampler = StructureWeightSampler.createStructureWeightSampler(structureAccessor, - chunk.getPos()); + chunk.getPos()); double threshold = compatibilityOptions.getBeardThreshold(); double airThreshold = compatibilityOptions.getAirThreshold(); int xi = chunk.getPos().x << 4; @@ -142,8 +142,8 @@ public class MinecraftChunkGeneratorWrapper extends net.minecraft.world.gen.chun double noise = structureWeightSampler.sample(new UnblendedNoisePos(x + xi, y, z + zi)); if(noise > threshold) { chunk.setBlockState(new BlockPos(x, y, z), (BlockState) delegate - .getPalette(x + xi, y, z + zi, world, biomeProvider) - .get(depth, x + xi, y, z + zi, world.getSeed()), false); + .getPalette(x + xi, y, z + zi, world, biomeProvider) + .get(depth, x + xi, y, z + zi, world.getSeed()), false); depth++; } else if(noise < airThreshold) { chunk.setBlockState(new BlockPos(x, y, z), Blocks.AIR.getDefaultState(), false); @@ -154,7 +154,7 @@ public class MinecraftChunkGeneratorWrapper extends net.minecraft.world.gen.chun } } } - + @Override public void generateFeatures(StructureWorldAccess world, Chunk chunk, StructureAccessor structureAccessor) { super.generateFeatures(world, chunk, structureAccessor); @@ -164,18 +164,18 @@ public class MinecraftChunkGeneratorWrapper extends net.minecraft.world.gen.chun } }); } - + @Override public int getSeaLevel() { return settings.value().seaLevel(); } - + @Override public int getMinimumY() { return settings.value().generationShapeConfig().minimumY(); } - - + + @Override public int getHeight(int x, int z, Type heightmap, HeightLimitView height, NoiseConfig noiseConfig) { WorldProperties properties = MinecraftAdapter.adapt(height, SeedHack.getSeed(noiseConfig.getMultiNoiseSampler())); @@ -183,12 +183,12 @@ public class MinecraftChunkGeneratorWrapper extends net.minecraft.world.gen.chun int min = height.getBottomY(); for(int y = height.getTopY() - 1; y >= min; y--) { if(heightmap - .getBlockPredicate() - .test((BlockState) delegate.getBlock(properties, x, y, z, biomeProvider))) return y + 1; + .getBlockPredicate() + .test((BlockState) delegate.getBlock(properties, x, y, z, biomeProvider))) return y + 1; } return min; } - + @Override public VerticalBlockSample getColumnSample(int x, int z, HeightLimitView height, NoiseConfig noiseConfig) { BlockState[] array = new BlockState[height.getHeight()]; @@ -199,39 +199,39 @@ public class MinecraftChunkGeneratorWrapper extends net.minecraft.world.gen.chun } return new VerticalBlockSample(height.getBottomY(), array); } - + @Override public void getDebugHudText(List text, NoiseConfig noiseConfig, BlockPos pos) { - + } - + public ConfigPack getPack() { return pack; } - + public void setPack(ConfigPack pack) { this.pack = pack; this.delegate = pack.getGeneratorProvider().newInstance(pack); biomeSource.setPack(pack); - + logger.debug("Loading world with config pack {}", pack.getID()); } - + @Override public void carve(ChunkRegion chunkRegion, long seed, NoiseConfig noiseConfig, BiomeAccess world, StructureAccessor structureAccessor, Chunk chunk, Carver carverStep) { // no op } - + @Override public ChunkGenerator getHandle() { return delegate; } - + public RegistryEntry getSettings() { return settings; } - + @Override public TerraBiomeSource getBiomeSource() { return biomeSource; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/TerraBiomeSource.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/TerraBiomeSource.java index 3e5404776..7aa5d8aea 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/TerraBiomeSource.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/generation/TerraBiomeSource.java @@ -36,46 +36,46 @@ import com.dfsek.terra.mod.util.SeedHack; public class TerraBiomeSource extends BiomeSource { - + private static final Logger LOGGER = LoggerFactory.getLogger(TerraBiomeSource.class); private ConfigPack pack; - + public TerraBiomeSource(ConfigPack pack) { this.pack = pack; - + LOGGER.debug("Biomes: " + getBiomes()); } - + @Override protected Codec getCodec() { return Codecs.TERRA_BIOME_SOURCE; } - + @Override protected Stream> biomeStream() { return StreamSupport - .stream(pack.getBiomeProvider() - .getBiomes() - .spliterator(), false) - .map(b -> ((ProtoPlatformBiome) b.getPlatformBiome()).getDelegate()); + .stream(pack.getBiomeProvider() + .getBiomes() + .spliterator(), false) + .map(b -> ((ProtoPlatformBiome) b.getPlatformBiome()).getDelegate()); } - + @Override public RegistryEntry getBiome(int biomeX, int biomeY, int biomeZ, MultiNoiseSampler noiseSampler) { return ((ProtoPlatformBiome) pack - .getBiomeProvider() - .getBiome(biomeX << 2, biomeY << 2, biomeZ << 2, SeedHack.getSeed(noiseSampler)) - .getPlatformBiome()).getDelegate(); + .getBiomeProvider() + .getBiome(biomeX << 2, biomeY << 2, biomeZ << 2, SeedHack.getSeed(noiseSampler)) + .getPlatformBiome()).getDelegate(); } - + public BiomeProvider getProvider() { return pack.getBiomeProvider(); } - + public ConfigPack getPack() { return pack; } - + public void setPack(ConfigPack pack) { this.pack = pack; } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftItemHandle.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftItemHandle.java index 8bed0298a..541e764ab 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftItemHandle.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftItemHandle.java @@ -37,7 +37,7 @@ import com.dfsek.terra.mod.CommonPlatform; public class MinecraftItemHandle implements ItemHandle { - + @Override public Item createItem(String data) { try { @@ -51,12 +51,12 @@ public class MinecraftItemHandle implements ItemHandle { throw new IllegalArgumentException("Invalid item data \"" + data + "\"", e); } } - + @Override public Enchantment getEnchantment(String id) { return (Enchantment) (Registries.ENCHANTMENT.get(Identifier.tryParse(id))); } - + @Override public Set getEnchantments() { return Registries.ENCHANTMENT.stream().map(enchantment -> (Enchantment) enchantment).collect(Collectors.toSet()); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftWorldHandle.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftWorldHandle.java index c48ab6244..52ea52dfa 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftWorldHandle.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/handle/MinecraftWorldHandle.java @@ -30,26 +30,26 @@ import com.dfsek.terra.api.handle.WorldHandle; public class MinecraftWorldHandle implements WorldHandle { - + private static final BlockState AIR = (BlockState) Blocks.AIR.getDefaultState(); - + @Override public @NotNull BlockState createBlockState(@NotNull String data) { try { net.minecraft.block.BlockState state = BlockArgumentParser.block(Registries.BLOCK.getReadOnlyWrapper(), data, true) - .blockState(); + .blockState(); if(state == null) throw new IllegalArgumentException("Invalid data: " + data); return (BlockState) state; } catch(CommandSyntaxException e) { throw new IllegalArgumentException(e); } } - + @Override public @NotNull BlockState air() { return AIR; } - + @Override public @NotNull EntityType getEntity(@NotNull String id) { Identifier identifier = Identifier.tryParse(id); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/fix/BeeMoveGoalsUnsynchronizedRandomAccessFix.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/fix/BeeMoveGoalsUnsynchronizedRandomAccessFix.java index f29e6d259..188e5b22c 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/fix/BeeMoveGoalsUnsynchronizedRandomAccessFix.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/fix/BeeMoveGoalsUnsynchronizedRandomAccessFix.java @@ -16,8 +16,8 @@ import com.dfsek.terra.mod.CommonPlatform; * Bees spawning uses world.random without synchronization. This causes issues when spawning bees during world generation. */ @Mixin({ - MoveToHiveGoal.class, - MoveToFlowerGoal.class + MoveToHiveGoal.class, + MoveToFlowerGoal.class }) public class BeeMoveGoalsUnsynchronizedRandomAccessFix { @Redirect(method = "", diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/compat/GenerationSettingsFloraFeaturesMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/compat/GenerationSettingsFloraFeaturesMixin.java index c254445d1..91614b99e 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/compat/GenerationSettingsFloraFeaturesMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/compat/GenerationSettingsFloraFeaturesMixin.java @@ -18,11 +18,11 @@ import com.dfsek.terra.mod.mixin_ifaces.FloraFeatureHolder; @Implements(@Interface(iface = FloraFeatureHolder.class, prefix = "terra$")) public class GenerationSettingsFloraFeaturesMixin { private List> flora; - + public void terra$setFloraFeatures(List> features) { this.flora = features; } - + @Inject(method = "getFlowerFeatures", cancellable = true, at = @At("HEAD")) public void inject(CallbackInfoReturnable>> cir) { if(flora != null) { diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/HandleImplementationMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/HandleImplementationMixin.java index 0257421ca..e1a79782e 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/HandleImplementationMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/HandleImplementationMixin.java @@ -28,29 +28,29 @@ import com.dfsek.terra.api.Handle; * A ton of Minecraft classes must implement Handle identically, we can just take care of it here */ @Mixin({ - ServerWorld.class, - ChunkRegion.class, - - Block.class, - BlockState.class, - - BlockEntity.class, - LootableContainerBlockEntity.class, - LockableContainerBlockEntity.class, - - ProtoChunk.class, - WorldChunk.class, - - Entity.class, - EntityType.class, - - ServerCommandSource.class, - - Item.class, - ItemStack.class, - Enchantment.class, - - Biome.class + ServerWorld.class, + ChunkRegion.class, + + Block.class, + BlockState.class, + + BlockEntity.class, + LootableContainerBlockEntity.class, + LockableContainerBlockEntity.class, + + ProtoChunk.class, + WorldChunk.class, + + Entity.class, + EntityType.class, + + ServerCommandSource.class, + + Item.class, + ItemStack.class, + Enchantment.class, + + Biome.class }) @Implements(@Interface(iface = Handle.class, prefix = "terra$")) public class HandleImplementationMixin { diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/BlockMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/BlockMixin.java index 480e4a86d..1665b2b8c 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/BlockMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/BlockMixin.java @@ -32,11 +32,11 @@ public abstract class BlockMixin { public com.dfsek.terra.api.block.state.BlockState terra$getDefaultState() { return (com.dfsek.terra.api.block.state.BlockState) ((Block) (Object) this).getDefaultState(); } - + public boolean terra$isSolid() { return ((Block) (Object) this).getDefaultState().isOpaque(); } - + @SuppressWarnings("ConstantConditions") public boolean terra$isWater() { return ((Object) this) == Blocks.WATER; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/BlockEntityMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/BlockEntityMixin.java index cfb7b795b..fb00e9475 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/BlockEntityMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/BlockEntityMixin.java @@ -31,23 +31,23 @@ public abstract class BlockEntityMixin { public boolean terra$update(boolean applyPhysics) { if(((net.minecraft.block.entity.BlockEntity) (Object) this).hasWorld()) //noinspection ConstantConditions ((net.minecraft.block.entity.BlockEntity) (Object) this).getWorld().getChunk( - ((net.minecraft.block.entity.BlockEntity) (Object) this).getPos()).setBlockEntity( - (net.minecraft.block.entity.BlockEntity) (Object) this); + ((net.minecraft.block.entity.BlockEntity) (Object) this).getPos()).setBlockEntity( + (net.minecraft.block.entity.BlockEntity) (Object) this); return true; } - + public int terra$getX() { return ((net.minecraft.block.entity.BlockEntity) (Object) this).getPos().getX(); } - + public int terra$getY() { return ((net.minecraft.block.entity.BlockEntity) (Object) this).getPos().getY(); } - + public int terra$getZ() { return ((net.minecraft.block.entity.BlockEntity) (Object) this).getPos().getZ(); } - + public BlockState terra$getBlockState() { return (BlockState) ((net.minecraft.block.entity.BlockEntity) (Object) this).getCachedState(); } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/MobSpawnerBlockEntityMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/MobSpawnerBlockEntityMixin.java index 43a0d8a39..1b882e5fd 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/MobSpawnerBlockEntityMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/MobSpawnerBlockEntityMixin.java @@ -45,78 +45,78 @@ public abstract class MobSpawnerBlockEntityMixin extends BlockEntity { private MobSpawnerBlockEntityMixin(BlockEntityType type, BlockPos pos, BlockState state) { super(type, pos, state); } - + @Shadow public abstract MobSpawnerLogic getLogic(); - + @Shadow public abstract void setEntityType(net.minecraft.entity.EntityType entityType, Random random); - + public EntityType terra$getSpawnedType() { return (EntityType) Registries.ENTITY_TYPE.get( - Identifier.tryParse(((MobSpawnerLogicAccessor) getLogic()).getSpawnEntry().getNbt().getString("id"))); + Identifier.tryParse(((MobSpawnerLogicAccessor) getLogic()).getSpawnEntry().getNbt().getString("id"))); } - + public void terra$setSpawnedType(@NotNull EntityType creatureType) { setEntityType((net.minecraft.entity.EntityType) creatureType, world.getRandom()); } - + public int terra$getDelay() { return 0; } - + public void terra$setDelay(int delay) { - + } - + public int terra$getMinSpawnDelay() { return 0; } - + public void terra$setMinSpawnDelay(int delay) { - + } - + public int terra$getMaxSpawnDelay() { return 0; } - + public void terra$setMaxSpawnDelay(int delay) { - + } - + public int terra$getSpawnCount() { return 0; } - + public void terra$setSpawnCount(int spawnCount) { - + } - + public int terra$getMaxNearbyEntities() { return 0; } - + public void terra$setMaxNearbyEntities(int maxNearbyEntities) { - + } - + public int terra$getRequiredPlayerRange() { return 0; } - + public void terra$setRequiredPlayerRange(int requiredPlayerRange) { - + } - + public int terra$getSpawnRange() { return 0; } - + public void terra$setSpawnRange(int spawnRange) { - + } - + public void terra$applyState(String state) { SerialState.parse(state).forEach((k, v) -> { switch(k) { diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/SignBlockEntityMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/SignBlockEntityMixin.java index b0ba7b69e..56536f9c0 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/SignBlockEntityMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/entity/SignBlockEntityMixin.java @@ -35,14 +35,14 @@ import com.dfsek.terra.api.block.entity.Sign; public abstract class SignBlockEntityMixin { @Shadow private SignText frontText; - + @Shadow public abstract boolean setText(SignText text, boolean front); - + public void terra$setLine(int index, @NotNull String line) throws IndexOutOfBoundsException { setText(frontText.withMessage(index, Text.literal(line)), true); } - + public @NotNull String[] terra$getLines() { Text[] texts = frontText.getMessages(false); String[] lines = new String[texts.length]; @@ -51,11 +51,11 @@ public abstract class SignBlockEntityMixin { } return lines; } - + public @NotNull String terra$getLine(int index) throws IndexOutOfBoundsException { return frontText.getMessage(index, false).getString(); } - + public void terra$applyState(String state) { SerialState.parse(state).forEach((k, v) -> { if(!k.startsWith("text")) throw new IllegalArgumentException("Invalid property: " + k); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/state/BlockStateMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/state/BlockStateMixin.java index a666b3491..7053dd4f5 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/state/BlockStateMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/state/BlockStateMixin.java @@ -28,17 +28,17 @@ public abstract class BlockStateMixin extends State codec) { super(owner, entries, codec); } - + @Shadow public abstract Block getBlock(); - + @Shadow public abstract boolean isAir(); - + public boolean terra$matches(BlockState other) { return getBlock() == ((net.minecraft.block.BlockState) other).getBlock(); } - + @Intrinsic public > boolean terra$has(Property property) { if(property instanceof net.minecraft.state.property.Property minecraftProperty) { @@ -46,36 +46,36 @@ public abstract class BlockStateMixin extends State> T terra$get(Property property) { return get((net.minecraft.state.property.Property) property); } - + @SuppressWarnings("unchecked") @Intrinsic public > BlockState terra$set(Property property, T value) { return (BlockState) with((net.minecraft.state.property.Property) property, value); } - + @Intrinsic public BlockType terra$getBlockType() { return (BlockType) getBlock(); } - + @Intrinsic public String terra$getAsString(boolean properties) { StringBuilder data = new StringBuilder(Registries.BLOCK.getId(getBlock()).toString()); if(properties && !getEntries().isEmpty()) { data.append('['); data.append( - getEntries().entrySet().stream().map(StateAccessor.getPropertyMapPrinter()).collect(Collectors.joining(","))); + getEntries().entrySet().stream().map(StateAccessor.getPropertyMapPrinter()).collect(Collectors.joining(","))); data.append(']'); } return data.toString(); } - + @Intrinsic public boolean terra$isAir() { return isAir(); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/state/PropertyMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/state/PropertyMixin.java index 2dd6100d6..4cb1b4858 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/state/PropertyMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/block/state/PropertyMixin.java @@ -22,20 +22,20 @@ public abstract class PropertyMixin { @Shadow @Final private String name; - + @Shadow public abstract Collection getValues(); - + @Intrinsic public Collection terra$values() { return getValues(); } - + @Intrinsic public Class terra$getType() { return type; } - + @Intrinsic public String terra$getID() { return name; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/ChunkRegionMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/ChunkRegionMixin.java index 7224f25d1..d3d5d9427 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/ChunkRegionMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/ChunkRegionMixin.java @@ -33,25 +33,25 @@ import com.dfsek.terra.api.world.chunk.Chunk; @Mixin(ChunkRegion.class) @Implements(@Interface(iface = Chunk.class, prefix = "terraChunk$")) public abstract class ChunkRegionMixin { - + @Shadow @Final private net.minecraft.world.chunk.Chunk centerPos; - + public void terraChunk$setBlock(int x, int y, int z, @NotNull BlockState blockState, boolean physics) { ((ChunkRegion) (Object) this).setBlockState(new BlockPos(x + (centerPos.getPos().x << 4), y, z + (centerPos.getPos().z << 4)), - (net.minecraft.block.BlockState) blockState, 0); + (net.minecraft.block.BlockState) blockState, 0); } - + public @NotNull BlockState terraChunk$getBlock(int x, int y, int z) { return (BlockState) ((ChunkRegion) (Object) this).getBlockState( - new BlockPos(x + (centerPos.getPos().x << 4), y, z + (centerPos.getPos().z << 4))); + new BlockPos(x + (centerPos.getPos().x << 4), y, z + (centerPos.getPos().z << 4))); } - + public int terraChunk$getX() { return centerPos.getPos().x; } - + public int terraChunk$getZ() { return centerPos.getPos().z; } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java index 54c89c1ec..005822f69 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/WorldChunkMixin.java @@ -41,17 +41,17 @@ public abstract class WorldChunkMixin { @Final @Shadow net.minecraft.world.World world; - + @Shadow public abstract net.minecraft.block.BlockState getBlockState(BlockPos pos); - + @Shadow @Nullable public abstract net.minecraft.block.BlockState setBlockState(BlockPos pos, net.minecraft.block.BlockState state, boolean moved); - + @Shadow public abstract TickSchedulers getTickSchedulers(); - + public void terra$setBlock(int x, int y, int z, BlockState data, boolean physics) { BlockPos blockPos = new BlockPos(x, y, z); setBlockState(blockPos, (net.minecraft.block.BlockState) data, false); @@ -62,28 +62,28 @@ public abstract class WorldChunkMixin { } else { world.getBlockTickScheduler().scheduleTick(OrderedTick.create(state.getBlock(), blockPos)); } - + } } - + public void terra$setBlock(int x, int y, int z, @NotNull BlockState blockState) { ((net.minecraft.world.chunk.Chunk) (Object) this).setBlockState(new BlockPos(x, y, z), (net.minecraft.block.BlockState) blockState, - false); + false); } - + @Intrinsic public @NotNull BlockState terra$getBlock(int x, int y, int z) { return (BlockState) getBlockState(new BlockPos(x, y, z)); } - + public int terra$getX() { return ((net.minecraft.world.chunk.Chunk) (Object) this).getPos().x; } - + public int terra$getZ() { return ((net.minecraft.world.chunk.Chunk) (Object) this).getPos().z; } - + public ServerWorld terra$getWorld() { return (ServerWorld) world; } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/data/ProtoChunkMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/data/ProtoChunkMixin.java index 25c8f196f..b9a6dd14c 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/data/ProtoChunkMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/chunk/data/ProtoChunkMixin.java @@ -34,19 +34,19 @@ import com.dfsek.terra.api.world.chunk.generation.ProtoChunk; public abstract class ProtoChunkMixin { @Shadow public abstract net.minecraft.block.BlockState getBlockState(BlockPos pos); - + @Shadow public abstract HeightLimitView getHeightLimitView(); - + public void terra$setBlock(int x, int y, int z, @NotNull BlockState blockState) { ((net.minecraft.world.chunk.Chunk) (Object) this).setBlockState(new BlockPos(x, y, z), (net.minecraft.block.BlockState) blockState, - false); + false); } - + public @NotNull BlockState terra$getBlock(int x, int y, int z) { return (BlockState) getBlockState(new BlockPos(x, y, z)); } - + public int terra$getMaxHeight() { return getHeightLimitView().getTopY(); } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/entity/EntityMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/entity/EntityMixin.java index dce95cf19..3225cd4a6 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/entity/EntityMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/entity/EntityMixin.java @@ -34,21 +34,21 @@ import com.dfsek.terra.mod.util.MinecraftAdapter; public abstract class EntityMixin { @Shadow public net.minecraft.world.World world; - + @Shadow private BlockPos blockPos; - + @Shadow public abstract void teleport(double destX, double destY, double destZ); - + public Vector3 terra$position() { return MinecraftAdapter.adapt(blockPos); } - + public void terra$position(Vector3 location) { teleport(location.getX(), location.getY(), location.getZ()); } - + public ServerWorld terra$world() { return (ServerWorld) world; } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/entity/ServerCommandSourceMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/entity/ServerCommandSourceMixin.java index 0dd882638..0afa29269 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/entity/ServerCommandSourceMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/entity/ServerCommandSourceMixin.java @@ -39,23 +39,23 @@ import com.dfsek.terra.api.entity.Player; public abstract class ServerCommandSourceMixin { @Shadow public abstract ServerPlayerEntity getPlayer() throws CommandSyntaxException; - + @Shadow @Nullable public abstract net.minecraft.entity.@Nullable Entity getEntity(); - + @Shadow public abstract void sendMessage(Text message); - + public void terra$sendMessage(String message) { sendMessage(Text.literal(message)); } - + @Nullable public Optional terra$getEntity() { return Optional.ofNullable((Entity) getEntity()); } - + public Optional terra$getPlayer() { try { return Optional.ofNullable((Player) getPlayer()); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/LockableContainerBlockEntityMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/LockableContainerBlockEntityMixin.java index 90c0275dc..41342d23f 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/LockableContainerBlockEntityMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/LockableContainerBlockEntityMixin.java @@ -34,11 +34,11 @@ public class LockableContainerBlockEntityMixin { public void terra$setItem(int slot, ItemStack newStack) { ((LockableContainerBlockEntity) (Object) this).setStack(slot, (net.minecraft.item.ItemStack) (Object) newStack); } - + public int terra$getSize() { return ((LockableContainerBlockEntity) (Object) this).size(); } - + @SuppressWarnings("ConstantConditions") public ItemStack terra$getItem(int slot) { net.minecraft.item.ItemStack itemStack = ((LockableContainerBlockEntity) (Object) this).getStack(slot); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/item/ItemMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/item/ItemMixin.java index 51687c45a..78593ecb1 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/item/ItemMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/item/ItemMixin.java @@ -31,12 +31,12 @@ import com.dfsek.terra.api.inventory.ItemStack; public abstract class ItemMixin { @Shadow public abstract int getMaxDamage(); - + @SuppressWarnings("ConstantConditions") public ItemStack terra$newItemStack(int amount) { return (ItemStack) (Object) new net.minecraft.item.ItemStack((Item) (Object) this, amount); } - + public double terra$getMaxDurability() { return getMaxDamage(); } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/item/ItemStackMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/item/ItemStackMixin.java index f41bce58d..089a6db1d 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/item/ItemStackMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/item/ItemStackMixin.java @@ -35,40 +35,40 @@ import com.dfsek.terra.api.inventory.item.ItemMeta; public abstract class ItemStackMixin { @Shadow public abstract int getCount(); - + @Shadow public abstract void setCount(int count); - + @Shadow public abstract net.minecraft.item.Item getItem(); - + @Shadow public abstract boolean isDamageable(); - + @Shadow public abstract void setNbt(@Nullable NbtCompound tag); - + public int terra$getAmount() { return getCount(); } - + public void terra$setAmount(int i) { setCount(i); } - + public Item terra$getType() { return (Item) getItem(); } - + public ItemMeta terra$getItemMeta() { return (ItemMeta) this; } - + @SuppressWarnings("ConstantConditions") public void terra$setItemMeta(ItemMeta meta) { setNbt(((ItemStack) (Object) meta).getNbt()); } - + @Intrinsic public boolean terra$isDamageable() { return isDamageable(); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/EnchantmentMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/EnchantmentMixin.java index f73b91cfe..24b096c85 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/EnchantmentMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/EnchantmentMixin.java @@ -34,19 +34,19 @@ import com.dfsek.terra.api.inventory.ItemStack; public abstract class EnchantmentMixin { @Shadow public abstract boolean isAcceptableItem(net.minecraft.item.ItemStack stack); - + @Shadow public abstract boolean canCombine(Enchantment other); - + @SuppressWarnings("ConstantConditions") public boolean terra$canEnchantItem(ItemStack itemStack) { return isAcceptableItem((net.minecraft.item.ItemStack) (Object) itemStack); } - + public boolean terra$conflictsWith(com.dfsek.terra.api.inventory.item.Enchantment other) { return !canCombine((Enchantment) other); } - + public String terra$getID() { return Objects.requireNonNull(Registries.ENCHANTMENT.getId((Enchantment) (Object) this)).toString(); } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/ItemStackDamageableMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/ItemStackDamageableMixin.java index 599dd232d..633df07d6 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/ItemStackDamageableMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/ItemStackDamageableMixin.java @@ -32,23 +32,23 @@ import com.dfsek.terra.api.inventory.item.Damageable; public abstract class ItemStackDamageableMixin { @Shadow public abstract boolean isDamaged(); - + @Shadow public abstract int getDamage(); - + @Shadow public abstract void setDamage(int damage); - + @Intrinsic public int terra$getDamage() { return getDamage(); } - + @Intrinsic public void terra$setDamage(int damage) { setDamage(damage); } - + public boolean terra$hasDamage() { return isDamaged(); } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/ItemStackMetaMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/ItemStackMetaMixin.java index bb8159c99..a6307b02c 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/ItemStackMetaMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/inventory/meta/ItemStackMetaMixin.java @@ -40,22 +40,22 @@ import com.dfsek.terra.api.inventory.item.ItemMeta; public abstract class ItemStackMetaMixin { @Shadow public abstract boolean hasEnchantments(); - + @Shadow public abstract NbtList getEnchantments(); - + @Shadow public abstract void addEnchantment(net.minecraft.enchantment.Enchantment enchantment, int level); - + public void terra$addEnchantment(Enchantment enchantment, int level) { addEnchantment((net.minecraft.enchantment.Enchantment) enchantment, level); } - + @Intrinsic(displace = true) public Map terra$getEnchantments() { if(!hasEnchantments()) return Collections.emptyMap(); Map map = new HashMap<>(); - + getEnchantments().forEach(enchantment -> { NbtCompound eTag = (NbtCompound) enchantment; map.put((Enchantment) Registries.ENCHANTMENT.get(eTag.getInt("id")), eTag.getInt("lvl")); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/world/ChunkRegionMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/world/ChunkRegionMixin.java index 64ed28314..82080579b 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/world/ChunkRegionMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/world/ChunkRegionMixin.java @@ -55,24 +55,24 @@ import com.dfsek.terra.mod.util.MinecraftUtil; @Implements(@Interface(iface = ProtoWorld.class, prefix = "terraWorld$")) public abstract class ChunkRegionMixin { private ConfigPack terra$config; - - + + @Shadow @Final private net.minecraft.server.world.ServerWorld world; - + @Shadow @Final private long seed; @Shadow @Final private Chunk centerPos; - + @Shadow @Final private MultiTickScheduler fluidTickScheduler; - - + + @Inject(at = @At("RETURN"), method = "(Lnet/minecraft/server/world/ServerWorld;Ljava/util/List;Lnet/minecraft/world/chunk/ChunkStatus;I)V") public void injectConstructor(net.minecraft.server.world.ServerWorld world, List list, @@ -80,69 +80,69 @@ public abstract class ChunkRegionMixin { CallbackInfo ci) { this.terra$config = ((ServerWorld) world).getPack(); } - - + + @Intrinsic(displace = true) public void terraWorld$setBlockState(int x, int y, int z, BlockState data, boolean physics) { BlockPos pos = new BlockPos(x, y, z); ((ChunkRegion) (Object) this).setBlockState(pos, (net.minecraft.block.BlockState) data, physics ? 3 : 1042); if(physics && ((net.minecraft.block.BlockState) data).getBlock() instanceof FluidBlock) { fluidTickScheduler.scheduleTick( - OrderedTick.create(((FluidBlock) ((net.minecraft.block.BlockState) data).getBlock()).getFluidState( - (net.minecraft.block.BlockState) data).getFluid(), pos)); + OrderedTick.create(((FluidBlock) ((net.minecraft.block.BlockState) data).getBlock()).getFluidState( + (net.minecraft.block.BlockState) data).getFluid(), pos)); } } - + @Intrinsic public long terraWorld$getSeed() { return seed; } - + public int terraWorld$getMaxHeight() { return world.getTopY(); } - + @Intrinsic(displace = true) public BlockState terraWorld$getBlockState(int x, int y, int z) { BlockPos pos = new BlockPos(x, y, z); return (BlockState) ((ChunkRegion) (Object) this).getBlockState(pos); } - + public BlockEntity terraWorld$getBlockEntity(int x, int y, int z) { return MinecraftUtil.createState((WorldAccess) this, new BlockPos(x, y, z)); } - + public int terraWorld$getMinHeight() { return world.getBottomY(); } - + public ChunkGenerator terraWorld$getGenerator() { return ((MinecraftChunkGeneratorWrapper) world.getChunkManager().getChunkGenerator()).getHandle(); } - + public BiomeProvider terraWorld$getBiomeProvider() { return terra$config.getBiomeProvider(); } - + public Entity terraWorld$spawnEntity(double x, double y, double z, EntityType entityType) { net.minecraft.entity.Entity entity = ((net.minecraft.entity.EntityType) entityType).create(world); entity.setPos(x, y, z); ((ChunkRegion) (Object) this).spawnEntity(entity); return (Entity) entity; } - + public int terraWorld$centerChunkX() { return centerPos.getPos().x; } - + public int terraWorld$centerChunkZ() { return centerPos.getPos().z; } - + public ServerWorld terraWorld$getWorld() { return (ServerWorld) world; } - + public ConfigPack terraWorld$getPack() { return terra$config; } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/world/ServerWorldMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/world/ServerWorldMixin.java index 74af91dbc..f9a5bd1ea 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/world/ServerWorldMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/implementations/terra/world/ServerWorldMixin.java @@ -47,53 +47,53 @@ public abstract class ServerWorldMixin { ((net.minecraft.server.world.ServerWorld) (Object) this).spawnEntity(entity); return (Entity) entity; } - + public void terra$setBlockState(int x, int y, int z, BlockState data, boolean physics) { BlockPos pos = new BlockPos(x, y, z); ((net.minecraft.server.world.ServerWorld) (Object) this).setBlockState(pos, (net.minecraft.block.BlockState) data, - physics ? 3 : 1042); + physics ? 3 : 1042); } - + @Intrinsic public long terra$getSeed() { return ((net.minecraft.server.world.ServerWorld) (Object) this).getSeed(); } - + public int terra$getMaxHeight() { return (((net.minecraft.server.world.ServerWorld) (Object) this).getBottomY()) + ((net.minecraft.server.world.ServerWorld) (Object) this).getHeight(); } - + public Chunk terra$getChunkAt(int x, int z) { return (Chunk) ((net.minecraft.server.world.ServerWorld) (Object) this).getChunk(x, z); } - + public BlockState terra$getBlockState(int x, int y, int z) { return (BlockState) ((net.minecraft.server.world.ServerWorld) (Object) this).getBlockState(new BlockPos(x, y, z)); } - + public BlockEntity terra$getBlockEntity(int x, int y, int z) { return MinecraftUtil.createState((WorldAccess) this, new BlockPos(x, y, z)); } - + public int terra$getMinHeight() { return ((net.minecraft.server.world.ServerWorld) (Object) this).getBottomY(); } - + public ChunkGenerator terra$getGenerator() { return ((MinecraftChunkGeneratorWrapper) ((net.minecraft.server.world.ServerWorld) (Object) this).getChunkManager() - .getChunkGenerator()).getHandle(); + .getChunkGenerator()).getHandle(); } - + public BiomeProvider terra$getBiomeProvider() { return ((TerraBiomeSource) ((net.minecraft.server.world.ServerWorld) (Object) this).getChunkManager() - .getChunkGenerator() - .getBiomeSource()).getProvider(); + .getChunkGenerator() + .getBiomeSource()).getProvider(); } - + public ConfigPack terra$getPack() { net.minecraft.world.gen.chunk.ChunkGenerator generator = - (((net.minecraft.server.world.ServerWorld) (Object) this).getChunkManager()).getChunkGenerator(); + (((net.minecraft.server.world.ServerWorld) (Object) this).getChunkManager()).getChunkGenerator(); if(generator instanceof MinecraftChunkGeneratorWrapper minecraftChunkGeneratorWrapper) { return minecraftChunkGeneratorWrapper.getPack(); } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/lifecycle/DataPackContentsMixin.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/lifecycle/DataPackContentsMixin.java index 81a9c2cae..48ea98519 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/lifecycle/DataPackContentsMixin.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/mixin/lifecycle/DataPackContentsMixin.java @@ -22,7 +22,7 @@ public class DataPackContentsMixin { @Inject(method = "refresh(Lnet/minecraft/registry/DynamicRegistryManager;)V", at = @At("RETURN")) private void injectReload(DynamicRegistryManager dynamicRegistryManager, CallbackInfo ci) { TagUtil.registerWorldPresetTags(dynamicRegistryManager.get(RegistryKeys.WORLD_PRESET)); - + Registry biomeRegistry = dynamicRegistryManager.get(RegistryKeys.BIOME); TagUtil.registerBiomeTags(biomeRegistry); MinecraftUtil.registerFlora(biomeRegistry); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftAdapter.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftAdapter.java index 2f43913e2..25ca7e4c5 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftAdapter.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftAdapter.java @@ -25,28 +25,28 @@ import com.dfsek.terra.api.world.info.WorldProperties; public final class MinecraftAdapter { - + public static Vector3 adapt(BlockPos pos) { return Vector3.of(pos.getX(), pos.getY(), pos.getZ()); } - + public static WorldProperties adapt(HeightLimitView height, long seed) { return new WorldProperties() { @Override public long getSeed() { return seed; } - + @Override public int getMaxHeight() { return height.getTopY(); } - + @Override public int getMinHeight() { return height.getBottomY(); } - + @Override public Object getHandle() { return height; diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftUtil.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftUtil.java index de0b9b841..692d0da5a 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftUtil.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/MinecraftUtil.java @@ -39,18 +39,18 @@ import com.dfsek.terra.mod.mixin_ifaces.FloraFeatureHolder; public final class MinecraftUtil { public static final Logger logger = LoggerFactory.getLogger(MinecraftUtil.class); public static final Map> - TERRA_BIOME_MAP = new HashMap<>(); - + TERRA_BIOME_MAP = new HashMap<>(); + private MinecraftUtil() { - + } - + public static Optional> getEntry(Registry registry, Identifier identifier) { return registry.getOrEmpty(identifier) - .flatMap(registry::getKey) - .flatMap(registry::getEntry); + .flatMap(registry::getKey) + .flatMap(registry::getEntry); } - + public static BlockEntity createState(WorldAccess worldAccess, BlockPos pos) { net.minecraft.block.entity.BlockEntity entity = worldAccess.getBlockEntity(pos); if(entity instanceof SignBlockEntity) { @@ -62,116 +62,116 @@ public final class MinecraftUtil { } return null; } - + public static void registerFlora(Registry biomes) { logger.info("Injecting flora into Terra biomes..."); TERRA_BIOME_MAP - .forEach((vb, terraBiomes) -> - biomes.getOrEmpty(vb) - .ifPresentOrElse(vanilla -> terraBiomes - .forEach(tb -> biomes.getOrEmpty(tb) - .ifPresentOrElse( - terra -> { - List> flowerFeatures = List.copyOf( - vanilla.getGenerationSettings() - .getFlowerFeatures()); - logger.debug("Injecting flora into biome" + - " {} : {}", tb, - flowerFeatures); - ((FloraFeatureHolder) terra.getGenerationSettings()).setFloraFeatures( - flowerFeatures); - }, - () -> logger.error( - "No such biome: {}", - tb))), - () -> logger.error("No vanilla biome: {}", vb))); - + .forEach((vb, terraBiomes) -> + biomes.getOrEmpty(vb) + .ifPresentOrElse(vanilla -> terraBiomes + .forEach(tb -> biomes.getOrEmpty(tb) + .ifPresentOrElse( + terra -> { + List> flowerFeatures = List.copyOf( + vanilla.getGenerationSettings() + .getFlowerFeatures()); + logger.debug("Injecting flora into biome" + + " {} : {}", tb, + flowerFeatures); + ((FloraFeatureHolder) terra.getGenerationSettings()).setFloraFeatures( + flowerFeatures); + }, + () -> logger.error( + "No such biome: {}", + tb))), + () -> logger.error("No vanilla biome: {}", vb))); + } - + public static Map> getTerraBiomeMap() { return Map.copyOf(TERRA_BIOME_MAP); } - + public static RegistryKey registerKey(Identifier identifier) { return RegistryKey.of(RegistryKeys.BIOME, identifier); } - + public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla, VanillaBiomeProperties vanillaBiomeProperties) { GenerationSettings.Builder generationSettings = new GenerationSettings.Builder(); - + BiomeEffects.Builder effects = new BiomeEffects.Builder(); - + net.minecraft.world.biome.Biome.Builder builder = new Builder(); - + effects.waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor())) - .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) - .fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor())) - .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())) - .grassColorModifier( - Objects.requireNonNullElse(vanillaBiomeProperties.getGrassColorModifier(), - vanilla.getEffects().getGrassColorModifier())); - + .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor())) + .fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor())) + .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor())) + .grassColorModifier( + Objects.requireNonNullElse(vanillaBiomeProperties.getGrassColorModifier(), + vanilla.getEffects().getGrassColorModifier())); + if(vanillaBiomeProperties.getFoliageColor() == null) { vanilla.getEffects().getFoliageColor().ifPresent(effects::foliageColor); } else { effects.foliageColor(vanillaBiomeProperties.getFoliageColor()); } - + if(vanillaBiomeProperties.getGrassColor() == null) { vanilla.getEffects().getGrassColor().ifPresent(effects::grassColor); } else { effects.grassColor(vanillaBiomeProperties.getGrassColor()); } - + if(vanillaBiomeProperties.getParticleConfig() == null) { vanilla.getEffects().getParticleConfig().ifPresent(effects::particleConfig); } else { effects.particleConfig(vanillaBiomeProperties.getParticleConfig()); } - + if(vanillaBiomeProperties.getLoopSound() == null) { vanilla.getEffects().getLoopSound().ifPresent(effects::loopSound); } else { effects.loopSound(Registries.SOUND_EVENT.getEntry(vanillaBiomeProperties.getLoopSound())); } - + if(vanillaBiomeProperties.getMoodSound() == null) { vanilla.getEffects().getMoodSound().ifPresent(effects::moodSound); } else { effects.moodSound(vanillaBiomeProperties.getMoodSound()); } - + if(vanillaBiomeProperties.getAdditionsSound() == null) { vanilla.getEffects().getAdditionsSound().ifPresent(effects::additionsSound); } else { effects.additionsSound(vanillaBiomeProperties.getAdditionsSound()); } - + if(vanillaBiomeProperties.getMusic() == null) { vanilla.getEffects().getMusic().ifPresent(effects::music); } else { effects.music(vanillaBiomeProperties.getMusic()); } - + builder.precipitation(Objects.requireNonNullElse(vanillaBiomeProperties.getPrecipitation(), vanilla.hasPrecipitation())); - + builder.temperature(Objects.requireNonNullElse(vanillaBiomeProperties.getTemperature(), vanilla.getTemperature())); - + builder.downfall(Objects.requireNonNullElse(vanillaBiomeProperties.getDownfall(), - ((BiomeAccessor) ((Object) vanilla)).getWeather().downfall())); - + ((BiomeAccessor) ((Object) vanilla)).getWeather().downfall())); + builder.temperatureModifier(Objects.requireNonNullElse(vanillaBiomeProperties.getTemperatureModifier(), - ((BiomeAccessor) ((Object) vanilla)).getWeather().temperatureModifier())); - + ((BiomeAccessor) ((Object) vanilla)).getWeather().temperatureModifier())); + builder.spawnSettings(Objects.requireNonNullElse(vanillaBiomeProperties.getSpawnSettings(), vanilla.getSpawnSettings())); - + return builder - .effects(effects.build()) - .generationSettings(generationSettings.build()) - .build(); + .effects(effects.build()) + .generationSettings(generationSettings.build()) + .build(); } - + public static String createBiomeID(ConfigPack pack, com.dfsek.terra.api.registry.key.RegistryKey biomeID) { return pack.getID() .toLowerCase() + "/" + biomeID.getNamespace().toLowerCase(Locale.ROOT) + "/" + biomeID.getID().toLowerCase(Locale.ROOT); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/PresetUtil.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/PresetUtil.java index 006fbc004..1c8627364 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/PresetUtil.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/PresetUtil.java @@ -32,57 +32,57 @@ import com.dfsek.terra.mod.generation.TerraBiomeSource; public class PresetUtil { private static final Logger LOGGER = LoggerFactory.getLogger(PresetUtil.class); private static final List PRESETS = new ArrayList<>(); - + public static Pair createDefault(ConfigPack pack, ModPlatform platform) { Registry dimensionTypeRegistry = platform.dimensionTypeRegistry(); Registry chunkGeneratorSettingsRegistry = platform.chunkGeneratorSettingsRegistry(); Registry multiNoiseBiomeSourceParameterLists = - platform.multiNoiseBiomeSourceParameterListRegistry(); - - + platform.multiNoiseBiomeSourceParameterListRegistry(); + + RegistryEntry overworldDimensionType = dimensionTypeRegistry.getEntry(DimensionTypes.OVERWORLD).orElseThrow(); RegistryEntry overworld = chunkGeneratorSettingsRegistry.getEntry(ChunkGeneratorSettings.OVERWORLD) - .orElseThrow(); - - + .orElseThrow(); + + Identifier generatorID = Identifier.of("terra", pack.getID().toLowerCase(Locale.ROOT) + "/" + pack.getNamespace().toLowerCase( - Locale.ROOT)); - + Locale.ROOT)); + PRESETS.add(generatorID); - + RegistryEntry registryEntry = dimensionTypeRegistry.getEntry(DimensionTypes.THE_NETHER).orElseThrow(); RegistryEntry.Reference reference = multiNoiseBiomeSourceParameterLists.getEntry( - MultiNoiseBiomeSourceParameterLists.NETHER).orElseThrow(); + MultiNoiseBiomeSourceParameterLists.NETHER).orElseThrow(); RegistryEntry registryEntry2 = chunkGeneratorSettingsRegistry.getEntry(ChunkGeneratorSettings.NETHER) - .orElseThrow(); - + .orElseThrow(); + RegistryEntry registryEntry3 = dimensionTypeRegistry.getEntry(DimensionTypes.THE_END).orElseThrow(); RegistryEntry registryEntry4 = chunkGeneratorSettingsRegistry.getEntry(ChunkGeneratorSettings.END) - .orElseThrow(); - + .orElseThrow(); + TerraBiomeSource biomeSource = new TerraBiomeSource(pack); ChunkGenerator generator = new MinecraftChunkGeneratorWrapper(biomeSource, pack, overworld); - + DimensionOptions dimensionOptions = new DimensionOptions(overworldDimensionType, generator); DimensionOptions netherDimensionOptions = new DimensionOptions(registryEntry, - new NoiseChunkGenerator(MultiNoiseBiomeSource.create(reference), - registryEntry2)); + new NoiseChunkGenerator(MultiNoiseBiomeSource.create(reference), + registryEntry2)); DimensionOptions endDimensionOptions = new DimensionOptions(registryEntry3, new NoiseChunkGenerator( - TheEndBiomeSource.createVanilla(platform.biomeRegistry().getReadOnlyWrapper()), registryEntry4)); - + TheEndBiomeSource.createVanilla(platform.biomeRegistry().getReadOnlyWrapper()), registryEntry4)); + WorldPreset preset = createPreset(dimensionOptions, netherDimensionOptions, endDimensionOptions); LOGGER.info("Created world type \"{}\"", generatorID); return Pair.of(generatorID, preset); } - + private static WorldPreset createPreset(DimensionOptions dimensionOptions, DimensionOptions netherDimensionOptions, DimensionOptions endDimensionOptions) { return new WorldPreset( - Map.of(DimensionOptions.OVERWORLD, dimensionOptions, DimensionOptions.NETHER, netherDimensionOptions, DimensionOptions.END, - endDimensionOptions) + Map.of(DimensionOptions.OVERWORLD, dimensionOptions, DimensionOptions.NETHER, netherDimensionOptions, DimensionOptions.END, + endDimensionOptions) ); } - + public static List getPresets() { return PRESETS; } diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/SeedHack.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/SeedHack.java index 74f9173ab..0979b346f 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/SeedHack.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/SeedHack.java @@ -12,16 +12,16 @@ import org.slf4j.LoggerFactory; */ public class SeedHack { private static final Logger LOGGER = LoggerFactory.getLogger(SeedHack.class); - + private static final Object2LongMap seedMap = new Object2LongOpenHashMap<>(); - + public static long getSeed(MultiNoiseSampler sampler) { if(!seedMap.containsKey(sampler)) { throw new IllegalArgumentException("Sampler is not registered: " + sampler); } return seedMap.getLong(sampler); } - + public static void register(MultiNoiseSampler sampler, long seed) { LOGGER.info("Registered seed {} to sampler {}", seed, sampler.hashCode()); seedMap.put(sampler, seed); diff --git a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/TagUtil.java b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/TagUtil.java index 3520c4718..36ed6afea 100644 --- a/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/TagUtil.java +++ b/platforms/mixin-common/src/main/java/com/dfsek/terra/mod/util/TagUtil.java @@ -18,86 +18,86 @@ import java.util.Map; public final class TagUtil { private static final Logger logger = LoggerFactory.getLogger(TagUtil.class); - + private TagUtil() { - + } - + private static Map, List>> tagsToMutableMap(Registry registry) { return registry - .streamTagsAndEntries() - .collect(HashMap::new, - (map, pair) -> - map.put(pair.getFirst(), new ArrayList<>(pair.getSecond().stream().toList())), - HashMap::putAll); + .streamTagsAndEntries() + .collect(HashMap::new, + (map, pair) -> + map.put(pair.getFirst(), new ArrayList<>(pair.getSecond().stream().toList())), + HashMap::putAll); } - + public static void registerWorldPresetTags(Registry registry) { logger.info("Doing preset tag garbage...."); Map, List>> collect = tagsToMutableMap(registry); - + PresetUtil - .getPresets() - .forEach(id -> MinecraftUtil - .getEntry(registry, id) - .ifPresentOrElse( - preset -> collect - .computeIfAbsent(WorldPresetTags.NORMAL, tag -> new ArrayList<>()) - .add(preset), - () -> logger.error("Preset {} does not exist!", id))); - + .getPresets() + .forEach(id -> MinecraftUtil + .getEntry(registry, id) + .ifPresentOrElse( + preset -> collect + .computeIfAbsent(WorldPresetTags.NORMAL, tag -> new ArrayList<>()) + .add(preset), + () -> logger.error("Preset {} does not exist!", id))); + registry.clearTags(); registry.populateTags(ImmutableMap.copyOf(collect)); } - + public static void registerBiomeTags(Registry registry) { logger.info("Doing biome tag garbage...."); Map, List>> collect = tagsToMutableMap(registry); - + MinecraftUtil - .getTerraBiomeMap() - .forEach((vb, terraBiomes) -> - MinecraftUtil - .getEntry(registry, vb) - .ifPresentOrElse( - vanilla -> terraBiomes - .forEach(tb -> MinecraftUtil - .getEntry(registry, tb) - .ifPresentOrElse( - terra -> { - logger.debug( - vanilla.getKey() - .orElseThrow() - .getValue() + - " (vanilla for " + - terra.getKey() - .orElseThrow() - .getValue() + - ": " + - vanilla.streamTags() - .toList()); - - vanilla.streamTags() - .forEach( - tag -> collect - .computeIfAbsent( - tag, - t -> new ArrayList<>()) - .add(terra)); - }, - () -> logger.error( - "No such biome: {}", - tb))), - () -> logger.error("No vanilla biome: {}", vb))); - + .getTerraBiomeMap() + .forEach((vb, terraBiomes) -> + MinecraftUtil + .getEntry(registry, vb) + .ifPresentOrElse( + vanilla -> terraBiomes + .forEach(tb -> MinecraftUtil + .getEntry(registry, tb) + .ifPresentOrElse( + terra -> { + logger.debug( + vanilla.getKey() + .orElseThrow() + .getValue() + + " (vanilla for " + + terra.getKey() + .orElseThrow() + .getValue() + + ": " + + vanilla.streamTags() + .toList()); + + vanilla.streamTags() + .forEach( + tag -> collect + .computeIfAbsent( + tag, + t -> new ArrayList<>()) + .add(terra)); + }, + () -> logger.error( + "No such biome: {}", + tb))), + () -> logger.error("No vanilla biome: {}", vb))); + registry.clearTags(); registry.populateTags(ImmutableMap.copyOf(collect)); - + if(logger.isDebugEnabled()) { registry.streamEntries() - .map(e -> e.registryKey().getValue() + ": " + - e.streamTags().reduce("", (s, t) -> t.id() + ", " + s, String::concat)) - .forEach(logger::debug); + .map(e -> e.registryKey().getValue() + ": " + + e.streamTags().reduce("", (s, t) -> t.id() + ", " + s, String::concat)) + .forEach(logger::debug); } } } diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java index 8530b57ad..f20038e5e 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java @@ -12,19 +12,19 @@ import com.dfsek.terra.api.event.events.platform.CommandRegistrationEvent; public final class LifecycleEntryPoint { private static final Logger logger = LoggerFactory.getLogger(LifecycleEntryPoint.class); - + public static void initialize(String modName, LifecyclePlatform platform) { logger.info("Initializing Terra {} mod...", modName); - + FabricServerCommandManager manager = new FabricServerCommandManager<>( - CommandExecutionCoordinator.simpleCoordinator(), - serverCommandSource -> (CommandSender) serverCommandSource, - commandSender -> (ServerCommandSource) commandSender + CommandExecutionCoordinator.simpleCoordinator(), + serverCommandSource -> (CommandSender) serverCommandSource, + commandSender -> (ServerCommandSource) commandSender ); - - + + manager.brigadierManager().setNativeNumberSuggestions(false); - + platform.getEventManager().callEvent(new CommandRegistrationEvent(manager)); } } diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java index 2008b1266..be845eb19 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecyclePlatform.java @@ -35,12 +35,12 @@ public abstract class LifecyclePlatform extends ModPlatform { private static final AtomicReference> SETTINGS = new AtomicReference<>(); private static final AtomicReference> NOISE = new AtomicReference<>(); private static MinecraftServer server; - + public LifecyclePlatform() { CommonPlatform.initialize(this); load(); } - + public static void setRegistries(Registry biomeRegistry, Registry dimensionTypeRegistry, Registry chunkGeneratorSettingsRegistry, @@ -50,23 +50,23 @@ public abstract class LifecyclePlatform extends ModPlatform { SETTINGS.set(chunkGeneratorSettingsRegistry); NOISE.set(multiNoiseBiomeSourceParameterListRegistry); } - + @Override public MinecraftServer getServer() { return server; } - + public static void setServer(MinecraftServer server) { LifecyclePlatform.server = server; } - + @Override public boolean reload() { getTerraConfig().load(this); getRawConfigRegistry().clear(); boolean succeed = getRawConfigRegistry().loadAll(this); - - + + if(server != null) { BiomeUtil.registerBiomes(server.getRegistryManager().get(RegistryKeys.BIOME)); server.reloadResources(server.getDataPackManager().getNames()).exceptionally(throwable -> { @@ -84,13 +84,13 @@ public abstract class LifecyclePlatform extends ModPlatform { } return succeed; } - + @Override protected Iterable platformAddon() { List addons = new ArrayList<>(); - + super.platformAddon().forEach(addons::add); - + String mcVersion = MinecraftVersion.CURRENT.getName(); try { addons.add(new EphemeralAddon(Versions.parseVersion(mcVersion), "minecraft")); @@ -101,12 +101,12 @@ public abstract class LifecyclePlatform extends ModPlatform { LOGGER.warn("Failed to parse Minecraft version", e); } } - + addons.addAll(getPlatformMods()); - + return addons; } - + protected Stream parseModData(String id, String modVersion, String platform) { if(id.equals("terra") || id.equals("minecraft") || id.equals("java")) return Stream.empty(); try { @@ -114,32 +114,32 @@ public abstract class LifecyclePlatform extends ModPlatform { return Stream.of(new EphemeralAddon(version, platform + ":" + id)); } catch(ParseException e) { LOGGER.warn( - "Mod {}, version {} does not follow semantic versioning specification, Terra addons will be unable to depend on " + - "it.", - id, modVersion); + "Mod {}, version {} does not follow semantic versioning specification, Terra addons will be unable to depend on " + + "it.", + id, modVersion); } return Stream.empty(); } - + @Override public Registry dimensionTypeRegistry() { return DIMENSIONS.get(); } - + @Override public Registry biomeRegistry() { return BIOMES.get(); } - + @Override public Registry chunkGeneratorSettingsRegistry() { return SETTINGS.get(); } - + @Override public Registry multiNoiseBiomeSourceParameterListRegistry() { return NOISE.get(); } - + protected abstract Collection getPlatformMods(); } diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/NoiseConfigMixin.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/NoiseConfigMixin.java index 8363e4c00..47fe9a9ca 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/NoiseConfigMixin.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/NoiseConfigMixin.java @@ -23,7 +23,7 @@ public class NoiseConfigMixin { @Shadow @Final private MultiNoiseSampler multiNoiseSampler; - + @Inject(method = "(Lnet/minecraft/world/gen/chunk/ChunkGeneratorSettings;Lnet/minecraft/registry/RegistryEntryLookup;J)V", at = @At("TAIL")) private void mapMultiNoise(ChunkGeneratorSettings chunkGeneratorSettings, diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/SimpleRegistryMixin.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/SimpleRegistryMixin.java index f388e57b6..27f28700c 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/SimpleRegistryMixin.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/SimpleRegistryMixin.java @@ -16,7 +16,7 @@ public class SimpleRegistryMixin implements RegistryHack { @Shadow @Final private Map> valueToEntry; - + @Override public void terra_bind() { valueToEntry.forEach((value, entry) -> { diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/RegistryLoaderMixin.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/RegistryLoaderMixin.java index 6e4cfefc4..052598ac2 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/RegistryLoaderMixin.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/RegistryLoaderMixin.java @@ -31,44 +31,44 @@ public class RegistryLoaderMixin { @Shadow @Final private static Logger LOGGER; - + @Redirect( - method = "load(Lnet/minecraft/resource/ResourceManager;Lnet/minecraft/registry/DynamicRegistryManager;Ljava/util/List;)" + - "Lnet/minecraft/registry/DynamicRegistryManager$Immutable;", - at = @At( - value = "INVOKE", - target = "Ljava/util/List;forEach(Ljava/util/function/Consumer;)V", - ordinal = 1 // we want right after the first forEach - ) + method = "load(Lnet/minecraft/resource/ResourceManager;Lnet/minecraft/registry/DynamicRegistryManager;Ljava/util/List;)" + + "Lnet/minecraft/registry/DynamicRegistryManager$Immutable;", + at = @At( + value = "INVOKE", + target = "Ljava/util/List;forEach(Ljava/util/function/Consumer;)V", + ordinal = 1 // we want right after the first forEach + ) ) private static void grabManager(List, Object>> instance, Consumer, Object>> consumer) { instance.forEach(mutableRegistryObjectPair -> LOGGER.debug("{}: {} entries", - mutableRegistryObjectPair.getFirst().toString(), - mutableRegistryObjectPair.getFirst().size()) - ); + mutableRegistryObjectPair.getFirst().toString(), + mutableRegistryObjectPair.getFirst().size()) + ); extractRegistry(instance, RegistryKeys.BIOME).ifPresent( - biomes -> { // this redirect triggers twice, second time only with dimension registry. don't try extraction second time - MutableRegistry dimensionTypes = extractRegistry(instance, RegistryKeys.DIMENSION_TYPE).orElseThrow(); - MutableRegistry worldPresets = extractRegistry(instance, RegistryKeys.WORLD_PRESET).orElseThrow(); - MutableRegistry chunkGeneratorSettings = extractRegistry(instance, - RegistryKeys.CHUNK_GENERATOR_SETTINGS).orElseThrow(); - MutableRegistry multiNoiseBiomeSourceParameterLists = extractRegistry(instance, - RegistryKeys.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST).orElseThrow(); - - LifecyclePlatform.setRegistries(biomes, dimensionTypes, chunkGeneratorSettings, multiNoiseBiomeSourceParameterLists); - LifecycleUtil.initialize(biomes, worldPresets); - }); + biomes -> { // this redirect triggers twice, second time only with dimension registry. don't try extraction second time + MutableRegistry dimensionTypes = extractRegistry(instance, RegistryKeys.DIMENSION_TYPE).orElseThrow(); + MutableRegistry worldPresets = extractRegistry(instance, RegistryKeys.WORLD_PRESET).orElseThrow(); + MutableRegistry chunkGeneratorSettings = extractRegistry(instance, + RegistryKeys.CHUNK_GENERATOR_SETTINGS).orElseThrow(); + MutableRegistry multiNoiseBiomeSourceParameterLists = extractRegistry(instance, + RegistryKeys.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST).orElseThrow(); + + LifecyclePlatform.setRegistries(biomes, dimensionTypes, chunkGeneratorSettings, multiNoiseBiomeSourceParameterLists); + LifecycleUtil.initialize(biomes, worldPresets); + }); instance.forEach(consumer); } - + @SuppressWarnings("unchecked") private static Optional> extractRegistry(List, Object>> instance, RegistryKey> key) { List> matches = instance - .stream() - .map(Pair::getFirst) - .filter(r -> r.getKey().equals(key)) - .toList(); + .stream() + .map(Pair::getFirst) + .filter(r -> r.getKey().equals(key)) + .toList(); if(matches.size() > 1) { throw new IllegalStateException("Illegal number of registries returned: " + matches); } else if(matches.isEmpty()) { diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/SaveLoadingMixin.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/SaveLoadingMixin.java index 953e23dc0..6f373130f 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/SaveLoadingMixin.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/SaveLoadingMixin.java @@ -13,15 +13,15 @@ import com.dfsek.terra.mod.util.MinecraftUtil; @Mixin(SaveLoading.class) public class SaveLoadingMixin { @ModifyArg( - method = "method_42097(Lnet/minecraft/registry/DynamicRegistryManager$Immutable;" + - "Lnet/minecraft/server/SaveLoading$SaveApplierFactory;Lnet/minecraft/resource/LifecycledResourceManager;" + - "Lnet/minecraft/registry/CombinedDynamicRegistries;Lnet/minecraft/server/SaveLoading$LoadContext;" + - "Lnet/minecraft/server/DataPackContents;)Ljava/lang/Object;", - at = @At( - value = "INVOKE", - target = "Lnet/minecraft/server/DataPackContents;refresh(Lnet/minecraft/registry/DynamicRegistryManager;)V" - ), - index = 0 + method = "method_42097(Lnet/minecraft/registry/DynamicRegistryManager$Immutable;" + + "Lnet/minecraft/server/SaveLoading$SaveApplierFactory;Lnet/minecraft/resource/LifecycledResourceManager;" + + "Lnet/minecraft/registry/CombinedDynamicRegistries;Lnet/minecraft/server/SaveLoading$LoadContext;" + + "Lnet/minecraft/server/DataPackContents;)Ljava/lang/Object;", + at = @At( + value = "INVOKE", + target = "Lnet/minecraft/server/DataPackContents;refresh(Lnet/minecraft/registry/DynamicRegistryManager;)V" + ), + index = 0 ) private static DynamicRegistryManager grabManager(DynamicRegistryManager in) { MinecraftUtil.registerFlora(in.get(RegistryKeys.BIOME)); diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/BiomeUtil.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/BiomeUtil.java index d3078b71a..5d5ab11c0 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/BiomeUtil.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/BiomeUtil.java @@ -24,11 +24,11 @@ import com.dfsek.terra.mod.util.MinecraftUtil; public final class BiomeUtil { private static final Logger logger = LoggerFactory.getLogger(BiomeUtil.class); - + private BiomeUtil() { - + } - + public static void registerBiomes(Registry biomeRegistry) { logger.info("Registering biomes..."); CommonPlatform.get().getConfigRegistry().forEach(pack -> { // Register all Terra biomes. @@ -37,7 +37,7 @@ public final class BiomeUtil { }); logger.info("Terra biomes registered."); } - + /** * Clones a Vanilla biome and injects Terra data to create a Terra-vanilla biome delegate. * @@ -48,36 +48,36 @@ public final class BiomeUtil { com.dfsek.terra.api.registry.key.RegistryKey id, Registry registry) { RegistryKey vanilla = ((ProtoPlatformBiome) biome.getPlatformBiome()).get(registry); - - + + if(pack.getContext().get(PreLoadCompatibilityOptions.class).useVanillaBiomes()) { ((ProtoPlatformBiome) biome.getPlatformBiome()).setDelegate(registry.getEntry(vanilla).orElseThrow()); } else { VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class); - + net.minecraft.world.biome.Biome minecraftBiome = MinecraftUtil.createBiome(biome, Objects.requireNonNull(registry.get(vanilla)), - vanillaBiomeProperties); - + vanillaBiomeProperties); + Identifier identifier = new Identifier("terra", MinecraftUtil.createBiomeID(pack, id)); - + if(registry.containsId(identifier)) { ((ProtoPlatformBiome) biome.getPlatformBiome()).setDelegate(MinecraftUtil.getEntry(registry, identifier) - .orElseThrow()); + .orElseThrow()); } else { ((ProtoPlatformBiome) biome.getPlatformBiome()).setDelegate(Registry.registerReference(registry, - MinecraftUtil.registerKey(identifier) - .getValue(), - minecraftBiome)); + MinecraftUtil.registerKey(identifier) + .getValue(), + minecraftBiome)); } - + Map, VillagerType> villagerMap = VillagerTypeAccessor.getBiomeTypeToIdMap(); - + villagerMap.put(RegistryKey.of(RegistryKeys.BIOME, identifier), - Objects.requireNonNullElse(vanillaBiomeProperties.getVillagerType(), - villagerMap.getOrDefault(vanilla, VillagerType.PLAINS))); - + Objects.requireNonNullElse(vanillaBiomeProperties.getVillagerType(), + villagerMap.getOrDefault(vanilla, VillagerType.PLAINS))); + MinecraftUtil.TERRA_BIOME_MAP.computeIfAbsent(vanilla.getValue(), i -> new ArrayList<>()).add(identifier); } } - + } diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/LifecycleUtil.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/LifecycleUtil.java index 6b4f36eeb..a251bedbd 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/LifecycleUtil.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/LifecycleUtil.java @@ -13,13 +13,13 @@ import com.dfsek.terra.mod.CommonPlatform; public final class LifecycleUtil { private LifecycleUtil() { - + } - + public static void initialize(MutableRegistry biomeMutableRegistry, MutableRegistry worldPresetMutableRegistry) { CommonPlatform.get().getEventManager().callEvent(new PlatformInitializationEvent()); BiomeUtil.registerBiomes(biomeMutableRegistry); CommonPlatform.get().registerWorldTypes( - (id, preset) -> Registry.register(worldPresetMutableRegistry, RegistryKey.of(RegistryKeys.WORLD_PRESET, id), preset)); + (id, preset) -> Registry.register(worldPresetMutableRegistry, RegistryKey.of(RegistryKeys.WORLD_PRESET, id), preset)); } } diff --git a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/RegistryUtil.java b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/RegistryUtil.java index aeffe254e..03f0639c7 100644 --- a/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/RegistryUtil.java +++ b/platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/RegistryUtil.java @@ -9,9 +9,9 @@ import com.dfsek.terra.mod.data.Codecs; public final class RegistryUtil { private RegistryUtil() { - + } - + public static void register() { Registry.register(Registries.CHUNK_GENERATOR, new Identifier("terra:terra"), Codecs.MINECRAFT_CHUNK_GENERATOR_WRAPPER); Registry.register(Registries.BIOME_SOURCE, new Identifier("terra:terra"), Codecs.TERRA_BIOME_SOURCE); diff --git a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/AwfulQuiltHacks.java b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/AwfulQuiltHacks.java index e702a5e4c..6dbcbaff4 100644 --- a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/AwfulQuiltHacks.java +++ b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/AwfulQuiltHacks.java @@ -23,12 +23,12 @@ public final class AwfulQuiltHacks { } catch(ReflectiveOperationException e) { throw new RuntimeException("Failed to load Classloader fields", e); } - + ADD_URL_METHOD = tempAddUrlMethod; } - + private AwfulQuiltHacks() { } - + /** * Hackily load the package which a mixin may exist within. *

diff --git a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltAddon.java b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltAddon.java index 6c3419a26..f0767fdcf 100644 --- a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltAddon.java +++ b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltAddon.java @@ -5,11 +5,11 @@ import com.dfsek.terra.mod.ModPlatform; public class QuiltAddon extends MinecraftAddon { - + public QuiltAddon(ModPlatform modPlatform) { super(modPlatform); } - + @Override public String getID() { return "terra-quilt"; diff --git a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltEntryPoint.java b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltEntryPoint.java index 5b8688962..7ddfbd58a 100644 --- a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltEntryPoint.java +++ b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltEntryPoint.java @@ -25,7 +25,7 @@ import com.dfsek.terra.lifecycle.LifecycleEntryPoint; public class QuiltEntryPoint extends LifecycleEntryPoint implements ModInitializer { private static final QuiltPlatform TERRA_PLUGIN = new QuiltPlatform(); - + @Override public void onInitialize(ModContainer container) { initialize("Quilt", TERRA_PLUGIN); diff --git a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java index 021f7b2ce..47910f518 100644 --- a/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java +++ b/platforms/quilt/src/main/java/com/dfsek/terra/quilt/QuiltPlatform.java @@ -29,26 +29,26 @@ import com.dfsek.terra.lifecycle.LifecyclePlatform; public class QuiltPlatform extends LifecyclePlatform { - + @Override protected Collection getPlatformMods() { return QuiltLoader.getAllMods() - .stream() - .flatMap(mod -> parseModData(mod.metadata().id(), mod.metadata().version().raw(), "quilt")) - .collect( - Collectors.toList()); + .stream() + .flatMap(mod -> parseModData(mod.metadata().id(), mod.metadata().version().raw(), "quilt")) + .collect( + Collectors.toList()); } - + @Override public @NotNull String platformName() { return "Quilt"; } - + @Override public @NotNull File getDataFolder() { return new File(QuiltLoader.getConfigDir().toFile(), "Terra"); } - + @Override public BaseAddon getPlatformAddon() { return new QuiltAddon(this); diff --git a/platforms/sponge/src/main/java/com/dfsek/terra/sponge/PlatformImpl.java b/platforms/sponge/src/main/java/com/dfsek/terra/sponge/PlatformImpl.java index c04ad7244..2096ed2ec 100644 --- a/platforms/sponge/src/main/java/com/dfsek/terra/sponge/PlatformImpl.java +++ b/platforms/sponge/src/main/java/com/dfsek/terra/sponge/PlatformImpl.java @@ -31,32 +31,32 @@ import com.dfsek.terra.sponge.handle.SpongeWorldHandle; public class PlatformImpl extends AbstractPlatform { private final TerraSpongePlugin plugin; private final SpongeWorldHandle worldHandle = new SpongeWorldHandle(); - + public PlatformImpl(TerraSpongePlugin plugin) { this.plugin = plugin; load(); } - + @Override public boolean reload() { return false; } - + @Override public @NotNull String platformName() { return "Sponge"; } - + @Override public @NotNull WorldHandle getWorldHandle() { return worldHandle; } - + @Override public @NotNull File getDataFolder() { return Sponge.configManager().pluginConfig(plugin.getPluginContainer()).directory().toFile(); } - + @Override public @NotNull ItemHandle getItemHandle() { return null; diff --git a/platforms/sponge/src/main/java/com/dfsek/terra/sponge/SpongeListener.java b/platforms/sponge/src/main/java/com/dfsek/terra/sponge/SpongeListener.java index e2373308c..77c272136 100644 --- a/platforms/sponge/src/main/java/com/dfsek/terra/sponge/SpongeListener.java +++ b/platforms/sponge/src/main/java/com/dfsek/terra/sponge/SpongeListener.java @@ -26,11 +26,11 @@ import com.dfsek.terra.api.event.events.platform.PlatformInitializationEvent; public class SpongeListener { private final TerraSpongePlugin plugin; - + public SpongeListener(TerraSpongePlugin plugin) { this.plugin = plugin; } - + @Listener public void initialize(StartingEngineEvent event) { plugin.getTerraPlugin().getEventManager().callEvent(new PlatformInitializationEvent()); diff --git a/platforms/sponge/src/main/java/com/dfsek/terra/sponge/TerraSpongePlugin.java b/platforms/sponge/src/main/java/com/dfsek/terra/sponge/TerraSpongePlugin.java index 109eb4750..e8a9c6983 100644 --- a/platforms/sponge/src/main/java/com/dfsek/terra/sponge/TerraSpongePlugin.java +++ b/platforms/sponge/src/main/java/com/dfsek/terra/sponge/TerraSpongePlugin.java @@ -27,18 +27,18 @@ import org.spongepowered.plugin.builtin.jvm.Plugin; public class TerraSpongePlugin { private final PluginContainer plugin; private final PlatformImpl terraPlugin; - + @Inject public TerraSpongePlugin(Game game) { this.plugin = null; this.terraPlugin = new PlatformImpl(this); game.eventManager().registerListeners(plugin, new SpongeListener(this)); } - + public PluginContainer getPluginContainer() { return plugin; } - + public PlatformImpl getTerraPlugin() { return terraPlugin; } diff --git a/platforms/sponge/src/main/java/com/dfsek/terra/sponge/block/SpongeBlockState.java b/platforms/sponge/src/main/java/com/dfsek/terra/sponge/block/SpongeBlockState.java index dbf1f8500..af74ef11f 100644 --- a/platforms/sponge/src/main/java/com/dfsek/terra/sponge/block/SpongeBlockState.java +++ b/platforms/sponge/src/main/java/com/dfsek/terra/sponge/block/SpongeBlockState.java @@ -26,51 +26,51 @@ import com.dfsek.terra.api.block.state.properties.Property; public class SpongeBlockState implements BlockState { private final org.spongepowered.api.block.BlockState delegate; - + public SpongeBlockState(org.spongepowered.api.block.BlockState delegate) { this.delegate = delegate; } - + @Override public org.spongepowered.api.block.BlockState getHandle() { return delegate; } - + @Override public boolean matches(BlockState other) { return delegate.type().equals(((SpongeBlockType) other.getBlockType()).getHandle()); } - + @Override public > boolean has(Property property) { return false; } - + @Override public > T get(Property property) { return null; } - + @Override public > BlockState set(Property property, T value) { return this; } - + @Override public BlockType getBlockType() { return new SpongeBlockType(delegate.type()); } - + @Override public String getAsString(boolean verbose) { return delegate.toString(); } - + @Override public boolean isAir() { return delegate.type().equals(BlockTypes.AIR.get()); } - + @Override public BlockState clone() { return this; diff --git a/platforms/sponge/src/main/java/com/dfsek/terra/sponge/block/SpongeBlockType.java b/platforms/sponge/src/main/java/com/dfsek/terra/sponge/block/SpongeBlockType.java index d27aaef24..762c6641d 100644 --- a/platforms/sponge/src/main/java/com/dfsek/terra/sponge/block/SpongeBlockType.java +++ b/platforms/sponge/src/main/java/com/dfsek/terra/sponge/block/SpongeBlockType.java @@ -26,26 +26,26 @@ import com.dfsek.terra.api.block.state.BlockState; public class SpongeBlockType implements BlockType { private final org.spongepowered.api.block.BlockType delegate; - + public SpongeBlockType(org.spongepowered.api.block.BlockType delegate) { this.delegate = delegate; } - + @Override public org.spongepowered.api.block.BlockType getHandle() { return delegate; } - + @Override public BlockState getDefaultState() { return new SpongeBlockState(delegate.defaultState()); } - + @Override public boolean isSolid() { return !delegate.getOrElse(Keys.IS_SOLID, false); } - + @Override public boolean isWater() { return delegate.equals(BlockTypes.WATER.get()); diff --git a/platforms/sponge/src/main/java/com/dfsek/terra/sponge/handle/SpongeWorldHandle.java b/platforms/sponge/src/main/java/com/dfsek/terra/sponge/handle/SpongeWorldHandle.java index 84cc0a55d..820dc9cd2 100644 --- a/platforms/sponge/src/main/java/com/dfsek/terra/sponge/handle/SpongeWorldHandle.java +++ b/platforms/sponge/src/main/java/com/dfsek/terra/sponge/handle/SpongeWorldHandle.java @@ -29,21 +29,21 @@ import com.dfsek.terra.sponge.block.SpongeBlockState; public class SpongeWorldHandle implements WorldHandle { private final Lazy air; - + public SpongeWorldHandle() { air = Lazy.lazy(() -> new SpongeBlockState(BlockTypes.AIR.get().defaultState())); } - + @Override public @NotNull BlockState createBlockState(@NotNull String data) { return new SpongeBlockState(org.spongepowered.api.block.BlockState.fromString(data)); } - + @Override public @NotNull BlockState air() { return air.value(); } - + @Override public @NotNull EntityType getEntity(@NotNull String id) { throw new UnsupportedOperationException(); From 1c3ee86376dca217926dac6b49bad74299dca221 Mon Sep 17 00:00:00 2001 From: Astrashh Date: Mon, 13 Nov 2023 11:57:27 +1100 Subject: [PATCH 81/83] Simplify PR template (#427) --- .github/PULL_REQUEST_TEMPLATE.md | 152 ++++++++++++++----------------- 1 file changed, 69 insertions(+), 83 deletions(-) diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md index 35418fc93..2a29d56d9 100644 --- a/.github/PULL_REQUEST_TEMPLATE.md +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -1,58 +1,19 @@ # Pull Request -## Brief description. +## Description - + - - - -### What Issues Does This Fix? - - -## Licensing - - - -- [ ] I am the original author of this code, and I am willing to release it - under [GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html). -- [ ] I am not the original author of this code, but it is in public domain or - released under [GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html) or a - compatible license. - - -## Goal of the PR +### Changelog - [ ] @@ -61,47 +22,58 @@ - [ ] - [ ] -## Affects of the PR +## Checklist - +#### Mandatory checks + +- [ ] The base branch of this PR is an unreleased version branch (that has a `ver/` prefix) + or is a branch that is intended to be merged into a version branch. + +- [ ] There are no already existing PRs that provide the same changes. + +- [ ] The PR is within the scope of Terra (i.e. is something a configurable terrain generator should be doing). +- [ ] Changes follow the code style for this project. + +- [ ] I have read the [`CONTRIBUTING.md`](https://github.com/PolyhedralDev/Terra/blob/master/CONTRIBUTING.md) + document in the root of the git repository. + #### Types of changes -- [ ] Bug Fix -- [ ] Build system -- [ ] Documentation -- [ ] New Feature -- [ ] Performance -- [ ] Refactoring -- [ ] Repository -- [ ] Revert -- [ ] Style -- [ ] Tests -- [ ] Translation +- [ ] Bug Fix +- [ ] Build system +- [ ] Documentation +- [ ] New Feature +- [ ] Performance +- [ ] Refactoring +- [ ] Repository +- [ ] Revert +- [ ] Style +- [ ] Tests +- [ ] Translation -#### Compatiblity +#### Compatibility -- [ ] Breaking - change -- [ ] Non-Breaking change. - + -#### Contribution Guidelines. - -- [ ] I have read - the [`CONTRIBUTING.md`](https://github.com/PolyhedralDev/Terra/blob/master/CONTRIBUTING.md) - document in the root of the git repository. -- [ ] My code follows the code style for this - project. +- [ ] Introduces a breaking change + +- [ ] Introduces new functionality in a backwards compatible way. +- [ ] Introduces bug fixes #### Documentation @@ -112,7 +84,21 @@ - [ ] I have added tests to cover my changes. - [ ] All new and existing tests passed. - + + +#### Licensing + + + +- [ ] I am the original author of this code, and I am willing to + release it under [GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html). +- [ ] I am not the original author of this code, but it is in public domain or + released under [GPLv3](https://www.gnu.org/licenses/gpl-3.0.en.html) or a compatible license. + From fd0c4df04ca7a69561bc09a6eb565333708bb941 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Sun, 12 Nov 2023 21:18:27 -0700 Subject: [PATCH 82/83] Revert "add stub for not physics" This reverts commit 839bc23a5a2ee5919b7c99620b1d14bdd61923c1. --- .../terrascript/script/functions/BlockFunction.java | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java index 84130e701..cbc105302 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java @@ -38,18 +38,6 @@ public class BlockFunction implements Function { private final Returnable physics; private final Position position; - public BlockFunction(Returnable x, Returnable y, Returnable z, Returnable blockData, - Returnable overwrite, Platform platform, Position position) { - this.x = x; - this.y = y; - this.z = z; - this.blockData = blockData; - this.overwrite = overwrite; - this.platform = platform; - this.position = position; - this.physics = new BooleanConstant(false, position); - } - public BlockFunction(Returnable x, Returnable y, Returnable z, Returnable blockData, Returnable overwrite, Returnable physics, Platform platform, Position position) { this.x = x; From 272556ed81967d147227635aa08781028f99dda1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Zo=C3=AB=20Gidiere?= Date: Sun, 12 Nov 2023 21:45:47 -0700 Subject: [PATCH 83/83] final reformat and import optimize --- .../extrusions/ReplaceExtrusion.java | 8 +-- .../biome/image/v2/ImageBiomeProvider.java | 4 +- .../script/functions/BlockFunction.java | 1 - .../terra/config/pack/ConfigPackImpl.java | 49 +++++++------------ .../bukkit/nms/v1_19_R1/NMSBiomeInfo.java | 4 +- 5 files changed, 25 insertions(+), 41 deletions(-) diff --git a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/extrusions/ReplaceExtrusion.java b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/extrusions/ReplaceExtrusion.java index 26b1ec4bb..daa1b12d9 100644 --- a/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/extrusions/ReplaceExtrusion.java +++ b/common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/extrusions/ReplaceExtrusion.java @@ -1,9 +1,5 @@ package com.dfsek.terra.addons.biome.extrusion.extrusions; -import java.util.Collection; -import java.util.function.Predicate; -import java.util.stream.Collectors; - import com.dfsek.terra.addons.biome.extrusion.api.Extrusion; import com.dfsek.terra.addons.biome.extrusion.api.ReplaceableBiome; import com.dfsek.terra.addons.biome.query.api.BiomeQueries; @@ -12,6 +8,10 @@ import com.dfsek.terra.api.util.Range; import com.dfsek.terra.api.util.collection.ProbabilityCollection; import com.dfsek.terra.api.world.biome.Biome; +import java.util.Collection; +import java.util.function.Predicate; +import java.util.stream.Collectors; + /** * Sets biomes at locations based on a sampler. diff --git a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java index 073bea70e..8809410c5 100644 --- a/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java +++ b/common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java @@ -7,13 +7,13 @@ package com.dfsek.terra.addons.biome.image.v2; -import java.util.Optional; - import com.dfsek.terra.addons.image.colorsampler.ColorSampler; import com.dfsek.terra.addons.image.converter.ColorConverter; import com.dfsek.terra.api.world.biome.Biome; import com.dfsek.terra.api.world.biome.generation.BiomeProvider; +import java.util.Optional; + public class ImageBiomeProvider implements BiomeProvider { private final int resolution; diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java index cbc105302..c4518b47c 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/functions/BlockFunction.java @@ -16,7 +16,6 @@ import java.util.Map; import com.dfsek.terra.addons.terrascript.parser.lang.ImplementationArguments; import com.dfsek.terra.addons.terrascript.parser.lang.Returnable; import com.dfsek.terra.addons.terrascript.parser.lang.Scope; -import com.dfsek.terra.addons.terrascript.parser.lang.constants.BooleanConstant; import com.dfsek.terra.addons.terrascript.parser.lang.constants.StringConstant; import com.dfsek.terra.addons.terrascript.parser.lang.functions.Function; import com.dfsek.terra.addons.terrascript.script.TerraImplementationArguments; diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackImpl.java index 82ec7d95b..06b617cd8 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackImpl.java @@ -26,33 +26,6 @@ import com.dfsek.tectonic.api.loader.AbstractConfigLoader; import com.dfsek.tectonic.api.loader.ConfigLoader; import com.dfsek.tectonic.api.loader.type.TypeLoader; import com.dfsek.tectonic.yaml.YamlConfiguration; -import com.google.common.collect.ListMultimap; -import com.google.common.collect.Multimaps; -import org.jetbrains.annotations.NotNull; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import java.awt.image.BufferedImage; -import java.io.File; -import java.io.FileInputStream; -import java.io.FileNotFoundException; -import java.io.IOException; -import java.io.UncheckedIOException; -import java.lang.reflect.ParameterizedType; -import java.lang.reflect.Type; -import java.util.ArrayList; -import java.util.Enumeration; -import java.util.HashMap; -import java.util.HashSet; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.TreeMap; -import java.util.concurrent.ConcurrentHashMap; -import java.util.function.Supplier; -import java.util.zip.ZipEntry; -import java.util.zip.ZipFile; import com.dfsek.terra.api.Platform; import com.dfsek.terra.api.addon.BaseAddon; @@ -83,16 +56,28 @@ import com.dfsek.terra.config.fileloaders.FolderLoader; import com.dfsek.terra.config.fileloaders.ZIPLoader; import com.dfsek.terra.config.loaders.GenericTemplateSupplierLoader; import com.dfsek.terra.config.loaders.config.BufferedImageLoader; -import com.dfsek.terra.config.preprocessor.MetaListLikePreprocessor; -import com.dfsek.terra.config.preprocessor.MetaMapPreprocessor; -import com.dfsek.terra.config.preprocessor.MetaNumberPreprocessor; -import com.dfsek.terra.config.preprocessor.MetaStringPreprocessor; -import com.dfsek.terra.config.preprocessor.MetaValuePreprocessor; +import com.dfsek.terra.config.preprocessor.*; import com.dfsek.terra.config.prototype.ProtoConfig; import com.dfsek.terra.registry.CheckedRegistryImpl; import com.dfsek.terra.registry.OpenRegistryImpl; import com.dfsek.terra.registry.ShortcutHolder; +import com.google.common.collect.ListMultimap; +import com.google.common.collect.Multimaps; +import org.jetbrains.annotations.NotNull; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.awt.image.BufferedImage; +import java.io.*; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Supplier; +import java.util.zip.ZipEntry; +import java.util.zip.ZipFile; + /** * Represents a Terra configuration pack. diff --git a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeInfo.java b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeInfo.java index 31024cf32..02e67dc8d 100644 --- a/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeInfo.java +++ b/platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeInfo.java @@ -1,10 +1,10 @@ package com.dfsek.terra.bukkit.nms.v1_19_R1; +import com.dfsek.terra.api.properties.Properties; + import net.minecraft.resources.ResourceKey; import net.minecraft.world.level.biome.Biome; -import com.dfsek.terra.api.properties.Properties; - public record NMSBiomeInfo(ResourceKey biomeKey) implements Properties { }