Fixed azalea generation not behaving as expected

supermassimo · supermassimo · commit cb6f308c1acb · 2025-05-22T00:49:21.000-03:00
diff --git a/src/main/java/com/ferreusveritas/dynamictrees/data/provider/DTBlockTagsProvider.java b/src/main/java/com/ferreusveritas/dynamictrees/data/provider/DTBlockTagsProvider.java
@@ -56,6 +56,9 @@ private void addDTOnlyTags() {
                 .add(Blocks.BROWN_MUSHROOM)
                 .add(Blocks.RED_MUSHROOM)
                 .add(Blocks.LILY_PAD)
+                .add(Blocks.AZALEA)
+                .add(Blocks.FLOWERING_AZALEA)
+                .add(Blocks.MOSS_CARPET)
                 .addTag(BlockTags.FLOWERS)
                 .addTag(BlockTags.REPLACEABLE_BY_TREES);
 
diff --git a/src/main/java/com/ferreusveritas/dynamictrees/resources/loader/BiomePopulatorsResourceLoader.java b/src/main/java/com/ferreusveritas/dynamictrees/resources/loader/BiomePopulatorsResourceLoader.java
@@ -96,7 +96,9 @@ public void registerAppliers() {
 
         this.caveRootedDataAppliers
                 .register("generate_on_surface", Boolean.class, BiomeDatabase.CaveRootedData::setGenerateOnSurface)
-                .register("max_dist_to_surface", Integer.class, BiomeDatabase.CaveRootedData::setMaxDistToSurface);
+                .register("max_dist_to_surface", Integer.class, BiomeDatabase.CaveRootedData::setMaxDistToSurface)
+                .register("species", JsonElement.class, this::applyCaveRootedSpecies)
+                .register("chance", JsonElement.class, this::applyCaveRootedChance);
 
         ApplierResourceLoader.postApplierEvent(new EntryApplierRegistryEvent<>(this.entryAppliers, ENTRY_APPLIERS));
     }
@@ -135,6 +137,20 @@ private void applyMultipass(BiomeDatabase.BaseEntry entry, Boolean multipass) {
         entry.enableDefaultMultipass();
     }
 
+    private PropertyApplierResult applyCaveRootedSpecies(BiomeDatabase.CaveRootedData entry, JsonElement jsonElement) {
+        return PropertyApplierResult.from(JsonDeserialisers.SPECIES_SELECTOR.deserialise(jsonElement)
+                .ifSuccess(speciesSelector ->
+                        entry.setCaveRootedSpeciesSelector(speciesSelector, getOperationOrWarn(jsonElement))
+                ));
+    }
+
+    private PropertyApplierResult applyCaveRootedChance(BiomeDatabase.CaveRootedData entry, JsonElement jsonElement) {
+        return PropertyApplierResult.from(JsonDeserialisers.CHANCE_SELECTOR.deserialise(jsonElement)
+                .ifSuccess(chanceSelector ->
+                        entry.setCaveRootedChanceSelector(chanceSelector, getOperationOrWarn(jsonElement))
+                ));
+    }
+
     public static BiomeDatabase.Operation getOperationOrWarn(final JsonElement jsonElement) {
         return getOperation(jsonElement).orElse(BiomeDatabase.Operation.REPLACE, LOGGER::error, LOGGER::warn);
     }
@@ -251,7 +267,6 @@ private void applyCaveRootedPopulatorSection(BiomeDatabase database, JsonObject
             JsonObject caveRootedJson = json.getAsJsonObject(CAVE_ROOTED);
             JsonMapWrapper applyData = new JsonMapWrapper(caveRootedJson);
             var entry = database.getJsonEntry(biomes);
-            this.entryAppliers.applyAll(applyData, entry);
             this.caveRootedDataAppliers.applyAll(applyData, entry.getOrCreateCaveRootedData());
         }
     }
