✨ Simulator and AIs for the steak market.

Author: coderanger

py/simulator/__main__.py

@@ -1,5 +1,8 @@
 import logging
+import os
+import random
 from time import monotonic_ns
+from typing import Optional
 
 import structlog
 import typer
@@ -86,21 +89,28 @@ def simulator(
     time: str = "7d",
     summary: bool = False,
     seconds: bool = False,  # Run with 1 second ticks instead of 1 minute.
+    seed: Optional[int] = None,
+    tick_length: Optional[int] = None,
 ):
     if not verbose:
         structlog.configure(
             wrapper_class=structlog.make_filtering_bound_logger(logging.INFO)
         )
     log = structlog.get_logger(mod="main")
-    tick_length = 1 if seconds else 60
+    if tick_length is None:
+        tick_length = 1 if seconds else 60
     ticks = parse_time(time, tick_length)
+    if seed is None:
+        seed = int.from_bytes(os.urandom(4), byteorder="big")
     log.info(
         "Starting simulation",
         ticks=ticks,
         tick_length=tick_length,
         ai=ai,
         player=player,
+        seed=seed,
     )
+    random.seed(seed)
     game = Game(ai_class=get_ai(ai))
     PLAYERS[player](game)
     game.player.silver += STARTER_SILVER

py/simulator/ai/__init__.py

@@ -1,10 +1,14 @@
 from .base import AI
 from .fisher import FisherAI
 from .silly import SillyAI
+from .steak import SimpleSteakAI, SleepySteakAI, ThresholdSteakAI
 
 AIS: dict[str, type] = {
     "silly": SillyAI,
     "fisher": FisherAI,
+    "simple_steak": SimpleSteakAI,
+    "threshold_steak": ThresholdSteakAI,
+    "sleepy_steak": SleepySteakAI,
 }
 
 

py/simulator/ai/base.py

@@ -32,3 +32,7 @@ def explore(self) -> Optional[Location]:
     def process(self) -> None:
         """Handle all other per-tick logic."""
         return None
+
+    def finish(self) -> None:
+        """Do any cleanup before the end."""
+        return None

py/simulator/ai/fisher.py

@@ -6,7 +6,7 @@
 
 
 class FisherAI(AI):
-    """An AI that makes net and does fishing."""
+    """An AI that makes nets and does fishing."""
 
     def fish(self) -> Optional[Location]:
         return Location["Large Island"]

py/simulator/ai/steak.py

