✨ First pass on a crafting implementation.

Also some typing fixes.

Author: coderanger

py/simulator/game.py

@@ -31,6 +31,8 @@ def tick(self, seconds: int) -> None:
         self.farm.tick(seconds)
 
     def process_ai(self):
+        if self.ai is None:
+            return
         if self.farm.can_harvest:
             self.log.debug("AI harvest")
             self.farm.harvest_all()

py/simulator/items.py

@@ -53,6 +53,8 @@ def get(cls, name: str) -> Optional[Item]:
         return cls._all_items.get(name)
 
     def growth_time_for(self, player: Player) -> int:
+        if self.growth_time is None:
+            raise ValueError(f"{self.name} is not growable")
         discount = player.perk_value(
             {
                 "Quicker Farming I": 0.05,
@@ -63,4 +65,4 @@ def growth_time_for(self, player: Player) -> int:
                 "Irrigation System II": 0.2,
             }
         )
-        return self.growth_time * (1 - discount)
+        return round(self.growth_time * (1 - discount))

py/simulator/locations.py

@@ -18,7 +18,7 @@
 class _ItemPicker:
     """Helper class for the logic to pick a random item from a dict[str,float] rates bucket."""
 
-    def __init__(self, rates: dict[str, float], allow_none: bool = False):
+    def __init__(self, rates: frozendict[str, float], allow_none: bool = False):
         # Copy the dict to be extra sure we get the population and weights in the same order.
         pairs = list(rates.items())
         self.items: list[Optional[Item]] = [Item[p[0]] for p in pairs]
@@ -76,7 +76,7 @@ def __attrs_post_init__(self):
     def _all_locations(cls) -> dict[str, Location]:
         """Lazy load the location data."""
         cls._all_locations = {
-            loc["name"]: cls(**loc)
+            str(loc["name"]): cls(**loc)
             for loc in json.load(
                 Path(__file__).joinpath("..", "data", "locations.json").resolve().open()
             )
@@ -126,14 +126,14 @@ def explore(self, player: Player) -> None:
             "Explored",
             location=self.name,
             effectiveness=effectiveness,
-            items=[it.name for it in found_items],
+            # items=[it.name for it in found_items],
             base_xp=base_xp,
             item_xp=item_xp,
             stamina_used=stamina_used,
         )
         for item in found_items:
             player.add_item(item)
-        player.exploring_xp += base_xp + item_xp
+        player.exploring_xp += round(base_xp) + item_xp
         player.stamina -= stamina_used
 
     def lemonade(self, player: Player) -> None:

py/simulator/player.py

@@ -1,19 +1,19 @@
 from __future__ import annotations
 
 from collections import Counter
-from numbers import Number
-from typing import TYPE_CHECKING, Optional, TypeVar
+from typing import TYPE_CHECKING, Literal, Optional, TypeVar
 
 import attrs
 import structlog
 
+from .items import Item
+
 if TYPE_CHECKING:
     from .game import Game
-    from .items import Item
     from .locations import Location
 
 
-PerkValue = TypeVar("PerkValue", bound=Number)
+PerkValue = TypeVar("PerkValue", int, float)
 
 
 @attrs.define
@@ -25,15 +25,15 @@ class Player:
     fishing_xp: int = 0
     crafting_xp: int = 0
     exploring_xp: int = 0
-    inventory: Counter[Item, int] = attrs.field(factory=Counter, converter=Counter)
+    inventory: Counter[Item] = attrs.field(factory=Counter, converter=Counter)
     max_inventory: int = 100
     stamina: int = 0
     max_stamina: int = 100
     perks: set[str] = attrs.Factory(set)
     has_all_perks: bool = False
-    exploring_effectiveness: dict[Location:int] = attrs.Factory(dict)
+    exploring_effectiveness: dict[Location, int] = attrs.Factory(dict)
     # Tracking stuff.
-    overflow_items: Counter[Item, int] = attrs.field(factory=Counter, converter=Counter)
+    overflow_items: Counter[Item] = attrs.field(factory=Counter, converter=Counter)
     seconds_until_stamina: int = 120
 
     log: structlog.stdlib.BoundLogger = structlog.stdlib.get_logger(mod="player")
@@ -71,7 +71,7 @@ def has_perk(self, perk: str) -> bool:
         # TODO validate perk names so I can catch typos.
         return self.has_all_perks or perk in self.perks
 
-    def perk_value(self, perks: dict[str, PerkValue]) -> PerkValue:
+    def perk_value(self, perks: dict[str, PerkValue]) -> PerkValue | Literal[0]:
         """Handle the very common case of needing to sum multiple values from different perks."""
         return sum(value for perk, value in perks.items() if self.has_perk(perk))
 
@@ -93,7 +93,7 @@ def sell_item(self, item: Item, quantity: Optional[int] = None) -> None:
         silver = quantity * item.sell_price * (1 + sell_bonus)
         # This check we have enough of the item.
         self.remove_item(item, quantity)
-        self.silver += silver
+        self.silver += round(silver)
         self.log.debug("Selling item", item=item.name, quantity=quantity, silver=silver)
 
     def buy_item(self, item: Item, quantity: Optional[int] = None) -> None:
@@ -116,3 +116,48 @@ def exploring_effectiveness_for(self, location: Location) -> int:
         if self.has_perk("Sprint Shoes II"):
             multiplier *= 2
         return self.exploring_effectiveness.get(location, 1) * multiplier
