Add mobreport.py

tungston/core/altitude.py

@@ -67,8 +67,20 @@ def span(*altitudes):
     if not altitudes: return ANYWHERE
     result = Altitude("", ANYWHERE.top, ANYWHERE.bottom)
 
-    for altitude in altitudes:
-        result.bottom = min(result.bottom, altitude.bottom)
-        result.top = max(result.top, altitude.top)
+    bottom = OVERGROUND[-1].top
+    bottomAltitude = None
 
+    top = UNDERGROUND[-1].bottom
+    topAltitude = None
+
+    for altitude in altitudes:
+        if altitude.bottom < bottom:
+            bottom = altitude.bottom
+            bottomAltitude = altitude
+
+        if altitude.top > top:
+            top = altitude.top
+            topAltitude = altitude
+
+    result = Altitude(f"{bottomAltitude.name}-{topAltitude.name}", bottom, top)
     return result

tungston/core/altitude_test.py

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

tungston/core/ecology/biomefilter.py

@@ -31,6 +31,30 @@ class BiomeFilter:
         self.required = required or []
         self.prohibited = prohibited or []
 
+    def __str__(self) -> str:
+        required = []
+        for trait in self.required:
+            if isinstance(trait, BiomeTrait):
+                required.append(str(trait))
+            else:
+                required.append("(" +
+                    ", ".join([str(option) for option in trait]) +
+                ")")
+
+        prohibited = []
+        for trait in self.prohibited:
+            prohibited.append(str(trait))
+
+        result = "".join([
+            "must:[",
+            ", ".join(required),
+            "], not:[",
+            ", ".join(prohibited),
+            "]"
+        ])
+
+        return result
+
     def __repr__(self) -> str:
         return f"BiomeFilter([{repr(self.required)}], [{repr(self.prohibited)}])"
 

tungston/core/fauna/group.py

