Add in New Surface Rules & Conditions

common/src/main/java/dev/worldgen/lithostitched/mixin/client/IntegratedServerMixin.java

@@ -1,7 +1,7 @@
 package dev.worldgen.lithostitched.mixin.client;
 
 import dev.worldgen.lithostitched.worldgen.modifier.Modifier;
-import dev.worldgen.lithostitched.worldgen.surface.SurfaceRuleManager;
+import dev.worldgen.lithostitched.worldgen.surface.technical.SurfaceRuleManager;
 import net.minecraft.client.server.IntegratedServer;
 import net.minecraft.server.MinecraftServer;
 import org.spongepowered.asm.mixin.Mixin;

common/src/main/java/dev/worldgen/lithostitched/mixin/common/ContextMixin.java

@@ -0,0 +1,91 @@
+package dev.worldgen.lithostitched.mixin.common;
+
+import dev.worldgen.lithostitched.worldgen.surface.conditions.LithostitchedSurfaceConditions;
+import dev.worldgen.lithostitched.worldgen.surface.technical.IContextExtension;
+import net.minecraft.core.*;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.levelgen.*;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.function.Function;
+
+@Mixin(SurfaceRules.Context.class)
+public final class ContextMixin implements IContextExtension {
+    // Shadowed variables from Context
+    @Shadow
+    long lastUpdateXZ;
+    @Shadow
+    public int blockX;
+    @Shadow
+    public int blockZ;
+    @Shadow
+    @Final
+    public ChunkAccess chunk;
+    @Shadow
+    @Final
+    public RandomState randomState;
+    // Variables for the cached conditions
+    @Unique
+    @SuppressWarnings("all")
+    SurfaceRules.Condition cliff, flat, flatLiquid, aboveWater;
+    // Caches for heightmap, alongside its update timer
+    @Unique
+    @SuppressWarnings("all")
+    private int oceanHeightmapDepthCache = -Integer.MAX_VALUE;
+    @Unique
+    @SuppressWarnings("all")
+    private long lastUpdateHeightmapDepth;
+
+    @Inject(method = "<init>", at = @At("RETURN"))
+    public void instantiateConditions(SurfaceSystem system,
+                                      RandomState randomState,
+                                      ChunkAccess chunk,
+                                      NoiseChunk noiseChunk,
+                                      Function<BlockPos, Holder<Biome>> biomeGetter,
+                                      Registry<Biome> biomeRegistry,
+                                      WorldGenerationContext context,
+                                      CallbackInfo ci) {
+        SurfaceRules.Context self = (SurfaceRules.Context) (Object) this;
+        cliff = new LithostitchedSurfaceConditions.CliffCondition(self);
+        flat = new LithostitchedSurfaceConditions.FlatCondition(self);
+        flatLiquid = new LithostitchedSurfaceConditions.FlatLiquidCondition(self);
+        aboveWater = new LithostitchedSurfaceConditions.LandTopLayerCondition(self);
+    }
+
+    @Override
+    public SurfaceRules.Condition lithostitched$getCliff() {
+        return cliff;
+    }
+
+    @Override
+    public SurfaceRules.Condition lithostitched$getFlat() {
+        return flat;
+    }
+
+    @Override
+    public SurfaceRules.Condition lithostitched$getFlatLiquid() {
+        return flatLiquid;
+    }
+
+    @Override
+    public SurfaceRules.Condition lithostitched$getLandTopLayer() {
+        return aboveWater;
+    }
+
+    @Override
+    public int lithostitched$getOceanHeightmapDepth() {
+        if (lastUpdateXZ != lastUpdateHeightmapDepth) {
+            oceanHeightmapDepthCache = chunk.getHeight(Heightmap.Types.OCEAN_FLOOR_WG, blockX, blockZ);
+            lastUpdateHeightmapDepth = lastUpdateXZ;
+        }
+        return oceanHeightmapDepthCache;
+    }
+}
+

common/src/main/java/dev/worldgen/lithostitched/mixin/common/GameTestServerMixin.java

@@ -1,7 +1,7 @@
 package dev.worldgen.lithostitched.mixin.common;
 
 import dev.worldgen.lithostitched.worldgen.modifier.Modifier;
-import dev.worldgen.lithostitched.worldgen.surface.SurfaceRuleManager;
+import dev.worldgen.lithostitched.worldgen.surface.technical.SurfaceRuleManager;
 import net.minecraft.gametest.framework.GameTestServer;
 import net.minecraft.server.MinecraftServer;
 import org.spongepowered.asm.mixin.Mixin;

common/src/main/java/dev/worldgen/lithostitched/mixin/server/DedicatedServerMixin.java

@@ -1,7 +1,7 @@
 package dev.worldgen.lithostitched.mixin.server;
 
 import dev.worldgen.lithostitched.worldgen.modifier.Modifier;
-import dev.worldgen.lithostitched.worldgen.surface.SurfaceRuleManager;
+import dev.worldgen.lithostitched.worldgen.surface.technical.SurfaceRuleManager;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.dedicated.DedicatedServer;
 import org.spongepowered.asm.mixin.Mixin;

