Add remaining mineral deposits

* update repr results to yield valid Python
* update biome report to display deposits
* add deposit report

mcpacker/format/report/biomereport.py

@@ -9,12 +9,30 @@ class BiomeReport(ReportComposer):
 
     def doCompose(self):
         for biome in self.pack.world.biomes:
-            self.line(f"# Biome: {biome.gameId} ({biome.city})")
+            self.line(f"Biome: {biome.gameId} ({biome.city})")
             self.line()
 
             self.indent()
+            needsDelimiter = False
+            self.text("Traits: ")
             for trait in biome.traits():
-                self.text("* ").line(trait)
+                if needsDelimiter: self.text(", ")
-            self.outdent()
+                needsDelimiter = True
+                self.text(trait)
+            self.line()
 
             self.line()
+            self.line("Deposits:")
+            self.indent()
+            depositCount = 0
+            for deposit in self.pack.world.deposits:
+                if not deposit.acceptsBiome(biome): continue
+                self.line(deposit.name)
+                depositCount += 1
+
+            if depositCount == 0:
+                self.line("<no deposits>")
+            self.outdent()
+
+            self.outdent()
+            self.line()

mcpacker/format/report/biomereport_test.py

@@ -48,21 +48,17 @@ def createReport(pack:ModPack):
 
 def test_report(report):
     assert str(report).strip() == textwrap.dedent("""
-        # Biome: minecraft:plains (kansascity)
+        Biome: minecraft:plains (kansascity)
 
-          * Flora: field
+            Traits: field, sedimentary, temperate, damp, loamy, inland
-          * Geology: sedimentary
-          * Heat: temperate
-          * Humidity: damp
-          * Soil: loamy
-          * Water: inland
 
-        # Biome: minecraft:savanna (dallas)
+            Deposits:
+                <no deposits>
 
-          * Flora: field
+        Biome: minecraft:savanna (dallas)
-          * Geology: sedimentary
+
-          * Heat: subtropical
+            Traits: field, sedimentary, subtropical, dry, sandy, inland
-          * Humidity: dry
+
-          * Soil: sandy
+            Deposits:
-          * Water: inland
+                <no deposits>
     """).strip()

mcpacker/format/report/composer.py

@@ -6,6 +6,6 @@ from mcpacker.model.modpack import ModPack
 
 class ReportComposer(TextComposer):
 
-    def __init__(self, pack:ModPack, indentText:str="  "):
+    def __init__(self, pack:ModPack):
-        super().__init__(indentText)
+        super().__init__()
         self.pack = pack

mcpacker/format/report/depositreport.py

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

mcpacker/format/report/depositreport_test.py

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

mcpacker/format/report/mineralreport.py

@@ -9,12 +9,12 @@ 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}")
             self.line()
 
             self.indent()
             for replacement in mineral.replacements:
-                self.text("* ").line(str(replacement))
+                self.line(str(replacement))
             self.outdent()
 
             self.line()

mcpacker/format/report/mineralreport_test.py

@@ -38,13 +38,13 @@ def createReport(pack:ModPack):
 
 def test_report(report:MineralReport):
     assert str(report).strip() == textwrap.dedent("""
-        # Mineral: copper
+        Mineral: copper
 
-          * #minecraft:stone_replaceables => minecraft:copper_ore
+            #minecraft:stone_replaceables => minecraft:copper_ore
-          * #minecraft:deepslate_replaceables => minecraft:deepslate_copper_ore
+            #minecraft:deepslate_replaceables => minecraft:deepslate_copper_ore
 
-        # Mineral: iron
+        Mineral: iron
 
-          * #minecraft:stone_replaceables => minecraft:iron_ore
+            #minecraft:stone_replaceables => minecraft:iron_ore
-          * #minecraft:deepslate_replaceables => minecraft:deepslate_iron_ore
+            #minecraft:deepslate_replaceables => minecraft:deepslate_iron_ore
     """).strip()

mcpacker/format/report/mobspawnreport.py

@@ -10,37 +10,23 @@ class MobSpawnReport(ReportComposer):
 
     def doCompose(self):
         for spawn in self.pack.world.mobSpawns:
-            self.line(f"# Mob: {spawn.gameId}")
+            self.line(f"Mob: {spawn.gameId}")
             self.line()
 
             self.indent()
+            needsDelimiter = False
             for index, habitat in enumerate(spawn.habitats, start=1):
-                self.text("* habitat ").line(index)
+                if needsDelimiter: self.line()
+                needsDelimiter = True
+
+                self.text("Habitat ").line(index)
                 self.indent()
-                self.text("* altitude: ").line(habitat.altitude)
+                self.text("altitude: ").line(habitat.altitude)
-                self.line("* biomeFilter:")
+                self.text("biomeFilter: ").line(habitat.biomeFilter)
-
+                self.text("seasons: ").line(", ".join([str(s) for s in habitat.seasons]))
-                self.indent()
+                self.text("group: ").line(habitat.group)
-                for trait in habitat.biomeFilter.required:
+                self.text("location: ").line(habitat.location)
-                    if isinstance(trait, BiomeTrait):
+                self.text("scarcity: ").line(habitat.scarcity)
-                        self.text("* ").line(trait)
-                    else:
-                        category = type(trait[0]).__name__
-                        self.text("* ").\
-                            text(category).\
-                            text(": any of: ").\
-                            line(", ".join([t.name for t in trait]))
-
-                for trait in habitat.biomeFilter.prohibited:
-                    category = type(trait).__name__
-                    self.text("* ").text(category).text(": not: ").line(trait.name)
-
-                self.outdent()
-
-                self.text("* seasons: ").line(", ".join([s.name for s in habitat.seasons]))
-                self.text("* group: ").line(habitat.group.name)
-                self.text("* location: ").line(habitat.location.name)
-                self.text("* scarcity: ").line(habitat.scarcity.name)
                 self.outdent()
 
             self.outdent()

