[Changes] Cleanup of old SurfaceRule code

2022-06-22 00:00:38 +02:00 · 2022-06-22 00:00:38 +02:00 · cc36c090a1
commit cc36c090a1
parent da1d4c6b40
19 changed files with 305 additions and 147 deletions
--- a/src/main/java/org/betterx/worlds/together/mixin/common/BuiltinRegistriesMixin.java
+++ b/src/main/java/org/betterx/worlds/together/mixin/common/BuiltinRegistriesMixin.java
@ -5,7 +5,6 @@ import org.betterx.worlds.together.surfaceRules.SurfaceRuleRegistry;
 import net.minecraft.core.Registry;
 import net.minecraft.data.BuiltinRegistries;
 import net.minecraft.resources.ResourceKey;
-import net.minecraft.world.level.levelgen.SurfaceRules;

 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@ -18,7 +17,7 @@ public class BuiltinRegistriesMixin {

    @Inject(method = "<clinit>", at = @At(value = "INVOKE", target = "Ljava/util/Map;forEach(Ljava/util/function/BiConsumer;)V"))
    private static void together_registerSurface(CallbackInfo ci) {
-        SurfaceRuleRegistry.SURFACE_RULES = (Registry<SurfaceRules.RuleSource>) registerSimple(
+        SurfaceRuleRegistry.BUILTIN_SURFACE_RULES = registerSimple(
                SurfaceRuleRegistry.SURFACE_RULES_REGISTRY,
                SurfaceRuleRegistry::bootstrap
        );
--- a/src/main/java/org/betterx/worlds/together/mixin/common/NoiseGeneratorSettingsMixin.java
+++ b/src/main/java/org/betterx/worlds/together/mixin/common/NoiseGeneratorSettingsMixin.java
@ -0,0 +1,103 @@
+package org.betterx.worlds.together.mixin.common;
+
+import org.betterx.bclib.api.v2.levelgen.surface.SurfaceRuleUtil;
+import org.betterx.worlds.together.surfaceRules.SurfaceRuleProvider;
+
+import net.minecraft.world.level.biome.BiomeSource;
+import net.minecraft.world.level.levelgen.NoiseGeneratorSettings;
+import net.minecraft.world.level.levelgen.SurfaceRules;
+import net.minecraft.world.level.levelgen.SurfaceRules.RuleSource;
+
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.Shadow;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+@Mixin(NoiseGeneratorSettings.class)
+public class NoiseGeneratorSettingsMixin implements SurfaceRuleProvider {
+    @Mutable
+    @Final
+    @Shadow
+    private SurfaceRules.RuleSource surfaceRule;
+
+    private SurfaceRules.RuleSource bclib_originalSurfaceRule;
+    private final Set<BiomeSource> bclib_biomeSources = new HashSet<>();
+
+    private void bclib_updateCustomRules() {
+        bclib_setCustomRules(SurfaceRuleUtil.getRuleSources(bclib_biomeSources));
+    }
+
+    @Override
+    public void bclib_addBiomeSource(BiomeSource source) {
+//        bclib_biomeSources.add(source);
+//        bclib_updateCustomRules();
+    }
+
+    @Override
+    public void bclib_clearBiomeSources() {
+//        bclib_biomeSources.clear();
+//        bclib_clearCustomRules();
+    }
+
+    private void bclib_clearCustomRules() {
+//        if (bclib_originalSurfaceRule != null) {
+//            this.surfaceRule = bclib_originalSurfaceRule;
+//            bclib_originalSurfaceRule = null;
+//        }
+    }
+
+    private void bclib_setCustomRules(List<RuleSource> rules) {
+//        if (rules.size() == 0) {
+//            bclib_clearCustomRules();
+//            return;
+//        }
+//
+//        RuleSource org = bclib_getOriginalSurfaceRule();
+//        if (org instanceof SurfaceRules.SequenceRuleSource sequenceRule) {
+//            List<RuleSource> currentSequence = sequenceRule.sequence();
+//            rules = rules.stream().filter(r -> currentSequence.indexOf(r) < 0).collect(Collectors.toList());
+//            rules.addAll(sequenceRule.sequence());
+//        } else {
+//            rules.add(org);
+//        }
+//
+//        bclib_setSurfaceRule(SurfaceRules.sequence(rules.toArray(new RuleSource[rules.size()])));
+    }
+
+    public void bclib_overwrite(SurfaceRules.RuleSource surfaceRule) {
+        if (surfaceRule == this.surfaceRule) return;
+        if (this.bcl_containsOverride) {
+            System.out.println("Adding another override");
+        }
+        this.bcl_containsOverride = true;
+        this.surfaceRule = surfaceRule;
+    }
+
+    void bclib_setSurfaceRule(SurfaceRules.RuleSource surfaceRule) {
+        if (bclib_originalSurfaceRule == null) {
+            bclib_originalSurfaceRule = this.surfaceRule;
+        }
+        this.surfaceRule = surfaceRule;
+    }
+
+    private boolean bcl_containsOverride = false;
+
+    RuleSource bclib_getOriginalSurfaceRule() {
+        if (bclib_originalSurfaceRule == null) {
+            return surfaceRule;
+        }
+
+        return bclib_originalSurfaceRule;
+    }
+
+//	@Inject(method = "surfaceRule", at = @At("HEAD"), cancellable = true)
+//	private void bclib_surfaceRule(CallbackInfoReturnable<SurfaceRules.RuleSource> info) {
+//		if (bclib_surfaceRule != null) {
+//			info.setReturnValue(bclib_surfaceRule);
+//		}
+//	}
+}
--- a/src/main/java/org/betterx/worlds/together/mixin/common/RegistryAccessMixin.java
+++ b/src/main/java/org/betterx/worlds/together/mixin/common/RegistryAccessMixin.java
@ -1,12 +1,12 @@
 package org.betterx.worlds.together.mixin.common;

+import org.betterx.worlds.together.surfaceRules.AssignedSurfaceRule;
 import org.betterx.worlds.together.surfaceRules.SurfaceRuleRegistry;

 import com.mojang.serialization.Codec;
 import net.minecraft.core.Registry;
 import net.minecraft.core.RegistryAccess;
 import net.minecraft.resources.ResourceKey;
-import net.minecraft.world.level.levelgen.SurfaceRules;

 import com.google.common.collect.ImmutableMap;
 import org.spongepowered.asm.mixin.Mixin;
@ -29,7 +29,7 @@ public interface RegistryAccessMixin {
            ImmutableMap.Builder<ResourceKey<Registry<?>>, RegistryAccess.RegistryData<?>> builder = ImmutableMap.builder();

            builder.putAll(res);
-            put(builder, SurfaceRuleRegistry.SURFACE_RULES_REGISTRY, SurfaceRules.RuleSource.CODEC);
+            put(builder, SurfaceRuleRegistry.SURFACE_RULES_REGISTRY, AssignedSurfaceRule.CODEC);
            return builder.build();
        };
    }
--- a/src/main/java/org/betterx/worlds/together/surfaceRules/AssignedSurfaceRule.java
+++ b/src/main/java/org/betterx/worlds/together/surfaceRules/AssignedSurfaceRule.java
@ -1,9 +1,19 @@
 package org.betterx.worlds.together.surfaceRules;

+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.level.levelgen.SurfaceRules;

 public class AssignedSurfaceRule {
+    public static final Codec<AssignedSurfaceRule> CODEC = RecordCodecBuilder.create(instance -> instance
+            .group(
+                    SurfaceRules.RuleSource.CODEC.fieldOf("ruleSource").forGetter(o -> o.ruleSource),
+                    ResourceLocation.CODEC.fieldOf("biome").forGetter(o -> o.biomeID)
+            )
+            .apply(instance, AssignedSurfaceRule::new)
+    );
+
    public final SurfaceRules.RuleSource ruleSource;
    public final ResourceLocation biomeID;

@ -12,4 +22,5 @@ public class AssignedSurfaceRule {
        this.biomeID = biomeID;
    }

+
 }
--- a/src/main/java/org/betterx/worlds/together/surfaceRules/SurfaceRuleProvider.java
+++ b/src/main/java/org/betterx/worlds/together/surfaceRules/SurfaceRuleProvider.java
@ -0,0 +1,10 @@
+package org.betterx.worlds.together.surfaceRules;
+
+import net.minecraft.world.level.biome.BiomeSource;
+import net.minecraft.world.level.levelgen.SurfaceRules;
+
+public interface SurfaceRuleProvider {
+    void bclib_addBiomeSource(BiomeSource source);
+    void bclib_clearBiomeSources();
+    void bclib_overwrite(SurfaceRules.RuleSource surfaceRule);
+}
--- a/src/main/java/org/betterx/worlds/together/surfaceRules/SurfaceRuleRegistry.java
+++ b/src/main/java/org/betterx/worlds/together/surfaceRules/SurfaceRuleRegistry.java
@ -8,26 +8,55 @@ import net.minecraft.data.BuiltinRegistries;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.dimension.LevelStem;
 import net.minecraft.world.level.levelgen.SurfaceRules;

-public class SurfaceRuleRegistry {
-    public static final ResourceKey<Registry<SurfaceRules.RuleSource>> SURFACE_RULES_REGISTRY =
-            createRegistryKey(WorldsTogether.makeID("worldgen/surface_rules"));
+import java.util.function.Predicate;
+import org.jetbrains.annotations.ApiStatus;

-    public static Registry<SurfaceRules.RuleSource> SURFACE_RULES;
+public class SurfaceRuleRegistry {
+    public static final ResourceKey<Registry<AssignedSurfaceRule>> SURFACE_RULES_REGISTRY =
+            createRegistryKey(WorldsTogether.makeID("worldgen/surface_rules"));
+    public static final Predicate<ResourceKey<LevelStem>> NON_MANAGED_DIMENSIONS = dim -> dim != LevelStem.NETHER && dim != LevelStem.END;
+    public static final Predicate<ResourceKey<LevelStem>> ALL_DIMENSIONS = dim -> true;
+
+    public static Registry<AssignedSurfaceRule> BUILTIN_SURFACE_RULES;

    private static <T> ResourceKey<Registry<T>> createRegistryKey(ResourceLocation location) {
        return ResourceKey.createRegistryKey(location);
    }

-    public static Holder<SurfaceRules.RuleSource> bootstrap(Registry<SurfaceRules.RuleSource> registry) {
+    @ApiStatus.Internal
+    public static Holder<AssignedSurfaceRule> bootstrap(Registry<AssignedSurfaceRule> registry) {
        return BuiltinRegistries.register(
                registry,
-                WorldsTogether.makeID("test"),
-                SurfaceRules.state(Blocks.SCULK.defaultBlockState())
+                WorldsTogether.makeID("dummy"),
+                new AssignedSurfaceRule(
+                        SurfaceRules.state(Blocks.YELLOW_CONCRETE.defaultBlockState()),
+                        WorldsTogether.makeID("none")
+                )
        );
    }

+    public static ResourceKey<AssignedSurfaceRule> registerRule(
+            ResourceLocation ruleID,
+            SurfaceRules.RuleSource rules,
+            ResourceLocation biomeID
+    ) {
+        ResourceKey<AssignedSurfaceRule> key = ResourceKey.create(
+                SurfaceRuleRegistry.SURFACE_RULES_REGISTRY,
+                ruleID
+        );
+        Registry.register(SurfaceRuleRegistry.BUILTIN_SURFACE_RULES, key, new AssignedSurfaceRule(
+                        SurfaceRules.ifTrue(
+                                SurfaceRules.isBiome(ResourceKey.create(Registry.BIOME_REGISTRY, biomeID)),
+                                rules
+                        ), biomeID
+                )
+        );
+        return key;
+    }
+
    public static void ensureStaticallyLoaded() {

    }
--- a/src/main/java/org/betterx/worlds/together/surfaceRules/SurfaceRuleUtil.java
+++ b/src/main/java/org/betterx/worlds/together/surfaceRules/SurfaceRuleUtil.java
@ -0,0 +1,122 @@
+package org.betterx.worlds.together.surfaceRules;
+
+import org.betterx.bclib.api.v2.levelgen.biomes.InternalBiomeAPI;
+import org.betterx.worlds.together.WorldsTogether;
+import org.betterx.worlds.together.world.event.WorldBootstrap;
+
+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.BiomeSource;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.dimension.LevelStem;
+import net.minecraft.world.level.levelgen.NoiseBasedChunkGenerator;
+import net.minecraft.world.level.levelgen.NoiseGeneratorSettings;
+import net.minecraft.world.level.levelgen.SurfaceRules;
+import net.minecraft.world.level.levelgen.WorldGenSettings;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+public class SurfaceRuleUtil {
+    public static List<SurfaceRules.RuleSource> getRulesForBiome(ResourceLocation biomeID) {
+        Registry<AssignedSurfaceRule> registry = SurfaceRuleRegistry.BUILTIN_SURFACE_RULES;
+        if (WorldBootstrap.getLastRegistryAccess() != null)
+            registry = WorldBootstrap.getLastRegistryAccess()
+                                     .registryOrThrow(SurfaceRuleRegistry.SURFACE_RULES_REGISTRY);
+        return registry.stream()
+                       .filter(a -> a != null && a.biomeID != null && a.biomeID.equals(
+                               biomeID))
+                       .map(a -> a.ruleSource)
+                       .toList();
+
+    }
+
+    public static List<SurfaceRules.RuleSource> getRulesForBiomes(List<Biome> biomes) {
+        Registry<Biome> biomeRegistry = WorldBootstrap.getLastRegistryAccess().registryOrThrow(Registry.BIOME_REGISTRY);
+        List<ResourceLocation> biomeIDs = biomes.stream()
+                                                .map(b -> biomeRegistry.getKey(b))
+                                                .filter(id -> id != null)
+                                                .toList();
+
+        return biomeIDs.stream().map(biomeID -> getRulesForBiome(biomeID)).flatMap(List::stream).toList();
+    }
+
+    public static SurfaceRules.RuleSource mergeSurfaceRulesFromBiomes(
+            SurfaceRules.RuleSource org,
+            BiomeSource source
+    ) {
+        return mergeSurfaceRules(org, getRulesForBiomes(source.possibleBiomes().stream().map(h -> h.value()).toList()));
+    }
+
+    public static SurfaceRules.RuleSource mergeSurfaceRulesFromBiomes(
+            SurfaceRules.RuleSource org,
+            List<Biome> biomes
+    ) {
+        return mergeSurfaceRules(org, getRulesForBiomes(biomes));
+    }
+
+    public static SurfaceRules.RuleSource mergeSurfaceRules(
+            SurfaceRules.RuleSource org,
+            List<SurfaceRules.RuleSource> additionalRules
+    ) {
+        if (additionalRules == null || additionalRules.isEmpty()) return org;
+
+        if (org instanceof SurfaceRules.SequenceRuleSource sequenceRule) {
+            List<SurfaceRules.RuleSource> existingSequence = sequenceRule.sequence();
+            additionalRules = additionalRules
+                    .stream()
+                    .filter(r -> existingSequence.indexOf(r) < 0)
+                    .collect(Collectors.toList());
+            if (additionalRules.size() == 0) return org;
+            additionalRules.addAll(existingSequence);
+        } else {
+            if (!additionalRules.contains(org))
+                additionalRules.add(org);
+        }
+
+        return new SurfaceRules.SequenceRuleSource(additionalRules);
+    }
+
+    public static void injectSurfaceRules(
+            ResourceKey<LevelStem> dimensionKey,
+            ChunkGenerator loadedChunkGenerator
+    ) {
+        WorldsTogether.LOGGER.debug("Checking Surface Rules for " + dimensionKey.location().toString());
+
+        final BiomeSource loadedBiomeSource = loadedChunkGenerator.getBiomeSource();
+        InternalBiomeAPI.applyModifications(loadedBiomeSource, dimensionKey);
+
+        if (loadedChunkGenerator instanceof NoiseBasedChunkGenerator nbc) {
+            injectSurfaceRules(nbc.generatorSettings().value(), loadedBiomeSource);
+        }
+    }
+
+    public static void injectSurfaceRules(NoiseGeneratorSettings noiseSettings, BiomeSource loadedBiomeSource) {
+        if (((Object) noiseSettings) instanceof SurfaceRuleProvider srp) {
+            SurfaceRules.RuleSource originalRules = noiseSettings.surfaceRule();
+            srp.bclib_overwrite(mergeSurfaceRulesFromBiomes(originalRules, loadedBiomeSource));
+        }
+    }
+
+    public static void injectSurfaceRules(WorldGenSettings settings, Predicate<ResourceKey<LevelStem>> filter) {
+        List<ResourceKey<LevelStem>> otherDimensions = settings
+                .dimensions()
+                .entrySet()
+                .stream()
+                .map(e -> e.getKey())
+                .filter(filter)
+                .toList();
+
+        for (ResourceKey<LevelStem> key : otherDimensions) {
+            Optional<Holder<LevelStem>> stem = settings.dimensions().getHolder(key);
+            if (stem.isPresent()) {
+                injectSurfaceRules(key, stem.get().value().generator());
+            }
+        }
+    }
+}
--- a/src/main/java/org/betterx/worlds/together/world/event/WorldBootstrap.java
+++ b/src/main/java/org/betterx/worlds/together/world/event/WorldBootstrap.java
@ -30,6 +30,10 @@ import org.jetbrains.annotations.ApiStatus;
 public class WorldBootstrap {
    private static RegistryAccess LAST_REGISTRY_ACCESS = null;

+    public static RegistryAccess getLastRegistryAccess() {
+        return LAST_REGISTRY_ACCESS;
+    }
+
    public static class Helpers {
        private static void initializeWorldDataAPI(
                LevelStorageSource.LevelStorageAccess levelStorageAccess,
--- a/src/main/java/org/betterx/worlds/together/worldPreset/settings/VanillaWorldPresetSettings.java
+++ b/src/main/java/org/betterx/worlds/together/worldPreset/settings/VanillaWorldPresetSettings.java
@ -1,5 +1,8 @@
 package org.betterx.worlds.together.worldPreset.settings;

+import org.betterx.worlds.together.surfaceRules.SurfaceRuleRegistry;
+import org.betterx.worlds.together.surfaceRules.SurfaceRuleUtil;
+
 import com.mojang.serialization.Codec;
 import net.minecraft.core.Holder;
 import net.minecraft.core.RegistryAccess;
@ -20,11 +23,12 @@ public class VanillaWorldPresetSettings extends WorldPresetSettings {

    @Override
    public WorldGenSettings repairSettingsOnLoad(RegistryAccess registryAccess, WorldGenSettings settings) {
+        SurfaceRuleUtil.injectSurfaceRules(settings, SurfaceRuleRegistry.ALL_DIMENSIONS);
        return settings;
    }

    @Override
-    public BiomeSource fixBiomeSource(BiomeSource biomeSource, Set<Holder<Biome>> datapackBiomes) {
+    public BiomeSource addDatapackBiomes(BiomeSource biomeSource, Set<Holder<Biome>> datapackBiomes) {
        return biomeSource;
    }
 }
--- a/src/main/java/org/betterx/worlds/together/worldPreset/settings/WorldPresetSettings.java
+++ b/src/main/java/org/betterx/worlds/together/worldPreset/settings/WorldPresetSettings.java
@ -51,5 +51,5 @@ public abstract class WorldPresetSettings {

    public abstract Codec<? extends WorldPresetSettings> codec();
    public abstract WorldGenSettings repairSettingsOnLoad(RegistryAccess registryAccess, WorldGenSettings settings);
-    public abstract BiomeSource fixBiomeSource(BiomeSource biomeSource, Set<Holder<Biome>> datapackBiomes);
+    public abstract BiomeSource addDatapackBiomes(BiomeSource biomeSource, Set<Holder<Biome>> datapackBiomes);
 }