@@ -5,7 +5,7 @@ class Group:
     How many individuals are commonly present when encountering a creature.
     """
 
-    def __init__(self, name, smallest, largest):
+    def __init__(self, name:str, smallest:int, largest:int):
         self.name = name
         self.smallest = smallest
         self.largest = largest
@@ -42,9 +42,19 @@ ALL = [SOLO, PAIR, FAMILY, TROUP, HERD]
 def merge(*groups):
     if not groups: return SOLO
 
-    result = Group(f"", HERD.largest, SOLO.smallest)
-    for group in groups:
-        result.smallest = min(result.smallest, group.smallest)
-        result.largest = max(result.largest, group.largest)
+    smallest = ALL[-1].largest
+    smallestGroup = None
 
-    return result
+    largest = ALL[0].smallest
+    largestGroup = None
+
+    for group in groups:
+        if group.smallest < smallest:
+            smallest = group.smallest
+            smallestGroup = group
+
+        if group.largest > largest:
+            largest = group.largest
+            largestGroup = group
+
+    return Group(f"{smallestGroup.name}-{largestGroup.name}", smallest, largest)

tungston/core/fauna/mobcatalog.py

@@ -1,16 +1,26 @@
-from tungston.core.fauna.mob import Mob
+from collections.abc import Iterator
+from tungston.core.fauna.mobplacement import MobPlacement
 
 
 # Class ############################################################################################
 
 class MobCatalog:
 
-    def __init__(self, mobs):
-        self.mobs = mobs
+    def __init__(self, mobs:tuple[MobPlacement]):
+        self._mobs = {}
 
-    def findByName(self, name):
-        for mob in self.mobs:
-            if mob.name == name:
-                return mob
+        for mob in mobs:
+            self.add(mob)
 
-        return None
+    def add(self, placement:MobPlacement) -> "MobCatalog":
+        if placement.mob.name in self._mobs:
+            raise Exception("Catalog already has an entry for {mob.name}")
+
+        self._mobs[placement.mob.name] = placement
+
+    def all(self) -> Iterator[MobPlacement]:
+        for placement in self._mobs.values():
+            yield placement
+
+    def get(self, name:str) -> MobPlacement:
+        return self._mobs.get(name, None)

tungston/core/fauna/mobplacement_test.py

@@ -30,7 +30,7 @@ def test_cowsInFields(placement):
         "Placement{" +
             "habitats: [" +
                 "Habitat{" +
-                    "altitude: [anywhere <-64 to 320>], " +
+                    "altitude: anywhere <-64 to 320>, " +
                     "biomeFilter: BiomeFilter([[Flora<field>, Heat<temperate>]], [[]]), " +
                     "seasons: [Season<spring>, Season<summer>, Season<autumn>, Season<winter>], " +
                     "group: solo<1 to 1>, " +

tungston/core/geology/deposit/metaldeposit_test.py

@@ -44,7 +44,7 @@ def test_repr(bifIron):
     assert repr(bifIron) == (
         "MetalDeposit<bifiron>{" +
             "scarcity: Scarcity<common>, " +
-            "biomeFilter: BiomeFilter([[Flora<forest>]], [[]]), " +
+            "biomeFilter: must:[Flora: forest], not:[], " +
             "inclusions: [" +
                 "Inclusion{mineral: iron, weight: 60}, " +
                 "Inclusion{mineral: quartz, weight: 40}" +

tungston/core/habitat.py

@@ -22,7 +22,7 @@ class Habitat:
     def __init__(
         self,
 
-        altitudes:tuple[Altitude]|Altitude=[A.ANYWHERE],
+        altitude:Altitude=A.ANYWHERE,
         biomeFilter:BiomeFilter=None,
         seasons:tuple[Season]=E.ALL,
 
@@ -30,7 +30,7 @@ class Habitat:
         location:Location=L.OUTSIDE,
         scarcity:Scarcity=C.SPARSE,
     ):
-        self.altitudes = (altitudes,) if isinstance(altitudes, Altitude) else altitudes
+        self.altitude = altitude
         self.biomeFilter = biomeFilter or BiomeFilter()
         self.seasons = (seasons,) if isinstance(seasons, Season) else seasons
 
@@ -41,19 +41,19 @@ class Habitat:
         self._source = None
 
     def __str__(self) -> str:
-        return "".join(str(p) for p in [
-            self.altitude, "|",
+        return "".join([str(p) for p in [
+            ", ".join(self.altitude), "|",
             self.biomeFilter, "|",
-            self.seasons, "|",
+            ", ".join([str(s) for s in self.seasons]), "|",
             self.group, "|",
             self.location, "|",
             self.scarcity
-        ])
+        ]])
 
     def __repr__(self) -> str:
         return "".join([str(p) for p in [
             "Habitat{",
-                "altitude: [", ", ".join([repr(a) for a in self.altitudes]), "], ",
+                "altitude: ", repr(self.altitude), ", ",
                 "biomeFilter: ", repr(self.biomeFilter), ", ",
                 "seasons: [", ", ".join([repr(s) for s in self.seasons]), "], ",
                 "group: ", repr(self.group), ", ",
@@ -64,7 +64,7 @@ class Habitat:
 
     def derive(self, **kwargs):
         kwargs = {
-            "altitudes": self.altitudes,
+            "altitude": self.altitude,
             "biomeFilter": self.biomeFilter,
             "seasons": self.seasons,
             "group": self.group,

tungston/core/habitat_test.py

@@ -35,7 +35,7 @@ def test_derive(derivedHabitats):
 def test_repr(fields):
     assert repr(fields) == (
         "Habitat{" +
-            "altitude: [anywhere <-64 to 320>], " +
+            "altitude: anywhere <-64 to 320>, " +
             "biomeFilter: BiomeFilter([[Flora<field>, Heat<temperate>]], [[]]), " +
             "seasons: [Season<spring>, Season<summer>, Season<autumn>, Season<winter>], " +
             "group: solo<1 to 1>, " +

tungston/core/placement_test.py

@@ -25,7 +25,7 @@ def test_repr(placement):
         "Placement{" +
             "habitats: [" +
                 "Habitat{" +
-                    "altitude: [anywhere <-64 to 320>], " +
+                    "altitude: anywhere <-64 to 320>, " +
                     "biomeFilter: BiomeFilter([[Flora<field>, Heat<temperate>]], [[]]), " +
                     "seasons: [Season<spring>, Season<summer>, Season<autumn>, Season<winter>], " +
                     "group: solo<1 to 1>, " +