mcpacker/format/report/mobspawnreport_test.py

@@ -69,26 +69,21 @@ def createReport(pack:ModPack):
 
 def test_write(report:MobSpawnReport):
     assert str(report).strip() == textwrap.dedent("""
-        # Mob: minecraft:chicken
+        Mob: minecraft:chicken
 
-          * habitat 1
+            Habitat 1
-            * altitude: lowlands-uplands
+                altitude: lowlands to uplands (70 to 124)
-            * biomeFilter:
+                biomeFilter: tropical and wet and (canopy or forest or clearing)
-              * Heat: tropical
+                seasons: summer
-              * Humidity: wet
+                group: troup (3 to 6)
-              * Flora: any of: canopy, forest, clearing
+                location: outside
-            * seasons: summer
+                scarcity: common
-            * group: troup
+
-            * location: outside
+            Habitat 2
-            * scarcity: common
+                altitude: lowlands to uplands (70 to 124)
-          * habitat 2
+                biomeFilter: tropical and wet and (canopy or forest or clearing)
-            * altitude: lowlands-uplands
+                seasons: spring, autumn, winter
-            * biomeFilter:
+                group: troup (3 to 6)
-              * Heat: tropical
+                location: outside
-              * Humidity: wet
+                scarcity: uncommon
-              * Flora: any of: canopy, forest, clearing
-            * seasons: spring, autumn, winter
-            * group: troup
-            * location: outside
-            * scarcity: uncommon
     """).strip()

mcpacker/format/textcomposer.py

@@ -24,6 +24,14 @@ class TextComposer:
     def doCompose(self):
         raise NotImplementedError()
 
+    def include(self, composer:"TextComposer") -> Self:
+        composer.reset()
+        composer.compose()
+        for line in composer._lines:
+            self._lines.append(line)
+
+        return self
+
     def indent(self) -> Self:
         self._indent += 1
         self._lineBuffer.insert(0, self._indentText)
@@ -32,7 +40,7 @@ class TextComposer:
     def line(self, text:Any="") -> Self:
         self.text(text)
 
-        self._lines.append("".join(self._lineBuffer))
+        self._lines.append("".join(self._lineBuffer).rstrip())
         self._lineBuffer = []
         while len(self._lineBuffer) < self._indent:
             self._lineBuffer.append(self._indentText)

mcpacker/model/blockfactory_test.py

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

mcpacker/model/core/altitude.py

@@ -23,10 +23,10 @@ class Altitude:
         return hash((self.bottom, self.top))
 
     def __str__(self) -> str:
-        return self.name
+        return f"{self.name} ({self.bottom} to {self.top})"
 
     def __repr__(self) -> str:
-        return f"{self.name} <{self.bottom} to {self.top}>"
+        return f"Altitude(name={self.name}, bottom={self.bottom}, top={self.top})"
 
 
 # Constants ########################################################################################
@@ -43,7 +43,7 @@ LOWLANDS   = Altitude("lowlands", 70,  92)
 DUNES      = Altitude("dunes",    62,  70)
 
 # Transition
-EVAPORATES = Altitude("evaporates",  60,  64)
+EVAPORITES = Altitude("evaporites",  60,  64)
 ANYWHERE   = Altitude("anywhere",   -64, 320)
 
 # Underground
