pyyol 1.10.0 → 1.11.0

package/skill/references/templates/goofspiel_agent.py

@@ -1,66 +0,0 @@
-"""Goofspiel agent — 2 players, 13 rounds, simultaneous bidding.
-
-Read references/games/goofspiel.md first. Replace `decide_card`; leave the rest.
-
-    pyyol login && pyyol dev --matches 5
-"""
-
-from __future__ import annotations
-
-from typing import List, Tuple
-
-from _shared import MatchMemory
-from pyyol import Adapter
-from pyyol.models import GoofspielMove, GoofspielView
-
-
-class GoofspielAgent(Adapter):
-    name = "atlas-goofspiel"
-    supported_games = ["goofspiel"]
-
-    def __init__(self) -> None:
-        self.mem = MatchMemory()
-
-    def step(self, view: GoofspielView) -> GoofspielMove:
-        safe = min(view.legal_actions) if view.legal_actions else 1
-
-        if self.mem.already_answered(view.match_id, view.round):
-            return GoofspielMove(round=view.round, card=safe, rationale="replayed turn")
-
-        try:
-            card, why = self.decide_card(view)
-        except Exception as e:  # noqa: BLE001 — never let the deadline decide
-            return GoofspielMove(round=view.round, card=safe, rationale=f"fallback: {e}")
-
-        # The model will occasionally name a card you do not hold. Sending it is
-        # recorded as YOUR illegal move.
-        if card not in view.legal_actions:
-            card, why = safe, f"model chose an illegal card; {why}"
-
-        return GoofspielMove(round=view.round, card=card, rationale=why[:200])
-
-    # --- your strategy -----------------------------------------------------
-
-    def decide_card(self, view: GoofspielView) -> Tuple[int, str]:
-        """Return (card, one-line reason).
-
-        Bid against `prize_pool`, not `current_prize` — ties carry.
-        """
-        opp = self.opponent_hand(view)
-        threat = max(opp) if opp else 0
-        beats = [c for c in view.legal_actions if c > threat]
-
-        # Win by ONE. Pips saved on cheap prizes buy the expensive ones later.
-        if beats and view.prize_pool >= 7:
-            return min(beats), f"pool {view.prize_pool}: cheapest card over {threat}"
-        return min(view.legal_actions), f"pool {view.prize_pool}: conceding cheaply"
-
-    @staticmethod
-    def opponent_hand(view: GoofspielView) -> List[int]:
-        """Exactly what they still hold — identical starting hands mean their played
-        cards tell you the rest."""
-        spent = {r["opp_card"] for r in (view.history or []) if r.get("opp_card")}
-        return [c for c in range(1, 14) if c not in spent]
-
-
-agent = GoofspielAgent()

package/skill/references/templates/mafia_agent.py

@@ -1,77 +0,0 @@
-"""Mafia agent — 12 seats, hidden roles, phase machine.
-
-Read references/games/mafia.md first. Note the view uses `legal`, NOT `legal_actions`,
-and `day`/`phase` rather than `round`.
-
-Replace `decide`; leave the rest.
-"""
-
-from __future__ import annotations
-
-from typing import Tuple
-
-from _shared import MatchMemory
-from pyyol import Adapter
-from pyyol.models import MafiaMove, MafiaView
-
-
-class MafiaAgent(Adapter):
-    name = "atlas-mafia"
-    supported_games = ["mafia"]
-
-    def __init__(self) -> None:
-        self.mem = MatchMemory()
-
-    def step(self, view: MafiaView) -> MafiaMove:
-        # `legal` — not `legal_actions`. Getting this wrong means every move is
-        # rejected and the engine plays for you.
-        legal = view.legal or []
-        if not legal:
-            return MafiaMove(action="", rationale="nothing legal this phase")
-        fallback = legal[0]
-
-        # A turn is (day, phase) here — there is no round number.
-        if self.mem.already_answered(view.match_id, (view.day, view.phase)):
-            return MafiaMove(action=fallback, rationale="replayed turn")
-
-        try:
-            action, target, text, why = self.decide(view)
-        except Exception as e:  # noqa: BLE001
-            return MafiaMove(action=fallback, rationale=f"fallback: {e}")
-
-        if action not in legal:
-            action, target, text, why = fallback, -1, "", f"illegal action; {why}"
-
-        # target stays -1 when unused: seat 0 is a REAL player, so a forgotten target
-        # would otherwise silently act on them.
-        return MafiaMove(action=action, target=target, text=text[:400], rationale=why[:200])
-
-    # --- your strategy -----------------------------------------------------
-
-    def decide(self, view: MafiaView) -> Tuple[str, int, str, str]:
-        """Return (action, target, text, reason).
-
-        `view.public` is the table transcript; `view.private` carries what only you
-        know (a Detective's finding arrives there and nowhere else). Rebuild your
-        read of each seat from them every turn.
-        """
-        notes = self.mem.get(view.match_id)["notes"]
-        living = [s for s, ok in (view.alive or {}).items() if ok and s != view.your_seat]
-        suspect = max(living, key=lambda s: notes.get(s, 0), default=-1)
-
-        if "message" in (view.legal or []):
-            return (
-                "message",
-                -1,
-                f"Seat {suspect} has been quiet. Thoughts?",
-                "opening a line on the current suspect",
-            )
-        if "vote" in (view.legal or []) and suspect >= 0:
-            return "vote", suspect, "", f"voting {suspect}, my standing read"
-        for act in ("investigate", "protect", "night_kill", "profile"):
-            if act in (view.legal or []) and suspect >= 0:
-                return act, suspect, "", f"{act} on {suspect}"
-        return (view.legal or [""])[0], -1, "", "no better option this phase"
-
-
-agent = MafiaAgent()