@@ -0,0 +1,119 @@
+import random
+
+from .base import AI
+
+
+class SteakAI(AI):
+    """Base class for steak AI experiments."""
+
+    def _buy_steaks(self, price: int) -> bool:
+        return False
+
+    def _sell_steaks(self, price: int) -> bool:
+        return not self._buy_steaks(price)
+
+    def _buy_kabobs(self, price: int) -> bool:
+        return False
+
+    def _sell_kabobs(self, price: int) -> bool:
+        return not self._buy_kabobs(price)
+
+    def process(self) -> None:
+        market = self.game.steak_market
+        player = self.game.player
+
+        if self._buy_steaks(market.steak_price):
+            market.buy_steaks(player)
+        elif self._sell_steaks(market.steak_price):
+            market.sell_steaks(player)
+
+        if self._buy_kabobs(market.kabob_price):
+            market.buy_kabobs(player)
+        elif self._sell_kabobs(market.kabob_price):
+            market.sell_kabobs(player)
+
+    def finish(self) -> None:
+        market = self.game.steak_market
+        player = self.game.player
+        market.sell_steaks(player)
+        market.sell_kabobs(player)
+
+
+class SimpleSteakAI(SteakAI):
+    """The simplest behavior, sell over average, buy below."""
+
+    def _buy_steaks(self, price: int) -> bool:
+        return price < 50_000
+
+    def _buy_kabobs(self, price: int) -> bool:
+        return price < 10_000
+
+
+class ThresholdSteakAI(SteakAI):
+    """Buy and sell thresholds."""
+
+    # BUY_STEAK = 40_000
+    # SELL_STEAK = 55_000
+    # BUY_KABOB = 9_900
+    # SELL_KABOB = 10_100
+
+    BUY_STEAK = 30_000
+    SELL_STEAK = 60_000
+    BUY_KABOB = 9_600
+    SELL_KABOB = 10_250
+
+    def _buy_steaks(self, price: int) -> bool:
+        return price <= self.BUY_STEAK
+
+    def _sell_steaks(self, price: int) -> bool:
+        return price >= self.SELL_STEAK
+
+    def _buy_kabobs(self, price: int) -> bool:
+        return price <= self.BUY_KABOB
+
+    def _sell_kabobs(self, price: int) -> bool:
+        return price >= self.SELL_KABOB
+
+
+class SleepySteakAI(ThresholdSteakAI):
+    """ "Like Threshold but it has to work and sleep."""
+
+    WORK_HOURS = range(9, 17)
+    SLEEP_HOURS = range(0, 8)
+
+    def _is_playing(self) -> bool:
+        hour = self.game.time.hour
+        if hour in self.SLEEP_HOURS:
+            return False
+        if hour in self.WORK_HOURS:
+            # 50% chance to be blocked until the next hour.
+            work_blocked = getattr(self, "work_blocked", None)
+            if hour == work_blocked:
+                return False
+            if random.random() < 0.5:
+                self.work_blocked = hour
+                return False
+            else:
+                self.work_blocked = None
+                return True
+        return True
+
+    def _buy_steaks(self, price: int) -> bool:
+        if self._is_playing():
+            return super()._buy_steaks(price)
+        return False
+
+    def _sell_steaks(self, price: int) -> bool:
+        if self._is_playing():
+            return super()._sell_steaks(price)
+        return False
+
+    def _buy_kabobs(self, price: int) -> bool:
+        if self._is_playing():
+            return super()._buy_kabobs(price)
+        return False
+
+    def _sell_kabobs(self, price: int) -> bool:
+        if self._is_playing():
+            return super()._sell_kabobs(price)
+        return False

py/simulator/game.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import datetime
 from io import StringIO
 from typing import Optional
 
@@ -10,6 +11,7 @@
 from .buildings import HayField, RaptorPen, Sawmill
 from .farm import Farm
 from .player import Player
+from .steak_market import SteakMarket
 from .utils import format_number
 
 
@@ -24,21 +26,26 @@ class Game:
     sawmill: Sawmill = SelfFactory(Sawmill)
     hay_field: HayField = SelfFactory(HayField)
     raptor_pen: RaptorPen = SelfFactory(RaptorPen)
+    steak_market: SteakMarket = SelfFactory(SteakMarket)
     ai_class: Optional[type] = None
     ai: Optional[AI] = None
 
+    time: datetime.datetime = datetime.datetime.now()
+
     log: structlog.stdlib.BoundLogger = structlog.stdlib.get_logger(mod="farm")
 
     def __attrs_post_init__(self):
         if self.ai is None and self.ai_class is not None:
             self.ai = self.ai_class(self)
 
     def tick(self, seconds: int) -> None:
+        self.time += datetime.timedelta(seconds=seconds)
         self.player.tick(seconds)
         self.farm.tick(seconds)
         self.sawmill.tick(seconds)
         self.hay_field.tick(seconds)
         self.raptor_pen.tick(seconds)
+        self.steak_market.tick(seconds)
 
     def process_ai(self):
         if self.ai is None:
@@ -79,6 +86,9 @@ def run(self, iterations: int = 60, interval: int = 60) -> None:
             )
             self.process_ai()
             self.tick(interval)
+        # Finalize the AI.
+        if self.ai:
+            self.ai.finish()
 
     def summary(self) -> str:
         """Render a string summary of the game state."""
@@ -92,4 +102,5 @@ def summary(self) -> str:
         out.write("Overflow:\n")
         for item, count in self.player.overflow_items.items():
             out.write(f"\t{item.name}: {count}\n")
+        out.write(self.steak_market.summary())
         return out.getvalue()