@@ -65,6 +65,8 @@ OVERGROUND  = (DUNES, LOWLANDS, UPLANDS, HILLS, ALPINE, CRAGS, PEAKS, SUMMIT, SK
 UNDERGROUND = (SOIL, SUBSTRATE, OVERBURDEN, CRUST, MANTLE, PLUTONIC)
 UNDERWATER  = (SURFACE, SHALLOWS, DEEPS, ABYSS)
 
+ALL = OVERGROUND + UNDERGROUND + UNDERWATER
+
 
 # Helper Functions #################################################################################
 
@@ -87,5 +89,8 @@ def span(*altitudes:Altitude):
             top = altitude.top
             topAltitude = altitude
 
-    result = Altitude(f"{bottomAltitude.name}-{topAltitude.name}", bottom, top)
+    if bottomAltitude == topAltitude:
+        return bottomAltitude
+
+    result = Altitude(f"{bottomAltitude.name} to {topAltitude.name}", bottom, top)
     return result

mcpacker/model/core/altitude_test.py

@@ -13,6 +13,6 @@ def mergeRange():
 # Tests ############################################################################################
 
 def test_span(merged):
-    assert merged.name == "lowlands-uplands"
+    assert merged.name == "lowlands to uplands"
     assert merged.bottom == A.LOWLANDS.bottom
     assert merged.top == A.UPLANDS.top

mcpacker/model/core/ecology/biome.py

@@ -45,18 +45,18 @@ class Biome(object):
         return hash((self.gameId, self.city))
 
     def __str__(self) -> str:
-        return f"{self.city}<{self.gameId}>"
+        return f"{self.gameId} ({self.city})"
 
     def __repr__(self) -> str:
         return "".join([str(p) for p in [
-            str(self), "{",
+            "Biome(",
-                repr(self.flora), ", ",
+                "flora=", repr(self.flora), ", ",
-                repr(self.geology), ", ",
+                "geology=", repr(self.geology), ", ",
-                repr(self.heat), ", ",
+                "heat=", repr(self.heat), ", ",
-                repr(self.humidity), ", ",
+                "humidity=", repr(self.humidity), ", ",
-                repr(self.soil), ", ",
+                "soil=", repr(self.soil), ", ",
-                repr(self.water),
+                "water=", repr(self.water),
-            "}"
+            ")"
         ]])
 
     def traits(self) -> list[BiomeTrait]:

mcpacker/model/core/ecology/biomefilter.py

@@ -32,6 +32,14 @@ class BiomeFilter:
         self.required = required or []
         self.prohibited = prohibited or []
 
+    def __repr__(self) -> str:
+        return (
+            "BiomeFilter(" +
+                f"required={repr(self.required)}, " +
+                f"prohibited={repr(self.prohibited)}" +
+            ")"
+        )
+
     def __str__(self) -> str:
         required = []
         for trait in self.required:
@@ -39,26 +47,23 @@ class BiomeFilter:
                 required.append(str(trait))
             else:
                 required.append("(" +
-                    ", ".join([str(option) for option in trait]) +
+                    " or ".join([str(option) for option in trait]) +
                 ")")
 
         prohibited = []
         for trait in self.prohibited:
             prohibited.append(str(trait))
 
+        if not prohibited:
+            result = " and ".join(required)
+        else:
             result = "".join([
-            "must:[",
+                "must:[", " and ".join(required), "], ",
-            ", ".join(required),
+                "not:[", " and ".join(prohibited), "]",
-            "], not:[",
-            ", ".join(prohibited),
-            "]"
             ])
 
         return result
 
-    def __repr__(self) -> str:
-        return f"BiomeFilter([{repr(self.required)}], [{repr(self.prohibited)}])"
-
     def accepts(self, biome: Biome) -> bool:
         biomeTraits = biome.traits()
 

mcpacker/model/core/ecology/biometrait.py

@@ -20,10 +20,10 @@ class BiomeTrait:
         return hash((type(self).__name__, self.name))
 
     def __str__(self):
-        return f"{type(self).__name__}: {self.name}"
+        return self.name
 
     def __repr__(self) -> str:
-        return f"{type(self).__name__}<{self.name}>"
+        return f"{type(self).__name__}(name='{self.name}')"
 
 
 # Type Support #####################################################################################

mcpacker/model/core/ecology/biometrait_test.py

@@ -49,10 +49,10 @@ def test_hash(green, blue, traitMap):
     assert traitMap[blue] == "sapphire"
 
 def test_repr(green):
-    assert repr(green) == "BiomeTrait<green>"
+    assert repr(green) == "BiomeTrait(name='green')"
 
 def test_str(green):
-    assert str(green) == "BiomeTrait: green"
+    assert str(green) == "green"
 
 def test_within(traitList, green, yellow, orange):
     assert biomeTrait.within(traitList, green, orange) == [green, yellow, orange]

mcpacker/model/core/fauna/group.py

@@ -20,10 +20,10 @@ class Group:
         return hash((self.smallest, self.largest))
 
     def __str__(self) -> str:
-        return self.name
+        return f"{self.name} ({self.smallest} to {self.largest})"
 
     def __repr__(self) -> str:
-        return str(self) + f"<{self.smallest} to {self.largest}>"
+        return f"Group(name='{self.name}', smallest={self.smallest}, largest={self.largest})"
 
 
 # Constants ########################################################################################
@@ -57,4 +57,4 @@ def merge(*groups:Group):
             largest = group.largest
             largestGroup = group
 
-    return Group(f"{smallestGroup.name}-{largestGroup.name}", smallest, largest)
+    return Group(f"{smallestGroup.name} to {largestGroup.name}", smallest, largest)

mcpacker/model/core/fauna/location.py

@@ -15,7 +15,7 @@ class Location:
         return self.name
 
     def __repr__(self) -> str:
-        return f"Location<{self.name}>"
+        return f"Location(name='{self.name}')"
 
 
 # Constants ########################################################################################

mcpacker/model/core/fauna/mobspawn_test.py

@@ -28,17 +28,25 @@ def createMobSpawn(cow, fields):
 
 def test_cowsInFields(spawn):
     assert str(spawn) == (
-        "Spawn{" +
+        "Spawn(" +
-            "habitats: [" +
+            "habitats=[" +
-                "Habitat{" +
+                "Habitat(" +
-                    "altitude: anywhere <-64 to 320>, " +
+                    "altitude=Altitude(name=anywhere, bottom=-64, top=320), " +
-                    "biomeFilter: BiomeFilter([[Flora<field>, Heat<temperate>]], [[]]), " +
+                    "biomeFilter=BiomeFilter(" +
-                    "seasons: [Season<spring>, Season<summer>, Season<autumn>, Season<winter>], " +
+                        "required=[Flora(name='field'), Heat(name='temperate')], " +
-                    "group: solo<1 to 1>, " +
+                        "prohibited=[]" +
-                    "location: Location<outside>, " +
+                    "), " +
-                    "scarcity: Scarcity<sparse>" +
+                    "seasons=[" +
-                "}" +
+                        "Season(name='spring'), " +
+                        "Season(name='summer'), " +
+                        "Season(name='autumn'), " +
+                        "Season(name='winter')" +
+                    "], " +
+                    "group=Group(name='solo', smallest=1, largest=1), " +
+                    "location=Location(name='outside'), " +
+                    "scarcity=Scarcity(name='sparse')" +
+                ")" +
             "]" +
-        "}"
+        ")"
     )
 

mcpacker/model/core/geology/bulk.py

@@ -1,3 +1,4 @@
+from typing import Any
 import math
 
 
@@ -10,11 +11,19 @@ class Bulk:
         self.smallest = smallest
         self.largest = largest
 
-    def __str__(self) -> str:
+    def __eq__(self, other:Any) -> bool:
-        return self.name
+        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"Bulk<{self.name}>{{smallest: {self.smallest}, largest: {self.largest}}}"
+        return f"Bulk(name='{self.name}', smallest={self.smallest}, largest={self.largest})"
+
+    def __str__(self) -> str:
+        return f"{self.name} ({self.smallest} to {self.largest})"
 
     def scale(self, factor) -> "Bulk":
         return Bulk(
@@ -26,8 +35,10 @@ class Bulk:
 
 # Constants ########################################################################################
 
-SMALL  = Bulk("tiny", 250, 500)
+TINY   = Bulk("tiny",   250,  500)
-MEDIUM = Bulk("small", 500, 1000)
+SMALL  = Bulk("small",  500,  750)
-LARGE  = Bulk("small", 1000, 2000)
+MEDIUM = Bulk("small",  750, 1000)
+LARGE  = Bulk("large", 1250, 1500)
+HUGE   = Bulk("huge",  1500, 1750)
 
-ALL = [SMALL, MEDIUM, LARGE]
+ALL = [TINY, SMALL, MEDIUM, LARGE, HUGE]

mcpacker/model/core/geology/bulk_test.py

@@ -16,5 +16,5 @@ def scaleBulk(bulk):
 # Fixture ##########################################################################################
 
 def test_repr(bulk, scaledBulk):
-    assert repr(bulk) == "Bulk<chunk>{smallest: 64, largest: 128}"
+    assert repr(bulk) == "Bulk(name='chunk', smallest=64, largest=128)"
-    assert repr(scaledBulk) == "Bulk<chunk>{smallest: 128, largest: 256}"
+    assert repr(scaledBulk) == "Bulk(name='chunk', smallest=128, largest=256)"

mcpacker/model/core/geology/deposit/__init__.py

@@ -1,8 +1,12 @@
+from collections.abc import Iterable
+from mcpacker.model.core.altitude import Altitude
+from mcpacker.model.core.ecology.biome import Biome
 from mcpacker.model.core.ecology.biomefilter import BiomeFilter
 from mcpacker.model.core.geology.bulk import Bulk
 from mcpacker.model.core.geology.mineral import Mineral
 from mcpacker.model.core.scarcity import Scarcity
 
+import mcpacker.model.core.altitude as altitude
 import mcpacker.model.core.scarcity as scarcity
 
 
@@ -13,11 +17,40 @@ class Deposit:
     def __init__(
         self,
         name:str,
+        altitude:Altitude=altitude.ANYWHERE,
+        biomeFilters:Iterable[BiomeFilter]|BiomeFilter|None=None,
         scarcity:Scarcity=scarcity.SPARSE,
-        biomeFilter:BiomeFilter|None=None,
     ):
-        self.name = name
+        self.altitude = altitude
+        self.biomeFilters:list[BiomeFilter] = []
         self.gameId = name
-        self.biomeFilter = biomeFilter or BiomeFilter()
+        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/core/geology/deposit/geodedeposit.py

@@ -0,0 +1,25 @@
+from collections.abc import Iterable
+from mcpacker.model.core.altitude import Altitude
+from mcpacker.model.core.ecology.biomefilter import BiomeFilter
+from mcpacker.model.core.geology.bulk import Bulk
+from mcpacker.model.core.geology.deposit import Deposit
+from mcpacker.model.core.geology.mineral import Mineral
+from mcpacker.model.core.scarcity import Scarcity
+
+import mcpacker.model.core.altitude as altitude
+import mcpacker.model.core.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/core/geology/deposit/geodedeposit_test.py

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

mcpacker/model/core/geology/deposit/metaldeposit.py

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

mcpacker/model/core/geology/deposit/mineraldeposit.py

@@ -0,0 +1,50 @@
+from collections.abc import Iterable
+from mcpacker.model.core.altitude import Altitude
+from mcpacker.model.core.ecology.biomefilter import BiomeFilter
+from mcpacker.model.core.geology.bulk import Bulk
+from mcpacker.model.core.geology.deposit import Deposit
+from mcpacker.model.core.geology.inclusion import Inclusion
+from mcpacker.model.core.geology.proportion import Proportion
+from mcpacker.model.core.scarcity import Scarcity
+
+import mcpacker.model.core.altitude as AL
+import mcpacker.model.core.geology.bulk as BU
+import mcpacker.model.core.geology.proportion as PR
+import mcpacker.model.core.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 = 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/core/geology/deposit/mineraldeposit_test.py

@@ -1,5 +1,5 @@
 from mcpacker.model.core.ecology.biomefilter import BiomeFilter
-from mcpacker.model.core.geology.deposit.metaldeposit import MetalDeposit
+from mcpacker.model.core.geology.deposit.mineraldeposit import MineralDeposit
 from mcpacker.model.core.geology.inclusion import Inclusion
 from mcpacker.model.core.geology.mineral import Mineral
 from mcpacker.model.core.geology.replacement import Replacement
@@ -15,23 +15,17 @@ import mcpacker.model.core.scarcity           as SC
 
 @fixture(name="quartz")
 def createQuartz():
-    yield Mineral("quartz", [
+    yield Mineral("quartz", [])
-        Replacement("#minecraft:stone_replaceables", "minecraft:quartz_ore"),
-        Replacement("#minecraft:deepslate_replaceables", "minecraft:deepslate_quartz_ore")
-    ])
 
 @fixture(name="iron")
 def createIron():
-    yield Mineral("iron", [
+    yield Mineral("iron", [])
-        Replacement("#minecraft:stone_replaceables", "minecraft:iron_ore"),
-        Replacement("#minecraft:deepslate_replaceables", "minecraft:deepslate_iron_ore")
-    ])
 
 @fixture(name="bifIron")
 def createBifIron(iron, quartz):
-    yield MetalDeposit(
+    yield MineralDeposit(
         name = "bifiron",
-        biomeFilter = BiomeFilter([FL.FOREST]),
+        biomeFilters = BiomeFilter([FL.FOREST]),
         bulk = BU.LARGE,
         inclusions = [Inclusion(iron, 60), Inclusion(quartz, 40)],
         proportion = PR.LENS,
@@ -42,14 +36,16 @@ def createBifIron(iron, quartz):
 
 def test_repr(bifIron):
     assert repr(bifIron) == (
-        "MetalDeposit<bifiron>{" +
+        "MineralDeposit(" +
-            "scarcity: Scarcity<common>, " +
+            "name='bifiron', " +
-            "biomeFilter: must:[Flora: forest], not:[], " +
+            "altitude=Altitude(name=anywhere, bottom=-64, top=320), " +
-            "inclusions: [" +
+            "biomeFilters=[BiomeFilter(required=[Flora(name='forest')], prohibited=[])], " +
-                "Inclusion{mineral: iron, weight: 60}, " +
+            "bulk=Bulk(name='large', smallest=1250, largest=1500), " +
-                "Inclusion{mineral: quartz, weight: 40}" +
+            "inclusions=[" +
+                "Inclusion(mineral=Mineral(name='iron', replacements=[]), weight=60), " +
+                "Inclusion(mineral=Mineral(name='quartz', replacements=[]), weight=40)" +
             "], " +
-            "bulk: Bulk<small>{smallest: 1000, largest: 2000}, " +
+            "proportion=Proportion(name='lens', ratio=0.4), " +
-            "proportion: Proportion<lens>{ratio: 0.4}" +
+            "scarcity=Scarcity(name='common')" +
-        "}"
+        ")"
     )

mcpacker/model/core/geology/inclusion.py

@@ -17,8 +17,8 @@ class Inclusion:
 
     def __repr__(self) -> str:
         return "".join([str(p) for p in [
-            "Inclusion{",
+            "Inclusion(",
-                "mineral: ", self.mineral.name, ", ",
+                "mineral=", repr(self.mineral), ", ",
-                "weight: ", self.weight,
+                "weight=", repr(self.weight),
-            "}"
+            ")"
         ]])

mcpacker/model/core/geology/inclusion_test.py

@@ -8,10 +8,7 @@ from pytest import fixture
 
 @fixture(name="iron")
 def createIron():
-    yield Mineral("iron", [
+    yield Mineral("iron", [])
-        Replacement("#minecraft:stone_replaceables", "minecraft:iron_ore"),
-        Replacement("#minecraft:deepslate_replaceables", "minecraft:deepslate_iron_ore")
-    ])
 
 @fixture(name="inclusion")
 def createInclusion(iron):
@@ -21,4 +18,4 @@ def createInclusion(iron):
 # Tests ############################################################################################I
 
 def test_repr(inclusion):
-    assert repr(inclusion) == "Inclusion{mineral: iron, weight: 75}"
+    assert repr(inclusion) == "Inclusion(mineral=Mineral(name='iron', replacements=[]), weight=75)"

mcpacker/model/core/geology/mineral.py

@@ -17,9 +17,8 @@ class Mineral:
 
     def __repr__(self) -> str:
         return "".join([str(p) for p in [
-            f"Mineral<{self.name}>", "{",
+            f"Mineral(" +
-                "replacements: [",
+                "name=", repr(self.name), ", ",
-                    ", ".join([str(r) for r in self.replacements]),
+                "replacements=", repr(self.replacements),
-                "]",
+            ")"
-            "}"
         ]])

mcpacker/model/core/geology/mineral_test.py

@@ -19,10 +19,19 @@ def createIron():
 
 def test_repr(iron):
     assert repr(iron) == (
-        "Mineral<iron>{" +
+        "Mineral(" +
-            "replacements: [" +
+            "name='iron', " +
-                "#minecraft:stone_ore_replaceables => minecraft:iron_ore, " +
+            "replacements=[" +
-                "#minecraft:deepslate_ore_replaceables => minecraft:deepslate_iron_ore" +
+                "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/core/geology/proportion.py

@@ -15,10 +15,10 @@ class Proportion:
         return hash(self.name)
 
     def __str__(self) -> str:
-        return self.name
+        return f"{self.name} ({self.ratio})"
 
     def __repr__(self) -> str:
-        return f"Proportion<{self.name}>{{ratio: {self.ratio}}}"
+        return f"Proportion(name='{self.name}', ratio={self.ratio})"
 
 
 # Constants ########################################################################################

mcpacker/model/core/geology/proportion_test.py

@@ -6,7 +6,7 @@ import mcpacker.model.core.geology.proportion as proportion
 # Tests ############################################################################################
 
 def test_str():
-    assert str(proportion.LENS) == "lens"
+    assert str(proportion.LENS) == "lens (0.4)"
 
 def test_repr():
-    assert repr(proportion.LENS) == "Proportion<lens>{ratio: 0.4}"
+    assert repr(proportion.LENS) == "Proportion(name='lens', ratio=0.4)"

mcpacker/model/core/geology/replacement.py

@@ -32,9 +32,9 @@ class Replacement:
 
     def __repr__(self) -> str:
         return "".join([str(p) for p in [
-            "Replacement{" +
+            "Replacement(" +
-                "source: ", self.source, ", ",
+                "source=", repr(self.source), ", ",
-                "target: ", self.target, ", ",
+                "target=", repr(self.target), ", ",
-                "weight: ", self.weight,
+                "weight=", repr(self.weight),
-            "}"
+            ")"
         ]])

mcpacker/model/core/geology/replacement_test.py

@@ -17,10 +17,10 @@ def createWeightedReplacement():
 
 def test_repr(replacement, weightedReplacement):
     assert repr(replacement) == (
-        "Replacement{source: #minecraft:stone, target: minecraft:iron_ore, weight: 100}"
+        "Replacement(source='#minecraft:stone', target='minecraft:iron_ore', weight=100)"
     )
     assert repr(weightedReplacement) == (
-        "Replacement{source: #minecraft:dirt, target: minecraft:gravel, weight: 25}"
+        "Replacement(source='#minecraft:dirt', target='minecraft:gravel', weight=25)"
     )
 
 def test_str(replacement, weightedReplacement):

mcpacker/model/core/habitat.py

@@ -53,14 +53,14 @@ class Habitat:
 
     def __repr__(self) -> str:
         return "".join([str(p) for p in [
-            "Habitat{",
+            "Habitat(",
-                "altitude: ", repr(self.altitude), ", ",
+                "altitude=", repr(self.altitude), ", ",
-                "biomeFilter: ", repr(self.biomeFilter), ", ",
+                "biomeFilter=", repr(self.biomeFilter), ", ",
-                "seasons: [", ", ".join([repr(s) for s in self.seasons]), "], ",
+                "seasons=[", ", ".join([repr(s) for s in self.seasons]), "], ",
-                "group: ", repr(self.group), ", ",
+                "group=", repr(self.group), ", ",
-                "location: ", repr(self.location), ", ",
+                "location=", repr(self.location), ", ",
-                "scarcity: ", repr(self.scarcity),
+                "scarcity=", repr(self.scarcity),
-            "}"
+            ")"
         ]])
 
     def derive(

mcpacker/model/core/habitat_test.py

@@ -34,12 +34,20 @@ def test_derive(derivedHabitats):
 
 def test_repr(fields):
     assert repr(fields) == (
-        "Habitat{" +
+        "Habitat(" +
-            "altitude: anywhere <-64 to 320>, " +
+            "altitude=Altitude(name=anywhere, bottom=-64, top=320), " +
-            "biomeFilter: BiomeFilter([[Flora<field>, Heat<temperate>]], [[]]), " +
+            "biomeFilter=BiomeFilter(" +
-            "seasons: [Season<spring>, Season<summer>, Season<autumn>, Season<winter>], " +
+                "required=[Flora(name='field'), Heat(name='temperate')], " +
-            "group: solo<1 to 1>, " +
+                "prohibited=[]"
-            "location: Location<outside>, " +
+            "), " +
-            "scarcity: Scarcity<sparse>" +
+            "seasons=[" +
-        "}"
+                "Season(name='spring'), " +
+                "Season(name='summer'), " +
+                "Season(name='autumn'), " +
+                "Season(name='winter')" +
+            "], " +
+            "group=Group(name='solo', smallest=1, largest=1), " +
+            "location=Location(name='outside'), " +
+            "scarcity=Scarcity(name='sparse')" +
+        ")"
     )

mcpacker/model/core/scarcity.py

@@ -12,7 +12,7 @@ class Scarcity:
         return self.name
 
     def __repr__(self) -> str:
-        return f"Scarcity<{self.name}>"
+        return f"Scarcity(name='{self.name}')"
 
 
 # Constants ########################################################################################

mcpacker/model/core/season.py

@@ -12,7 +12,7 @@ class Season:
         return self.name
 
     def __repr__(self) -> str:
-        return f"Season<{self.name}>"
+        return f"Season(name='{self.name}')"
 
 
 # Constants ########################################################################################

mcpacker/model/core/spawn.py

@@ -18,7 +18,7 @@ class Spawn:
 
     def __repr__(self) -> str:
         return (
-            "Spawn{" +
+            "Spawn(" +
-                f"habitats: [{', '.join([repr(h) for h in self.habitats])}]" +
+                f"habitats=[{', '.join([repr(h) for h in self.habitats])}]" +
-            "}"
+            ")"
         )

mcpacker/model/core/spawn_test.py

@@ -22,17 +22,23 @@ def createSpawn(fields):
 
 def test_repr(spawn):
     assert repr(spawn) == (
-        "Spawn{" +
+        "Spawn(habitats=[" +
-            "habitats: [" +
+            "Habitat(" +
-                "Habitat{" +
+                "altitude=Altitude(name=anywhere, bottom=-64, top=320), " +
-                    "altitude: anywhere <-64 to 320>, " +
+                "biomeFilter=BiomeFilter(" +
-                    "biomeFilter: BiomeFilter([[Flora<field>, Heat<temperate>]], [[]]), " +
+                    "required=[Flora(name='field'), Heat(name='temperate')], " +
-                    "seasons: [Season<spring>, Season<summer>, Season<autumn>, Season<winter>], " +
+                    "prohibited=[]" +
-                    "group: solo<1 to 1>, " +
+                "), "
-                    "location: Location<outside>, " +
+                "seasons=[" +
-                    "scarcity: Scarcity<sparse>" +
+                    "Season(name='spring'), " +
-                "}" +
+                    "Season(name='summer'), " +
-            "]" +
+                    "Season(name='autumn'), " +
-        "}"
+                    "Season(name='winter')" +
+                "], " +
+                "group=Group(name='solo', smallest=1, largest=1), " +
+                "location=Location(name='outside'), " +
+                "scarcity=Scarcity(name='sparse')" +
+            ")" +
+        "])"
     )
 

mcpacker/model/resourcepack/blockstate_test.py

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

mcpacker/pack/mysteriousisland/addbiomes.py

@@ -1,5 +1,4 @@
 from mcpacker.model.core.ecology.biome import Biome
-from mcpacker.model.core.ecology.biomefilter import BiomeFilter
 from mcpacker.model.modpack import ModPack
 
 import mcpacker.model.core.ecology.flora as FL
@@ -40,14 +39,14 @@ def addBiomes(pack:ModPack):
     ))
 
     biomes.add(Biome("calcutta", "minecraft:mangrove_swamp",
-        FL.FOREST, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.WET, SO.CLAYEY, WA.INLAND
+        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("dallas", "minecraft:savanna",
+    biomes.add(Biome("dakar", "minecraft:savanna",
         FL.FIELD, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.DRY, SO.SANDY, WA.INLAND
     ))
 
@@ -55,7 +54,7 @@ def addBiomes(pack:ModPack):
         FL.BARREN, GE.SEDIMENTARY, HE.FROZEN, HU.WET, SO.SANDY, WA.RIVER
     ))
 
-    biomes.add(Biome("durango", "minecraft:savanna_plateau",
+    biomes.add(Biome("khartoum", "minecraft:savanna_plateau",
         FL.FIELD, GE.IGNEOUS, HE.SUBTROPICAL, HU.DRY, SO.SANDY, WA.INLAND
     ))
 
@@ -83,16 +82,16 @@ def addBiomes(pack:ModPack):
         FL.BARREN, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.WET, SO.SANDY, WA.OCEAN
     ))
 
-    biomes.add(Biome("hilo", "minecraft:mushroom_fields",
+    biomes.add(Biome("tahiti", "minecraft:mushroom_fields",
-        FL.CLEARING, GE.IGNEOUS, HE.SUBTROPICAL, HU.WET, SO.FUNGAL, WA.INLAND
+        FL.CLEARING, GE.IGNEOUS, HE.TROPICAL, HU.WET, SO.FUNGAL, WA.INLAND
     ))
 
     biomes.add(Biome("honolulu", "minecraft:deep_ocean",
-        FL.BARREN, GE.SEDIMENTARY, HE.TEMPERATE, HU.WET, SO.SANDY, WA.OCEAN
+        FL.BARREN, GE.IGNEOUS, HE.TEMPERATE, HU.WET, SO.SANDY, WA.OCEAN
     ))
 
-    biomes.add(Biome("innnesbruk", "minecraft:meadow",
+    biomes.add(Biome("innsbruck", "minecraft:meadow",
-        FL.FIELD, GE.SEDIMENTARY, HE.BOREAL, HU.DAMP, SO.PEATY, WA.INLAND
+        FL.FIELD, GE.IGNEOUS, HE.BOREAL, HU.DAMP, SO.LOAMY, WA.INLAND
     ))
 
     biomes.add(Biome("irkutsk", "minecraft:taiga",
@@ -140,7 +139,7 @@ def addBiomes(pack:ModPack):
     ))
 
     biomes.add(Biome("moscow", "minecraft:snowy_plains",
-        FL.FIELD, GE.SEDIMENTARY, HE.FROZEN, HU.DAMP, SO.LOAMY, WA.INLAND
+        FL.FIELD, GE.SEDIMENTARY, HE.FROZEN, HU.DAMP, SO.PEATY, WA.INLAND
     ))
 
     biomes.add(Biome("nassau", "minecraft:warm_ocean",
@@ -159,7 +158,7 @@ def addBiomes(pack:ModPack):
         FL.FOREST, GE.METAMORPHIC, HE.BOREAL, HU.DAMP, SO.ACIDIC, WA.INLAND
     ))
 
-    biomes.add(Biome("phoenix", "minecraft:desert",
+    biomes.add(Biome("timbuktu", "minecraft:desert",
         FL.BARREN, GE.SEDIMENTARY, HE.TROPICAL, HU.DRY, SO.SANDY, WA.INLAND
     ))
 
@@ -167,7 +166,7 @@ def addBiomes(pack:ModPack):
         FL.BARREN, GE.METAMORPHIC, HE.TEMPERATE, HU.DAMP, SO.ROCKY, WA.COAST
     ))
 
-    biomes.add(Biome("portland", "minecraft:forest",
+    biomes.add(Biome("sherwood", "minecraft:forest",
         FL.FOREST, GE.SEDIMENTARY, HE.TEMPERATE, HU.DAMP, SO.LOAMY, WA.INLAND
     ))
 
@@ -176,7 +175,7 @@ def addBiomes(pack:ModPack):
     ))
 
     biomes.add(Biome("rangoon", "minecraft:bamboo_jungle",
-        FL.BARREN, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.DRY, SO.LOAMY, WA.INLAND
+        FL.FOREST, GE.SEDIMENTARY, HE.TROPICAL, HU.WET, SO.ACIDIC, WA.INLAND
     ))
 
     biomes.add(Biome("sanfrancisco", "minecraft:ocean",
@@ -195,7 +194,7 @@ def addBiomes(pack:ModPack):
         FL.BARREN, GE.SEDIMENTARY, HE.SUBTROPICAL, HU.DRY, SO.CLAYEY, WA.INLAND
     ))
 
-    biomes.add(Biome("topeka", "minecraft:sunflower_plains",
+    biomes.add(Biome("stlouis", "minecraft:sunflower_plains",
         FL.FIELD, GE.SEDIMENTARY, HE.TEMPERATE, HU.DAMP, SO.LOAMY, WA.INLAND
     ))
 

mcpacker/pack/mysteriousisland/adddeposits.py

@@ -1,5 +1,6 @@
 from mcpacker.model.core.ecology.biomefilter import BiomeFilter as BF
-from mcpacker.model.core.geology.deposit.metaldeposit import MetalDeposit
+from mcpacker.model.core.geology.deposit.geodedeposit import GeodeDeposit
+from mcpacker.model.core.geology.deposit.mineraldeposit import MineralDeposit
 from mcpacker.model.core.geology.inclusion import Inclusion as I
 from mcpacker.model.modpack import ModPack
 
@@ -14,21 +15,236 @@ import mcpacker.model.core.geology.bulk       as BU
 import mcpacker.model.core.geology.proportion as PR
 import mcpacker.model.core.scarcity as SC
 
+
 # Catalog ##########################################################################################
 
 def addDeposits(pack:ModPack):
     minerals = pack.world.minerals
     deposits = pack.world.deposits
 
-    deposits.add(MetalDeposit(
+    # 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]),
+        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",
-        scarcity = SC.COMMON,
+        altitude = AL.span(AL.CRUST, AL.SUBSTRATE),
-        biomeFilter = BF([GE.METAMORPHIC, (HE.BOREAL, HE.FROZEN), HU.DAMP]),
+        biomeFilters = BF([FL.FIELD, HE.SUBTROPICAL, HU.DRY]),
+        bulk = BU.LARGE,
         inclusions = [
             I(minerals["iron"], 50),
             I(minerals["quartz"], 45),
             I(minerals["uranium"], 5)
         ],
-        bulk = BU.LARGE,
         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([
+            FL.within(FL.CANOPY, FL.CLEARING),
+            (HE.TEMPERATE, HE.BOREAL)
+        ]),
+        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, HU.WET), (SO.ACIDIC, SO.ROCKY)]),
+        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]),
+        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([FL.FOREST, GE.SEDIMENTARY, HE.TEMPERATE]),
+            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/addminerals.py

@@ -30,13 +30,13 @@ def makeOreMineral(name:str) -> Mineral:
 def makeImmersiveEngineeringOreMineral(name:str) -> Mineral:
     return Mineral(name, [
         Replacement.inStone(f"{IE}:ore_{name}"),
-        Replacement.inDeepslate("{IE}:deepslate_ore_{name}")
+        Replacement.inDeepslate(f"{IE}:deepslate_ore_{name}")
     ])
 
 def makeRailcraftOreMineral(name:str) -> Mineral:
     return Mineral(name, [
         Replacement.inStone(f"{RC}:{name}_ore"),
-        Replacement.inDeepslate("{RC}:deepslate_{name}_ore")
+        Replacement.inDeepslate(f"{RC}:deepslate_{name}_ore")
     ])
 
 
@@ -102,7 +102,7 @@ def addMinerals(pack:ModPack):
     minerals.add(makeImmersiveEngineeringOreMineral("uranium"))
 
     # Railcraft Ores
-    minerals.add(Mineral("saltpeter", [
+    minerals.add(Mineral("nitrate", [
         Replacement("sand", f"{RC}:saltpeter_ore"),
         Replacement("sandstone", f"{RC}:saltpeter_ore"),
     ]))

mcpacker/ui/runner.py

@@ -1,4 +1,5 @@
 from mcpacker.format.report.biomereport import BiomeReport
+from mcpacker.format.report.depositreport import DepositReport
 from mcpacker.format.report.mineralreport import MineralReport
 from mcpacker.format.report.mobspawnreport import MobSpawnReport
 from mcpacker.model.modpack import ModPack
@@ -49,9 +50,10 @@ class Runner:
 
     def _command_writeReports(self):
         CompositeWriter(self.pack, self.outputDir, [
-            ReportWriter(self.pack, BiomeReport, self.outputDir, "biomes.md"),
+            ReportWriter(self.pack, BiomeReport, self.outputDir, "biomes.txt"),
-            ReportWriter(self.pack, MineralReport, self.outputDir, "minerals.md"),
+            ReportWriter(self.pack, DepositReport, self.outputDir, "deposits.txt"),
-            ReportWriter(self.pack, MobSpawnReport, self.outputDir, "mobspawns.md"),
+            ReportWriter(self.pack, MineralReport, self.outputDir, "minerals.txt"),
+            ReportWriter(self.pack, MobSpawnReport, self.outputDir, "mobspawns.txt"),
         ]).write()
 
     def _command_writeModPack(self):

mcpacker/ui/runner_test.py

@@ -95,6 +95,6 @@ def test_writeModPack(tmp_path:Path, modPackRunner:Runner):
     assert (tmp_path/"testpack"/"test.md").exists()
 
 def test_writeReports(tmp_path:Path, reportRunner:Runner):
-    assert (tmp_path/"testpack"/"reports"/"biomes.md").exists()
+    assert (tmp_path/"testpack"/"reports"/"biomes.txt").exists()
-    assert (tmp_path/"testpack"/"reports"/"minerals.md").exists()
+    assert (tmp_path/"testpack"/"reports"/"minerals.txt").exists()
-    assert (tmp_path/"testpack"/"reports"/"mobspawns.md").exists()
+    assert (tmp_path/"testpack"/"reports"/"mobspawns.txt").exists()