common/src/main/java/dev/worldgen/lithostitched/registry/LithostitchedMaterialRules.java

@@ -7,6 +7,20 @@
 import net.minecraft.world.level.levelgen.SurfaceRules;
 
 public final class LithostitchedMaterialRules {
+    // Technical rules, used for merging modifiers into the main rule
     public static final ResourceKey<MapCodec<? extends SurfaceRules.RuleSource>> TRANSIENT_MERGED = LithostitchedCommon.createResourceKey(Registries.MATERIAL_RULE, "transient_merged");
-
+    // Content rules, used for adding new features or simplifying existing constructions
+    public static final ResourceKey<MapCodec<? extends SurfaceRules.RuleSource>> BILAYER_FILL = LithostitchedCommon.createResourceKey(Registries.MATERIAL_RULE, "bilayer_fill");
+    public static final ResourceKey<MapCodec<? extends SurfaceRules.RuleSource>> NOISE_THRESHOLD_SELECTOR = LithostitchedCommon.createResourceKey(Registries.MATERIAL_RULE, "noise_threshold_selector");
+    public static final ResourceKey<MapCodec<? extends SurfaceRules.RuleSource>> RANDOM_THRESHOLD_SELECTOR = LithostitchedCommon.createResourceKey(Registries.MATERIAL_RULE, "random_threshold_selector");
+    public static final ResourceKey<MapCodec<? extends SurfaceRules.RuleSource>> HEIGHT_THRESHOLD_SELECTOR = LithostitchedCommon.createResourceKey(Registries.MATERIAL_RULE, "height_threshold_selector");
+    public static final ResourceKey<MapCodec<? extends SurfaceRules.RuleSource>> STONE_DEPTH_THRESHOLD_SELECTOR = LithostitchedCommon.createResourceKey(Registries.MATERIAL_RULE, "stone_depth_threshold_selector");
+    // Material conditions, which are under a separate registry but are used in the TestRule rule so we incl. here
+    public static final ResourceKey<MapCodec<? extends SurfaceRules.ConditionSource>> CLIFF = LithostitchedCommon.createResourceKey(Registries.MATERIAL_CONDITION, "cliff");
+    public static final ResourceKey<MapCodec<? extends SurfaceRules.ConditionSource>> FLAT = LithostitchedCommon.createResourceKey(Registries.MATERIAL_CONDITION, "flat");
+    public static final ResourceKey<MapCodec<? extends SurfaceRules.ConditionSource>> FLAT_LIQUID = LithostitchedCommon.createResourceKey(Registries.MATERIAL_CONDITION, "flat_liquid");
+    public static final ResourceKey<MapCodec<? extends SurfaceRules.ConditionSource>> LAND_TOP_LAYER = LithostitchedCommon.createResourceKey(Registries.MATERIAL_CONDITION, "land_top_layer");
+    public static final ResourceKey<MapCodec<? extends SurfaceRules.ConditionSource>> UNDERWATER = LithostitchedCommon.createResourceKey(Registries.MATERIAL_CONDITION, "underwater");
+    public static final ResourceKey<MapCodec<? extends SurfaceRules.ConditionSource>> CAVE_DEPTH = LithostitchedCommon.createResourceKey(Registries.MATERIAL_CONDITION, "cave_depth");
+    public static final ResourceKey<MapCodec<? extends SurfaceRules.ConditionSource>> EXTENDED_BIOME = LithostitchedCommon.createResourceKey(Registries.MATERIAL_CONDITION, "biome");
 }

common/src/main/java/dev/worldgen/lithostitched/worldgen/surface/conditions/LithostitchedConditionSources.java