package/skill/references/templates/monopoly_agent.py

@@ -1,82 +0,0 @@
-"""Monopoly agent — 2–8 players, board, near-perfect information.
-
-Read references/games/monopoly.md first. Drive off `phase` + `legal_actions`; the
-board lives in the raw `state` dict.
-
-Replace `decide`; leave the rest.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, Tuple
-
-from _shared import MatchMemory
-from pyyol import Adapter
-from pyyol.models import MonopolyMove, MonopolyView
-
-
-class MonopolyAgent(Adapter):
-    name = "atlas-monopoly"
-    supported_games = ["monopoly"]
-
-    def __init__(self) -> None:
-        self.mem = MatchMemory()
-
-    def step(self, view: MonopolyView) -> MonopolyMove:
-        legal = view.legal_actions or []
-        if not legal:
-            return MonopolyMove(action="", rationale="nothing legal this phase")
-        fallback = "end_turn" if "end_turn" in legal else legal[0]
-
-        # Monopoly has no round number — the phase plus the board's turn counter is
-        # the closest thing, so key on both.
-        turn_no = (view.state or {}).get("turn", 0)
-        if self.mem.already_answered(view.match_id, (turn_no, view.phase)):
-            return MonopolyMove(action=fallback, rationale="replayed turn")
-
-        try:
-            action, prop, amount, why = self.decide(view)
-        except Exception as e:  # noqa: BLE001
-            return MonopolyMove(action=fallback, rationale=f"fallback: {e}")
-
-        if action not in legal:
-            action, prop, amount, why = fallback, 0, 0, f"illegal action; {why}"
-
-        return MonopolyMove(action=action, property=prop, amount=amount, rationale=why[:200])
-
-    # --- your strategy -----------------------------------------------------
-
-    def decide(self, view: MonopolyView) -> Tuple[str, int, int, str]:
-        """Return (action, property, amount, reason).
-
-        Read `phase` for the situation and `legal_actions` for what is allowed —
-        do not assume fixed field names in `state`.
-        """
-        legal = view.legal_actions or []
-        me: Dict[str, Any] = (view.state or {}).get("players", {}).get(str(view.seat), {})
-        cash = int(me.get("cash", 0) or 0)
-
-        if view.phase == "acquire" and "buy" in legal:
-            # Keep a reserve: bankruptcy is the only true loss condition, and it is
-            # usually caused by buying into a rent spike.
-            if cash > 400:
-                return "buy", 0, 0, f"buying with {cash} cash in hand"
-            return (
-                "decline" if "decline" in legal else legal[0],
-                0,
-                0,
-                f"declining, only {cash} cash",
-            )
-
-        if view.phase == "auction" and "pass" in legal:
-            return "pass", 0, 0, "not overpaying at auction"
-
-        if view.phase == "roll" and "roll" in legal:
-            return "roll", 0, 0, "rolling"
-
-        if "end_turn" in legal:
-            return "end_turn", 0, 0, "nothing worth doing this phase"
-        return legal[0], 0, 0, "first legal action"
-
-
-agent = MonopolyAgent()