Switch to simpler ore gen config

- Ditch use of LargeOreDepsoits in favor of using Minecraft's native
  placed features, but with auto-generated files which give more
  subtly and expression in an automated way

mcpacker/format/datapack/__init__.py

@@ -1,49 +0,0 @@
-from collections.abc import Iterable
-from mcpacker.format.datapack.moddata import ModData
-
-
-# Class ############################################################################################
-
-class DataPack:
-    """
-    A collection of data used to configure a Minecraft instance.
-
-    see: https://minecraft.wiki/w/Data_pack
-    """
-
-    def __init__(self, name:str, mods:Iterable[ModData]|None=None):
-        self.name = name
-        self._mods:dict[str,ModData] = {}
-        self._defaultMod:ModData|None = None
-
-        for mod in (mods or []):
-            self.add(mod)
-
-    def add(self, mod:ModData) -> "DataPack":
-        if not self._defaultMod:
-            self._defaultMod = mod
-
-        self._mods[mod.name] = mod
-        return self
-
-    def get(self, name:str) -> ModData:
-        result = self._mods.get(name, None)
-        if not result:
-            result = self._mods[name] = ModData(name)
-
-        return result
-
-    @property
-    def defaultMod(self) -> ModData|None:
-        return self._defaultMod
-
-    @defaultMod.setter
-    def defaultMod(self, mod:ModData):
-        if mod:
-            existingModData = self.get(mod.name)
-            if not existingModData:
-                self.add(mod)
-            elif existingModData != mod:
-                raise Exception(f"Datapack already has a mod named {mod.name}")
-
-        self._defaultMod = mod

mcpacker/format/datapack/biomemodifier/__init__.py

@@ -1,11 +0,0 @@
-from mcpacker.json import JsonBlob
-
-
-# Classes ##########################################################################################
-
-class BiomeModifier:
-
-    def asJsonBlob(self) -> JsonBlob:
-        return {
-            "type": "neoforge:none",
-        }

mcpacker/format/datapack/biomemodifier/addfeature.py

@@ -1,12 +1,11 @@
 from collections.abc import Iterable
-from mcpacker.format.datapack.biomemodifier import BiomeModifier
 from mcpacker.format.datapack.generationstep import GenerationStep
-from mcpacker.json import JsonBlob
+from mcpacker.format.json import JsonBlob
 
 
 # Class ############################################################################################
 
-class AddFeatureBiomeModifier(BiomeModifier):
+class AddFeatureBiomeModifier:
 
     def __init__(self, biomes:Iterable[str]|str, features:Iterable[str]|str, step:GenerationStep):
         if isinstance(biomes, str):