diff --git a/src/main/java/com/ferreusveritas/dynamictrees/worldgen/BiomeDatabase.java b/src/main/java/com/ferreusveritas/dynamictrees/worldgen/BiomeDatabase.java
@@ -349,6 +349,9 @@ public void reset() {
     }
 
     public static class CaveRootedData {
+
+        SpeciesSelector speciesSelector = (pos, dirt, rnd) -> new SpeciesSelection();
+        ChanceSelector chanceSelector = (rnd, spc, rad) -> Chance.UNHANDLED;
         /**
          * If {@code true}, the tree will always be generated on the surface. Otherwise, it will be
          * generated on the next available ground position.
@@ -376,6 +379,45 @@ public int getMaxDistToSurface() {
         public void setMaxDistToSurface(int maxDistToSurface) {
             this.maxDistToSurface = maxDistToSurface;
         }
+
+        public SpeciesSelector getCaveRootedSpeciesSelector() {
+            return speciesSelector;
+        }
+
+        public ChanceSelector getCaveRootedChanceSelector(){
+            return chanceSelector;
+        }
+
+        public void setCaveRootedSpeciesSelector(SpeciesSelector selector, Operation op) {
+            SpeciesSelector existing = speciesSelector;
+            switch (op) {
+                case REPLACE -> speciesSelector = selector;
+                case SPLICE_BEFORE -> speciesSelector = (pos, dirt, rnd) -> {
+                    SpeciesSelection ss = selector.getSpecies(pos, dirt, rnd);
+                    return ss.isHandled() ? ss : existing.getSpecies(pos, dirt, rnd);
+                };
+                case SPLICE_AFTER -> speciesSelector = (pos, dirt, rnd) -> {
+                    SpeciesSelection ss = existing.getSpecies(pos, dirt, rnd);
+                    return ss.isHandled() ? ss : selector.getSpecies(pos, dirt, rnd);
+                };
+            }
+        }
+
+        public void setCaveRootedChanceSelector(ChanceSelector selector, Operation op) {
+            ChanceSelector existing = chanceSelector;
+            switch (op) {
+                case REPLACE -> chanceSelector = selector;
+                case SPLICE_BEFORE -> chanceSelector = (rnd, spc, rad) -> {
+                    Chance c = selector.getChance(rnd, spc, rad);
+                    return c != Chance.UNHANDLED ? c : existing.getChance(rnd, spc, rad);
+                };
+                case SPLICE_AFTER -> chanceSelector = (rnd, spc, rad) -> {
+                    Chance c = existing.getChance(rnd, spc, rad);
+                    return c != Chance.UNHANDLED ? c : selector.getChance(rnd, spc, rad);
+                };
+            }
+        }
+
     }
 
     /**
diff --git a/src/main/java/com/ferreusveritas/dynamictrees/worldgen/CaveRootedTreeFeature.java b/src/main/java/com/ferreusveritas/dynamictrees/worldgen/CaveRootedTreeFeature.java
@@ -1,18 +1,22 @@
 package com.ferreusveritas.dynamictrees.worldgen;
 
+import com.ferreusveritas.dynamictrees.api.worldgen.BiomePropertySelectors;
 import com.ferreusveritas.dynamictrees.api.worldgen.GroundFinder;
 import com.ferreusveritas.dynamictrees.systems.poissondisc.PoissonDisc;
 import com.ferreusveritas.dynamictrees.util.LevelContext;
 import com.ferreusveritas.dynamictrees.util.SafeChunkBounds;
 import net.minecraft.core.BlockPos;
+import net.minecraft.core.Vec3i;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.level.ChunkPos;
 import net.minecraft.world.level.WorldGenLevel;
 import net.minecraft.world.level.levelgen.feature.FeaturePlaceContext;
 import net.minecraft.world.level.levelgen.feature.configurations.NoneFeatureConfiguration;
 
+import java.util.Comparator;
 import java.util.List;
 import java.util.Optional;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 public class CaveRootedTreeFeature extends DynamicTreeFeature {
 
@@ -41,18 +45,41 @@ public boolean place(FeaturePlaceContext<NoneFeatureConfiguration> context) {
         }
 
         BiomeDatabase.Entry biomeEntry = BiomeDatabases.getDefault().getEntry(level.getLevel().getBiome(originPos));
-        if (!biomeEntry.hasCaveRootedData())
+        if (biomeEntry.getCaveRootedData() == null)
             return false;
 
         BiomeDatabase.CaveRootedData caveRootedData = biomeEntry.getCaveRootedData();
-        BlockPos groundPos = caveRootedData.shouldGenerateOnSurface() ? groundPositions.get(groundPositions.size() - 1)
-                : getNextGroundPos(originPos, groundPositions).orElse(null);
-        if (groundPos == null || groundPos.getY() - originPos.getY() > caveRootedData.getMaxDistToSurface()) {
-            return false;
+
+        groundPositions = groundPositions.stream()
+                .filter(pos-> pos != BlockPos.ZERO)
+                //.filter(pos-> pos.getY() - originPos.getY() < caveRootedData.getMaxDistToSurface())
+                .sorted(Comparator.comparingInt(Vec3i::getY)).toList();
+
+        if (groundPositions.isEmpty()) return false;
+
+        if (caveRootedData.shouldGenerateOnSurface()){
+            groundPositions = List.of(groundPositions.get(groundPositions.size() - 1));
         }
 
-        GeneratorResult result = this.generateTree(levelContext, biomeEntry, disc, originPos, groundPos, SafeChunkBounds.ANY_WG);
-        return result == GeneratorResult.GENERATED;
+        AtomicBoolean generated = new AtomicBoolean(false);
+        groundPositions.forEach(groundPos -> {
+                    GeneratorResult result = this.generateTree(levelContext, biomeEntry, disc, originPos, groundPos, SafeChunkBounds.ANY_WG);
+                    if (result == GeneratorResult.GENERATED) generated.set(true);
+                });
+
+        return generated.get();
+    }
+
+    protected BiomePropertySelectors.SpeciesSelector getSpeciesSelector (BiomeDatabase.EntryReader biomeEntry){
+        if (biomeEntry instanceof BiomeDatabase.Entry entry && entry.getCaveRootedData() != null)
+            return entry.getCaveRootedData().getCaveRootedSpeciesSelector();
+        return biomeEntry.getSpeciesSelector();
+    }
+
+    protected BiomePropertySelectors.ChanceSelector getChanceSelector (BiomeDatabase.EntryReader biomeEntry){
+        if (biomeEntry instanceof BiomeDatabase.Entry entry && entry.getCaveRootedData() != null)
+            return entry.getCaveRootedData().getCaveRootedChanceSelector();
+        return biomeEntry.getChanceSelector();
     }
 
     private Optional<PoissonDisc> getDisc(LevelContext levelContext, ChunkPos chunkPos, BlockPos originPos) {
diff --git a/src/main/java/com/ferreusveritas/dynamictrees/worldgen/DynamicTreeFeature.java b/src/main/java/com/ferreusveritas/dynamictrees/worldgen/DynamicTreeFeature.java
@@ -79,7 +79,7 @@ protected void generateTrees(LevelContext levelContext, BiomeDatabase biomeDatab
         Holder<Biome> biome = levelContext.accessor().getBiome(basePos);
         Heightmap.Types heightmap = Heightmap.Types.valueOf(biomeDatabase.getHeightmap(biome).toUpperCase());
         for (BlockPos groundPos : GroundFinder.getGroundFinder(levelContext.level()).findGround(levelContext.accessor(), basePos, heightmap)) {
-            BiomeDatabase.EntryReader entry = biomeDatabase.getEntry(levelContext.accessor().getBiome(groundPos));
+            BiomeDatabase.Entry entry = biomeDatabase.getEntry(levelContext.accessor().getBiome(groundPos));
             generateTree(levelContext, entry, disc, originPos, groundPos, safeBounds);
         }
     }
@@ -105,14 +105,14 @@ protected GeneratorResult generateTree(LevelContext levelContext, BiomeDatabase.
 
         GeneratorResult result = GeneratorResult.GENERATED;
 
-        BiomePropertySelectors.SpeciesSelector speciesSelector = biomeEntry.getSpeciesSelector();
+        BiomePropertySelectors.SpeciesSelector speciesSelector = getSpeciesSelector(biomeEntry);
         BiomePropertySelectors.SpeciesSelection speciesSelection = speciesSelector.getSpecies(groundPos, dirtState, RANDOM);
 
         if (!biomeEntry.isBlacklisted() && speciesSelection.isHandled()) {
             Species species = speciesSelection.getSpecies();
             if (species.isValid()) {
                 if (species.isAcceptableSoilForWorldgen(levelContext.accessor(), groundPos, dirtState)) {
-                    if (biomeEntry.getChanceSelector().getChance(RANDOM, species, circle.radius) == BiomePropertySelectors.Chance.OK) {
+                    if (getChanceSelector(biomeEntry).getChance(RANDOM, species, circle.radius) == BiomePropertySelectors.Chance.OK) {
                         Holder<Biome> biome = levelContext.level().getBiome(groundPos);
                         if (!species.generate(new GenerationContext(levelContext, species, originPos, groundPos.mutable(), biome, CoordUtils.getRandomDir(RANDOM), circle.radius, safeBounds))) {
                             result = GeneratorResult.FAIL_GENERATION;
@@ -138,6 +138,13 @@ protected GeneratorResult generateTree(LevelContext levelContext, BiomeDatabase.
         return result;
     }
 
+    protected BiomePropertySelectors.SpeciesSelector getSpeciesSelector (BiomeDatabase.EntryReader biomeEntry){
+        return biomeEntry.getSpeciesSelector();
+    }
+    protected BiomePropertySelectors.ChanceSelector getChanceSelector (BiomeDatabase.EntryReader biomeEntry){
+        return biomeEntry.getChanceSelector();
+    }
+
     private void generateConcreteCircle(LevelAccessor level, PoissonDisc circle, int h, GeneratorResult resultType, SafeChunkBounds safeBounds) {
         generateConcreteCircle(level, circle, h, resultType, safeBounds, 0);
     }
diff --git a/src/main/java/com/ferreusveritas/dynamictrees/worldgen/biomemodifiers/AddDynamicTreesBiomeModifier.java b/src/main/java/com/ferreusveritas/dynamictrees/worldgen/biomemodifiers/AddDynamicTreesBiomeModifier.java
@@ -21,8 +21,8 @@ public void modify(Holder<Biome> biome, Phase phase, ModifiableBiomeInfo.BiomeIn
         if (phase == Phase.ADD && DTConfigs.WORLD_GEN.get()) {
             BiomeGenerationSettingsBuilder generationSettings = builder.getGenerationSettings();
             var placedFeatures = ServerLifecycleHooks.getCurrentServer().registryAccess().registryOrThrow(Registries.PLACED_FEATURE);
-            generationSettings.addFeature(GenerationStep.Decoration.VEGETAL_DECORATION, placedFeatures.getHolderOrThrow(DTFeatures.DYNAMIC_TREE_PLACED_FEATURE));
             generationSettings.addFeature(GenerationStep.Decoration.VEGETAL_DECORATION, placedFeatures.getHolderOrThrow(DTFeatures.CAVE_ROOTED_TREE_PLACED_FEATURE));
+            generationSettings.addFeature(GenerationStep.Decoration.VEGETAL_DECORATION, placedFeatures.getHolderOrThrow(DTFeatures.DYNAMIC_TREE_PLACED_FEATURE));
         }
     }
 
diff --git a/src/main/resources/trees/dynamictrees/world_gen/default.json b/src/main/resources/trees/dynamictrees/world_gen/default.json
@@ -260,7 +260,7 @@
     "apply": {
       "cave_rooted": {
         "species": "azalea",
-        "chance": 0.66
+        "chance": 1.0
       }
     }
   },

Original file line number	Diff line number	Diff line change
`@@ -21,8 +21,8 @@ public void modify(Holder<Biome> biome, Phase phase, ModifiableBiomeInfo.BiomeIn`
`21`	`21`	`if (phase == Phase.ADD && DTConfigs.WORLD_GEN.get()) {`
`22`	`22`	`BiomeGenerationSettingsBuilder generationSettings = builder.getGenerationSettings();`
`23`	`23`	`var placedFeatures = ServerLifecycleHooks.getCurrentServer().registryAccess().registryOrThrow(Registries.PLACED_FEATURE);`
`24`		`- generationSettings.addFeature(GenerationStep.Decoration.VEGETAL_DECORATION, placedFeatures.getHolderOrThrow(DTFeatures.DYNAMIC_TREE_PLACED_FEATURE));`
`25`	`24`	`generationSettings.addFeature(GenerationStep.Decoration.VEGETAL_DECORATION, placedFeatures.getHolderOrThrow(DTFeatures.CAVE_ROOTED_TREE_PLACED_FEATURE));`
	`25`	`+ generationSettings.addFeature(GenerationStep.Decoration.VEGETAL_DECORATION, placedFeatures.getHolderOrThrow(DTFeatures.DYNAMIC_TREE_PLACED_FEATURE));`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
Original file line number	Diff line number	Diff line change
`@@ -260,7 +260,7 @@`
`260`	`260`	`"apply": {`
`261`	`261`	`"cave_rooted": {`
`262`	`262`	`"species": "azalea",`
`263`		`- "chance": 0.66`
	`263`	`+ "chance": 1.0`
`264`	`264`	`}`
`265`	`265`	`}`
`266`	`266`	`},`