leaps and bounds

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

···
         data.putInt("monster_spawn_block_light_limit", random.nextInt(16));
         NbtCompound lightLevel = new NbtCompound();
         lightLevel.putString("type", "uniform");
-            lightLevel.put("value", RandomProvider.genBounds(0, random.nextInt(16)));
+            lightLevel.put("value", RandomProvider.genBounds(0, random.nextInt(15)));
         data.put("monster_spawn_light_level", lightLevel);
         data.putString("infiniburn", "#" + dim.PROVIDER.randomName(random, "tags"));
         String s = dim.PROVIDER.randomName(random, "dimension_effects");

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

···
 
     NbtCompound feature() {
         NbtCompound config = new NbtCompound();
-        addRandomIntProvider(config, "radius", 0, 12);
+        addRandomIntProvider(config, "radius", 0, 11);
         config.put("state", block);
         config.put("target", daddy.default_block);
         return feature(config);

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

···
 
     NbtCompound feature() {
         NbtCompound config = new NbtCompound();
-        addRandomIntProvider(config, "reach", 0, 3);
-        addRandomIntProvider(config, "height", 1, 15);
+        addRandomIntProvider(config, "reach", 0, 2);
+        addRandomIntProvider(config, "height", 1, 14);
         addRandomBlockProvider(config, "block_provider", "full_blocks_worldgen");
         return feature(config);
     }

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

···
         NbtCompound block = genBlockOrFluid();
         config.put("contents", block);
         addRandomBlock(config, "rim", "full_blocks");
-        config.put("size", NbtUtils.randomIntProvider(random, 17, true));
-        config.put("rim_size", NbtUtils.randomIntProvider(random, 17, true));
+        config.put("size", NbtUtils.randomIntProvider(random, 16, true));
+        config.put("rim_size", NbtUtils.randomIntProvider(random, 16, true));
         return feature(config);
     }
 }

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

···
         NbtCompound config = new NbtCompound();
         NbtCompound blockProvider = PROVIDER.randomBlockProvider(random, "full_blocks_worldgen");
         config.putInt("half_height", random.nextInt(5));
-        addRandomIntProvider(config, "radius", 0, 9);
+        addRandomIntProvider(config, "radius", 0, 8);
         NbtCompound targets = new NbtCompound();
         boolean awt = PROVIDER.roll(random, "ores_spawn_everywhere");
         targets.putString("type", awt ? "true" : "matching_blocks");

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