@@ -21,7 +20,7 @@ class AddFeatureBiomeModifier(BiomeModifier):
 
     def asJsobBlob(self) -> JsonBlob:
         return {
-            "type": "neoforge:add_features",
+            "type": "forge:add_features",
             "biomes": list(self.biomes),
             "features": list(self.features),
             "step": str(self.step),

mcpacker/format/datapack/biomemodifier/addfeature_test.py

@@ -1,7 +0,0 @@
-import mcpacker.format.datapack.biomemodifier.addfeature
-
-
-# Tests ############################################################################################
-
-def test_syntax():
-    pass

mcpacker/format/datapack/biomemodifier/noop.py

@@ -1,14 +1,11 @@
-from mcpacker.json import JsonBlob
+from mcpacker.format.json import JsonBlob
 
 
 # Class ############################################################################################
 
-class Placement:
+class NoopBiomeModifier:
-
-    def __init__(self, gameId:str):
-        self.gameId = gameId
 
     def asJsonBlob(self) -> JsonBlob:
         return {
-            "type": self.gameId,
+            "type": "forge:none",
         }

mcpacker/format/datapack/biomemodifier/removefeature.py

@@ -1,12 +1,11 @@
 from collections.abc import Iterable
-from mcpacker.format.datapack.biomemodifier import BiomeModifier
 from mcpacker.format.datapack.generationstep import GenerationStep
-from mcpacker.json import JsonBlob
+from mcpacker.format.json import JsonBlob
 
 
-# Classes ##########################################################################################
+# Class ############################################################################################
 
-class RemoveFeatureBiomeModifier(BiomeModifier):
+class RemoveFeatureBiomeModifier:
 
     def __init__(
         self,
@@ -26,7 +25,7 @@ class RemoveFeatureBiomeModifier(BiomeModifier):
 
     def asJsobBlob(self) -> JsonBlob:
         result:dict[str,JsonBlob] = {
-            "type": "neoforge:remove_features",
+            "type": "forge:remove_features",
             "biomes": list(self.biomes),
             "features": list(self.features),
         }

mcpacker/format/datapack/biomemodifier/removefeature_test.py

@@ -1,7 +0,0 @@
-import mcpacker.format.datapack.biomemodifier.removefeature
-
-
-# Tests ############################################################################################
-
-def test_syntax():
-    pass

mcpacker/format/datapack/biomemodifier/removespawn.py

@@ -1,12 +1,11 @@
 from collections.abc import Iterable
-from mcpacker.format.datapack.biomemodifier import BiomeModifier
+from mcpacker.format.json import JsonBlob
 from mcpacker.model.resourceid import ResourceId
-from mcpacker.json import JsonBlob
 
 
-# Classes ##########################################################################################
+# Class ############################################################################################
 
-class RemoveSpawnBiomeModifier(BiomeModifier):
+class RemoveSpawnBiomeModifier:
 
     def __init__(self, biomes:Iterable[str]|str, entityTypes:Iterable[ResourceId]):
         if isinstance(biomes, str):

mcpacker/format/datapack/biomemodifier/removespawn_test.py

@@ -1,7 +0,0 @@
-import mcpacker.format.datapack.biomemodifier.removespawn
-
-
-# Tests ############################################################################################
-
-def test_syntax():
-    pass

mcpacker/format/datapack/blockstate.py

@@ -1,20 +0,0 @@
-from mcpacker.json import JsonBlob
-from typing import Any
-from typing import cast
-
-
-# Class ############################################################################################
-
-class BlockState:
-
-    def __init__(self, blockId:str, properties:JsonBlob|None=None):
-        self.blockId = blockId
-        self.properties = properties
-
-    def asJsonBlob(self) -> JsonBlob:
-        result = cast(dict[str,JsonBlob], { "Name": self.blockId })
-
-        if self.properties:
-            result["Properties"] = self.properties
-
-        return result

mcpacker/format/datapack/blockstate_test.py

@@ -1,20 +0,0 @@
-from mcpacker.format.datapack.blockstate import BlockState
-from pytest import fixture
-
-
-# Fixtures #########################################################################################
-
-@fixture(name="state")
-def createBlockState():
-    yield BlockState("minecraft:button", {"waterlogged": "true"})
-
-
-# Tests ############################################################################################
-
-def test_asData(state:BlockState):
-    assert state.asJsonBlob() == {
-        "Name": "minecraft:button",
-        "Properties": {
-            "waterlogged": "true"
-        }
-    }

mcpacker/format/datapack/blockstateprovider/__init__.py

@@ -1,12 +0,0 @@
-from mcpacker.json import JsonBlob
-
-
-# Class ############################################################################################
-
-class BlockStateProvider:
-
-    def __init__(self, gameId:str):
-        self.gameId = gameId
-
-    def asJsonBlob(self) -> JsonBlob:
-        raise NotImplementedError()

mcpacker/format/datapack/blockstateprovider/simplestateprovider.py

@@ -1,19 +0,0 @@
-from mcpacker.json import JsonBlob
-from mcpacker.format.datapack.blockstate import BlockState
-from mcpacker.format.datapack.blockstateprovider import BlockStateProvider
-from typing import Any
-
-
-# Class ############################################################################################
-
-class SimpleStateProvider(BlockStateProvider):
-
-    def __init__(self, state:BlockState):
-        super().__init__("minecraft:simple_state_provider")
-        self.state = state
-
-    def asJsonBlob(self) -> JsonBlob:
-        return {
-            "type": self.gameId,
-            "state": self.state.asJsonBlob(),
-        }

mcpacker/format/datapack/blockstateprovider/simplestateprovider_test.py

@@ -1,28 +0,0 @@
-from mcpacker.format.datapack.blockstate import BlockState
-from mcpacker.format.datapack.blockstateprovider.simplestateprovider import SimpleStateProvider
-from pytest import fixture
-
-
-# Fixtures #########################################################################################
-
-@fixture(name="state")
-def createBlockState():
-    yield BlockState("minecraft:button", {"waterlogged": "true"})
-
-@fixture(name="provider")
-def createProvider(state:BlockState):
-    return SimpleStateProvider(state)
-
-
-# Tests ############################################################################################
-
-def test_asData(provider:SimpleStateProvider):
-    assert provider.asJsonBlob() == {
-        "type": "minecraft:simple_state_provider",
-        "state": {
-            "Name": "minecraft:button",
-            "Properties": {
-                "waterlogged": "true"
-            }
-        }
-    }

mcpacker/format/datapack/configuredfeature/__init__.py

@@ -1,15 +0,0 @@
-from mcpacker.json import JsonBlob
-
-
-# Class ############################################################################################
-
-class ConfiguredFeature:
-
-    def __init__(self, gameId:str):
-        self.gameId = gameId
-
-    def asJsonBlob(self) -> JsonBlob:
-        return {
-            "type": self.gameId,
-            "config": {},
-        }

mcpacker/format/datapack/configuredfeature/randompatch.py

@@ -1,36 +0,0 @@
-from mcpacker.format.datapack.configuredfeature import ConfiguredFeature
-from mcpacker.json import JsonBlob
-from typing import Any
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from mcpacker.format.datapack.placedfeature import PlacedFeature
-
-
-# Class ############################################################################################
-
-class RandomPatch(ConfiguredFeature):
-
-    def __init__(
-        self,
-        gameId:str,
-        feature:"PlacedFeature",
-        tries:int=128,
-        xzSpread:int=7,
-        ySpread:int=3,
-    ):
-        super().__init__("minecraft:random_patch")
-
-        self.feature = feature
-        self.tries = tries
-        self.xzSpread = xzSpread
-        self.ySpread = ySpread
-
-    def asJsonBlob(self) -> JsonBlob:
-        return {
-            "type": self.gameId,
-            "feature": self.feature.gameId,
-            "tries": self.tries,
-            "xz_spread": self.xzSpread,
-            "y_spread": self.ySpread
-        }

mcpacker/format/datapack/configuredfeature/randompatch_test.py

@@ -1,36 +0,0 @@
-from mcpacker.format.datapack.blockstate import BlockState
-from mcpacker.format.datapack.placedfeature import PlacedFeature
-from mcpacker.format.datapack.blockstateprovider.simplestateprovider import SimpleStateProvider
-from mcpacker.format.datapack.configuredfeature.randompatch import RandomPatch
-from pytest import fixture
-
-
-# Fixtures #########################################################################################
-
-@fixture(name="state")
-def createBlockState():
-    yield BlockState("minecraft:button", {"waterlogged": "true"})
-
-@fixture(name="provider")
-def createProvider(state:BlockState):
-    return SimpleStateProvider(state)
-
-@fixture(name="placedFeature")
-def createPlacedFeature():
-    return PlacedFeature("noop", [])
-
-@fixture(name="feature")
-def createFeature(placedFeature:PlacedFeature):
-    return RandomPatch("test", placedFeature)
-
-
-# Tests ############################################################################################
-
-def test_asJsonBlob(feature:RandomPatch):
-    assert feature.asJsonBlob() == {
-        "type": "minecraft:random_patch",
-        "feature": "noop",
-        "tries": 128,
-        "xz_spread": 7,
-        "y_spread": 3,
-    }

mcpacker/format/datapack/configuredfeature/simpleblock.py

@@ -1,21 +0,0 @@
-from mcpacker.json import JsonBlob
-from mcpacker.format.datapack.blockstateprovider import BlockStateProvider
-from mcpacker.format.datapack.configuredfeature import ConfiguredFeature
-from typing import Any
-
-
-# Class ############################################################################################
-
-class SimpleBlock(ConfiguredFeature):
-
-    def __init__(self, toPlace:BlockStateProvider):
-        super().__init__("minecraft:simple_block")
-        self.toPlace = toPlace
-
-    def asJsonBlob(self) -> JsonBlob:
-        return {
-            "type": self.gameId,
-            "config": {
-                "to_place": self.toPlace.asJsonBlob()
-            }
-        }

mcpacker/format/datapack/configuredfeature/simpleblock_test.py

@@ -1,38 +0,0 @@
-from mcpacker.format.datapack.blockstate import BlockState
-from mcpacker.format.datapack.blockstateprovider.simplestateprovider import SimpleStateProvider
-from mcpacker.format.datapack.configuredfeature.simpleblock import SimpleBlock
-from pytest import fixture
-
-
-# Fixtures #########################################################################################
-
-@fixture(name="state")
-def createBlockState():
-    yield BlockState("minecraft:button", {"waterlogged": "true"})
-
-@fixture(name="provider")
-def createProvider(state:BlockState):
-    return SimpleStateProvider(state)
-
-@fixture(name="feature")
-def createSimpleBlockFeature(provider:SimpleStateProvider):
-    return SimpleBlock(provider)
-
-
-# Tests ############################################################################################
-
-def test_asData(feature:SimpleBlock):
-    assert feature.asJsonBlob() == {
-        "type": "minecraft:simple_block",
-        "config": {
-            "to_place": {
-                "type": "minecraft:simple_state_provider",
-                "state": {
-                    "Name": "minecraft:button",
-                    "Properties": {
-                        "waterlogged": "true"
-                    }
-                }
-            }
-        }
-    }

mcpacker/format/datapack/generationstep_test.py

@@ -1,7 +0,0 @@
-import mcpacker.format.datapack.generationstep
-
-
-# Tests ############################################################################################
-
-def test_syntax():
-    pass

mcpacker/format/datapack/heightmaptype.py

@@ -1,30 +0,0 @@
-# Class ############################################################################################
-
-class HeightMapType:
-    """
-    A cached record of the top block at all points in the world.
-
-    see: https://minecraft.wiki/w/Heightmap
-    """
-
-    def __init__(self, name:str):
-        self.name = name
-
-    def __repr__(self) -> str:
-        return f"HeightMapType(name={self.name})"
-
-    def __str__(self) -> str:
-        return self.name
-
-    def asData(self) -> str:
-        return self.name
-
-
-# Constants ########################################################################################
-
-MOTION_BLOCKING           = HeightMapType("MOTION_BLOCKING")
-MOTION_BLOCKING_NO_LEAVES = HeightMapType("MOTION_BLOCKING_NO_LEAVES")
-OCEAN_FLOOR               = HeightMapType("OCEAN_FLOOR")
-OCEAN_FLOOR_WG            = HeightMapType("OCEAN_FLOOR_WG")
-WORLD_SURFACE             = HeightMapType("WORLD_SURFACE")
-WORLD_SURFACE_WG          = HeightMapType("WORLD_SURFACE_WG")

mcpacker/format/datapack/heightmaptype_test.py

@@ -1,7 +0,0 @@
-from mcpacker.format.datapack.heightmaptype import HeightMapType
-
-
-# Tests ############################################################################################
-
-def test_syntax():
-    pass

mcpacker/format/datapack/moddata.py

@@ -1,23 +0,0 @@
-from mcpacker.format.datapack.configuredfeature import ConfiguredFeature
-from mcpacker.format.datapack.placedfeature import PlacedFeature
-from typing import Any
-
-
-# Class ############################################################################################
-
-class ModData:
-
-    def __init__(self, name:str):
-        self.name = name
-        self.biomeModifiers:list[Any] = []
-        self.configuredFeatures:list[ConfiguredFeature] = []
-        self.functions:list[Any] = []
-        self.functionTags:list[Any] = []
-        self.lootModifiers:list[Any] = []
-        self.lootTables:list[Any] = []
-        self.placedFeatures:list[PlacedFeature] = []
-        self.recipes:list[Any] = []
-        self.structures:list[Any] = []
-        self.structureSets:list[Any] = []
-        self.tags:list[Any] = []
-        self.templatePools:list[Any] = []

mcpacker/format/datapack/moddata_test.py

@@ -1,7 +0,0 @@
-import mcpacker.format.datapack.moddata
-
-
-# Tests ############################################################################################
-
-def test_syntax():
-    pass

mcpacker/format/datapack/noop.py

@@ -0,0 +1,21 @@
+from mcpacker.format.json import JsonBlob
+
+
+# Class ############################################################################################
+
+class NoopConfiguredFeature:
+
+    def asJsonBlob(self) -> JsonBlob:
+        return {
+            "type": "minecraft:noop",
+            "config": {},
+        }
+
+class NoopPlacedFeature:
+
+    def asJsonBlob(self) -> JsonBlob:
+        return {
+            "feature": NoopConfiguredFeature().asJsonBlob(),
+            "placement": []
+        }
+

mcpacker/format/datapack/placedfeature.py

@@ -1,18 +0,0 @@
-from collections.abc import Iterable
-from mcpacker.format.datapack.placement import Placement
-from mcpacker.json import JsonBlob
-
-
-# Class ############################################################################################
-
-class PlacedFeature:
-
-    def __init__(self, gameId:str, placements:Iterable[Placement]):
-        self.gameId = gameId
-        self.placements = placements
-
-    def asJsonBlob(self) -> JsonBlob:
-        return {
-            "feature": self.gameId,
-            "placements": [p.asJsonBlob() for p in self.placements],
-        }

mcpacker/format/datapack/placedfeature_test.py

@@ -1,7 +0,0 @@
-from mcpacker.format.datapack.placedfeature import PlacedFeature
-
-
-# Tests ############################################################################################
-
-def test_syntax():
-    pass

mcpacker/format/datapack/placement/biome.py

@@ -1,9 +0,0 @@
-from mcpacker.format.datapack.placement import Placement
-from typing import Any
-
-# Class ############################################################################################
-
-class Biome(Placement):
-
-    def __init__(self):
-        super().__init__("minecraft:biome")

mcpacker/format/datapack/placement/biome_test.py

@@ -1,18 +0,0 @@
-from mcpacker.format.datapack.placement.biome import Biome
-from pytest import fixture
-
-
-# Fixtures #########################################################################################
-
-@fixture(name="placement")
-def createPlacement():
-    yield Biome()
-
-
-# Tests ############################################################################################
-
-def test_asData(placement):
-    assert placement.asJsonBlob() == {
-        "type": "minecraft:biome",
-    }
-

mcpacker/format/datapack/placement/heightmap.py

@@ -1,19 +0,0 @@
-from mcpacker.format.datapack.heightmaptype import HeightMapType
-from mcpacker.format.datapack.placement import Placement
-from mcpacker.json import JsonBlob
-from typing import Any
-
-
-# Class ############################################################################################
-
-class HeightMap(Placement):
-
-    def __init__(self, heightMap:HeightMapType):
-        super().__init__("minecraft:heightmap")
-        self.heightMap = heightMap
-
-    def asJsonBlob(self) -> JsonBlob:
-        return {
-            "type": self.gameId,
-            "heightmap": self.heightMap.asData()
-        }

mcpacker/format/datapack/placement/heightmap_test.py

@@ -1,20 +0,0 @@
-from mcpacker.format.datapack.heightmaptype import WORLD_SURFACE
-from mcpacker.format.datapack.placement.heightmap import HeightMap
-from pytest import fixture
-
-
-# Fixtures #########################################################################################
-
-@fixture(name="placement")
-def createPlacement():
-    yield HeightMap(WORLD_SURFACE)
-
-
-# Tests ############################################################################################
-
-def test_asData(placement):
-    assert placement.asJsonBlob() == {
-        "type": "minecraft:heightmap",
-        "heightmap": "WORLD_SURFACE"
-    }
-

mcpacker/format/datapack/placement/insquare.py

@@ -1,10 +0,0 @@
-from mcpacker.format.datapack.placement import Placement
-from typing import Any
-
-
-# Class ############################################################################################
-
-class InSquare(Placement):
-
-    def __init__(self):
-        super().__init__("minecraft:in_square")

mcpacker/format/datapack/placement/insquare_test.py

@@ -1,18 +0,0 @@
-from mcpacker.format.datapack.placement.insquare import InSquare
-from pytest import fixture
-
-
-# Fixtures #########################################################################################
-
-@fixture(name="placement")
-def createPlacement():
-    yield InSquare()
-
-
-# Tests ############################################################################################
-
-def test_asData(placement):
-    assert placement.asJsonBlob() == {
-        "type": "minecraft:in_square",
-    }
-

mcpacker/format/datapack/placement/rarityfilter.py

@@ -1,19 +0,0 @@
-from mcpacker.format.datapack.placement import Placement
-from mcpacker.json import JsonBlob
-from typing import Any
-
-
-# Class ############################################################################################
-
-class RarityFilter(Placement):
-
-    def __init__(self, chance:int):
-        super().__init__("minecraft:rarity_filter")
-        self.chance = chance
-
-    def asJsonBlob(self) -> JsonBlob:
-        return {
-            "type": self.gameId,
-            "chance": self.chance,
-        }
-

mcpacker/format/datapack/placement/rarityfilter_test.py

@@ -1,19 +0,0 @@
-from mcpacker.format.datapack.placement.rarityfilter import RarityFilter
-from pytest import fixture
-
-
-# Fixtures #########################################################################################
-
-@fixture(name="placement")
-def createPlacement():
-    yield RarityFilter(4)
-
-
-# Tests ############################################################################################
-
-def test_asData(placement):
-    assert placement.asJsonBlob() == {
-        "type": "minecraft:rarity_filter",
-        "chance": 4
-    }
-

mcpacker/format/datapack/recipe/__init__.py

@@ -1,20 +0,0 @@
-from collections.abc import Iterable
-from collections.abc import Mapping
-from mcpacker.model.resourceid import ResourceId
-
-
-# Class ############################################################################################
-
-class Recipe:
-
-    def __init__(
-        self,
-        gameId:str|ResourceId,
-        resultId:str|ResourceId,
-        resultCount:int=1,
-        resultComponents:Mapping[str,str]|None=None,
-    ):
-        self.gameId           = ResourceId.parse(gameId)
-        self.resultComponents = resultComponents
-        self.resultCount      = resultCount
-        self.resultId         = ResourceId.parse(resultId)

mcpacker/format/datapack/recipe/shapedrecipe.py

@@ -1,56 +0,0 @@
-from collections.abc import Iterable
-from collections.abc import Mapping
-from mcpacker.format.datapack.recipe import Recipe
-from mcpacker.model.resourceid import ResourceId
-
-
-# Class ############################################################################################
-
-class ShapedRecipe(Recipe):
-
-    def __init__(
-        self,
-        gameId:str|ResourceId,
-        key:Mapping[str,(str|ResourceId|Iterable[ResourceId|str])],
-        pattern:Iterable[str],
-        resultId:str|ResourceId,
-        resultCount:int=1,
-        resultComponents:Mapping[str,str]|None=None,
-    ):
-        super().__init__(gameId, resultId, resultCount, resultComponents)
-        self.key = self._parseKey(key)
-        self.pattern = self._parsePattern(pattern)
-
-    # Private Methods ##########################################################
-
-    def _parseKey(
-        self,
-        key:Mapping[str,(str|ResourceId|Iterable[ResourceId|str])]
-    ) -> dict[str, list[ResourceId]]:
-        result:dict[str, list[ResourceId]] = {}
-
-        for name, value in key.items():
-            finalValue:list[ResourceId] = []
-
-            if isinstance(value, str) or isinstance(value, ResourceId):
-                finalValue = [ ResourceId.parse(value) ]
-            elif isinstance(value, Iterable):
-                finalValue = [ ResourceId.parse(e) for e in value ]
-
-            if len(name) != 1:
-                raise ValueError(f"key names must be a single letter (\"{name}\" is not valid)")
-
-            result[name] = finalValue
-
-        return result
-
-    def _parsePattern(self, pattern:Iterable[str]) -> list[str]:
-        result:list[str] = []
-
-        for row in pattern:
-            if len(row) not in [2, 3]:
-                raise ValueError(f"pattern rows must be 2 or 3 letters: (\"{row}\" is not valid)")
-
-            result.append(row)
-
-        return result

mcpacker/format/datapack/recipe/shapedrecipe_test.py

@@ -1,27 +0,0 @@
-from pytest import fixture
-from mcpacker.format.datapack.recipe.shapedrecipe import ShapedRecipe
-
-
-# Fixtures #########################################################################################
-
-@fixture(name="recipe")
-def createRecipe():
-    yield ShapedRecipe(
-        "iron_pickaxe",
-        {"s": "stick", "i": "iron_ingot"},
-        ["iii", " s ", " s "],
-        "iron_pickaxe"
-    )
-
-
-# Tests ############################################################################################
-
-def test_recipe(recipe:ShapedRecipe):
-    keyText = ", ".join(f"{k}:{str(v[0])}" for k,v in recipe.key.items())
-    recipeText = "|".join(str(i) for i in recipe.pattern)
-
-    assert keyText == "s:minecraft:stick, i:minecraft:iron_ingot"
-    assert recipeText == "iii| s | s "
-    assert str(recipe.resultId) == "minecraft:iron_pickaxe"
-    assert recipe.resultCount == 1
-

mcpacker/format/datapack/recipe/shapelessrecipe.py

@@ -1,28 +0,0 @@
-from collections.abc import Iterable
-from collections.abc import Mapping
-from mcpacker.model.resourceid import ResourceId
-from mcpacker.format.datapack.recipe import Recipe
-
-
-# Class ############################################################################################
-
-class ShapelessRecipe(Recipe):
-
-    def __init__(
-        self,
-        gameId:str|ResourceId,
-        ingredients:Iterable[str|ResourceId],
-        resultId:str|ResourceId,
-        resultCount:int=1,
-        resultComponents:Mapping[str,str]|None=None,
-    ):
-        super().__init__(gameId, resultId, resultCount, resultComponents)
-        self.ingredients = self._parseIngredients(ingredients)
-
-    def _parseIngredients(self, ingredients:Iterable[str|ResourceId]) -> list[ResourceId]:
-        result = [ ResourceId.parse(e) for e in ingredients ]
-
-        if len(result) > 9:
-            raise ValueError("cannot have more than 9 ingredients (\"{len(result}\" is not valid")
-
-        return result

mcpacker/format/datapack/recipe/shapelessrecipe_test.py

@@ -1,17 +0,0 @@
-from pytest import fixture
-from mcpacker.format.datapack.recipe.shapelessrecipe import ShapelessRecipe
-
-
-# Fixtures #########################################################################################
-
-@fixture(name="recipe")
-def createRecipe():
-    yield ShapelessRecipe("flint_and_steel", ["iron_ingot", "flint"], "flint_and_steel")
-
-
-# Tests ############################################################################################
-
-def test_recipe(recipe:ShapelessRecipe):
-    assert ", ".join(str(i) for i in recipe.ingredients) == "minecraft:iron_ingot, minecraft:flint"
-    assert str(recipe.resultId) == "minecraft:flint_and_steel"
-    assert recipe.resultCount == 1

mcpacker/format/datapack/structure.py

@@ -1,33 +0,0 @@
-from collections.abc import Iterable
-from mcpacker.model.resourceid import ResourceId
-from mcpacker.json import JsonBlob
-
-import mcpacker.format.datapack.heightmaptype as HM
-import mcpacker.format.datapack.generationstep as GS
-
-
-# Class ############################################################################################
-
-class Structure:
-
-    def __init__(
-        self,
-        gameId:ResourceId,
-        biomes:Iterable[ResourceId],
-    ):
-        self.gameId = gameId
-        self.biomes = list(biomes)
-
-    def asJsonBlob(self) -> JsonBlob:
-        return {
-            "biomes": [str(b) for b in self.biomes],
-            "max_distance_from_center": 10,
-            "project_start_to_heightmap": str(HM.OCEAN_FLOOR),
-            "size": 1,
-            "spawn_overrides": {},
-            "start_height": { "absolute": 0 },
-            "start_pool": f"{self.gameId.mod}:deposit/{self.gameId.name}_marker",
-            "step": str(GS.SURFACE_STRUCTURES),
-            "type": "minecraft:jigsaw",
-            "use_expansion_hack": False,
-        }

mcpacker/format/datapack/structure_test.py

@@ -1,7 +0,0 @@
-import mcpacker.format.datapack.structure
-
-
-# Tests ############################################################################################
-
-def test_syntax():
-    pass

mcpacker/format/json.py

@@ -1,18 +1,13 @@
-from json import dump
+from typing import Protocol
-from json import dumps
-from json import load
-from json import loads
-from typing import TypeAlias
-
-
-# Constants ########################################################################################
-
-INDENT = "    "
 
 
 # Type Support #####################################################################################
 
-JsonBlob:TypeAlias = dict[str, "JsonBlob"] | list["JsonBlob"] | str | int | float | bool | None
+type JsonBlob = dict[str, "JsonBlob"] | list["JsonBlob"] | str | int | float | bool | None
+
+class JsonBlobSource(Protocol):
+
+    def asJsonBlob(self) -> JsonBlob:...
 
 
 # Functions ########################################################################################

mcpacker/format/json_test.py

@@ -1,8 +1,8 @@
-from mcpacker.json import JsonBlob
+from mcpacker.format.json import JsonBlob
 from pytest import fixture
 from typing import cast
 
-import mcpacker.json as json
+import mcpacker.format.json as json
 
 
 # Fixtures #########################################################################################

mcpacker/format/largeoredeposit/mineraldepositcomposer.py

@@ -1,127 +0,0 @@
-from collections.abc import Iterator
-from collections.abc import Mapping
-from mcpacker.model.geology.inclusion import Inclusion
-from mcpacker.format.templatecomposer import TemplateComposer
-from mcpacker.model.geology.deposit.mineraldeposit import MineralDeposit
-
-
-# Constants ########################################################################################
-
-TEMPLATE = """
-Config {{
-    B:enabled = true
-}}
-
-Deposit {{
-    S:customReplacements <
-        {customReplacements}
-    >
-    S:ores <
-        {ores}
-    >
-    I:rarity={rarity}
-    S:replaceableBlocks <
-        {replaceableBlocks}
-    >
-    B:vanilla=false
-    Dimensions {{
-        S:blackList <
-        >
-        S:whiteList <
-        >
-    }}
-    Biomes {{
-        S:blackList <
-        >
-        S:whiteList <
-        >
-    }}
-    Altitude {{
-        I:min={altitudeMin}
-        I:max={altitudeMax}
-    }}
-    Miscellaneous {{
-        B:exposed=true
-        S:proportions={proportions}
-        B:strictBounds=false
-        B:strictStart=false
-    }}
-    Indicator {{
-        S:circles <
-        >
-        S:continuity=0
-        I:distortion=0
-        S:id={indicatorId}
-        S:threshold=100
-    }}
-    Size {{
-        i:min={sizeMin}
-        I:max={sizeMax}
-    }}
-}}
-""".strip()
-
-# Class ############################################################################################
-
-class MineralDepositComposer(TemplateComposer):
-
-    def __init__(self, deposit:MineralDeposit):
-        super().__init__(TEMPLATE)
-        self._deposit = deposit
-
-    def gatherData(self) -> dict[str,str]:
-        return {
-            "altitudeMin": f"{self._deposit.altitude.bottom}",
-            "altitudeMax": f"{self._deposit.altitude.top}",
-            "customReplacements": "\n        ".join(self._gatherCustomReplacements()),
-            "indicatorId": f"deposit/{self._deposit.gameId}_marker",
-            "ores": "\n        ".join(self._gatherOres()),
-            "proportions": f"{self._deposit.proportion.ratio:0.2f}",
-            "rarity": f"{self._gatherRarity()}",
-            "replaceableBlocks": "\n        ".join(self._gatherReplaceableBlocks()),
-            "sizeMin": f"{self._deposit.bulk.smallest}",
-            "sizeMax": f"{self._deposit.bulk.largest}",
-        }
-
-    # Private Methods ##########################################################
-
-    def _gatherCustomReplacements(self) -> list[str]:
-        result = {}
-
-        for inclusion in self._deposit.inclusions:
-            if len(inclusion.mineral.replacements) < 2: continue
-            for replacement in inclusion.mineral.replacements[1:]:
-                result[f"{replacement.source}->{replacement.target},{inclusion.weight}"] = True
-
-        return list(result.keys())
-
-    def _gatherOres(self) -> list[str]:
-        result = {}
-
-        for inclusion in self._deposit.inclusions:
-            if len(inclusion.mineral.replacements) < 1: continue
-            for replacement in inclusion.mineral.replacements[0:1]:
-                result[f"{replacement.target},{inclusion.weight}"] = True
-
-        return list(result.keys())
-
-    def _gatherReplaceableBlocks(self) -> list[str]:
-        result = {}
-
-        for inclusion in self._deposit.inclusions:
-            if len(inclusion.mineral.replacements) < 1: continue
-            for replacement in inclusion.mineral.replacements[0:1]:
-                result[f"{replacement.source}"] = True
-
-        return list(result.keys())
-
-    def _gatherRarity(self) -> int:
-        return {
-            "absent": 1000**2,
-            "rare": 21**2,
-            "unusual": 13**2,
-            "sparse": 8**2,
-            "uncommon": 5**2,
-            "common": 3**2,
-            "carpet": 1**2,
-        }[self._deposit.scarcity.name]

mcpacker/format/largeoredeposit/mineraldepositcomposer_test.py

@@ -1,107 +0,0 @@
-from mcpacker.model.ecology.biomefilter import BiomeFilter
-from mcpacker.model.geology.deposit.mineraldeposit import MineralDeposit
-from mcpacker.model.geology.inclusion import Inclusion
-from mcpacker.model.geology.mineral import Mineral
-from mcpacker.model.geology.replacement import Replacement
-from pytest import fixture
-from mcpacker.format.largeoredeposit.mineraldepositcomposer import MineralDepositComposer
-from pytest import fixture
-
-import mcpacker.model.altitude as AL
-import mcpacker.model.ecology.flora as FL
-import mcpacker.model.geology.bulk as BU
-import mcpacker.model.geology.proportion as PR
-import mcpacker.model.scarcity as SC
-import textwrap
-
-
-# Fixtures #########################################################################################
-
-@fixture(name="quartz")
-def createQuartz():
-    yield Mineral("quartz", [
-        Replacement.inStone("quartz_ore"),
-        Replacement.inDeepslate("deepslate_quartz_ore"),
-    ])
-
-@fixture(name="iron")
-def createIron():
-    yield Mineral("iron", [
-        Replacement.inStone("iron_ore"),
-        Replacement.inDeepslate("deepslate_iron_ore"),
-    ])
-
-@fixture(name="bifIron")
-def createBifIron(iron, quartz):
-    yield MineralDeposit(
-        name = "bifiron",
-        altitude = AL.CRUST,
-        biomeFilters = BiomeFilter([FL.FOREST]),
-        bulk = BU.LARGE,
-        inclusions = [Inclusion(iron, 60), Inclusion(quartz, 40)],
-        proportion = PR.LENS,
-        scarcity = SC.COMMON,
-    )
-
-@fixture(name="composer")
-def createComposer(bifIron):
-    yield MineralDepositComposer(bifIron).compose()
-
-# Tests ############################################################################################
-
-def test_str(composer):
-    assert str(composer) == textwrap.dedent("""
-        Config {
-            B:enabled = true
-        }
-
-        Deposit {
-            S:customReplacements <
-                #minecraft:deepslate_ore_replaceables->minecraft:deepslate_iron_ore,60
-                #minecraft:deepslate_ore_replaceables->minecraft:deepslate_quartz_ore,40
-            >
-            S:ores <
-                minecraft:iron_ore,60
-                minecraft:quartz_ore,40
-            >
-            I:rarity=9
-            S:replaceableBlocks <
-                #minecraft:stone_ore_replaceables
-            >
-            B:vanilla=false
-            Dimensions {
-                S:blackList <
-                >
-                S:whiteList <
-                >
-            }
-            Biomes {
-                S:blackList <
-                >
-                S:whiteList <
-                >
-            }
-            Altitude {
-                I:min=-32
-                I:max=32
-            }
-            Miscellaneous {
-                B:exposed=true
-                S:proportions=0.40
-                B:strictBounds=false
-                B:strictStart=false
-            }
-            Indicator {
-                S:circles <
-                >
-                S:continuity=0
-                I:distortion=0
-                S:id=deposit/bifiron_marker
-                S:threshold=100
-            }
-            Size {
-                i:min=1250
-                I:max=1500
-            }
-        }
-    """).strip()

mcpacker/format/report/biomereport.py

@@ -1,4 +1,5 @@
 from mcpacker.model.modpack import ModPack
+from mcpacker.model.geology.mineralspawn import MineralSpawn
 from mcpacker.model.ecology.biome import Biome
 from mcpacker.format.report.composer import ReportComposer
 from pathlib import Path
@@ -26,15 +27,17 @@ class BiomeReport(ReportComposer):
 
     def _composeGeologySection(self, biome:Biome):
         self.line().line("Geology:").indent()
-        depositCount = 0
+        mineralCount = 0
-        for deposit in self.pack.world.deposits:
+        for spawn in self.pack.world.mineralSpawns:
-            if not deposit.acceptsBiome(biome): continue
+            if "plutonic" in spawn.name: continue
-            self.line(f"{deposit.name} ({deposit.scarcity})")
-            depositCount += 1
 
-        if depositCount == 0:
+            if not spawn.habitat.accepts(biome): continue
-            self.line("<no deposits>")
+            self.line(f"{spawn.name} ({spawn.ecotype.scarcity})")
-        self.outdent() # deposits
+            mineralCount += 1
+
+        if mineralCount == 0:
+            self.line("<no minerals>")
+        self.outdent() # minerals
 
     def _composeFaunaSection(self, biome:Biome):
         self.line().line("Fauna:").indent()

mcpacker/format/report/biomereport_test.py

@@ -52,7 +52,7 @@ def test_report(report):
             Traits: field, sedimentary, subtropical, dry, sandy, inland
 
             Geology:
-                <no deposits>
+                <no minerals>
 
             Flora:
                 <no flora>
@@ -65,7 +65,7 @@ def test_report(report):
             Traits: field, sedimentary, temperate, damp, loamy, inland
 
             Geology:
-                <no deposits>
+                <no minerals>
 
             Flora:
                 <no flora>

mcpacker/format/report/depositreport.py

@@ -1,5 +1,4 @@
 from mcpacker.format.report.composer import ReportComposer
-from mcpacker.model.geology.deposit.mineraldeposit import MineralDeposit
 from mcpacker.model.modpack import ModPack
 from pathlib import Path
 
@@ -11,31 +10,31 @@ class DepositReport(ReportComposer):
     def doCompose(self):
         biomes = self.pack.world.biomes
 
-        for deposit in self.pack.world.deposits:
+#       for deposit in self.pack.world.deposits:
-            self.line(f"Deposit: {deposit.name}")
+#           self.line(f"Deposit: {deposit.name}")
-            self.line()
+#           self.line()
-            self.indent()
+#           self.indent()
-            self.text("altitude: ").line(deposit.altitude)
+#           self.text("altitude: ").line(deposit.altitude)
-            self.text("biome filters: ").line(", ".join(str(b) for b in deposit.biomeFilters))
+#           self.text("biome filters: ").line(", ".join(str(b) for b in deposit.biomeFilters))
-            self.text("scarcity: ").line(deposit.scarcity)
+#           self.text("scarcity: ").line(deposit.scarcity)
-            if isinstance(deposit, MineralDeposit):
+#           if isinstance(deposit, MineralDeposit):
-                self.text("bulk: ").line(deposit.bulk)
+#               self.text("bulk: ").line(deposit.bulk)
-                self.text("inclusions: ").line(", ".join(str(i) for i in deposit.inclusions))
+#               self.text("inclusions: ").line(", ".join(str(i) for i in deposit.inclusions))
-                self.text("proportion: ").line(deposit.proportion)
+#               self.text("proportion: ").line(deposit.proportion)
-
+#
-            self.line()
+#           self.line()
-            self.line("Found in:")
+#           self.line("Found in:")
-            self.indent()
+#           self.indent()
-
+#
-            biomeCount = 0
+#           biomeCount = 0
-            for biome in biomes.filter(lambda b: deposit.acceptsBiome(b)):
+#           for biome in biomes.filter(lambda b: deposit.acceptsBiome(b)):
-                self.line(biome)
+#               self.line(biome)
-                biomeCount += 1
+#               biomeCount += 1
-
+#
-            if biomeCount == 0:
+#           if biomeCount == 0:
-                self.line("WARNING: no suitable biomes")
+#               self.line("WARNING: no suitable biomes")
-
+#
-            self.outdent()
+#           self.outdent()
-
+#
-            self.outdent()
+#           self.outdent()
-            self.line()
+#           self.line()

mcpacker/format/report/mineralreport.py

@@ -1,4 +1,6 @@
 from mcpacker.format.report.composer import ReportComposer
+from mcpacker.model.ecology.biome import Biome
+from mcpacker.model.geology.mineral import Mineral
 from mcpacker.model.modpack import ModPack
 from pathlib import Path
 
@@ -9,12 +11,39 @@ class MineralReport(ReportComposer):
 
     def doCompose(self):
         for mineral in self.pack.world.minerals:
-            self.line(f"Mineral: {mineral.name}")
+            self.line(f"Mineral: {mineral.name}").line().indent()
-            self.line()
 
-            self.indent()
+            self.line("Replacements:").line().indent()
             for replacement in mineral.replacements:
                 self.line(str(replacement))
-            self.outdent()
+            self.outdent().line() # replacements
 
-            self.line()
+            self.line("Spawns:").line().indent()
+            for spawn in self.pack.world.mineralSpawns:
+                if spawn.mineral != mineral: continue
+
+                self.text(spawn.name).line(":").line().indent()
+                self.text("altitude: ").line(spawn.habitat.altitude)
+                self.text("biomeFilters: ")
+                self.line(" -or- ".join(str(f) for f in spawn.habitat.biomeFilters))
+                self.text("bulk: ").line(spawn.ecotype.bulk)
+                self.text("scarcity: ").line(spawn.ecotype.scarcity)
+                self.outdent().line() # spawn.name
+            self.outdent() # spawns
+
+            self.line("Biomes:").line().indent()
+            for biome in self._collateBiomes(mineral):
+                self.line(str(biome))
+            self.outdent().line() # biomes
+
+            self.outdent() # mineral
+
+    def _collateBiomes(self, mineral:Mineral) -> list[Biome]:
+        result:set[Biome] = set()
+        spawns = [s for s in self.pack.world.mineralSpawns if s.mineral == mineral]
+        for biome in self.pack.world.biomes:
+            for spawn in spawns:
+                if not spawn.habitat.accepts(biome): continue
+                result.add(biome)
+
+        return sorted(result)

mcpacker/format/report/mineralreport_test.py

@@ -40,11 +40,24 @@ def test_report(report:MineralReport):
     assert str(report).strip() == textwrap.dedent("""
         Mineral: copper
 
+            Replacements:
+
                 #minecraft:stone_replaceables => minecraft:copper_ore
                 #minecraft:deepslate_replaceables => minecraft:deepslate_copper_ore
 
+            Spawns:
+
+            Biomes:
+
+
         Mineral: iron
 
+            Replacements:
+
                 #minecraft:stone_replaceables => minecraft:iron_ore
                 #minecraft:deepslate_replaceables => minecraft:deepslate_iron_ore
+
+            Spawns:
+
+            Biomes:
     """).strip()

mcpacker/format/report/plantspawnreport.py

@@ -1,6 +1,7 @@
 from mcpacker.model.flora.patch import Patch
 from mcpacker.model.flora.tree import Tree
 from mcpacker.format.report.composer import ReportComposer
+from mcpacker.model.ecology.biomefilter import BiomeFilter
 from mcpacker.model.ecology.biometrait import BiomeTrait
 from mcpacker.model.modpack import ModPack
 from pathlib import Path
@@ -52,7 +53,7 @@ class PlantSpawnReport(ReportComposer):
 
             self.line().line("Biomes:")
             self.indent() # biomes
-            for biome in self.pack.world.biomes.find(spawn.habitat.biomeFilters):
+            for biome in BiomeFilter.collate(self.pack.world.biomes, spawn.habitat.biomeFilters):
                 self.line(biome)
             self.outdent() # biomes
 

mcpacker/model/blockfactory.py

@@ -1,26 +0,0 @@
-from mcpacker.format.resourcepack.blockstate import BlockState
-from mcpacker.format.resourcepack.variant import Variant
-from mcpacker.format.resourcepack.model import Model
-from mcpacker.model.modpack import ModPack
-from mcpacker.model.resourceid import ResourceId
-from mcpacker.format.datapack.recipe.shapedrecipe import ShapedRecipe
-
-
-# Class ############################################################################################
-
-class BlockFactory:
-
-    def __init__(self, pack:ModPack):
-        self.pack = pack
-
-    def makeBasicBlock(self, name:str, gameId:ResourceId):
-        basicCubeModelId = ResourceId.parse("block/cube_all")
-        textureId = ResourceId.parse(f"{gameId.mod}:block/{gameId.name}")
-        blockId = ResourceId.parse(f"{gameId.mod}:block/{gameId.name}")
-
-        resource = self.pack.resourcePack.get(gameId.mod)
-        resource.blockModels.append(Model(basicCubeModelId, {"all": textureId}))
-        resource.itemModels.append(Model(blockId))
-        resource.blockStates.append(BlockState(Variant(blockId)))
-
-        data = self.pack.dataPack.get(gameId.mod)

mcpacker/model/blockfactory_test.py

@@ -1,9 +0,0 @@
-import mcpacker.model.blockfactory
-
-
-# Tests ############################################################################################
-
-def test_syntax():
-    pass
-
-# TODO: add some meaningful tests

mcpacker/model/blockstate.py

@@ -1,7 +1,10 @@
-from mcpacker.json import JsonBlob
 from mcpacker.model.resourceid import ResourceId
 from typing import Any
 
+# Type Support  ####################################################################################
+
+type PropertyDict = dict[str, str|int]
+
 
 # Class ############################################################################################
 
@@ -12,7 +15,7 @@ class BlockState:
         if isinstance(value, BlockState): return value
         return BlockState(ResourceId.parse(value))
 
-    def __init__(self, gameId:ResourceId|str, properties:JsonBlob=None):
+    def __init__(self, gameId:ResourceId|str, properties:PropertyDict|None=None):
         self.gameId = ResourceId.parse(gameId)
         self.properties = properties
 

mcpacker/model/catalog.py

@@ -47,7 +47,7 @@ class Catalog[CatalogItem: HasName]:
 
     def add(self, item:CatalogItem) -> "Catalog[CatalogItem]":
         if item.name in self._items:
-            raise Exception(f"Catalog already contains {item.name}")
+            raise Exception(f"Catalog already contains '{item.name}'")
 
         self._items[item.name] = item
         return self

mcpacker/model/ecology/biome.py

@@ -6,6 +6,7 @@ from mcpacker.model.ecology.humidity import Humidity
 from mcpacker.model.ecology.soil import Soil
 from mcpacker.model.ecology.water import Water
 from mcpacker.model.resourceid import ResourceId
+from typing import Any
 
 
 ####################################################################################################
@@ -36,7 +37,7 @@ class Biome:
         self.soil = soil
         self.water = water
 
-    def __eq__(self, other) -> bool:
+    def __eq__(self, other:Any) -> bool:
         if type(self) != type(other): return False
         if self.gameId != other.gameId: return False
         if self.name != other.name: return False
@@ -45,20 +46,26 @@ class Biome:
     def __hash__(self) -> int:
         return hash((self.gameId, self.name))
 
+    def __lt__(self, other:Any) -> bool:
+        if type(self) != type(other): raise ValueError()
+        return self.gameId < other.gameId
+
     def __str__(self) -> str:
         return f"{self.gameId} ({self.name})"
 
     def __repr__(self) -> str:
-        return "".join([str(p) for p in [
+        return (
-            "Biome(",
+            "Biome("
-                "flora=", repr(self.flora), ", ",
+                f"flora={self.flora!r}, "
-                "geology=", repr(self.geology), ", ",
+                f"gameId={self.gameId!r}, "
-                "heat=", repr(self.heat), ", ",
+                f"geology={self.geology!r}, "
-                "humidity=", repr(self.humidity), ", ",
+                f"heat={self.heat!r}, "
-                "soil=", repr(self.soil), ", ",
+                f"humidity={self.humidity!r}, "
-                "water=", repr(self.water),
+                f"name={self.name!r}, "
+                f"soil={self.soil!r}, "
+                f"water={self.water!r}"
             ")"
-        ]])
+        )
 
     def traits(self) -> list[BiomeTrait]:
         return list([

mcpacker/model/ecology/biomefilter.py

@@ -1,4 +1,5 @@
 from collections.abc import Sequence
+from collections.abc import Iterable
 from mcpacker.model.resourceid import ResourceId
 from mcpacker.model.ecology.biome import Biome
 from mcpacker.model.ecology.biometrait import BiomeTrait
@@ -25,6 +26,21 @@ class BiomeFilter:
     required traits while simultaneously not possessing *any* of the prohibited ones.
     """
 
+    @staticmethod
+    def collate(biomes:Iterable[Biome], biomeFilters:Iterable["BiomeFilter"]) -> list[Biome]:
+        """
+        Return the subset of given biomes which are accepted by all of the given filters.
+        """
+        accepted:set[Biome] = set()
+
+        for biome in biomes:
+            for biomeFilter in biomeFilters:
+                if not biomeFilter.accepts(biome): continue
+                accepted.add(biome)
+                break
+
+        return sorted(accepted)
+
     def __init__(
         self,
         required:Sequence[BiomeTrait|ResourceId|Sequence[BiomeTrait]]|None=None,

mcpacker/model/ecology/humidity.py

@@ -15,11 +15,13 @@ class Humidity(BiomeTrait):
 
 # Constants ########################################################################################
 
+SOAKED  = Humidity("soaked")
 WET  = Humidity("wet")
 DAMP = Humidity("damp")
 DRY = Humidity("dry")
+ARID  = Humidity("arid")
 
-ALL = [WET, DAMP, DRY]
+ALL = [SOAKED, WET, DAMP, DRY, ARID]
 
 
 # Helpers ##########################################################################################

mcpacker/model/fauna/mobspawnbuilder.py

@@ -1,9 +1,9 @@
+from mcpacker.model.catalog import Catalog
 from mcpacker.model.fauna.group import Group
 from mcpacker.model.fauna.location import Location
 from mcpacker.model.fauna.mob import Mob
 from mcpacker.model.fauna.mobecotype import MobEcotype
 from mcpacker.model.fauna.mobspawn import MobSpawn
-from mcpacker.model.fauna.mobspawncatalog import MobSpawnCatalog
 from mcpacker.model.scarcity import Scarcity
 from mcpacker.model.spawnbuilder import SpawnBuilder
 from typing import Self
@@ -16,7 +16,7 @@ import mcpacker.model.fauna.location as LO
 
 class MobSpawnBuilder(SpawnBuilder[Mob, MobEcotype, MobSpawn]):
 
-    def __init__(self, catalog:MobSpawnCatalog):
+    def __init__(self, catalog:Catalog[MobSpawn]):
         super().__init__(catalog, MobSpawn)
 
     @property

mcpacker/model/flora/plantspawnbuilder.py

@@ -1,7 +1,7 @@
+from mcpacker.model.catalog import Catalog
 from mcpacker.model.ecotype import Ecotype
 from mcpacker.model.flora.plant import Plant
 from mcpacker.model.flora.plantspawn import PlantSpawn
-from mcpacker.model.flora.plantspawncatalog import PlantSpawnCatalog
 from mcpacker.model.spawnbuilder import SpawnBuilder
 from typing import Self
 
@@ -10,7 +10,7 @@ from typing import Self
 
 class PlantSpawnBuilder(SpawnBuilder[Plant, Ecotype, PlantSpawn]):
 
-    def __init__(self, catalog:PlantSpawnCatalog):
+    def __init__(self, catalog:Catalog[PlantSpawn]):
         super().__init__(catalog, PlantSpawn)
 
     def _createEcotype(self) -> Ecotype:

mcpacker/model/geology/bulk.py

@@ -5,11 +5,20 @@ import math
 # Class ############################################################################################
 
 class Bulk:
+    """
+    Bulk describes the tendency of the material in a mineral deposit to clump together.
 
-    def __init__(self, name:str, smallest:int, largest:int):
+    The `blobCount` describes how many blobs of mineral will appear in a 16mx16mx16m cube, more bulk
+    implies fewer overall blobs of larger size. For 2D deposit types (e.g., disk), this refers to
+    how many individual shapes are placed.
+
+    In any case, the total amount of mineral deposited remains the same (i.e., controlled by
+    `Scarcity`).
+    """
+
+    def __init__(self, name:str, blobCount:int):
         self.name = name
-        self.smallest = smallest
+        self.blobCount = blobCount
-        self.largest = largest
 
     def __eq__(self, other:Any) -> bool:
         if type(self) != type(other): return False
@@ -20,25 +29,37 @@ class Bulk:
         return hash(self.name)
 
     def __repr__(self) -> str:
-        return f"Bulk(name='{self.name}', smallest={self.smallest}, largest={self.largest})"
+        return f"Bulk(name={self.name!r}, blobCount={self.blobCount!r})"
 
     def __str__(self) -> str:
-        return f"{self.name} ({self.smallest} to {self.largest})"
+        return f"{self.name} ({self.blobCount})"
-
-    def scale(self, factor) -> "Bulk":
-        return Bulk(
-            self.name,
-            math.floor(self.smallest * factor),
-            math.floor(self.largest * factor)
-        )
 
 
 # Constants ########################################################################################
 
-TINY   = Bulk("tiny",   250,  500)
+TINY   = Bulk("tiny", 5)
-SMALL  = Bulk("small",  500,  750)
+SMALL  = Bulk("small", 4)
-MEDIUM = Bulk("small",  750, 1000)
+MEDIUM = Bulk("medium", 3)
-LARGE  = Bulk("large", 1250, 1500)
+LARGE  = Bulk("large", 2)
-HUGE   = Bulk("huge",  1500, 1750)
+HUGE   = Bulk("huge", 1)
 
 ALL = [TINY, SMALL, MEDIUM, LARGE, HUGE]
+
+# Helper Functions #################################################################################
+
+# TODO: The following properly belong somewhere in mcpacker.format, but I'm not sure where yet.
+
+ORE_MAX_BLOCKS = [
+    0, 0, 0, 4, 5, 8, 9, 10, 10, 13, 16, 17, 23, 24, 24, 29, 32, 37, 46, 52, 52, 60, 68, 68, 74, 82,
+    94, 104, 106, 120, 128, 135, 149, 160, 180, 190, 204, 212, 228, 246, 262, 276, 292, 308, 324,
+    344, 360, 381, 403, 429, 452, 480, 500, 530, 558, 584, 616, 634, 664, 694, 730, 760, 790, 826,
+    864
+]
+
+def convertBlockCountToSize(blockCount:int) -> int:
+    """Return the smallest integer `size` whose vein can reach at least max_blocks."""
+    for size, maxCount in enumerate(ORE_MAX_BLOCKS):
+        if maxCount >= blockCount:
+            return size
+
+    return len(ORE_MAX_BLOCKS) - 1

mcpacker/model/geology/bulk_test.py

@@ -1,20 +0,0 @@
-from mcpacker.model.geology.bulk import Bulk
-from pytest import fixture
-
-
-# Fixture ##########################################################################################
-
-@fixture(name="bulk")
-def createBulk():
-    return Bulk("chunk", 64, 128)
-
-@fixture(name="scaledBulk")
-def scaleBulk(bulk):
-    yield bulk.scale(2.0)
-
-
-# Fixture ##########################################################################################
-
-def test_repr(bulk, scaledBulk):
-    assert repr(bulk) == "Bulk(name='chunk', smallest=64, largest=128)"
-    assert repr(scaledBulk) == "Bulk(name='chunk', smallest=128, largest=256)"

mcpacker/model/geology/deposit/__init__.py

@@ -1,56 +0,0 @@
-from collections.abc import Iterable
-from mcpacker.model.altitude import Altitude
-from mcpacker.model.ecology.biome import Biome
-from mcpacker.model.ecology.biomefilter import BiomeFilter
-from mcpacker.model.geology.bulk import Bulk
-from mcpacker.model.geology.mineral import Mineral
-from mcpacker.model.scarcity import Scarcity
-
-import mcpacker.model.altitude as altitude
-import mcpacker.model.scarcity as scarcity
-
-
-# Class ############################################################################################
-
-class Deposit:
-
-    def __init__(
-        self,
-        name:str,
-        altitude:Altitude=altitude.ANYWHERE,
-        biomeFilters:Iterable[BiomeFilter]|BiomeFilter|None=None,
-        scarcity:Scarcity=scarcity.SPARSE,
-    ):
-        self.altitude = altitude
-        self.biomeFilters:list[BiomeFilter] = []
-        self.gameId = name
-        self.name = name
-        self.scarcity = scarcity
-
-        if not biomeFilters:
-            biomeFilters = [BiomeFilter()]
-
-        if isinstance(biomeFilters, BiomeFilter):
-            biomeFilters = [biomeFilters]
-
-        for biomeFilter in biomeFilters:
-            self.biomeFilters.append(biomeFilter)
-
-    def __repr__(self) -> str:
-        return "".join([str(p) for p in [
-            "Deposit(",
-                "name=", self.name, ", ",
-                "altitude=", repr(self.altitude), ", ",
-                "biomeFilters=[", ", ".join(repr(self.biomeFilters)), "], ",
-                "scarcity=", repr(self.scarcity),
-            ")"
-        ]])
-
-    def __str__(self) -> str:
-        return self.name
-
-    def acceptsBiome(self, biome:Biome) -> bool:
-        for biomeFilter in self.biomeFilters:
-            if biomeFilter.accepts(biome): return True
-
-        return False

mcpacker/model/geology/deposit/__init___test.py

@@ -1,7 +0,0 @@
-import mcpacker.model.geology.deposit
-
-
-# Tests ############################################################################################
-
-def test_syntax():
-    pass

mcpacker/model/geology/deposit/geodedeposit.py

@@ -1,25 +0,0 @@
-from collections.abc import Iterable
-from mcpacker.model.altitude import Altitude
-from mcpacker.model.ecology.biomefilter import BiomeFilter
-from mcpacker.model.geology.bulk import Bulk
-from mcpacker.model.geology.deposit import Deposit
-from mcpacker.model.geology.mineral import Mineral
-from mcpacker.model.scarcity import Scarcity
-
-import mcpacker.model.altitude as altitude
-import mcpacker.model.scarcity as scarcity
-
-
-# Class ############################################################################################
-
-class GeodeDeposit(Deposit):
-
-    def __init__(
-        self,
-        name:str,
-        altitude:Altitude=altitude.ANYWHERE,
-        biomeFilters:Iterable[BiomeFilter]|BiomeFilter|None=None,
-        scarcity:Scarcity=scarcity.SPARSE,
-    ):
-        super().__init__(name, altitude, biomeFilters, scarcity)
-        # TODO: add geode layers

mcpacker/model/geology/deposit/geodedeposit_test.py

@@ -1,7 +0,0 @@
-import mcpacker.model.geology.deposit.geodedeposit
-
-
-# Class ############################################################################################
-
-def test_syntax():
-    pass

mcpacker/model/geology/deposit/mineraldeposit.py

@@ -1,50 +0,0 @@
-from collections.abc import Iterable
-from mcpacker.model.altitude import Altitude
-from mcpacker.model.ecology.biomefilter import BiomeFilter
-from mcpacker.model.geology.bulk import Bulk
-from mcpacker.model.geology.deposit import Deposit
-from mcpacker.model.geology.inclusion import Inclusion
-from mcpacker.model.geology.proportion import Proportion
-from mcpacker.model.scarcity import Scarcity
-
-import mcpacker.model.altitude as AL
-import mcpacker.model.geology.bulk as BU
-import mcpacker.model.geology.proportion as PR
-import mcpacker.model.scarcity as SC
-
-
-# Class ############################################################################################
-
-class MineralDeposit(Deposit):
-
-    def __init__(
-        self,
-        name:str,
-        altitude:Altitude=AL.ANYWHERE,
-        biomeFilters:Iterable[BiomeFilter]|BiomeFilter|None=None,
-        bulk:Bulk=BU.MEDIUM,
-        inclusions:Iterable[Inclusion]|None=None,
-        proportion:Proportion=PR.BODY,
-        scarcity:Scarcity=SC.SPARSE,
-    ):
-        super().__init__(name, altitude, biomeFilters, scarcity)
-
-        self.bulk = bulk
-        self.inclusions = list(inclusions or [])
-        self.proportion = proportion
-
-    def __repr__(self) -> str:
-        return "".join([str(p) for p in [
-            "MineralDeposit(" +
-                "name=", repr(self.name), ", ",
-                "altitude=", repr(self.altitude), ", ",
-                "biomeFilters=", repr(self.biomeFilters), ", ",
-                "bulk=", repr(self.bulk), ", ",
-                "inclusions=[", ", ".join([repr(m) for m in self.inclusions]), "], ",
-                "proportion=", repr(self.proportion), ", ",
-                "scarcity=", repr(self.scarcity),
-            ")"
-        ]])
-
-    def __str__(self) -> str:
-        return self.name

mcpacker/model/geology/deposit/mineraldeposit_test.py

@@ -1,51 +0,0 @@
-from mcpacker.model.ecology.biomefilter import BiomeFilter
-from mcpacker.model.geology.deposit.mineraldeposit import MineralDeposit
-from mcpacker.model.geology.inclusion import Inclusion
-from mcpacker.model.geology.mineral import Mineral
-from mcpacker.model.geology.replacement import Replacement
-from pytest import fixture
-
-import mcpacker.model.ecology.flora      as FL
-import mcpacker.model.geology.bulk       as BU
-import mcpacker.model.geology.proportion as PR
-import mcpacker.model.scarcity           as SC
-
-
-# Fixtures #########################################################################################
-
-@fixture(name="quartz")
-def createQuartz():
-    yield Mineral("quartz", [])
-
-@fixture(name="iron")
-def createIron():
-    yield Mineral("iron", [])
-
-@fixture(name="bifIron")
-def createBifIron(iron, quartz):
-    yield MineralDeposit(
-        name = "bifiron",
-        biomeFilters = BiomeFilter([FL.FOREST]),
-        bulk = BU.LARGE,
-        inclusions = [Inclusion(iron, 60), Inclusion(quartz, 40)],
-        proportion = PR.LENS,
-        scarcity = SC.COMMON,
-    )
-
-# Tests ############################################################################################
-
-def test_repr(bifIron):
-    assert repr(bifIron) == (
-        "MineralDeposit(" +
-            "name='bifiron', " +
-            "altitude=Altitude(name=anywhere, bottom=-64, top=320), " +
-            "biomeFilters=[BiomeFilter(required=[Flora(name='forest')], prohibited=[])], " +
-            "bulk=Bulk(name='large', smallest=1250, largest=1500), " +
-            "inclusions=[" +
-                "Inclusion(mineral=Mineral(name='iron', replacements=[]), weight=60), " +
-                "Inclusion(mineral=Mineral(name='quartz', replacements=[]), weight=40)" +
-            "], " +
-            "proportion=Proportion(name='lens', ratio=0.4), " +
-            "scarcity=Scarcity(name='common')" +
-        ")"
-    )

mcpacker/model/geology/depositcatalog.py

@@ -1,8 +0,0 @@
-from mcpacker.model.catalog import Catalog
-from mcpacker.model.geology.deposit import Deposit
-
-
-# Classes ##########################################################################################
-
-class DepositCatalog(Catalog[Deposit]):
-    pass

mcpacker/model/geology/depositcatalog_test.py

@@ -1,7 +0,0 @@
-import mcpacker.model.geology.depositcatalog
-
-
-# Tests ############################################################################################
-
-def test_syntax():
-    pass

mcpacker/model/geology/deposittype.py

@@ -0,0 +1,32 @@
+from typing import Any
+
+
+# Class ############################################################################################
+
+class DepositType:
+
+    def __init__(self, name:str):
+        self.name = name
+
+    def __eq__(self, other:Any) -> bool:
+        if type(self) != type(other): return False
+        if self.name != other.name: return False
+        return True
+
+    def __hash__(self) -> int:
+        return hash(self.name)
+
+    def __repr__(self) -> str:
+        return f"DepositType(name={self.name!r})"
+
+    def __str__(self) -> str:
+        return self.name
+
+
+# Constants ########################################################################################
+
+VEIN = DepositType("vein")
+DISK = DepositType("disk")
+STRATA = DepositType("strata")
+
+ALL = [VEIN, STRATA]

mcpacker/model/geology/inclusion_test.py

@@ -1,21 +0,0 @@
-from mcpacker.model.geology.inclusion import Inclusion
-from mcpacker.model.geology.mineral import Mineral
-from mcpacker.model.geology.replacement import Replacement
-from pytest import fixture
-
-
-# Fixtures #########################################################################################I
-
-@fixture(name="iron")
-def createIron():
-    yield Mineral("iron", [])
-
-@fixture(name="inclusion")
-def createInclusion(iron):
-    yield Inclusion(iron, 75)
-
-
-# Tests ############################################################################################I
-
-def test_repr(inclusion):
-    assert repr(inclusion) == "Inclusion(mineral=Mineral(name='iron', replacements=[]), weight=75)"

mcpacker/model/geology/mineral.py

@@ -1,24 +1,29 @@
 from collections.abc import Iterable
 from mcpacker.model.geology.replacement import Replacement
 from mcpacker.model.resourceid import ResourceId
+from mcpacker.model.spawnable import Spawnable
 
 
 # Class ############################################################################################
 
-class Mineral:
+class Mineral(Spawnable):
+
+    def __init__(self, name:str, replacements:Iterable[Replacement]|Replacement):
+        super().__init__(name)
+
+        if isinstance(replacements, Replacement):
+            replacements = [replacements]
 
-    def __init__(self, name:str, replacements:Iterable[Replacement]|None=None):
         self.name = name
-        self.gameId = name
+        self.replacements = list(replacements)
-        self.replacements = list(replacements or [])
 
     def __str__(self) -> str:
         return self.name
 
     def __repr__(self) -> str:
-        return "".join([str(p) for p in [
+        return (
-            f"Mineral(" +
+            "Mineral("
-                "name=", repr(self.name), ", ",
+                f"name={self.name!r}, "
-                "replacements=", repr(self.replacements),
+                f"replacements={self.replacements!r}"
             ")"
-        ]])
+        )

mcpacker/model/geology/mineral_test.py

@@ -1,37 +0,0 @@
-from mcpacker.model.geology.mineral import Mineral
-from mcpacker.model.geology.replacement import Replacement
-from pytest import fixture
-
-import mcpacker.model.geology.mineral as mineral
-
-
-# Fixtures #########################################################################################
-
-@fixture(name="iron")
-def createIron():
-    yield Mineral("iron", [
-        Replacement.inStone("iron_ore"),
-        Replacement.inDeepslate("deepslate_iron_ore"),
-    ])
-
-
-# Tests ############################################################################################
-
-def test_repr(iron):
-    assert repr(iron) == (
-        "Mineral(" +
-            "name='iron', " +
-            "replacements=[" +
-                "Replacement(" +
-                    "source='#minecraft:stone_ore_replaceables', " +
-                    "target='minecraft:iron_ore', " +
-                    "weight=100" +
-                "), " +
-                "Replacement(" +
-                    "source='#minecraft:deepslate_ore_replaceables', " +
-                    "target='minecraft:deepslate_iron_ore', " +
-                    "weight=100" +
-                ")"
-            "]" +
-        ")"
-    )

mcpacker/model/geology/mineralcatalog.py

@@ -1,8 +0,0 @@
-from mcpacker.model.catalog import Catalog
-from mcpacker.model.geology.mineral import Mineral
-
-
-# Classes ##########################################################################################
-
-class MineralCatalog(Catalog[Mineral]):
-    pass

mcpacker/model/geology/mineralcatalog_test.py

@@ -1,7 +0,0 @@
-import mcpacker.model.geology.mineralcatalog
-
-
-# Tests ############################################################################################
-
-def test_syntax():
-    pass

mcpacker/model/geology/mineralecotype.py

@@ -0,0 +1,19 @@
+from mcpacker.model.ecotype import Ecotype
+from mcpacker.model.geology.bulk import Bulk
+from mcpacker.model.geology.deposittype import DepositType
+from mcpacker.model.scarcity import Scarcity
+from mcpacker.model.resourceid import ResourceId
+
+import mcpacker.model.geology.bulk as BU
+import mcpacker.model.geology.deposittype as DE
+
+
+
+# Class ############################################################################################
+
+class MineralEcotype(Ecotype):
+
+    def __init__(self, scarcity:Scarcity, bulk:Bulk=BU.MEDIUM, depositType:DepositType=DE.VEIN):
+        super().__init__(scarcity)
+        self.bulk = bulk
+        self.depositType = depositType

mcpacker/model/geology/mineralspawn.py

@@ -0,0 +1,16 @@
+from mcpacker.model.geology.mineralecotype import MineralEcotype
+from mcpacker.model.geology.mineral import Mineral
+from mcpacker.model.habitat import Habitat
+from mcpacker.model.spawn import Spawn
+
+
+# Class ############################################################################################
+
+class MineralSpawn(Spawn[Mineral, MineralEcotype]):
+
+    def __init__(self, name:str, habitat:Habitat, deposit:Mineral, ecotype:MineralEcotype):
+        super().__init__(name, habitat, deposit, ecotype)
+
+    @property
+    def mineral(self) -> Mineral:
+        return self.spawnable

mcpacker/model/geology/mineralspawnbuilder.py

@@ -0,0 +1,51 @@
+from mcpacker.model.catalog import Catalog
+from mcpacker.model.ecotype import Ecotype
+from mcpacker.model.geology.bulk import Bulk
+from mcpacker.model.geology.deposittype import DepositType
+from mcpacker.model.geology.mineral import Mineral
+from mcpacker.model.geology.mineralecotype import MineralEcotype
+from mcpacker.model.geology.mineralspawn import MineralSpawn
+from mcpacker.model.resourceid import ResourceId
+from mcpacker.model.spawnbuilder import SpawnBuilder
+from typing import Self
+
+import mcpacker.model.geology.bulk as BU
+import mcpacker.model.geology.deposittype as DE
+
+
+# Class ############################################################################################
+
+class MineralSpawnBuilder(SpawnBuilder[Mineral, MineralEcotype, MineralSpawn]):
+
+    def __init__(self, catalog:Catalog[MineralSpawn]):
+        super().__init__(catalog, MineralSpawn)
+
+    def _createEcotype(self) -> MineralEcotype:
+        return MineralEcotype(self.scarcity, self.bulk, self.depositType)
+
+    def _reset(self):
+        super()._reset()
+        self.bulk = None
+        self.depositType = None
+
+    @property
+    def bulk(self) -> Bulk:
+        return self._bulk
+
+    @bulk.setter
+    def bulk(self, value:Bulk|None):
+        if value == None:
+            value = BU.MEDIUM
+
+        self._bulk = value
+
+    @property
+    def depositType(self) -> DepositType:
+        return self._depositType
+
+    @depositType.setter
+    def depositType(self, value:DepositType|None):
+        if value == None:
+            value = DE.VEIN
+
+        self._depositType = value

mcpacker/model/geology/proportion.py

@@ -1,34 +0,0 @@
-# Class ############################################################################################
-
-class Proportion:
-
-    def __init__(self, name:str, ratio:float):
-        self.name = name
-        self.ratio = ratio
-
-    def __eq__(self, other) -> bool:
-        if type(self) != type(other): return False
-        if self.name != other.name: return False
-        return True
-
-    def __hash__(self) -> int:
-        return hash(self.name)
-
-    def __str__(self) -> str:
-        return f"{self.name} ({self.ratio})"
-
-    def __repr__(self) -> str:
-        return f"Proportion(name='{self.name}', ratio={self.ratio})"
-
-
-# Constants ########################################################################################
-
-BED   = Proportion("bed",   0.1) # salt, nitrate, redbed, loam, bif iron, peat coal
-LENS  = Proportion("lens",  0.4) # bit.coal, aluminum, lapis, quartzite
-LODE  = Proportion("lode",  0.7) # au.quartz, mvt lead
-BODY  = Proportion("body",  1.0) # sed.iron
-STOCK = Proportion("stock", 1.3) # tin
-VENT  = Proportion("vent",  1.6) # sulfur
-PIPE  = Proportion("pipe",  1.9) # por.copper
-
-ALL = [BED, LENS, LODE, BODY, STOCK, VENT, PIPE]

mcpacker/model/geology/proportion_test.py

@@ -1,12 +0,0 @@
-from pytest import fixture
-
-import mcpacker.model.geology.proportion as proportion
-
-
-# Tests ############################################################################################
-
-def test_str():
-    assert str(proportion.LENS) == "lens (0.4)"
-
-def test_repr():
-    assert repr(proportion.LENS) == "Proportion(name='lens', ratio=0.4)"

mcpacker/model/geology/replacement.py

@@ -3,8 +3,9 @@ from mcpacker.model.resourceid import ResourceId
 
 # Constants ########################################################################################
 
-STONE_REPLACEABLES = "#minecraft:stone_ore_replaceables"
 DEEPSLATE_REPLACEABLES = "#minecraft:deepslate_ore_replaceables"
+NETHERRACK_REPLACEABLES = "#minecraft:base_stone_nether"
+STONE_REPLACEABLES = "#minecraft:stone_ore_replaceables"
 
 
 # Class ############################################################################################
@@ -12,29 +13,28 @@ DEEPSLATE_REPLACEABLES = "#minecraft:deepslate_ore_replaceables"
 class Replacement:
 
     @staticmethod
-    def inStone(target:str, weight:int=100):
+    def inDeepslate(target:ResourceId|str):
-        return Replacement(STONE_REPLACEABLES, target, weight)
+        return Replacement(DEEPSLATE_REPLACEABLES, target)
 
     @staticmethod
-    def inDeepslate(target:str, weight:int=100):
+    def inNetherrack(target:ResourceId|str):
-        return Replacement(DEEPSLATE_REPLACEABLES, target, weight)
+        return Replacement(NETHERRACK_REPLACEABLES, target)
 
-    def __init__(self, source:str, target:str, weight:int=100):
+    @staticmethod
-        self.source = ResourceId.canonical(source)
+    def inStone(target:ResourceId|str):
-        self.target = ResourceId.canonical(target)
+        return Replacement(STONE_REPLACEABLES, target)
-        self.weight = weight
+
+    def __init__(self, source:ResourceId|str, target:ResourceId|str):
+        self.source = ResourceId.parse(source)
+        self.target = ResourceId.parse(target)
 
     def __str__(self) -> str:
-        if self.weight == 100:
         return f"{self.source} => {self.target}"
 
-        return f"{self.source} => {self.target} ({self.weight}%)"
-
     def __repr__(self) -> str:
-        return "".join([str(p) for p in [
+        return (
-            "Replacement(" +
+            "Replacement("
-                "source=", repr(self.source), ", ",
+                f"source={self.source!r}, "
-                "target=", repr(self.target), ", ",
+                f"target={self.target!r}"
-                "weight=", repr(self.weight),
             ")"
-        ]])
+        )

mcpacker/model/geology/replacement_test.py

@@ -1,28 +0,0 @@
-from pytest import fixture
-from mcpacker.model.geology.replacement import Replacement
-
-
-# Fixtures #########################################################################################
-
-@fixture(name="replacement")
-def createReplacement():
-    yield Replacement("#minecraft:stone", "minecraft:iron_ore")
-
-@fixture(name="weightedReplacement")
-def createWeightedReplacement():
-    yield Replacement("#minecraft:dirt", "minecraft:gravel", 25)
-
-
-# Tests ############################################################################################
-
-def test_repr(replacement, weightedReplacement):
-    assert repr(replacement) == (
-        "Replacement(source='#minecraft:stone', target='minecraft:iron_ore', weight=100)"
-    )
-    assert repr(weightedReplacement) == (
-        "Replacement(source='#minecraft:dirt', target='minecraft:gravel', weight=25)"
-    )
-
-def test_str(replacement, weightedReplacement):
-    assert str(replacement) == "#minecraft:stone => minecraft:iron_ore"
-    assert str(weightedReplacement) == "#minecraft:dirt => minecraft:gravel (25%)"

mcpacker/model/modpack.py

@@ -1,9 +1,7 @@
 from collections.abc import Iterable
-from mcpacker.format.datapack import DataPack
 from mcpacker.model.resourceid import ResourceId
 from mcpacker.model.world import World
 from mcpacker.model.mod import Mod
-from mcpacker.format.resourcepack import ResourcePack
 from typing import Callable
 from typing import Self
 
@@ -22,16 +20,12 @@ class ModPack:
         name:str,
         mods:Iterable[Mod]|None=None,
         world:World|None=None,
-        dataPack:DataPack|None=None,
-        resourcePack:ResourcePack|None=None,
         disabledFeatures:Iterable[ResourceId]|None=None
     ):
         self.name = name
 
-        self.dataPack = dataPack or DataPack(self.name)
         self.mods = {mod.name: mod for mod in (mods or [])}
         self.disabledFeatures = list(disabledFeatures or [])
-        self.resourcePack = resourcePack or ResourcePack(self.name)
         self.world = world or World()
 
     def augment(self, doAugment:AugmentFunc) -> Self:

mcpacker/model/spawnbuilder.py

@@ -32,6 +32,13 @@ class SpawnBuilder[SpawnableKind:Spawnable, EcotypeKind:Ecotype, SpawnKind:Spawn
         self._spawnable = spawnable
         return self
 
+    def switch(self, spawnable:SpawnableKind) -> Self:
+        biomeFilters = self.biomeFilters
+        self._reset()
+        self._biomeFilters = biomeFilters
+        self._spawnable = spawnable
+        return self
+
     def save(self, name:str) -> Self:
         if not self._spawnable: raise RuntimeError("you must call start before save")
 

mcpacker/model/world.py

@@ -1,51 +1,56 @@
-from mcpacker.model.ecology.biomecatalog import BiomeCatalog
+from mcpacker.model.catalog import Catalog
-from mcpacker.model.fauna.mobcatalog import MobCatalog
+from mcpacker.model.ecology.biome import Biome
-from mcpacker.model.fauna.mobspawncatalog import MobSpawnCatalog
+from mcpacker.model.fauna.mob import Mob
-from mcpacker.model.flora.plantcatalog import PlantCatalog
+from mcpacker.model.fauna.mobspawn import MobSpawn
-from mcpacker.model.flora.plantspawncatalog import PlantSpawnCatalog
+from mcpacker.model.flora.plant import Plant
-from mcpacker.model.geology.depositcatalog import DepositCatalog
+from mcpacker.model.flora.plantspawn import PlantSpawn
-from mcpacker.model.geology.mineralcatalog import MineralCatalog
+from mcpacker.model.geology.mineral import Mineral
-from mcpacker.model.material.blockcatalog import BlockCatalog
+from mcpacker.model.geology.mineralspawn import MineralSpawn
-from mcpacker.model.material.itemcatalog import ItemCatalog
+from mcpacker.model.material.block import Block
+from mcpacker.model.material.item import Item
 
 
 # Class ############################################################################################
 
 class World:
 
-    def __init__(
+    def __init__(self):
-        self,
+        self.biomes = Catalog[Biome]()
-        biomes:BiomeCatalog|None=None,
+        self.blocks = Catalog[Block]()
-        blocks:BlockCatalog|None=None,
+        self.items = Catalog[Item]()
-        deposits:DepositCatalog|None=None,
+        self.minerals = Catalog[Mineral]()
-        items:ItemCatalog|None=None,
+        self.mineralSpawns = Catalog[MineralSpawn]()
-        minerals:MineralCatalog|None=None,
+        self.mobs = Catalog[Mob]()
-        mobs:MobCatalog|None=None,
+        self.mobSpawns = Catalog[MobSpawn]()
-        mobSpawns:MobSpawnCatalog|None=None,
+        self.plants = Catalog[Plant]()
-        plants:PlantCatalog|None=None,
+        self.plantSpawns = Catalog[PlantSpawn]()
-        plantSpawns:PlantSpawnCatalog|None=None,
+
-    ):
+    def __str__(self) -> str:
-        self.biomes = biomes or BiomeCatalog()
+        return (
-        self.blocks = blocks or BlockCatalog()
+            "World("
-        self.deposits = deposits or DepositCatalog()
+                f"{len(self.biomes)} biomes, "
-        self.items = items or ItemCatalog()
+                f"{len(self.blocks)} blocks, "
-        self.minerals = minerals or MineralCatalog()
+                f"{len(self.items)} items, "
-        self.mobs = mobs or MobCatalog()
+                f"{len(self.minerals)} minerals, "
-        self.mobSpawns = mobSpawns or MobSpawnCatalog()
+                f"{len(self.mineralSpawns)} mineralSpawns, "
-        self.plants = plants or PlantCatalog()
+                f"{len(self.mobs)} mobs, "
-        self.plantSpawns = plantSpawns or PlantSpawnCatalog()
+                f"{len(self.mobSpawns)} mobSpawns, "
+                f"{len(self.plants)} plants, "
+                f"{len(self.plantSpawns)} plantSpawns"
+            ")"
+        )
 
     def __repr__(self) -> str:
-        return "".join([
+        return (
-            "World(",
+            "World("
-                "biomes=", repr(self.biomes), ", ",
+                f"biomes={self.biomes!r}, "
-                "blocks=", repr(self.blocks), ", ",
+                f"blocks={self.blocks!r}, "
-                "deposits=", repr(self.deposits), ", ",
+                f"items={self.items!r}, "
-                "items=", repr(self.items), ", ",
+                f"minerals={self.minerals!r}, "
-                "minerals=", repr(self.minerals), ", ",
+                f"mineralSpawns={self.mineralSpawns!r}, "
-                "mobs=", repr(self.mobs), ", ",
+                f"mobs={self.mobs!r}, "
-                "mobSpawns=", repr(self.mobSpawns), ", ",
+                f"mobSpawns={self.mobSpawns!r}, "
-                "plants=", repr(self.plants), ", ",
+                f"plants={self.plants!r}, "
-                "plantSpawns=", repr(self.plantSpawns),
+                f"plantSpawns={self.plantSpawns!r}"
             ")"
-        ])
+        )

mcpacker/pack/mysteriousisland/addbiomes.py

@@ -14,94 +14,122 @@ import mcpacker.model.ecology.water as WA
 def addBiomes(pack:ModPack):
     biomes = pack.world.biomes
 
-    biomes.add(Biome("aberdeen", "minecraft:windswept_gravelly_hills",
+    biomes.add(Biome("tombstone", "minecraft:badlands",
-        FL.BARREN, GE.METAMORPHIC, HE.BOREAL, HU.DAMP, SO.ROCKY, WA.INLAND
+        FL.BARREN, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.ARID, SO.CLAYEY, WA.INLAND
     ))
 
-    biomes.add(Biome("archangel", "minecraft:frozen_ocean",
+    biomes.add(Biome("rangoon", "minecraft:bamboo_jungle",
-        FL.BARREN, GE.SEDIMENTARY, HE.FROZEN, HU.WET, SO.SANDY, WA.OCEAN
+        FL.FOREST, GE.SEDIMENTARY, HE.TROPICAL, HU.WET, SO.ACIDIC, WA.INLAND
     ))
 
-    biomes.add(Biome("aspen", "minecraft:frozen_peaks",
+    biomes.add(Biome("nice", "minecraft:beach",
-        FL.BARREN, GE.IGNEOUS, HE.FROZEN, HU.WET, SO.ROCKY, WA.INLAND
+        FL.BARREN, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.DAMP, SO.SANDY, WA.COAST
     ))
 
-    biomes.add(Biome("bombay", "minecraft:lukewarm_ocean",
+    biomes.add(Biome("helsinki", "minecraft:birch_forest",
-        FL.BARREN, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.WET, SO.SANDY, WA.OCEAN
+        FL.FOREST, GE.SEDIMENTARY, HE.TEMPERATE, HU.WET, SO.ACIDIC, WA.INLAND
+    ))
+
+    biomes.add(Biome("tokyo", "minecraft:cherry_grove",
+        FL.CLEARING, GE.SEDIMENTARY, HE.TEMPERATE, HU.DAMP, SO.ROCKY, WA.INLAND
     ))
 
     biomes.add(Biome("boston", "minecraft:cold_ocean",
-        FL.BARREN, GE.SEDIMENTARY, HE.BOREAL, HU.WET, SO.CLAYEY, WA.OCEAN
+        FL.BARREN, GE.SEDIMENTARY, HE.BOREAL, HU.DAMP, SO.CLAYEY, WA.OCEAN
-    ))
-
-    biomes.add(Biome("bryce", "minecraft:eroded_badlands",
-        FL.BARREN, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.DRY, SO.CLAYEY, WA.INLAND
-    ))
-
-    biomes.add(Biome("calcutta", "minecraft:mangrove_swamp",
-        FL.FOREST, GE.SEDIMENTARY, HE.TROPICAL, HU.WET, SO.CLAYEY, WA.SWAMP
-    ))
-
-    biomes.add(Biome("cornwall", "minecraft:windswept_hills",
-        FL.BARREN, GE.METAMORPHIC, HE.BOREAL, HU.DAMP, SO.ROCKY, WA.INLAND
-    ))
-
-    biomes.add(Biome("dakar", "minecraft:savanna",
-        FL.FIELD, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.DRY, SO.SANDY, WA.INLAND
-    ))
-
-    biomes.add(Biome("duluth", "minecraft:frozen_river",
-        FL.BARREN, GE.SEDIMENTARY, HE.FROZEN, HU.WET, SO.SANDY, WA.RIVER
-    ))
-
-    biomes.add(Biome("khartoum", "minecraft:savanna_plateau",
-        FL.FIELD, GE.IGNEOUS, HE.SUBTROPICAL, HU.DRY, SO.SANDY, WA.INLAND
     ))
 
     biomes.add(Biome("freiburg", "minecraft:dark_forest",
-        FL.CANOPY, GE.SEDIMENTARY, HE.TEMPERATE, HU.WET, SO.CLAYEY, WA.INLAND
+        FL.CANOPY, GE.METAMORPHIC, HE.TEMPERATE, HU.SOAKED, SO.CLAYEY, WA.INLAND
-    ))
-
-    biomes.add(Biome("glasgow", "minecraft:windswept_forest",
-        FL.CLEARING, GE.METAMORPHIC, HE.BOREAL, HU.DAMP, SO.ACIDIC, WA.INLAND
-    ))
-
-    biomes.add(Biome("haarlem", "minecraft:flower_forest",
-        FL.CLEARING, GE.SEDIMENTARY, HE.TEMPERATE, HU.DAMP, SO.LOAMY, WA.INLAND
     ))
 
     biomes.add(Biome("halifax", "minecraft:deep_cold_ocean",
-        FL.BARREN, GE.SEDIMENTARY, HE.BOREAL, HU.WET, SO.SANDY, WA.OCEAN
+        FL.BARREN, GE.METAMORPHIC, HE.BOREAL, HU.WET, SO.CLAYEY, WA.OCEAN
+    ))
+
+    biomes.add(Biome("tromso", "minecraft:deep_frozen_ocean",
+        FL.BARREN, GE.METAMORPHIC, HE.FROZEN, HU.DAMP, SO.CLAYEY, WA.OCEAN
+    ))
+
+    biomes.add(Biome("havana", "minecraft:deep_lukewarm_ocean",
+        FL.BARREN, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.WET, SO.CLAYEY, WA.OCEAN
+    ))
+
+    biomes.add(Biome("auckland", "minecraft:deep_ocean",
+        FL.BARREN, GE.IGNEOUS, HE.TEMPERATE, HU.DAMP, SO.CLAYEY, WA.OCEAN
+    ))
+
+    biomes.add(Biome("timbuktu", "minecraft:desert",
+        FL.BARREN, GE.SEDIMENTARY, HE.TROPICAL, HU.ARID, SO.SANDY, WA.INLAND
+    ))
+
+    biomes.add(Biome("canoncity", "minecraft:eroded_badlands",
+        FL.BARREN, GE.IGNEOUS, HE.SUBTROPICAL, HU.ARID, SO.ROCKY, WA.INLAND
+    ))
+
+    biomes.add(Biome("haarlem", "minecraft:flower_forest",
+        FL.CLEARING, GE.SEDIMENTARY, HE.TEMPERATE, HU.WET, SO.LOAMY, WA.INLAND
+    ))
+
+    biomes.add(Biome("sherwood", "minecraft:forest",
+        FL.FOREST, GE.SEDIMENTARY, HE.TEMPERATE, HU.WET, SO.LOAMY, WA.INLAND
+    ))
+
+    biomes.add(Biome("archangel", "minecraft:frozen_ocean",
+        FL.BARREN, GE.IGNEOUS, HE.FROZEN, HU.DAMP, SO.SANDY, WA.OCEAN
+    ))
+
+    biomes.add(Biome("chamonix", "minecraft:frozen_peaks",
+        FL.BARREN, GE.IGNEOUS, HE.FROZEN, HU.DAMP, SO.ROCKY, WA.INLAND
+    ))
+
+    biomes.add(Biome("winnipeg", "minecraft:frozen_river",
+        FL.BARREN, GE.IGNEOUS, HE.FROZEN, HU.DAMP, SO.SANDY, WA.RIVER
+    ))
+
+    biomes.add(Biome("umea", "minecraft:grove",
+        FL.CLEARING, GE.METAMORPHIC, HE.FROZEN, HU.DAMP, SO.ACIDIC, WA.INLAND
     ))
 
     biomes.add(Biome("hammerfest", "minecraft:ice_spikes",
         FL.BARREN, GE.METAMORPHIC, HE.FROZEN, HU.WET, SO.ROCKY, WA.INLAND
     ))
 
-    biomes.add(Biome("havana", "minecraft:deep_lukewarm_ocean",
+    biomes.add(Biome("jackson", "minecraft:jagged_peaks",
-        FL.BARREN, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.WET, SO.SANDY, WA.OCEAN
+        FL.BARREN, GE.METAMORPHIC, HE.BOREAL, HU.DRY, SO.ROCKY, WA.INLAND
     ))
 
-    biomes.add(Biome("tahiti", "minecraft:mushroom_fields",
+    biomes.add(Biome("singapore", "minecraft:jungle",
-        FL.CLEARING, GE.IGNEOUS, HE.TROPICAL, HU.WET, SO.FUNGAL, WA.INLAND
+        FL.CANOPY, GE.IGNEOUS, HE.TROPICAL, HU.SOAKED, SO.ACIDIC, WA.INLAND
     ))
 
-    biomes.add(Biome("honolulu", "minecraft:deep_ocean",
+    biomes.add(Biome("bombay", "minecraft:lukewarm_ocean",
-        FL.BARREN, GE.IGNEOUS, HE.TEMPERATE, HU.WET, SO.SANDY, WA.OCEAN
+        FL.BARREN, GE.IGNEOUS, HE.SUBTROPICAL, HU.WET, SO.SANDY, WA.OCEAN
+    ))
+
+    biomes.add(Biome("calcutta", "minecraft:mangrove_swamp",
+        FL.FOREST, GE.SEDIMENTARY, HE.TROPICAL, HU.SOAKED, SO.CLAYEY, WA.SWAMP
     ))
 
     biomes.add(Biome("innsbruck", "minecraft:meadow",
-        FL.FIELD, GE.IGNEOUS, HE.BOREAL, HU.DAMP, SO.LOAMY, WA.INLAND
+        FL.FIELD, GE.METAMORPHIC, HE.BOREAL, HU.DAMP, SO.LOAMY, WA.INLAND
     ))
 
-    biomes.add(Biome("irkutsk", "minecraft:taiga",
+    biomes.add(Biome("krakatoa", "minecraft:mushroom_fields",
+        FL.CLEARING, GE.IGNEOUS, HE.TROPICAL, HU.WET, SO.FUNGAL, WA.INLAND
+    ))
+
+    biomes.add(Biome("sanfrancisco", "minecraft:ocean",
+        FL.BARREN, GE.IGNEOUS, HE.TEMPERATE, HU.DAMP, SO.SANDY, WA.OCEAN
+    ))
+
+    biomes.add(Biome("minsk", "minecraft:old_growth_birch_forest",
+        FL.FOREST, GE.SEDIMENTARY, HE.TEMPERATE, HU.WET, SO.SANDY, WA.INLAND
+    ))
+
+    biomes.add(Biome("stpetersburg", "minecraft:old_growth_pine_taiga",
         FL.FOREST, GE.METAMORPHIC, HE.BOREAL, HU.DAMP, SO.ACIDIC, WA.INLAND
     ))
 
-    biomes.add(Biome("jackson", "minecraft:jagged_peaks",
-        FL.BARREN, GE.METAMORPHIC, HE.BOREAL, HU.DRY, SO.ROCKY, WA.INLAND
-    ))
-
     biomes.add(Biome("juneau", "minecraft:old_growth_spruce_taiga",
         FL.FOREST, GE.METAMORPHIC, HE.BOREAL, HU.DAMP, SO.PEATY, WA.INLAND
     ))
@@ -110,106 +138,78 @@ def addBiomes(pack:ModPack):
         FL.FIELD, GE.SEDIMENTARY, HE.TEMPERATE, HU.DAMP, SO.LOAMY, WA.INLAND
     ))
 
-    biomes.add(Biome("kola", "minecraft:snowy_taiga",
-        FL.FOREST, GE.METAMORPHIC, HE.FROZEN, HU.DAMP, SO.ACIDIC, WA.INLAND
-    ))
-
-    biomes.add(Biome("kyoto", "minecraft:cherry_grove",
-        FL.CLEARING, GE.SEDIMENTARY, HE.TEMPERATE, HU.DAMP, SO.ROCKY, WA.INLAND
-    ))
-
-    biomes.add(Biome("madras", "minecraft:sparse_jungle",
-        FL.CLEARING, GE.SEDIMENTARY, HE.TROPICAL, HU.WET, SO.ACIDIC, WA.INLAND
-    ))
-
     biomes.add(Biome("memphis", "minecraft:river",
         FL.BARREN, GE.SEDIMENTARY, HE.TEMPERATE, HU.WET, SO.SANDY, WA.RIVER
     ))
 
-    biomes.add(Biome("minsk", "minecraft:old_growth_birch_forest",
+    biomes.add(Biome("katanga", "minecraft:savanna",
-        FL.FOREST, GE.SEDIMENTARY, HE.TEMPERATE, HU.DAMP, SO.ACIDIC, WA.INLAND
+        FL.FIELD, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.DRY, SO.SANDY, WA.INLAND
     ))
 
-    biomes.add(Biome("moab", "minecraft:windswept_savanna",
+    biomes.add(Biome("khartoum", "minecraft:savanna_plateau",
-        FL.FIELD, GE.IGNEOUS, HE.SUBTROPICAL, HU.DRY, SO.ROCKY, WA.INLAND
+        FL.FIELD, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.DRY, SO.SANDY, WA.INLAND
-    ))
-
-    biomes.add(Biome("mobile", "minecraft:swamp",
-        FL.CLEARING, GE.SEDIMENTARY, HE.TEMPERATE, HU.WET, SO.PEATY, WA.SWAMP
-    ))
-
-    biomes.add(Biome("moscow", "minecraft:snowy_plains",
-        FL.FIELD, GE.SEDIMENTARY, HE.FROZEN, HU.DAMP, SO.PEATY, WA.INLAND
-    ))
-
-    biomes.add(Biome("nassau", "minecraft:warm_ocean",
-        FL.BARREN, GE.SEDIMENTARY, HE.TROPICAL, HU.WET, SO.SANDY, WA.COAST
-    ))
-
-    biomes.add(Biome("nice", "minecraft:beach",
-        FL.BARREN, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.DAMP, SO.SANDY, WA.COAST
     ))
 
     biomes.add(Biome("nuuk", "minecraft:snowy_beach",
-        FL.BARREN, GE.SEDIMENTARY, HE.FROZEN, HU.DAMP, SO.SANDY, WA.COAST
+        FL.BARREN, GE.METAMORPHIC, HE.FROZEN, HU.DAMP, SO.SANDY, WA.COAST
     ))
 
-    biomes.add(Biome("perm", "minecraft:old_growth_pine_taiga",
+    biomes.add(Biome("rovaniemi", "minecraft:snowy_plains",
-        FL.FOREST, GE.METAMORPHIC, HE.BOREAL, HU.DAMP, SO.ACIDIC, WA.INLAND
+        FL.FIELD, GE.SEDIMENTARY, HE.FROZEN, HU.DAMP, SO.PEATY, WA.INLAND
     ))
 
-    biomes.add(Biome("timbuktu", "minecraft:desert",
+    biomes.add(Biome("zurich", "minecraft:snowy_slopes",
-        FL.BARREN, GE.SEDIMENTARY, HE.TROPICAL, HU.DRY, SO.SANDY, WA.INLAND
+        FL.BARREN, GE.METAMORPHIC, HE.FROZEN, HU.DAMP, SO.ROCKY, WA.INLAND
     ))
 
-    biomes.add(Biome("plymouth", "minecraft:stony_shore",
+    biomes.add(Biome("kola", "minecraft:snowy_taiga",
-        FL.BARREN, GE.METAMORPHIC, HE.TEMPERATE, HU.DAMP, SO.ROCKY, WA.COAST
+        FL.FOREST, GE.METAMORPHIC, HE.FROZEN, HU.DAMP, SO.ACIDIC, WA.INLAND
     ))
 
-    biomes.add(Biome("sherwood", "minecraft:forest",
+    biomes.add(Biome("madras", "minecraft:sparse_jungle",
-        FL.FOREST, GE.SEDIMENTARY, HE.TEMPERATE, HU.DAMP, SO.LOAMY, WA.INLAND
+        FL.CLEARING, GE.METAMORPHIC, HE.TROPICAL, HU.SOAKED, SO.ACIDIC, WA.INLAND
     ))
 
     biomes.add(Biome("quito", "minecraft:stony_peaks",
         FL.BARREN, GE.IGNEOUS, HE.BOREAL, HU.DRY, SO.ROCKY, WA.INLAND
     ))
 
-    biomes.add(Biome("rangoon", "minecraft:bamboo_jungle",
+    biomes.add(Biome("plymouth", "minecraft:stony_shore",
-        FL.FOREST, GE.SEDIMENTARY, HE.TROPICAL, HU.WET, SO.ACIDIC, WA.INLAND
+        FL.BARREN, GE.METAMORPHIC, HE.TEMPERATE, HU.DAMP, SO.ROCKY, WA.COAST
     ))
 
-    biomes.add(Biome("sanfrancisco", "minecraft:ocean",
+    biomes.add(Biome("stlouis", "minecraft:sunflower_plains",
-        FL.BARREN, GE.SEDIMENTARY, HE.TEMPERATE, HU.WET, SO.SANDY, WA.OCEAN
+        FL.FIELD, GE.SEDIMENTARY, HE.TEMPERATE, HU.DAMP, SO.SANDY, WA.INLAND
+    ))
+
+    biomes.add(Biome("neworleans", "minecraft:swamp",
+        FL.CLEARING, GE.SEDIMENTARY, HE.TEMPERATE, HU.SOAKED, SO.PEATY, WA.SWAMP
+    ))
+
+    biomes.add(Biome("irkutsk", "minecraft:taiga",
+        FL.FOREST, GE.IGNEOUS, HE.BOREAL, HU.DAMP, SO.ACIDIC, WA.INLAND
+    ))
+
+    biomes.add(Biome("nassau", "minecraft:warm_ocean",
+        FL.BARREN, GE.SEDIMENTARY, HE.TROPICAL, HU.SOAKED, SO.SANDY, WA.COAST
+    ))
+
+    biomes.add(Biome("stirling", "minecraft:windswept_forest",
+        FL.CLEARING, GE.SEDIMENTARY, HE.BOREAL, HU.DAMP, SO.ACIDIC, WA.INLAND
+    ))
+
+    biomes.add(Biome("inverness", "minecraft:windswept_gravelly_hills",
+        FL.BARREN, GE.METAMORPHIC, HE.BOREAL, HU.DRY, SO.ROCKY, WA.INLAND
+    ))
+
+    biomes.add(Biome("cornwall", "minecraft:windswept_hills",
+        FL.BARREN, GE.IGNEOUS, HE.BOREAL, HU.DRY, SO.ROCKY, WA.INLAND
+    ))
+
+    biomes.add(Biome("moab", "minecraft:windswept_savanna",
+        FL.FIELD, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.DRY, SO.ROCKY, WA.INLAND
     ))
 
     biomes.add(Biome("santafe", "minecraft:wooded_badlands",
         FL.CLEARING, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.DRY, SO.CLAYEY, WA.INLAND
     ))
-
-    biomes.add(Biome("singapore", "minecraft:jungle",
-        FL.CANOPY, GE.SEDIMENTARY, HE.TROPICAL, HU.WET, SO.ACIDIC, WA.INLAND
-    ))
-
-    biomes.add(Biome("tombstone", "minecraft:badlands",
-        FL.BARREN, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.DRY, SO.CLAYEY, WA.INLAND
-    ))
-
-    biomes.add(Biome("stlouis", "minecraft:sunflower_plains",
-        FL.FIELD, GE.SEDIMENTARY, HE.TEMPERATE, HU.DAMP, SO.LOAMY, WA.INLAND
-    ))
-
-    biomes.add(Biome("tromso", "minecraft:deep_frozen_ocean",
-        FL.BARREN, GE.SEDIMENTARY, HE.FROZEN, HU.WET, SO.SANDY, WA.OCEAN
-    ))
-
-    biomes.add(Biome("umea", "minecraft:grove",
-        FL.CLEARING, GE.METAMORPHIC, HE.FROZEN, HU.DAMP, SO.ACIDIC, WA.INLAND
-    ))
-
-    biomes.add(Biome("warsaw", "minecraft:birch_forest",
-        FL.FOREST, GE.SEDIMENTARY, HE.TEMPERATE, HU.DAMP, SO.ACIDIC, WA.INLAND
-    ))
-
-    biomes.add(Biome("zurich", "minecraft:snowy_slopes",
-        FL.BARREN, GE.METAMORPHIC, HE.FROZEN, HU.DAMP, SO.ROCKY, WA.INLAND
-    ))

mcpacker/pack/mysteriousisland/adddatapack.py

@@ -1,8 +0,0 @@
-from mcpacker.model.modpack import ModPack
-from mcpacker.format.datapack import DataPack
-
-
-# Functions ########################################################################################
-
-def addDataPack(modPack:ModPack):
-    pass

mcpacker/pack/mysteriousisland/adddatapack_test.py

@@ -1,7 +0,0 @@
-import mcpacker.pack.mysteriousisland.adddatapack
-
-
-# Tests ############################################################################################
-
-def test_syntax():
-    pass

mcpacker/pack/mysteriousisland/adddeposits.py

@@ -1,246 +0,0 @@
-from mcpacker.model.ecology.biomefilter import BiomeFilter as BF
-from mcpacker.model.geology.deposit.geodedeposit import GeodeDeposit
-from mcpacker.model.geology.deposit.mineraldeposit import MineralDeposit
-from mcpacker.model.geology.inclusion import Inclusion as I
-from mcpacker.model.modpack import ModPack
-
-import mcpacker.model.altitude as AL
-import mcpacker.model.ecology.flora as FL
-import mcpacker.model.ecology.geology as GE
-import mcpacker.model.ecology.heat as HE
-import mcpacker.model.ecology.humidity as HU
-import mcpacker.model.ecology.soil as SO
-import mcpacker.model.ecology.water as WA
-import mcpacker.model.geology.bulk as BU
-import mcpacker.model.geology.proportion as PR
-import mcpacker.model.scarcity as SC
-
-
-# Catalog ##########################################################################################
-
-def addDeposits(pack:ModPack):
-    minerals = pack.world.minerals
-    deposits = pack.world.deposits
-
-    # Geode Deposits ###########################################################
-
-    deposits.add(GeodeDeposit(
-        name = "geode_amethyst",
-        altitude = AL.span(AL.MANTLE, AL.CRUST),
-        # TODO: these filter exclude all biomes
-        biomeFilters = BF([GE.IGNEOUS, HE.TEMPERATE, HU.DAMP]),
-        scarcity = SC.UNCOMMON,
-    ))
-
-    deposits.add(GeodeDeposit(
-        name = "geode_kimberlite",
-        altitude = AL.span(AL.MANTLE, AL.CRUST),
-        biomeFilters = BF([GE.IGNEOUS, SO.ROCKY, WA.INLAND]),
-        scarcity = SC.SPARSE,
-    ))
-
-    deposits.add(MineralDeposit(
-        name = "hydrothermal_emerald",
-        altitude = AL.span(AL.CRUST, AL.SUBSTRATE),
-        biomeFilters = BF([HE.FROZEN, GE.METAMORPHIC, SO.ROCKY]),
-        scarcity = SC.UNCOMMON,
-    ))
-
-    # Metal Deposits ###########################################################
-
-    deposits.add(MineralDeposit(
-        name = "bif_iron",
-        altitude = AL.span(AL.CRUST, AL.SUBSTRATE),
-        biomeFilters = BF([FL.FIELD, HE.SUBTROPICAL, HU.DRY]),
-        bulk = BU.LARGE,
-        inclusions = [
-            I(minerals["iron"], 50),
-            I(minerals["quartz"], 45),
-            I(minerals["uranium"], 5)
-        ],
-        proportion = PR.BED,
-        scarcity = SC.UNCOMMON,
-    ))
-
-    deposits.add(MineralDeposit(
-        name = "epithermal_silver",
-        altitude = AL.span(AL.OVERBURDEN, AL.SUBSTRATE),
-        biomeFilters = BF([(HE.BOREAL, HE.FROZEN), SO.ROCKY, GE.IGNEOUS]),
-        bulk = BU.SMALL,
-        inclusions = [I(minerals["silver"], 75), I(minerals["gold"], 25)],
-        proportion = PR.PIPE,
-        scarcity = SC.RARE,
-    ))
-
-    deposits.add(MineralDeposit(
-        name = "greisen_tin",
-        altitude = AL.span(AL.OVERBURDEN, AL.SUBSTRATE),
-        biomeFilters = BF([HE.BOREAL, SO.ROCKY, GE.METAMORPHIC]),
-        bulk = BU.MEDIUM,
-        inclusions = [I(minerals["tin"], 100)],
-        proportion = PR.STOCK,
-        scarcity = SC.COMMON,
-    ))
-
-    deposits.add(MineralDeposit(
-        name = "laterite_aluminum",
-        altitude = AL.span(AL.DUNES, AL.UPLANDS),
-        biomeFilters = BF([FL.within(FL.CANOPY, FL.CLEARING), HU.WET, HE.TROPICAL, GE.SEDIMENTARY]),
-        bulk = BU.MEDIUM,
-        inclusions = [I(minerals["aluminum"], 70), I(minerals["nickel"], 30)],
-        proportion = PR.LENS,
-        scarcity = SC.UNCOMMON,
-    ))
-
-    deposits.add(MineralDeposit(
-        name = "mvt_lead",
-        altitude = AL.span(AL.CRUST, AL.SUBSTRATE),
-        biomeFilters = [
-            BF([FL.FIELD, GE.SEDIMENTARY, HE.TEMPERATE, HU.DAMP]),
-            BF([GE.SEDIMENTARY, HE.TEMPERATE, SO.CLAYEY]),
-        ],
-        bulk = BU.MEDIUM,
-        inclusions = [
-            I(minerals["lead"], 45),
-            I(minerals["zinc"], 40),
-            I(minerals["silver"], 15),
-        ],
-        proportion = PR.LODE,
-        scarcity = SC.SPARSE,
-    ))
-
-    deposits.add(MineralDeposit(
-        name = "porphyry_copper",
-        altitude = AL.span(AL.MANTLE, AL.OVERBURDEN),
-        biomeFilters = BF([GE.SEDIMENTARY, HE.SUBTROPICAL, HU.DRY, SO.CLAYEY]),
-        bulk = BU.LARGE,
-        inclusions = [
-            I(minerals["copper"], 55),
-            I(minerals["redstone"], 25),
-            I(minerals["gold"], 20),
-        ],
-        proportion = PR.PIPE,
-        scarcity = SC.UNUSUAL,
-    ))
-
-    deposits.add(MineralDeposit(
-        name = "sedimentary_iron",
-        altitude = AL.span(AL.OVERBURDEN, AL.SOIL),
-        biomeFilters = BF([SO.PEATY]),
-        bulk = BU.LARGE,
-        inclusions = [I(minerals["iron"], 100)],
-        proportion = PR.LODE,
-        scarcity = SC.COMMON,
-    ))
-
-    deposits.add(MineralDeposit(
-        name = "serpentine_nickel",
-        altitude = AL.span(AL.UPLANDS, AL.HILLS),
-        biomeFilters = BF([GE.METAMORPHIC, HU.DAMP, SO.ACIDIC]),
-        bulk = BU.SMALL,
-        inclusions = [I(minerals["nickel"], 70), I(minerals["iron"], 30)],
-        proportion = PR.LENS,
-        scarcity = SC.UNCOMMON,
-    ))
-
-    # Mineral Deposits #########################################################
-
-    deposits.add(MineralDeposit(
-        name = "evaporite_salt",
-        altitude = AL.EVAPORITES,
-        biomeFilters = BF([HE.TROPICAL, HU.DRY, SO.SANDY]),
-        bulk = BU.TINY,
-        inclusions = [I(minerals["salt"], 100)],
-        proportion = PR.BED,
-        scarcity = SC.SPARSE,
-    ))
-
-    deposits.add(MineralDeposit(
-        name = "evaporite_nitrate",
-        altitude = AL.EVAPORITES,
-        biomeFilters = BF([FL.BARREN, HE.SUBTROPICAL, HU.DRY, SO.CLAYEY]),
-        bulk = BU.TINY,
-        inclusions = [I(minerals["nitrate"], 100)],
-        proportion = PR.BED,
-        scarcity = SC.SPARSE,
-    ))
-
-    deposits.add(MineralDeposit(
-        name = "fumarole_sulfur",
-        altitude = AL.CRUST,
-        biomeFilters = BF([GE.IGNEOUS, SO.ROCKY, WA.INLAND]),
-        bulk = BU.MEDIUM,
-        inclusions = [I(minerals["sulfur"], 100)],
-        proportion = PR.VENT,
-        scarcity = SC.UNUSUAL,
-    ))
-
-    deposits.add(MineralDeposit(
-        name = "sedimentary_redbed",
-        altitude = AL.span(AL.SOIL, AL.HILLS),
-        biomeFilters = BF([GE.SEDIMENTARY, HE.SUBTROPICAL, HU.DRY, SO.CLAYEY]),
-        bulk = BU.SMALL,
-        inclusions = [I(minerals["redstone"], 80), I(minerals["iron"], 20)],
-        proportion = PR.BED,
-        scarcity = SC.UNCOMMON,
-    ))
-
-    deposits.add(MineralDeposit(
-        name = "skarn_lapis",
-        altitude = AL.CRUST,
-        biomeFilters = BF([GE.METAMORPHIC, HE.BOREAL, SO.ROCKY]),
-        bulk = BU.LARGE,
-        inclusions = [
-            I(minerals["greywacke"], 50),
-            I(minerals["lapis"], 25),
-            I(minerals["diorite"], 10),
-            I(minerals["quartz"], 10),
-            I(minerals["iron"], 5),
-        ],
-        proportion = PR.LENS,
-        scarcity = SC.SPARSE,
-    ))
-
-    deposits.add(MineralDeposit(
-        name = "vein_quartz",
-        altitude = AL.span(AL.SUBSTRATE, AL.OVERBURDEN),
-        biomeFilters = BF([HE.TROPICAL, HU.DRY, SO.SANDY]),
-        bulk = BU.MEDIUM,
-        inclusions = [I(minerals["quartz"], 95), I(minerals["gold"], 5)],
-        proportion = PR.LODE,
-        scarcity = SC.UNUSUAL,
-    ))
-
-    # Organic Deposits #########################################################
-
-    deposits.add(MineralDeposit(
-        name = "bed_loam",
-        altitude = AL.span(AL.SOIL),
-        biomeFilters = BF([HE.TEMPERATE, HU.DAMP, SO.LOAMY]),
-        bulk = BU.TINY,
-        inclusions = [I(minerals["loam"], 100)],
-        proportion = PR.BED,
-        scarcity = SC.COMMON,
-    ))
-
-    deposits.add(MineralDeposit(
-        name = "seam_bituminouscoal",
-        altitude = AL.span(AL.CRUST, AL.OVERBURDEN),
-        biomeFilters = [
-            BF([HE.BOREAL, GE.METAMORPHIC, (SO.ACIDIC, SO.ROCKY)]),
-        ],
-        bulk = BU.HUGE,
-        inclusions = [I(minerals["coal"], 100)],
-        proportion = PR.BED,
-        scarcity = SC.COMMON,
-    ))
-
-    deposits.add(MineralDeposit(
-        name = "seam_peatcoal",
-        altitude = AL.span(AL.SOIL),
-        biomeFilters = BF([SO.PEATY]),
-        bulk = BU.LARGE,
-        inclusions = [I(minerals["peat"], 100)],
-        proportion = PR.BED,
-        scarcity = SC.COMMON,
-    ))

mcpacker/pack/mysteriousisland/adddeposits_test.py

@@ -1,7 +0,0 @@
-import mcpacker.pack.mysteriousisland.adddeposits
-
-
-# Class ############################################################################################
-
-def test_syntax():
-    pass

mcpacker/pack/mysteriousisland/adddisabledfeatures.py

@@ -10,6 +10,7 @@ def addDisabledFeatures(pack:ModPack):
         pack.disabledFeatures.append(ResourceId.parse(resourceText))
 
     # Disable vanilla ore generation
+    add("minecraft:amethyst_geode")
     add("minecraft:ore_coal_lower")
     add("minecraft:ore_coal_upper")
     add("minecraft:ore_copper_large")

mcpacker/pack/mysteriousisland/addminerals.py

@@ -1,5 +1,4 @@
 from mcpacker.model.geology.mineral import Mineral
-from mcpacker.model.geology.mineralcatalog import MineralCatalog
 from mcpacker.model.geology.replacement import Replacement
 from mcpacker.model.modpack import ModPack
 
@@ -21,6 +20,12 @@ def makeMineral(name:str, blockId:str, deepslateBlockId:None|str=None) -> Minera
         Replacement.inDeepslate(blockId)
     ])
 
+def makeEvaporate(name:str, blockId:str) -> Mineral:
+    return Mineral(name, [
+        Replacement("minecraft:sand", blockId),
+        Replacement("minecraft:sandstone", blockId)
+    ])
+
 def makeOreMineral(name:str) -> Mineral:
     return Mineral(name, [
         Replacement.inStone(f"{name}_ore"),
@@ -45,30 +50,43 @@ def makeRailcraftOreMineral(name:str) -> Mineral:
 def addMinerals(pack:ModPack):
     minerals = pack.world.minerals
 
-    # Basic Ores
+    # Metals
-    minerals.add(makeOreMineral("coal"))
+    minerals.add(makeImmersiveEngineeringOreMineral("aluminum"))
+    minerals.add(makeImmersiveEngineeringOreMineral("lead"))
+    minerals.add(makeImmersiveEngineeringOreMineral("nickel"))
+    minerals.add(makeImmersiveEngineeringOreMineral("silver"))
+    minerals.add(makeImmersiveEngineeringOreMineral("uranium"))
     minerals.add(makeOreMineral("copper"))
-    minerals.add(makeOreMineral("diamond"))
-    minerals.add(makeOreMineral("emerald"))
     minerals.add(makeOreMineral("gold"))
     minerals.add(makeOreMineral("iron"))
-    minerals.add(makeOreMineral("lapis"))
+    minerals.add(makeRailcraftOreMineral("tin"))
-    minerals.add(makeOreMineral("redstone"))
+    minerals.add(makeRailcraftOreMineral("zinc"))
 
-    # Crystals
+    # Organic Minerals
+    minerals.add(makeOreMineral("coal"))
+    minerals.add(makeMineral("peat", "kubejs:peat_block"))
+    minerals.add(makeMineral("loam", "farmersdelight:rich_soil"))
+
+    # Industrial Minerals
+    minerals.add(makeEvaporate("salt", "butcher:saltblock"))
+    minerals.add(makeRailcraftOreMineral("sulfur"))
+    minerals.add(makeEvaporate("nitrate", f"{RC}:saltpeter_ore"))
+
+    # Crystaline Minerals
     minerals.add(makeMineral("amethyst", "amethyst_block"))
     minerals.add(makeMineral("glowstone", "glowstone"))
     minerals.add(makeMineral("quartz", f"{OQ}:quartz_ore", f"{OQ}:deepslate_quartz_ore"))
-    minerals.add(makeMineral("salt",       "butcher:saltblock"))
+    minerals.add(makeOreMineral("diamond"))
+    minerals.add(makeOreMineral("emerald"))
+    minerals.add(makeOreMineral("lapis"))
+    minerals.add(makeOreMineral("redstone"))
 
     # Earth, gravel, etc.
     minerals.add(makeMineral("clay", "clay"))
     minerals.add(makeMineral("coarsedirt", "coarse_dirt"))
     minerals.add(makeMineral("dirt", "dirt"))
     minerals.add(makeMineral("gravel", "gravel"))
-    minerals.add(makeMineral("loam",       "farmersdelight:rich_soil"))
     minerals.add(makeMineral("packedice", "packed_ice"))
-    minerals.add(makeMineral("peat",       "kubejs:peat_block"))
     minerals.add(makeMineral("redsand", "redsand"))
     minerals.add(makeMineral("sand", "sand"))
     minerals.add(makeMineral("soulsand", "soulsand"))
@@ -88,24 +106,7 @@ def addMinerals(pack:ModPack):
     minerals.add(makeMineral("limestone", "dripstone_block"))
     minerals.add(makeMineral("magma", "magma_block"))
     minerals.add(makeMineral("marble", f"{RC}:quarried_stone"))
-    minerals.add(makeMineral("netherite",  "ancient_debris"))
     minerals.add(makeMineral("obsidian", "obsidian"))
     minerals.add(makeMineral("pumice", "netherrack"))
     minerals.add(makeMineral("sandstone", "sandstone"))
     minerals.add(makeMineral("tuff", "tuff"))
-
-    # Immersive Engineering Ores
-    minerals.add(makeImmersiveEngineeringOreMineral("aluminum"))
-    minerals.add(makeImmersiveEngineeringOreMineral("lead"))
-    minerals.add(makeImmersiveEngineeringOreMineral("nickel"))
-    minerals.add(makeImmersiveEngineeringOreMineral("silver"))
-    minerals.add(makeImmersiveEngineeringOreMineral("uranium"))
-
-    # Railcraft Ores
-    minerals.add(Mineral("nitrate", [
-        Replacement("sand", f"{RC}:saltpeter_ore"),
-        Replacement("sandstone", f"{RC}:saltpeter_ore"),
-    ]))
-    minerals.add(makeRailcraftOreMineral("sulfur"))
-    minerals.add(makeRailcraftOreMineral("tin"))
-    minerals.add(makeRailcraftOreMineral("zinc"))

mcpacker/pack/mysteriousisland/addmineralspawns.py

@@ -0,0 +1,251 @@
+from mcpacker.model.ecology.biomefilter import BiomeFilter as BF
+from mcpacker.model.geology.mineralspawnbuilder import MineralSpawnBuilder
+from mcpacker.model.modpack import ModPack
+
+import mcpacker.model.altitude as AL
+import mcpacker.model.ecology.flora as FL
+import mcpacker.model.ecology.geology as GE
+import mcpacker.model.ecology.heat as HE
+import mcpacker.model.ecology.humidity as HU
+import mcpacker.model.ecology.soil as SO
+import mcpacker.model.ecology.water as WA
+import mcpacker.model.geology.bulk as BU
+import mcpacker.model.geology.deposittype as DE
+import mcpacker.model.scarcity as SC
+
+# Helper Functions #################################################################################
+
+def addMineralSpawns(pack:ModPack):
+    minerals = pack.world.minerals
+    b = MineralSpawnBuilder(pack.world.mineralSpawns)
+
+    # Aluminum Family ##########################################################
+
+    b.start(minerals["basalt"])
+    b.biomeFilters = BF([HE.TROPICAL, HU.SOAKED, WA.INLAND])
+    b.save("aluminum-indicator")
+
+    b.switch(minerals["aluminum"])
+    b.altitude = AL.span(AL.SUBSTRATE, AL.OVERBURDEN)
+    b.bulk = BU.HUGE
+    b.depositType = DE.STRATA
+    b.scarcity = SC.COMMON
+    b.save("aluminum-primary-aluminum")
+
+    b.switch(minerals["nickel"])
+    b.altitude = AL.span(AL.OVERBURDEN, AL.CRUST)
+    b.bulk = BU.SMALL
+    b.scarcity = SC.UNCOMMON
+    b.save("aluminum-secondary-nickel")
+
+    b.switch(minerals["amethyst"])
+    b.altitude = AL.CRUST
+    b.bulk = BU.TINY
+    b.scarcity = SC.RARE
+    b.save("aluminum-tertiary-amethyst")
+
+    # Coal Family ##############################################################
+
+    b.start(minerals["tuff"])
+    b.biomeFilters = BF([GE.SEDIMENTARY, HE.TEMPERATE, HU.SOAKED])
+    b.save("coal-indicator")
+
+    b.switch(minerals["coal"])
+    b.altitude = AL.span(AL.SUBSTRATE, AL.OVERBURDEN)
+    b.bulk = BU.LARGE
+    b.depositType = DE.STRATA
+    b.scarcity = SC.COMMON
+    b.save("coal-primary-coal")
+
+    b.switch(minerals["sulfur"])
+    b.altitude = AL.CRUST
+    b.bulk = BU.SMALL
+    b.scarcity = SC.SPARSE
+    b.save("coal-secondary-sulfur")
+
+    b.switch(minerals["iron"])
+    b.altitude = AL.span(AL.CRUST, AL.MANTLE)
+    b.bulk = BU.SMALL
+    b.scarcity = SC.UNUSUAL
+    b.save("coal-tertiary-iron")
+
+    # Copper Family ############################################################
+
+    b.start(minerals["diorite"])
+    b.biomeFilters = BF([GE.SEDIMENTARY, HE.SUBTROPICAL, HU.DRY])
+    b.save("copper-indicator")
+
+    b.switch(minerals["copper"])
+    b.altitude = AL.CRUST
+    b.bulk = BU.MEDIUM
+    b.scarcity = SC.UNCOMMON
+    b.save("copper-primary-copper")
+
+    b.switch(minerals["redstone"])
+    b.altitude = AL.MANTLE
+    b.bulk = BU.SMALL
+    b.scarcity = SC.UNUSUAL
+    b.save("copper-secondary-redstone")
+
+    b.switch(minerals["gold"])
+    b.altitude = AL.span(AL.CRUST, AL.MANTLE)
+    b.bulk = BU.TINY
+    b.scarcity = SC.RARE
+    b.save("copper-tertiary-gold")
+
+    # Gold Family ##############################################################
+
+    b.start(minerals["marble"])
+    b.biomeFilters = BF([GE.METAMORPHIC, HE.BOREAL, HU.DRY])
+    b.save("gold-indicator")
+
+    b.start(minerals["quartz"])
+    b.altitude = AL.span(AL.CRAGS, AL.PEAKS)
+    b.bulk = BU.MEDIUM
+    b.scarcity = SC.SPARSE
+    b.save("gold-primary-quartz")
+
+    b.switch(minerals["lapis"])
+    b.altitude = AL.span(AL.CRUST, AL.MANTLE)
+    b.bulk = BU.SMALL
+    b.scarcity = SC.UNUSUAL
+    b.save("gold-secondary-lapis")
+
+    b.switch(minerals["gold"])
+    b.altitude = AL.CRUST
+    b.bulk = BU.TINY
+    b.scarcity = SC.RARE
+    b.save("gold-tertiary-gold")
+
+    b.switch(minerals["emerald"])
+    b.altitude = AL.MANTLE
+    b.bulk = BU.TINY
+    b.scarcity = SC.RARE
+    b.save("gold-quarternary-emerald")
+
+    # Iron Family ##############################################################
+
+    b.start(minerals["andesite"])
+    b.biomeFilters = BF([GE.SEDIMENTARY, HE.TEMPERATE, HU.WET])
+    b.save("iron-indicator")
+
+    b.start(minerals["iron"])
+    b.altitude = AL.CRUST
+    b.bulk = BU.MEDIUM
+    b.scarcity = SC.COMMON
+    b.save("iron-primary-iron")
+
+    b.switch(minerals["quartz"])
+    b.altitude = AL.CRUST
+    b.bulk = BU.SMALL
+    b.scarcity = SC.UNUSUAL
+    b.save("iron-secondary-quartz")
+
+    b.switch(minerals["uranium"])
+    b.altitude = AL.MANTLE
+    b.bulk = BU.TINY
+    b.scarcity = SC.RARE
+    b.save("iron-tertiary-uranium")
+
+    # Lead Family ##############################################################
+
+    b.start(minerals["dolostone"])
+    b.biomeFilters = BF([GE.SEDIMENTARY, HE.TEMPERATE, HU.DAMP])
+    b.save("lead-indicator")
+
+    b.start(minerals["lead"])
+    b.altitude = AL.CRUST
+    b.bulk = BU.MEDIUM
+    b.scarcity = SC.SPARSE
+    b.save("lead-primary-lead")
+
+    b.switch(minerals["zinc"])
+    b.altitude = AL.CRUST
+    b.bulk = BU.SMALL
+    b.scarcity = SC.SPARSE
+    b.save("lead-secondary-zinc")
+
+    b.switch(minerals["silver"])
+    b.altitude = AL.span(AL.CRUST, AL.MANTLE)
+    b.bulk = BU.SMALL
+    b.scarcity = SC.UNUSUAL
+    b.save("lead-tertiary-silver")
+
+    # Plutonic Family ##########################################################
+
+    b.start(minerals["sulfur"])
+    b.altitude = AL.PLUTONIC
+    b.save("plutonic-special-sulfur")
+
+    b.switch(minerals["glowstone"])
+    b.save("plutonic-special-glowstone")
+
+    b.switch(minerals["diamond"])
+    b.save("plutonic-special-diamond")
+
+    # Salt Family ##############################################################
+
+    b.start(minerals["chalk"])
+    b.biomeFilters = BF([GE.SEDIMENTARY, HE.TROPICAL, HU.ARID])
+    b.save("salt-indicator")
+
+    b.switch(minerals["salt"])
+    b.altitude = AL.span(AL.CRUST, AL.MANTLE)
+    b.bulk = BU.LARGE
+    b.depositType = DE.STRATA
+    b.scarcity = SC.UNCOMMON
+    b.save("salt-primary-salt")
+
+    b.switch(minerals["nitrate"])
+    b.altitude = AL.EVAPORITES
+    b.bulk = BU.SMALL
+    b.depositType = DE.DISK
+    b.scarcity = SC.UNCOMMON
+    b.save("salt-secondary-nitrate")
+
+    # Soil Family ##############################################################
+
+    b.start(minerals["loam"])
+    b.altitude = AL.SOIL
+    b.bulk = BU.HUGE
+    b.biomeFilters = BF([SO.LOAMY])
+    b.scarcity = SC.CARPET
+    b.save("soil-special-loam")
+
+    b.start(minerals["peat"])
+    b.altitude = AL.SOIL
+    b.bulk = BU.LARGE
+    b.biomeFilters = BF([SO.PEATY])
+    b.scarcity = SC.COMMON
+    b.save("soil-special-peat")
+
+    # Tin Family ###############################################################
+
+    b.start(minerals["granite"])
+    b.biomeFilters = BF([GE.IGNEOUS, HE.BOREAL, HU.DRY])
+    b.save("tin-indicator")
+
+    b.switch(minerals["tin"])
+    b.altitude = AL.CRUST
+    b.bulk = BU.MEDIUM
+    b.scarcity = SC.SPARSE
+    b.save("tin-primary-tin")
+
+    b.switch(minerals["copper"])
+    b.altitude = AL.span(AL.CRUST, AL.MANTLE)
+    b.bulk = BU.SMALL
+    b.scarcity = SC.UNUSUAL
+    b.save("tin-secondary-copper")
+
+"""
+
+        vein    strata
+absent      0       0
+rare        0.024   0.5
+unusual     0.12    2.0
+sparse      0.3     5.0
+uncommon    0.61    10.0
+common      1.83    25.0
+carpet      3.66    60.0
+
+"""

mcpacker/pack/mysteriousisland/addplantspawns.py

@@ -27,25 +27,25 @@ def addPlantSpawns(pack:ModPack):
     b.altitude = AL.span(AL.LOWLANDS, AL.HILLS)
     b.biomeFilters = BF([FL.CANOPY, HE.TEMPERATE])
     b.scarcity = SC.SPARSE
-    b.save("")
+    b.save("athelas")
 
     b.start(plants["beetroot"])
     b.altitude = AL.LOWLANDS
     b.biomeFilters = BF([FL.FOREST, HE.BOREAL, SO.ACIDIC])
     b.scarcity = SC.COMMON
-    b.save("")
+    b.save("beetroot")
 
     b.start(plants["bellpepper"])
     b.altitude = AL.LOWLANDS
     b.biomeFilters = BF([FL.CLEARING, HE.TROPICAL, HU.WET, WA.INLAND])
     b.scarcity = SC.COMMON
-    b.save("")
+    b.save("bellpepper")
 
     b.start(plants["blueberry"])
     b.altitude = AL.span(AL.UPLANDS, AL.ALPINE)
     b.biomeFilters = BF([FL.within(FL.FOREST, FL.FIELD), HE.BOREAL])
     b.scarcity = SC.SPARSE
-    b.save("")
+    b.save("blueberry")
 
     b.start(plants["brownmushroom"])
     b.altitude = AL.span(AL.SOIL, AL.ALPINE)
@@ -55,13 +55,13 @@ def addPlantSpawns(pack:ModPack):
         BF([SO.FUNGAL]),
     ]
     b.scarcity = SC.COMMON
-    b.save("")
+    b.save("brownmushroom")
 
     b.start(plants["cabbage"])
     b.altitude = AL.HILLS
     b.biomeFilters = BF([(HE.SUBTROPICAL, HE.TEMPERATE), SO.SANDY, WA.COAST])
     b.scarcity = SC.COMMON
-    b.save("")
+    b.save("cabbage")
 
     b.start(plants["carrot"])
     b.altitude = AL.LOWLANDS
@@ -69,37 +69,37 @@ def addPlantSpawns(pack:ModPack):
         [(FL.FOREST, FL.CLEARING), HE.TEMPERATE, SO.LOAMY], [ResourceId.parse("flower_forest")],
     )
     b.scarcity = SC.COMMON
-    b.save("")
+    b.save("carrot")
 
     b.start(plants["coffee"])
     b.altitude = AL.span(AL.HILLS, AL.ALPINE)
     b.biomeFilters = BF([FL.CANOPY, HE.TROPICAL, HU.WET])
     b.scarcity = SC.SPARSE
-    b.save("")
+    b.save("coffee")
 
     b.start(plants["corn"])
     b.altitude = AL.span(AL.LOWLANDS, AL.UPLANDS)
     b.biomeFilters = BF([FL.FIELD, HE.SUBTROPICAL, (SO.LOAMY, SO.SANDY)])
     b.scarcity = SC.COMMON
-    b.save("")
+    b.save("corn")
 
     b.start(plants["cotton"])
     b.altitude = AL.LOWLANDS
     b.biomeFilters = BF([FL.FIELD, HE.SUBTROPICAL, HU.DRY, (SO.LOAMY, SO.SANDY)])
     b.scarcity = SC.UNCOMMON
-    b.save("")
+    b.save("cotton")
 
     b.start(plants["currant"])
     b.altitude = AL.span(AL.UPLANDS, AL.ALPINE)
     b.biomeFilters = BF([FL.within(FL.FOREST, FL.FIELD), (HE.BOREAL, HE.FROZEN)])
     b.scarcity = SC.UNCOMMON
-    b.save("")
+    b.save("currant")
 
     b.start(plants["cranberry"])
     b.altitude = AL.DUNES
     b.biomeFilters = BF([HU.WET, SO.PEATY])
     b.scarcity = SC.UNCOMMON
-    b.save("")
+    b.save("cranberry")
 
     # NOTE: Due to a bug in Supplementaries, flax can *only* be planted on sand, despite the actual
     #       plant requiring an entirely different soil. Therefore, we're imaginging *this* so-called
@@ -108,13 +108,13 @@ def addPlantSpawns(pack:ModPack):
     b.altitude = AL.DUNES
     b.biomeFilters = BF([FL.BARREN, HU.DRY, SO.SANDY])
     b.scarcity = SC.COMMON
-    b.save("")
+    b.save("flax")
 
     b.start(plants["hamimelon"])
     b.altitude = AL.span(AL.LOWLANDS, AL.UPLANDS)
     b.biomeFilters = BF([FL.FIELD, HE.SUBTROPICAL, HU.DRY, (SO.LOAMY, SO.SANDY)])
     b.scarcity = SC.RARE
-    b.save("")
+    b.save("hamimelon")
 
     b.start(plants["hemp"])
     b.altitude = AL.span(AL.DUNES, AL.UPLANDS)
@@ -122,25 +122,25 @@ def addPlantSpawns(pack:ModPack):
         [FL.FIELD, HE.TEMPERATE, HU.DAMP, SO.LOAMY], [ResourceId.parse("sunflower_plains")]
     ),
     b.scarcity = SC.UNCOMMON
-    b.save("")
+    b.save("hemp")
 
     b.start(plants["lemon"])
     b.altitude = AL.UPLANDS
     b.biomeFilters = BF([FL.FIELD, HE.SUBTROPICAL, HU.DRY])
     b.scarcity = SC.SPARSE
-    b.save("")
+    b.save("lemon")
 
     b.start(plants["melon"])
     b.altitude = AL.LOWLANDS
     b.biomeFilters = BF([FL.CLEARING, HE.TROPICAL, HU.WET], [SO.FUNGAL])
     b.scarcity = SC.SPARSE
-    b.save("")
+    b.save("melon")
 
     b.start(plants["onion"])
     b.altitude = AL.span(AL.UPLANDS, AL.HILLS)
     b.biomeFilters = BF([FL.FOREST, HE.TEMPERATE, HU.DAMP, SO.ACIDIC])
     b.scarcity = SC.SPARSE
-    b.save("")
+    b.save("onion")
 
     # NOTE: Due to a bug in Fruits Delight, pineapple can *only* be planted on sand: despite this
     #       in now way reflecting the plant's actual ecology. As such, we have to imagine these as
@@ -150,19 +150,19 @@ def addPlantSpawns(pack:ModPack):
     b.biomeFilters = BF([FL.BARREN, HE.TROPICAL, HU.DRY, SO.SANDY])
     b.scarcity = SC.SPARSE
     # TODO: add sand as substrate in addplants.py
-    b.save("")
+    b.save("pineapple")
 
     b.start(plants["potato"])
     b.altitude = AL.span(AL.UPLANDS, AL.HILLS)
     b.biomeFilters = BF([FL.FOREST, HE.BOREAL, HU.DAMP, SO.ACIDIC])
     b.scarcity = SC.UNCOMMON
-    b.save("")
+    b.save("potato")
 
     b.start(plants["pumpkin"])
     b.altitude = AL.LOWLANDS
     b.biomeFilters = BF([FL.FIELD, HE.TEMPERATE, SO.LOAMY])
     b.scarcity = SC.UNUSUAL
-    b.save("")
+    b.save("pumpkin")
 
     b.start(plants["redmushroom"])
     b.altitude = AL.span(AL.SOIL, AL.ALPINE)
@@ -172,37 +172,37 @@ def addPlantSpawns(pack:ModPack):
         BF([SO.FUNGAL]),
     ]
     b.scarcity = SC.UNCOMMON
-    b.save("")
+    b.save("redmushroom")
 
     b.start(plants["rice"])
     b.altitude = AL.SURFACE
     b.biomeFilters = BF([(HE.SUBTROPICAL, HE.TEMPERATE), (WA.RIVER, WA.SWAMP)])
     b.scarcity = SC.COMMON
-    b.save("")
+    b.save("rice")
 
     b.start(plants["sugarcane"])
     b.altitude = AL.DUNES
     b.biomeFilters = BF([(HE.TROPICAL, HE.TEMPERATE), (WA.RIVER, WA.SWAMP)])
     b.scarcity = SC.COMMON
-    b.save("")
+    b.save("sugarcane")
 
     b.start(plants["sunflower"])
     b.altitude = AL.span(AL.LOWLANDS, AL.UPLANDS)
     b.biomeFilters = BF([ResourceId.parse("sunflower_plains")])
     b.scarcity = SC.CARPET
-    b.save("")
+    b.save("sunflower")
 
     b.start(plants["tomato"])
     b.altitude = AL.span(AL.UPLANDS, AL.HILLS)
     b.biomeFilters = BF([FL.CLEARING, HE.TROPICAL, HU.WET], [SO.FUNGAL])
     b.scarcity = SC.UNCOMMON
-    b.save("")
+    b.save("tomato")
 
     b.start(plants["wheat"])
     b.altitude = AL.span(AL.LOWLANDS, AL.UPLANDS)
     b.biomeFilters = BF([FL.FIELD, HE.TEMPERATE, HU.DAMP, SO.LOAMY])
     b.scarcity = SC.COMMON
-    b.save("")
+    b.save("wheat")
 
     # Flower Patches ###########################################################
 
@@ -210,31 +210,31 @@ def addPlantSpawns(pack:ModPack):
     b.altitude = AL.span(AL.UPLANDS, AL.HILLS)
     b.biomeFilters = BF([FL.FOREST, HE.TEMPERATE, HU.DAMP, SO.ACIDIC])
     b.scarcity = SC.UNCOMMON
-    b.save("")
+    b.save("allium")
 
     b.start(plants["azurebluet"])
     b.altitude = AL.span(AL.UPLANDS, AL.ALPINE)
     b.biomeFilters = BF([FL.FIELD, (HE.TEMPERATE, HE.BOREAL), HU.DAMP, (SO.LOAMY, SO.PEATY)])
     b.scarcity = SC.SPARSE
-    b.save("")
+    b.save("azurebluet")
 
     b.start(plants["blueorchid"])
     b.altitude = AL.span(AL.LOWLANDS, AL.UPLANDS)
     b.biomeFilters = BF([FL.CANOPY, HE.TROPICAL, HU.WET])
     b.scarcity = SC.RARE
-    b.save("")
+    b.save("blueorchid")
 
     b.start(plants["cornflower"])
     b.altitude = AL.span(AL.UPLANDS, AL.ALPINE)
     b.biomeFilters = BF([FL.FIELD, HE.TEMPERATE, (SO.LOAMY, SO.PEATY)])
     b.scarcity = SC.COMMON
-    b.save("")
+    b.save("cornflower")
 
     b.start(plants["daisy"])
     b.altitude = AL.span(AL.UPLANDS, AL.ALPINE)
     b.biomeFilters = BF([FL.FIELD, (HE.TEMPERATE, HE.BOREAL)])
     b.scarcity = SC.UNCOMMON
-    b.save("")
+    b.save("daisy")
 
     b.start(plants["dandelion"])
     b.altitude = AL.span(AL.DUNES, AL.HILLS)
@@ -243,25 +243,25 @@ def addPlantSpawns(pack:ModPack):
         [HE.FROZEN, HU.WET, SO.FUNGAL, SO.ROCKY, ResourceId.parse("flower_forest")]
     )
     b.scarcity = SC.COMMON
-    b.save("")
+    b.save("dandelion")
 
     b.start(plants["lilac"])
     b.altitude = AL.LOWLANDS
     b.biomeFilters = BF([FL.FOREST, HE.TEMPERATE, HU.DAMP, SO.LOAMY])
     b.scarcity = SC.UNUSUAL
-    b.save("")
+    b.save("lilac")
 
     b.start(plants["lily"])
     b.altitude = AL.span(AL.LOWLANDS, AL.UPLANDS)
     b.biomeFilters = BF([FL.FOREST, (HE.TEMPERATE, HE.BOREAL), HU.DAMP, SO.ACIDIC])
     b.scarcity = SC.RARE
-    b.save("")
+    b.save("lily")
 
     b.start(plants["peony"])
     b.altitude = AL.LOWLANDS
     b.biomeFilters = BF([FL.CLEARING, HE.TEMPERATE, HU.DAMP, SO.ROCKY])
     b.scarcity = SC.SPARSE
-    b.save("")
+    b.save("peony")
 
     b.start(plants["poppy"])
     b.altitude = AL.span(AL.DUNES, AL.UPLANDS)
@@ -270,43 +270,43 @@ def addPlantSpawns(pack:ModPack):
         [SO.FUNGAL]
     ),
     b.scarcity = SC.SPARSE
-    b.save("")
+    b.save("poppy")
 
     b.start(plants["rose_black"])
     b.altitude = AL.HILLS
     b.biomeFilters = BF([FL.CANOPY, HE.TEMPERATE])
     b.scarcity = SC.RARE
-    b.save("")
+    b.save("rose_black")
 
     b.start(plants["rose_bush"])
     b.altitude = AL.span(AL.UPLANDS, AL.ALPINE)
     b.biomeFilters = BF([FL.FOREST, (HE.TEMPERATE, HE.BOREAL), SO.LOAMY])
     b.scarcity = SC.UNUSUAL
-    b.save("")
+    b.save("rose_bush")
 
     b.start(plants["tulip_orange"])
     b.altitude = AL.span(AL.DUNES, AL.LOWLANDS)
     b.biomeFilters = BF([ResourceId.parse("flower_forest")])
     b.scarcity = SC.UNUSUAL
-    b.save("")
+    b.save("tulip_orange")
 
     b.start(plants["tulip_pink"])
     b.altitude = AL.span(AL.DUNES, AL.LOWLANDS)
     b.biomeFilters = BF([ResourceId.parse("flower_forest")])
     b.scarcity = SC.SPARSE
-    b.save("")
+    b.save("tulip-pink")
 
     b.start(plants["tulip_red"])
     b.altitude = AL.span(AL.DUNES, AL.LOWLANDS)
     b.biomeFilters = BF([ResourceId.parse("flower_forest")])
     b.scarcity = SC.COMMON
-    b.save("")
+    b.save("tulip-red")
 
     b.start(plants["tulip_white"])
     b.altitude = AL.span(AL.DUNES, AL.LOWLANDS)
     b.biomeFilters = BF([ResourceId.parse("flower_forest")])
     b.scarcity = SC.UNCOMMON
-    b.save("")
+    b.save("tulip-white")
 
     # Trees ####################################################################
 
@@ -317,37 +317,37 @@ def addPlantSpawns(pack:ModPack):
         [ResourceId.parse("flower_forest")],
     )
     b.scarcity = SC.SPARSE
-    b.save("")
+    b.save("apple-tree")
 
     b.start(plants["bayberry"])
     b.altitude = AL.span(AL.DUNES, AL.UPLANDS)
     b.biomeFilters = BF([HE.TEMPERATE, (SO.ROCKY, SO.SANDY), WA.COAST])
     b.scarcity = SC.SPARSE
-    b.save("")
+    b.save("bayberry-tree")
 
     b.start(plants["durian"])
     b.altitude = AL.HILLS
     b.biomeFilters = BF([FL.within(FL.CANOPY, FL.CLEARING), HE.TROPICAL, HU.WET, SO.ACIDIC])
     b.scarcity = SC.UNUSUAL
-    b.save("")
+    b.save("durian-tree")
 
     b.start(plants["fig"])
     b.altitude = AL.span(AL.UPLANDS, AL.HILLS)
     b.biomeFilters = BF([HE.SUBTROPICAL, HU.DRY, SO.SANDY], [FL.BARREN])
     b.scarcity = SC.UNCOMMON
-    b.save("")
+    b.save("fig-tree")
 
     b.start(plants["hawberry"])
     b.altitude = AL.span(AL.UPLANDS, AL.HILLS)
     b.biomeFilters = BF([(FL.FOREST, FL.CLEARING), HE.TEMPERATE, (SO.ACIDIC, SO.LOAMY)])
     b.scarcity = SC.SPARSE
-    b.save("")
+    b.save("hawberry-tree")
 
     b.start(plants["lychee"])
     b.altitude = AL.UPLANDS
     b.biomeFilters = BF([FL.CLEARING, HE.TROPICAL, HU.WET], [SO.FUNGAL])
     b.scarcity = SC.SPARSE
-    b.save("")
+    b.save("lychee-tree")
 
     b.start(plants["mango"])
     b.altitude = AL.LOWLANDS
@@ -355,34 +355,34 @@ def addPlantSpawns(pack:ModPack):
         [FL.within(FL.CANOPY, FL.CLEARING), HE.TROPICAL, (HU.DAMP, HU.WET), SO.ACIDIC]
     )
     b.scarcity = SC.UNCOMMON
-    b.save("")
+    b.save("mango-tree")
 
     b.start(plants["mangosteen"])
     b.altitude = AL.UPLANDS
     b.biomeFilters = BF([FL.CANOPY, HE.TROPICAL, HU.WET, SO.ACIDIC])
     b.scarcity = SC.UNUSUAL
-    b.save("")
+    b.save("mangosteen-tree")
 
     b.start(plants["orange"])
     b.altitude = AL.LOWLANDS
     b.biomeFilters = BF([FL.FIELD, HE.SUBTROPICAL, HU.DRY])
     b.scarcity = SC.SPARSE
-    b.save("")
+    b.save("orange-tree")
 
     b.start(plants["peach"])
     b.altitude = AL.span(AL.LOWLANDS, AL.UPLANDS)
     b.biomeFilters = BF([FL.CLEARING, HE.TEMPERATE, HU.DAMP, SO.ROCKY])
     b.scarcity = SC.UNCOMMON
-    b.save("")
+    b.save("peach-tree")
 
     b.start(plants["pear"])
     b.altitude = AL.span(AL.LOWLANDS, AL.UPLANDS)
     b.biomeFilters = BF([FL.CLEARING, HE.TEMPERATE, HU.DAMP, (SO.ACIDIC, SO.LOAMY)])
     b.scarcity = SC.UNCOMMON
-    b.save("")
+    b.save("pear-tree")
 
     b.start(plants["persimmon"])
     b.altitude = AL.span(AL.LOWLANDS, AL.UPLANDS)
     b.biomeFilters = BF([FL.FOREST, HE.TEMPERATE, SO.LOAMY])
     b.scarcity = SC.UNCOMMON
-    b.save("")
+    b.save("persimmon-tree")

mcpacker/pack/mysteriousisland/addresourcepack.py

@@ -1,8 +0,0 @@
-from mcpacker.model.modpack import ModPack
-from mcpacker.format.resourcepack import ResourcePack
-
-
-# Functions ########################################################################################
-
-def addResourcePack(modPack:ModPack):
-    pass

mcpacker/pack/mysteriousisland/addresourcepack_test.py

@@ -1,7 +0,0 @@
-import mcpacker.pack.mysteriousisland.addresourcepack
-
-
-# Tests ############################################################################################
-
-def test_syntax():
-    pass

mcpacker/pack/mysteriousisland/modpack.py

@@ -1,14 +1,12 @@
 from mcpacker.model.modpack import ModPack
 from mcpacker.pack.mysteriousisland.addbiomes import addBiomes
 from mcpacker.pack.mysteriousisland.addblocks import addBlocks
-from mcpacker.pack.mysteriousisland.adddatapack import addDataPack
-from mcpacker.pack.mysteriousisland.adddeposits import addDeposits
 from mcpacker.pack.mysteriousisland.adddisabledfeatures import addDisabledFeatures
 from mcpacker.pack.mysteriousisland.additems import addItems
 from mcpacker.pack.mysteriousisland.addminerals import addMinerals
+from mcpacker.pack.mysteriousisland.addmineralspawns import addMineralSpawns
 from mcpacker.pack.mysteriousisland.addmobs import addMobs
 from mcpacker.pack.mysteriousisland.addmobspawns import addMobSpawns
-from mcpacker.pack.mysteriousisland.addresourcepack import addResourcePack
 from mcpacker.pack.mysteriousisland.addplants import addPlants
 from mcpacker.pack.mysteriousisland.addplantspawns import addPlantSpawns
 
@@ -23,13 +21,11 @@ def buildModPack():
     pack.augment(addItems)
     pack.augment(addBlocks)
     pack.augment(addMinerals)
-    pack.augment(addDeposits)
+    pack.augment(addMineralSpawns)
     pack.augment(addPlants)
     pack.augment(addPlantSpawns)
     pack.augment(addMobs)
     pack.augment(addMobSpawns)
     pack.augment(addDisabledFeatures)
-    pack.augment(addResourcePack)
-    pack.augment(addDataPack)
 
     return pack