+
+    def items_needed_to_craft(self, item: Item) -> dict[Item, int]:
+        """Return how many of each direct ingredient are not currently available."""
+        if not item.recipe:
+            raise ValueError(f"{item.name} is not craftable")
+        needed: dict[Item, int] = {}
+        for name, quantity in item.recipe.items():
+            ingredient = Item[name]
+            ingredient_needed = quantity - self.inventory[ingredient]
+            if ingredient_needed > 0:
+                needed[ingredient] = ingredient_needed
+        return needed
+
+    def craft(self, item: Item) -> None:
+        if item.craft_price is None:
+            raise ValueError(f"{item.name} is not craftable")
+        needed = self.items_needed_to_craft(item)
+        if needed:
+            raise ValueError(f"{item.name} is missing ingredients: {needed}")
+        price_reduction = self.perk_value(
+            {
+                "Artisan I": 0.05,
+                "Artisan II": 0.1,
+                "Artisan III": 0.15,
+                "Artisan IV": 0.2,
+                "Toolbox I": 0.1,
+            }
+        )
+        craft_price = round(item.craft_price * (1 - price_reduction))
+        if self.silver < craft_price:
+            raise ValueError("not enough silver")
+        xp_bonus = self.perk_value(
+            {
+                "Crafting Primer": 0.1,
+                "Crafting Primer II": 0.1,
+                "Crafting Almanac": 0.1,
+            }
+        )
+        xp = round(item.xp * (1 + xp_bonus))
+        self.log.debug("Crafting", item=item, price=craft_price, xp=xp)
+        for name, quantity in item.recipe.items():
+            self.remove_item(Item[name], quantity)
+        self.silver -= craft_price
+        self.add_item(item)
+        self.crafting_xp += xp

py/simulator/tests/test_items.py

@@ -14,6 +14,7 @@ def test_growth_time_for_all_perks(super_player):
 
 def test_get():
     apple = Item.get("Apple")
+    assert apple is not None
     assert apple.name == "Apple"
     assert apple.id == "44"
 

py/simulator/tests/test_locations.py

@@ -6,6 +6,7 @@
 
 def test_get():
     loc = Location.get("Forest")
+    assert loc is not None
     assert loc.type == "explore"
     assert "Antler" in loc.items
 
@@ -87,11 +88,16 @@ def test_explore_drop(player: Player, forest: Location):
     assert 1300 < player.inventory[Item["Wood"]] < 1600
 
 
-def test_explore_wanderer(super_player: Player, forest: Location):
-    super_player.stamina = 40000
-    super_player.exploring_effectiveness[forest] = 10000
-    forest.explore(super_player)
-    assert 25000 < super_player.stamina < 28000
+def test_explore_wanderer(player: Player, forest: Location):
+    player.stamina = 40000
+    player.exploring_effectiveness[forest] = 40000
+    player.perks.add("Wanderer I")
+    player.perks.add("Wanderer II")
+    player.perks.add("Wanderer III")
+    player.perks.add("Wanderer IV")
+    forest.explore(player)
+    # Technically this could fail, but not likely.
+    assert 25000 < player.stamina < 28000
 
 
 def test_lemonade(player: Player, forest: Location):

py/simulator/tests/test_player.py

@@ -1,39 +1,60 @@
 import pytest
 from simulator.items import Item
+from simulator.player import Player
 
 
-def test_add_inventory(player):
+def test_add_inventory(player: Player):
     player.max_inventory = 100
     player.add_item(Item["Wood"])
     assert player.inventory[Item["Wood"]] == 1
     assert player.overflow_items[Item["Wood"]] == 0
 
 
-def test_add_inventory_overflow(player):
+def test_add_inventory_overflow(player: Player):
     player.max_inventory = 100
     player.add_item(Item["Wood"], 300)
     assert player.inventory[Item["Wood"]] == 100
     assert player.overflow_items[Item["Wood"]] == 200
 
 
-def test_remove_inventory(player):
-    player.inventory = {Item["Wood"]: 10}
+def test_remove_inventory(player: Player):
+    player.inventory[Item["Wood"]] = 10
     player.remove_item(Item["Wood"])
     assert player.inventory[Item["Wood"]] == 9
 
 
-def test_remove_inventory_underflow(player):
+def test_remove_inventory_underflow(player: Player):
     with pytest.raises(ValueError):
         player.remove_item(Item["Wood"])
 
 
-def test_stamina(player):
+def test_stamina(player: Player):
     assert player.stamina == 0
     player.tick(60 * 10)
     assert player.stamina == 20
 
 
-def test_stamina_energy_drink(super_player):
+def test_stamina_energy_drink(super_player: Player):
     assert super_player.stamina == 0
     super_player.tick(60 * 10)
     assert super_player.stamina == 40
+
+
+def test_items_needed_to_craft(player: Player):
+    needed = player.items_needed_to_craft(Item["Fancy Pipe"])
+    assert needed == {Item["Iron"]: 1, Item["Wood"]: 2, Item["Iron Ring"]: 3}
+
+
+def test_items_needed_to_craft_partial(player: Player):
+    player.inventory[Item["Wood"]] = 2
+    player.inventory[Item["Iron Ring"]] = 2
+    needed = player.items_needed_to_craft(Item["Fancy Pipe"])
+    assert needed == {Item["Iron"]: 1, Item["Iron Ring"]: 1}
+
+
+def test_items_needed_to_craft_over(player: Player):
+    player.inventory[Item["Iron"]] = 2
+    player.inventory[Item["Wood"]] = 2
+    player.inventory[Item["Iron Ring"]] = 5
+    needed = player.items_needed_to_craft(Item["Fancy Pipe"])
+    assert needed == {}