···
     }
 
     void placement() {
-        int a = random.nextInt(1, 9);
+        int a = random.nextInt(1, 8);
         if (a>1) addCount(a);
         addRarityFilter(1 + random.nextInt(32));
         addInSquare();

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

···
         NbtCompound res = new NbtCompound();
         res.putString("type", "mangrove_root_placer");
         addRandomBlockProvider(res, "root_provider", "full_blocks");
-        res.put("trunk_offset_y", NbtUtils.randomIntProvider(random, 10, true));
+        res.put("trunk_offset_y", NbtUtils.randomIntProvider(random, 9, true));
         if (random.nextBoolean()) {
             NbtCompound above = new NbtCompound();
             addRandomBlockProvider(above, "above_root_provider", "blocks_features");
···
                 res.putString("can_grow_through", "#" + PROVIDER.randomName(random, "tags"));
             }
             case "cherry_trunk_placer" -> {
-                addRandomIntProvider(res, "branch_count", 1, 3);
-                addRandomIntProvider(res, "branch_horizontal_length", 2, 16);
+                addRandomIntProvider(res, "branch_count", 1, 2);
+                addRandomIntProvider(res, "branch_horizontal_length", 2, 15);
                 NbtCompound branch_start_offset_from_top = new NbtCompound();
                 int a = random.nextInt(-16, 0);
                 int b = random.nextInt(-16, 0);
···
                 branch_start_offset_from_top.putInt("min_inclusive", Math.min(a, b));
                 branch_start_offset_from_top.putInt("max_inclusive", Math.max(a, b));
                 res.put("branch_start_offset_from_top", branch_start_offset_from_top);
-                addRandomIntProvider(res, "branch_end_offset_from_top", -16, 16);
+                addRandomIntProvider(res, "branch_end_offset_from_top", -16, 15);
             }
             case "infinity:wonky" -> {
                 float a = random.nextFloat();
···
             case "spruce_foliage_placer" -> res.put("trunk_height", NbtUtils.randomIntProvider(random, ishuge ? 24 : 6, true));
             case "mega_pine_foliage_placer" -> res.put("crown_height", NbtUtils.randomIntProvider(random, ishuge ? 24 : 6, true));
             case "random_spread_foliage_placer" -> {
-                addRandomIntProvider(res, "foliage_height", 1, ishuge ? 512 : 16);
+                addRandomIntProvider(res, "foliage_height", 1, ishuge ? 512 : 15);
                 res.putInt("leaf_placement_attempts", random.nextInt(256));
             }
             case "cherry_foliage_placer" -> {
-                res.put("height", NbtUtils.randomIntProvider(random, 4, 16, true));
+                res.put("height", NbtUtils.randomIntProvider(random, 4, 15, true));
                 res.putFloat("wide_bottom_layer_hole_chance", random.nextFloat());
                 res.putFloat("corner_hole_chance", random.nextFloat());
                 res.putFloat("hanging_leaves_chance", random.nextFloat());

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

···
             }
             case 1, 2 -> {
                 res.putString("type", i==1 ? "uniform" : "biased_to_bottom");
-                addBounds(res, random, lbound, bound);
+                res.put("value", genBounds(lbound, bound));
                 return res;
             }
             case 4 -> {
···
             }
             case 3 -> {
                 res.putString("type", "clamped_normal");
-                addBounds(res, random, lbound, bound);
                 NbtCompound value = genBounds(lbound, bound);
                 value.putDouble("mean", lbound + random.nextDouble()*(bound-lbound));
                 value.putDouble("deviation", random.nextExponential());
···
         return res;
     }
 
-    static NbtCompound randomFloatProvider(Random random, float lbound, float bound) {
-        int i = random.nextInt(3);
-        String[] types = new String[]{"uniform", "clamped_normal", "trapezoid"};
-        NbtCompound res = new NbtCompound();
-        res.putString("type", types[i]);
-        float a = random.nextFloat(lbound, bound);
-        float b = random.nextFloat(lbound, bound);
-        float min = Math.min(a, b);
-        float max = Math.max(a, b);
-        switch (i) {
-            case 0 -> {
-                res.putFloat("max_exclusive", max);
-                res.putFloat("min_inclusive", min);
-            }
-            case 1 -> {
-                res.putFloat("max", max);
-                res.putFloat("min", min);
-                res.putFloat("mean", random.nextFloat(min, max));
-                res.putFloat("deviation", random.nextFloat(max - min));
-            }
-            case 2 -> {
-                res.putFloat("max", max);
-                res.putFloat("min", min);
-                res.putFloat("plateau", random.nextFloat(max - min));
+        static NbtCompound randomFloatProvider(Random random, float lbound, float bound) {
+            int i = random.nextInt(3);
+            String[] types = new String[]{"uniform", "clamped_normal", "trapezoid"};
+            NbtCompound res = new NbtCompound();
+            res.putString("type", types[i]);
+            NbtCompound value = new NbtCompound();
+            float a = random.nextFloat(lbound, bound);
+            float b = random.nextFloat(lbound, bound);
+            float min = Math.min(a, b);
+            float max = Math.max(a, b);
+            switch (i) {
+                case 0 -> {
+                    value.putFloat("max_exclusive", max);
+                    value.putFloat("min_inclusive", min);
+                }
+                case 1 -> {
+                    value.putFloat("max", max);
+                    value.putFloat("min", min);
+                    value.putFloat("mean", random.nextFloat(min, max));
+                    value.putFloat("deviation", random.nextFloat(max - min));
+                }
+                case 2 -> {
+                    value.putFloat("max", max);
+                    value.putFloat("min", min);
+                    value.putFloat("plateau", random.nextFloat(max - min));
+                }
             }
+            res.put("value", value);
+            return res;
         }
-        return res;
-    }
 }

common/src/main/resources/data/infinity/loot_tables/blocks/chromatic_carpet.json

···
           "name": "infinity:chromatic_carpet",
           "functions": [
             {
-              "function": "minecraft:copy_components",
+              "function": "minecraft:copy_nbt",
               "include": [
                 "infinity:color"
               ],
-              "source": "block_entity"
+              "source": "block_entity",
+              "ops": [
+                {
+                  "source": "infinity:color",
+                  "target": "infinity:color",
+                  "op": "replace"
+                }
+              ]
             }
           ]
         }
···
       ]
     }
   ]
-}
+}

common/src/main/resources/data/infinity/loot_tables/blocks/chromatic_wool.json

···
           "name": "infinity:chromatic_wool",
           "functions": [
             {
-              "function": "minecraft:copy_components",
-              "include": [
-                "infinity:color"
-              ],
-              "source": "block_entity"
+              "function": "minecraft:copy_nbt",
+              "source": "block_entity",
+              "ops": [
+                {
+                  "source": "infinity:color",
+                  "target": "infinity:color",
+                  "op": "replace"
+                }
+              ]
             }
           ]
         }
···
       ]
     }
   ]
-}
+}

common/src/main/resources/data/infinity/recipes/iridescence_bottle_from_portal.json

···
     "item": "infinity:chromatic_potion"
   },
   "output": {
-    "id": "infinity:iridescent_potion"
+    "item": "infinity:iridescent_potion"
   }
 }