continued dehardcoding of features

common/src/main/java/net/lerariemann/infinity/dimensions/RandomFeaturesList.java

···
 import net.lerariemann.infinity.dimensions.features.underground_ores.RandomDisk;
 import net.lerariemann.infinity.dimensions.features.underground_ores.RandomOre;
 import net.lerariemann.infinity.dimensions.features.underground_structures.RandomDungeon;
-import net.lerariemann.infinity.dimensions.features.vegetation.RandomFloatingPatch;
-import net.lerariemann.infinity.dimensions.features.vegetation.RandomFlowerPatch;
-import net.lerariemann.infinity.dimensions.features.vegetation.RandomSurfacePatch;
-import net.lerariemann.infinity.dimensions.features.vegetation.RandomVegetation;
+import net.lerariemann.infinity.dimensions.features.underground_structures.RandomFossil;
+import net.lerariemann.infinity.dimensions.features.vegetation.*;
 import net.lerariemann.infinity.util.core.ConfigType;
 import net.lerariemann.infinity.util.core.RandomProvider;
 import net.minecraft.nbt.NbtCompound;
···
         blocks = new ArrayList<>();
         useVanillaFeatures = roll("generate_vanilla_features");
         data = new NbtList();
-        data.add(endIsland());
+        data.add(rawGeneration());
         data.add(lakes());
         data.add(localModifications());
         data.add(undergroundStructures());
···
         data.add(fluidSprings());
         data.add(vegetation());
         data.add(getAllElements(ConfigType.TOP_LAYER));
-    }
-
-    NbtString randomPlant(ConfigType path) {
-        return NbtString.of(PROVIDER.randomName(random, path));
     }
 
     NbtList getAllElements(ConfigType name) {
···
         return PROVIDER.roll(random, key);
     }
 
-    NbtList endIsland() {
+    NbtList rawGeneration() {
         NbtList res = new NbtList();
         addRandomFeature("end_island", res, RandomEndIsland::new);
         if (roll("shape")) addRandomFeature(res, new RandomShape(this, PROVIDER.randomName(random, ConfigType.SHAPE_TYPES)));
···
     }
 
     NbtList lakes() {
-        NbtList res = getAllElements(ConfigType.LAKES);
+        NbtList res = new NbtList();
         addRandomFeature("lake", res, RandomLake::new);
         return res;
     }
···
     }
 
     NbtList undergroundStructures() {
-        NbtList res = getAllElements(ConfigType.UNDERGROUND_STRUCTURES);
+        NbtList res = new NbtList();
         addRandomFeature("dungeon", res, RandomDungeon::new);
+        addRandomFeature("fossil", res, RandomFossil::new);
         return res;
     }
 
···
         addRandomFeature("vegetation", res, RandomVegetation::new);
         res.addAll(getAllElements(ConfigType.VEG1));
         addRandomFeature(res, RandomFlowerPatch::new);
-        res.add(randomPlant(ConfigType.GRASS));
+        res.add(NbtString.of(PROVIDER.randomName(random, ConfigType.GRASS)));
         res.addAll(getAllElements(ConfigType.VEG2));
         addRandomFeature("surface_patch", res, RandomSurfacePatch::new);
         addRandomFeature("floating_patch", res, RandomFloatingPatch::new);
-        res.add(randomPlant(ConfigType.SEAGRASS));
-        res.addAll(getAllElements(ConfigType.VEG3));
+        if (parent.parent.default_fluid.getString("Name").contains("water")) {
+            addRandomFeature("water_plants", res, RandomSeagrass::new);
+            addRandomFeature("water_plants", res, RandomPickle::new);
+            addRandomFeature("water_plants", res, RandomKelp::new);
+        }
         return res;
     }
 

common/src/main/java/net/lerariemann/infinity/dimensions/features/RandomisedFeature.java

···
         CommonIO.write(moredata, parent.storagePath + "/worldgen/placed_feature", name + ".json");
     }
 
