Merge branch 'ver/6.4.0' into dev/terrascript-2

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

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

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

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

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

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

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

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<CubicSplineNoiseSampler> {
+    
+    @Value("points")
+    private @Meta List<@Meta Point> points;
+    
+    @Override
+    public NoiseSampler get() {
+        return new CubicSplineNoiseSampler(function, new CubicSpline(points));
+    }
+}

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<Point> 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<Point> {
+        
+        @Override
+        public int compareTo(@NotNull CubicSpline.Point o) {
+            return Double.compare(from, o.from);
+        }
+    }
+}

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

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) {
@@ -351,6 +289,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;
@@ -382,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) {
@@ -514,6 +380,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 +407,7 @@ public class CellularSampler extends NoiseFunction {
         Distance2Mul,
         Distance2Div,
         NoiseLookup,
+        LocalNoiseLookup,
         Distance3,
         Distance3Add,
         Distance3Sub,

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>("shadowJar") {
+    relocate("com.dfsek.paralithic", "com.dfsek.terra.addons.numberpredicate.lib.paralithic")
+}

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

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

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

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.

common/addons/config-ore-v2/README.md

@@ -0,0 +1,3 @@
+# config-ore-v2
+
+Registers the default configuration for Terra Ores, `ORE`.

common/addons/config-ore-v2/build.gradle.kts

@@ -0,0 +1,11 @@
+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<com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar>("shadowJar") {
+    relocate("net.jafama", "com.dfsek.terra.addons.ore.lib.jafama")
+}

common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/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.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();
+    }
+}

common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/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.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<OreTemplate, Structure> {
+    public static final TypeKey<Structure> 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<OreTemplate, Structure> getFactory() {
+        return factory;
+    }
+    
+    @Override
+    public TypeKey<Structure> getTypeKey() {
+        return ORE_TYPE_TOKEN;
+    }
+}

common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/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.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<OreTemplate, Structure> {
+    @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());
+    }
+}

common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/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.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<BlockType, BlockState> getMaterialOverrides() {
+        return materials;
+    }
+    
+    public double isExposed() {
+        return exposed;
+    }
+}

common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java

@@ -0,0 +1,207 @@
+/*
+ * 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 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<BlockType, BlockState> materials;
+    
+    public VanillaOre(BlockState material, double size, MaterialSet replaceable, boolean applyGravity,
+                      double exposed, Map<BlockType, BlockState> 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() + 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 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 = ((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;
+        }
+        
+        // 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) 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];
+                
+                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
+                                            
+                                            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;
+    }
+}

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.v2.OreAddon"
+website:
+  issues: https://github.com/PolyhedralDev/Terra/issues
+  source: https://github.com/PolyhedralDev/Terra
+  docs: https://terra.polydev.org
+license: MIT License

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,8 @@ public class OreAddon implements AddonInitializer {
                 .register(addon, ConfigPackPreLoadEvent.class)
                 .then(event -> event.getPack().registerConfigType(new OreConfigType(), addon.key("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.");
     }
 }

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

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

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<Supplier<ObjectTemplate<Locator>>> 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();
+    }
+}

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<Locator> {
+    
+    @Value("condition")
+    private DoublePredicate predicate;
+    
+    @Override
+    public Locator get() {
+        return new SlantLocator(predicate);
+    }
+}

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

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

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;