@@ -0,0 +1,153 @@
+package dev.worldgen.lithostitched.worldgen.surface.conditions;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.MapCodec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import dev.worldgen.lithostitched.worldgen.surface.technical.IContextExtension;
+import net.minecraft.core.HolderSet;
+import net.minecraft.core.RegistryCodecs;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.util.KeyDispatchDataCodec;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.levelgen.SurfaceRules;
+
+/**
+ * Surface conditions, used for creating the condition stack.
+ * @author VoidsongDragonfly
+ */
+public class LithostitchedConditionSources {
+
+    public enum CliffConditionSource implements SurfaceRules.ConditionSource {
+        INSTANCE;
+
+        public static final KeyDispatchDataCodec<CliffConditionSource> CODEC = KeyDispatchDataCodec.of(MapCodec.unit(INSTANCE));
+
+        @Override
+        public KeyDispatchDataCodec<? extends SurfaceRules.ConditionSource> codec() {
+            return CODEC;
+        }
+
+        @SuppressWarnings("DataFlowIssue")
+        public SurfaceRules.Condition apply(SurfaceRules.Context pContext) {
+            return ((IContextExtension)(Object)pContext).lithostitched$getCliff();
+        }
+    }
+
+    public enum FlatConditionSource implements SurfaceRules.ConditionSource {
+        INSTANCE;
+
+        public static final KeyDispatchDataCodec<FlatConditionSource> CODEC = KeyDispatchDataCodec.of(MapCodec.unit(INSTANCE));
+
+        @Override
+        public KeyDispatchDataCodec<? extends SurfaceRules.ConditionSource> codec() {
+            return CODEC;
+        }
+
+        @SuppressWarnings("DataFlowIssue")
+        public SurfaceRules.Condition apply(SurfaceRules.Context pContext) {
+            return ((IContextExtension)(Object)pContext).lithostitched$getFlat();
+        }
+    }
+
+    public enum FlatLiquidConditionSource implements SurfaceRules.ConditionSource {
+        INSTANCE;
+
+        public static final KeyDispatchDataCodec<FlatLiquidConditionSource> CODEC = KeyDispatchDataCodec.of(MapCodec.unit(INSTANCE));
+
+        @Override
+        public KeyDispatchDataCodec<? extends SurfaceRules.ConditionSource> codec() {
+            return CODEC;
+        }
+
+        @SuppressWarnings("DataFlowIssue")
+        public SurfaceRules.Condition apply(SurfaceRules.Context pContext) {
+            return ((IContextExtension)(Object)pContext).lithostitched$getFlatLiquid();
+        }
+    }
+
+    public enum LandTopLayerConditionSource implements SurfaceRules.ConditionSource {
+        INSTANCE;
+
+        public static final KeyDispatchDataCodec<LandTopLayerConditionSource> CODEC = KeyDispatchDataCodec.of(MapCodec.unit(INSTANCE));
+
+        @Override
+        public KeyDispatchDataCodec<? extends SurfaceRules.ConditionSource> codec() {
+            return CODEC;
+        }
+
+        @SuppressWarnings("DataFlowIssue")
+        public SurfaceRules.Condition apply(SurfaceRules.Context pContext) {
+            return ((IContextExtension)(Object)pContext).lithostitched$getLandTopLayer();
+        }
+    }
+
+    public record UnderwaterConditionSource(boolean shallow) implements SurfaceRules.ConditionSource {
+        public static final KeyDispatchDataCodec<UnderwaterConditionSource> CODEC = KeyDispatchDataCodec.of(
+            RecordCodecBuilder.mapCodec(
+                source -> source.group(
+                    Codec.BOOL.optionalFieldOf("shallow", false).forGetter(UnderwaterConditionSource::shallow)
+                ).apply(source, UnderwaterConditionSource::new)
+            )
+        );
+
+        @Override
+        public KeyDispatchDataCodec<? extends SurfaceRules.ConditionSource> codec() {
+            return CODEC;
+        }
+
+        public SurfaceRules.Condition apply(SurfaceRules.Context pContext) {
+            return new LithostitchedSurfaceConditions.UnderwaterCondition(pContext, shallow);
+        }
+    }
+
+    public record CaveDepthConditionSource(int depth) implements SurfaceRules.ConditionSource {
+        public static final KeyDispatchDataCodec<CaveDepthConditionSource> CODEC = KeyDispatchDataCodec.of(
+            RecordCodecBuilder.mapCodec(
+                source -> source.group(
+                    Codec.INT.fieldOf("depth").forGetter(CaveDepthConditionSource::depth)
+                ).apply(source, CaveDepthConditionSource::new)
+            )
+        );
+
+        @Override
+        public KeyDispatchDataCodec<? extends SurfaceRules.ConditionSource> codec() {
+            return CODEC;
+        }
+
+        public SurfaceRules.Condition apply(SurfaceRules.Context pContext) {
+            return new LithostitchedSurfaceConditions.CaveDepthCondition(pContext, depth);
+        }
+    }
+
+    public static class ExtendedBiomeConditionSource implements SurfaceRules.ConditionSource {
+        public static final KeyDispatchDataCodec<ExtendedBiomeConditionSource> CODEC = KeyDispatchDataCodec.of(
+            RegistryCodecs.homogeneousList(Registries.BIOME).fieldOf("biome_is").xmap(ExtendedBiomeConditionSource::new, biomeSource -> biomeSource.biomeSet)
+        );
+        public final HolderSet<Biome> biomeSet;
+
+        public ExtendedBiomeConditionSource(HolderSet<Biome> biomes) {
+            this.biomeSet = biomes;
+        }
+
+        @Override
+        public KeyDispatchDataCodec<? extends SurfaceRules.ConditionSource> codec() {
+            return CODEC;
+        }
+
+        public SurfaceRules.Condition apply(final SurfaceRules.Context pContext) {
+            class ExtendedBiomeCondition implements SurfaceRules.Condition {
+                @Override
+                public boolean test() {
+                    return biomeSet.contains(pContext.biome.get());
+                }
+            }
+
+            return new ExtendedBiomeCondition();
+        }
+
+        @Override
+        public String toString() {
+            return "ExtendedBiomeConditionSource[biomes=" + this.biomeSet + "]";
+        }
+    }
+}