+    protected void savePlacement(String feature) {
+        NbtCompound moredata = new NbtCompound();
+        moredata.putString("feature", feature);
+        moredata.put("placement", placement());
+        CommonIO.write(moredata, parent.storagePath + "/worldgen/placed_feature", name + ".json");
+    }
+
     public NbtCompound genBlockOrFluid() {
         NbtCompound block2;
         if (parent.roll("solid_lakes")) {

common/src/main/java/net/lerariemann/infinity/dimensions/features/surface_structures/RandomWell.java

···
 import net.lerariemann.infinity.dimensions.RandomFeaturesList;
 import net.lerariemann.infinity.dimensions.features.Placement;
 import net.lerariemann.infinity.dimensions.features.RandomisedFeature;
-import net.lerariemann.infinity.util.core.CommonIO;
 import net.minecraft.nbt.NbtCompound;
 import net.minecraft.nbt.NbtList;
 
 public class RandomWell extends RandomisedFeature {
     public RandomWell(RandomFeaturesList lst) {
         super(lst, "well");
-
-        NbtCompound moredata = new NbtCompound();
-        moredata.putString("feature", "minecraft:desert_well");
-        moredata.put("placement", placement());
-        CommonIO.write(moredata, parent.storagePath + "/worldgen/placed_feature", name + ".json");
+        savePlacement("minecraft:desert_well");
     }
 
     public NbtCompound feature() {
···
     }
     public NbtList placement() {
         Placement res = new Placement();
-        res.addRarityFilter(random.nextInt(1200));
+        res.addRarityFilter(random.nextInt(1, 1000));
         res.addInSquare();
         res.addHeightmap("MOTION_BLOCKING");
         res.addBiome();

common/src/main/java/net/lerariemann/infinity/dimensions/features/underground_structures/RandomFossil.java

···
+package net.lerariemann.infinity.dimensions.features.underground_structures;
+
+import net.lerariemann.infinity.dimensions.RandomFeaturesList;
+import net.lerariemann.infinity.dimensions.features.Placement;
+import net.lerariemann.infinity.dimensions.features.RandomisedFeature;
+import net.lerariemann.infinity.util.core.NbtUtils;
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.nbt.NbtList;
+
+public class RandomFossil extends RandomisedFeature {
+    public RandomFossil(RandomFeaturesList lst) {
+        super(lst, "well");
+        savePlacement("minecraft:fossil_coal");
+    }
+
+    public NbtCompound feature() {
+        return null;
+    }
+    public NbtList placement() {
+        Placement res = new Placement();
+        res.addRarityFilter(random.nextInt(1, 128));
+        res.addInSquare();
+        res.addHeightRange(NbtUtils.randomHeightProvider(random, daddy.min_y,
+                daddy.min_y + daddy.height, false, true));
+        res.addBiome();
+        return res.data;
+    }
+}

common/src/main/java/net/lerariemann/infinity/dimensions/features/vegetation/RandomKelp.java

···
+package net.lerariemann.infinity.dimensions.features.vegetation;
+
+import net.lerariemann.infinity.dimensions.RandomFeaturesList;
+import net.lerariemann.infinity.dimensions.features.Placement;
+import net.lerariemann.infinity.dimensions.features.RandomisedFeature;
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.nbt.NbtList;
+
+public class RandomKelp extends RandomisedFeature {
+    public RandomKelp(RandomFeaturesList lst) {
+        super(lst.parent.id, lst, "kelp");
+        savePlacement("minecraft:kelp");
+    }
+    public NbtCompound feature() {
+        return null;
+    }
+    public NbtCompound noiseCount() {
+        NbtCompound res = Placement.ofType("minecraft:noise_based_count");
+        res.putDouble("noise_factor", 80.0);
+        res.putDouble("noise_offset", 0.0);
+        res.putInt("noise_to_count_ratio", 20 + random.nextInt(120));
+        return res;
+    }
+
+    public NbtList placement() {
+        Placement res = new Placement();
+        res.data.add(noiseCount());
+        res.addInSquare();
+        res.addHeightmap("OCEAN_FLOOR_WG");
+        res.addBiome();
+        return res.data;
+    }
+}

common/src/main/java/net/lerariemann/infinity/dimensions/features/vegetation/RandomPickle.java

···
+package net.lerariemann.infinity.dimensions.features.vegetation;
+
+import net.lerariemann.infinity.dimensions.RandomFeaturesList;
+import net.lerariemann.infinity.dimensions.features.Placement;
+import net.lerariemann.infinity.dimensions.features.RandomisedFeature;
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.nbt.NbtList;
+
+public class RandomPickle extends RandomisedFeature {
+    public RandomPickle(RandomFeaturesList lst) {
+        super(lst.parent.id, lst, "pickle");
+        id = "minecraft:sea_pickle";
+        savePlacement();
+    }
+    public NbtCompound feature() {
+        NbtCompound config = new NbtCompound();
+        config.putInt("count", 1 + random.nextInt(30));
+        return feature(config);
+    }
+    public NbtList placement() {
+        Placement res = new Placement();
+        res.addRarityFilter(4 + random.nextInt(20));
+        res.addInSquare();
+        res.addHeightmap("OCEAN_FLOOR_WG");
+        res.addBiome();
+        return res.data;
+    }
+}

common/src/main/java/net/lerariemann/infinity/dimensions/features/vegetation/RandomSeagrass.java

···
+package net.lerariemann.infinity.dimensions.features.vegetation;
+
+import net.lerariemann.infinity.dimensions.RandomFeaturesList;
+import net.lerariemann.infinity.dimensions.features.Placement;
+import net.lerariemann.infinity.dimensions.features.RandomisedFeature;
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.nbt.NbtList;
+
+public class RandomSeagrass extends RandomisedFeature {
+    public RandomSeagrass(RandomFeaturesList lst) {
+        super(lst.parent.id, lst, "seagrass");
+        id = "minecraft:seagrass";
+        savePlacement();
+    }
+    public NbtCompound feature() {
+        NbtCompound config = new NbtCompound();
+        config.putDouble("probability", random.nextDouble());
+        return feature(config);
+    }
+    public NbtList placement() {
+        Placement res = new Placement();
+        res.addInSquare();
+        res.addHeightmap("OCEAN_FLOOR_WG");
+        res.addCount(random.nextInt(10, 100));
+        res.addBiome();
+        return res.data;
+    }
+}

common/src/main/java/net/lerariemann/infinity/util/core/ConfigType.java

···
     TREE_DECORATORS("tree_decorators", "attached_to_leaves"),
     TRUNK_PLACERS("trunk_placers", "straight_trunk_placer"),
     GRASS("grass", "minecraft:patch_grass_normal"),
-    SEAGRASS("seagrass", "minecraft:seagrass_normal"),
     VEG1("vegetation_part1", "minecraft:patch_sunflower"),
     VEG2("vegetation_part2", "minecraft:patch_pumpkin"),
-    VEG3("vegetation_part3", "minecraft:sea_pickle"),
-    LAKES("lakes", "minecraft:lake_lava_surface"),
     LOCAL_MOD("localmodifications", "minecraft:large_dripstone"),
     TOP_LAYER("toplayermodification", "minecraft:freeze_top_layer"),
     UNDERGROUND_DEC("undergrounddecoration", "minecraft:pointed_dripstone"),
-    UNDERGROUND_ORES("undergroundores", "minecraft:ore_dirt"),
-    UNDERGROUND_STRUCTURES("undergroundstructures", "minecraft:fossil_upper");
+    UNDERGROUND_ORES("undergroundores", "minecraft:ore_dirt");
 
     public static final ConfigType[] normalModular = new ConfigType[]{COLOR_PRESETS, EFFECTS, STRUCTURES,
             LOOT_TABLES, TAGS, PARTICLES, MUSIC, SOUNDS, ITEMS, TREES, JUKEBOXES};
···
             FLORAL_DISTRIBUTION, FOLIAGE_PLACERS, GENERATOR_TYPES, MOB_CATEGORIES, MULTINOISE_PRESETS, NOISE_PRESETS,
             SHAPE_TYPES, STRUCTURE_PLACEMENT_TYPES, TREE_DECORATORS, TRUNK_PLACERS};
 
-    public static final ConfigType[] vegetation = new ConfigType[]{GRASS, SEAGRASS, VEG1, VEG2, VEG3};
+    public static final ConfigType[] vegetation = new ConfigType[]{GRASS, VEG1, VEG2};
 
-    public static final ConfigType[] features = new ConfigType[]{LAKES, LOCAL_MOD, TOP_LAYER, UNDERGROUND_DEC,
-            UNDERGROUND_ORES, UNDERGROUND_STRUCTURES};
+    public static final ConfigType[] features = new ConfigType[]{LOCAL_MOD, TOP_LAYER, UNDERGROUND_DEC, UNDERGROUND_ORES};
 
     public static boolean addsName(ConfigType type) {
         return type != STRUCTURES;

common/src/main/resources/config/hardcoded/features/lakes.json

···
-{
-  "elements": [
-    {
-      "key": "minecraft:lake_lava_underground",
-      "weight": 0.5
-    },
-    {
-      "key": "minecraft:lake_lava_surface",
-      "weight": 0.5
-    }
-  ]
-}

common/src/main/resources/config/hardcoded/features/undergroundstructures.json

···
-{
-  "elements": [
-    {
-      "key": "minecraft:fossil_upper",
-      "weight": 0.1
-    },
-    {
-      "key": "minecraft:fossil_lower",
-      "weight": 0.1
-    },
-    {
-      "key": "minecraft:monster_room",
-      "weight": 0.5
-    },
-    {
-      "key": "minecraft:monster_room_deep",
-      "weight": 0.5
-    }
-  ]
-}

common/src/main/resources/config/hardcoded/vegetation/seagrass.json

···
-{
-  "elements": [
-    {
-      "key": "minecraft:seagrass_cold",
-      "weight": 1.0
-    },
-    {
-      "key": "minecraft:seagrass_normal",
-      "weight": 1.0
-    },
-    {
-      "key": "minecraft:seagrass_warm",
-      "weight": 1.0
-    },
-    {
-      "key": "minecraft:seagrass_deep_cold",
-      "weight": 1.0
-    },
-    {
-      "key": "minecraft:seagrass_deep",
-      "weight": 1.0
-    },
-    {
-      "key": "minecraft:seagrass_deep_warm",
-      "weight": 1.0
-    },
-    {
-      "key": "minecraft:seagrass_simple",
-      "weight": 1.0
-    },
-    {
-      "key": "minecraft:seagrass_river",
-      "weight": 1.0
-    },
-    {
-      "key": "minecraft:seagrass_swamp",
-      "weight": 1.0
-    }
-  ]
-}

common/src/main/resources/config/hardcoded/vegetation/vegetation_part3.json

···
-{
-  "elements": [
-    {
-      "key": "minecraft:sea_pickle",
-      "weight": 0.1
-    },
-    {
-      "key": "minecraft:kelp_cold",
-      "weight": 0.2
-    },
-    {
-      "key": "minecraft:kelp_warm",
-      "weight": 0.2
-    }
-  ]
-}

common/src/main/resources/config/infinity.json

···
 {
-  "infinity_version": 2004004,
+  "infinity_version": 2004005,
   "gameRules": {
     "runtimeGenerationEnabled": true,
     "longArithmeticEnabled": false,
···
       "geode": 0.5,
       "rock": 0.33,
       "dungeon": 1.0,
+      "fossil": 0.2,
       "end_spikes": 0.2,
       "end_gateway": 0.05,
       "delta": 0.2,
···
       "ceiling_blobs": 0.5,
       "vegetation": 1.0,
       "surface_patch": 0.5,
-      "floating_patch": 0.1
+      "floating_patch": 0.1,
+      "water_plants": 0.75
     },
     "features_rules": {
       "generate_vanilla_features": 0.5,