Add microservices, web UI, and replay tooling

services/game/app.py

@@ -0,0 +1,478 @@
+from __future__ import annotations
+
+import datetime as dt
+import random
+from typing import Any, Dict, List, Optional
+
+import httpx
+from fastapi import Depends, FastAPI, HTTPException
+from sqlmodel import SQLModel
+
+from catan.data import Resource
+from catan.game import GameConfig
+from catan.sdk import Action, ActionType, CatanEnv
+from services.common.db import engine
+from services.common.schemas import (
+    ActionRequest,
+    ActionSchema,
+    AddAIRequest,
+    CreateGameRequest,
+    GameStateSchema,
+    GameSummarySchema,
+    JoinGameRequest,
+    TradeOfferRequest,
+    TradeOfferSchema,
+    TradeRespondRequest,
+)
+from services.common.settings import settings
+from services.game.models import Game, GameEvent, TradeOffer
+from services.game.runtime import manager
+
+app = FastAPI(title="Catan Game Service")
+
+
+@app.on_event("startup")
+def _startup() -> None:
+    SQLModel.metadata.create_all(engine)
+
+
+def _serialize_resources(resources: Dict[Resource, int]) -> Dict[str, int]:
+    return {res.value if isinstance(res, Resource) else str(res): int(val) for res, val in resources.items()}
+
+
+def _serialize_player(player: Dict[str, Any]) -> Dict[str, Any]:
+    data = dict(player)
+    resources = data.get("resources", {})
+    if resources:
+        data["resources"] = _serialize_resources(resources)
+    return data
+
+
+def _serialize_game_observation(observation: Dict[str, Any]) -> Dict[str, Any]:
+    game = dict(observation["game"])
+    players = {name: _serialize_player(info) for name, info in game["players"].items()}
+    game["players"] = players
+    bank = game.get("bank", {})
+    if bank:
+        game["bank"] = _serialize_resources(bank)
+    return {"game": game, "board": observation["board"]}
+
+
+def _serialize_action(action: Action) -> ActionSchema:
+    return ActionSchema(type=action.type.value, payload=action.payload)
+
+
+def _serialize_legal_actions(actions: List[Action]) -> List[ActionSchema]:
+    return [_serialize_action(action) for action in actions]
+
+
+def _slots_to_schema(game: Game) -> List[Dict[str, Any]]:
+    return game.slots.get("slots", [])
+
+
+def _to_game_summary(game: Game) -> GameSummarySchema:
+    return GameSummarySchema(
+        id=game.id,
+        name=game.name,
+        status=game.status,
+        max_players=game.max_players,
+        created_by=game.created_by,
+        created_at=game.created_at,
+        players=[slot for slot in _slots_to_schema(game)],
+    )
+
+
+def _trade_to_schema(trade: TradeOffer) -> TradeOfferSchema:
+    return TradeOfferSchema(
+        id=trade.id,
+        from_player=trade.from_player,
+        to_player=trade.to_player,
+        offer=trade.offer,
+        request=trade.request,
+        status=trade.status,
+        created_at=trade.created_at,
+    )
+
+
+def _build_state(game: Game, runtime) -> GameStateSchema:
+    if game.status != "running" or runtime is None:
+        return GameStateSchema(
+            id=game.id,
+            name=game.name,
+            status=game.status,
+            max_players=game.max_players,
+            created_by=game.created_by,
+            created_at=game.created_at,
+            players=[slot for slot in _slots_to_schema(game)],
+        )
+    obs = _serialize_game_observation(runtime.env.observe())
+    legal_actions = _serialize_legal_actions(runtime.env.legal_actions())
+    trades = manager.list_trade_offers(game.id, status="open")
+    history = manager.list_events(game.id)
+    return GameStateSchema(
+        id=game.id,
+        name=game.name,
+        status=game.status,
+        max_players=game.max_players,
+        created_by=game.created_by,
+        created_at=game.created_at,
+        players=[slot for slot in _slots_to_schema(game)],
+        game=obs["game"],
+        board=obs["board"],
+        legal_actions=legal_actions,
+        pending_trades=[_trade_to_schema(trade) for trade in trades],
+        history=[
+            {
+                "idx": event.idx,
+                "ts": event.ts,
+                "actor": event.actor,
+                "action": {"type": event.action_type, "payload": event.payload},
+                "applied": event.applied,
+                "meta": event.debug_payload or {},
+            }
+            for event in history
+        ],
+    )
+
+
+def _ensure_game(game_id: str) -> Game:
+    try:
+        return manager.get(game_id).game
+    except KeyError:
+        raise HTTPException(status_code=404, detail="Game not found")
+
+
+def _get_runtime(game_id: str):
+    try:
+        return manager.get(game_id)
+    except KeyError:
+        raise HTTPException(status_code=404, detail="Game not found")
+
+
+def _find_slot(game: Game, predicate) -> Optional[Dict[str, Any]]:
+    for slot in game.slots.get("slots", []):
+        if predicate(slot):
+            return slot
+    return None
+
+
+def _ai_slots(game: Game) -> Dict[str, Dict[str, Any]]:
+    return {
+        slot["name"]: slot
+        for slot in game.slots.get("slots", [])
+        if slot.get("is_ai") and slot.get("name")
+    }
+
+
+def _ai_trade_decision(resources: Dict[str, int], offer: Dict[str, int], request: Dict[str, int]) -> bool:
+    if any(resources.get(res, 0) < amount for res, amount in request.items()):
+        return False
+    offer_value = sum(offer.values())
+    request_value = sum(request.values())
+    if offer_value >= request_value:
+        return True
+    return random.random() < 0.35
+
+
+async def _request_ai_action(agent: Dict[str, Any], observation: Dict[str, Any], legal_actions: List[ActionSchema]) -> Dict[str, Any]:
+    payload = {
+        "observation": observation,
+        "legal_actions": [action.model_dump() for action in legal_actions],
+        "agent": agent,
+        "debug": settings.debug,
+    }
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        resp = await client.post(f"{settings.ai_service_url}/act", json=payload)
+        resp.raise_for_status()
+        return resp.json()
+
+
+async def _run_ai_turns(runtime) -> None:
+    game = runtime.game
+    if game.status != "running":
+        return
+    ai_slots = _ai_slots(game)
+    safety = 0
+    while safety < 200:
+        safety += 1
+        current = runtime.env.game.current_player.name
+        open_trades = manager.list_trade_offers(game.id, status="open")
+        for trade in open_trades:
+            if trade.from_player != current:
+                continue
+            target = trade.to_player
+            if target is None:
+                candidates = [name for name in ai_slots if name != trade.from_player]
+                target = candidates[0] if candidates else None
+            if target and target in ai_slots:
+                resources = runtime.env.game.player_by_name(target).resources
+                resources_map = {res.value: count for res, count in resources.items()}
+                accept = _ai_trade_decision(resources_map, trade.offer, trade.request)
+                trade.status = "accepted" if accept else "declined"
+                manager.update_trade_offer(trade)
+                manager.record_event(
+                    game.id,
+                    target,
+                    Action(ActionType.TRADE_PLAYER if accept else ActionType.END_TURN, {
+                        "trade_id": trade.id,
+                        "accept": accept,
+                    }),
+                    applied=False,
+                )
+                if accept:
+                    action = Action(
+                        ActionType.TRADE_PLAYER,
+                        {"target": trade.from_player, "offer": trade.offer, "request": trade.request},
+                    )
+                    _, _, _, info = runtime.env.step(action)
+                    manager.record_event(game.id, trade.from_player, action, applied=True)
+                break
+        if current not in ai_slots:
+            break
+        slot = ai_slots[current]
+        observation = _serialize_game_observation(runtime.env.observe())
+        legal_actions = _serialize_legal_actions(runtime.env.legal_actions())
+        agent_cfg = {
+            "kind": slot.get("ai_kind", "random"),
+            "model": slot.get("ai_model"),
+            "stochastic": True,
+        }
+        response = await _request_ai_action(agent_cfg, observation, legal_actions)
+        action_data = response.get("action")
+        debug = response.get("debug") or {}
+        if settings.debug:
+            debug = {
+                **debug,
+                "observation": observation,
+                "legal_actions": [action.model_dump() for action in legal_actions],
+            }
+        action = Action(ActionType(action_data["type"]), action_data.get("payload") or {})
+        _, _, done, info = runtime.env.step(action)
+        manager.record_event(game.id, current, action, applied=True, debug=debug)
+        if info.get("invalid"):
+            break
+        if action.type == ActionType.END_TURN:
+            _expire_trades(game.id)
+        if done:
+            game.status = "finished"
+            game.winner = runtime.env.game.winner
+            manager.save_game(game)
+            break
+
+
+def _expire_trades(game_id: str) -> None:
+    offers = manager.list_trade_offers(game_id, status="open")
+    for offer in offers:
+        offer.status = "expired"
+        manager.update_trade_offer(offer)
+
+
+@app.get("/health")
+def health() -> Dict[str, str]:
+    return {"status": "ok"}
+
+
+@app.get("/games")
+def list_games() -> Dict[str, Any]:
+    games = manager.list_games()
+    return {"games": [_to_game_summary(game).model_dump() for game in games]}
+
+
+@app.post("/games")
+def create_game(payload: CreateGameRequest) -> Dict[str, Any]:
+    if payload.max_players < 2 or payload.max_players > 4:
+        raise HTTPException(status_code=400, detail="max_players must be 2-4")
+    game = manager.create_game(payload.name, payload.max_players, created_by=payload.created_by or "host")
+    return _to_game_summary(game).model_dump()
+
+
+@app.post("/games/{game_id}/join")
+def join_game(game_id: str, payload: JoinGameRequest) -> Dict[str, Any]:
+    runtime = _get_runtime(game_id)
+    game = runtime.game
+    slot = _find_slot(game, lambda s: s.get("user_id") == payload.user_id)
+    if slot:
+        return _to_game_summary(game).model_dump()
+    open_slot = _find_slot(game, lambda s: s.get("name") is None)
+    if not open_slot:
+        raise HTTPException(status_code=400, detail="No available slots")
+    open_slot.update({
+        "name": payload.username,
+        "user_id": payload.user_id,
+        "ready": True,
+    })
+    manager.save_game(game)
+    return _to_game_summary(game).model_dump()
+
+
+@app.post("/games/{game_id}/leave")
+def leave_game(game_id: str, payload: JoinGameRequest) -> Dict[str, Any]:
+    runtime = _get_runtime(game_id)
+    game = runtime.game
+    slot = _find_slot(game, lambda s: s.get("user_id") == payload.user_id)
+    if not slot:
+        return _to_game_summary(game).model_dump()
+    slot.update({
+        "name": None,
+        "user_id": None,
+        "ready": False,
+        "is_ai": False,
+        "ai_kind": None,
+        "ai_model": None,
+        "color": None,
+    })
+    manager.save_game(game)
+    return _to_game_summary(game).model_dump()
+
+
+@app.post("/games/{game_id}/add_ai")
+def add_ai(game_id: str, payload: AddAIRequest) -> Dict[str, Any]:
+    runtime = _get_runtime(game_id)
+    game = runtime.game
+    open_slot = _find_slot(game, lambda s: s.get("name") is None)
+    if not open_slot:
+        raise HTTPException(status_code=400, detail="No available slots")
+    ai_type = payload.ai_type.lower()
+    if ai_type not in {"random", "model"}:
+        raise HTTPException(status_code=400, detail="Unknown AI type")
+    name_base = "AI" if ai_type == "random" else "Model"
+    existing = {slot.get("name") for slot in game.slots.get("slots", []) if slot.get("name")}
+    suffix = 1
+    name = f"{name_base}-{suffix}"
+    while name in existing:
+        suffix += 1
+        name = f"{name_base}-{suffix}"
+    open_slot.update({
+        "name": name,
+        "is_ai": True,
+        "ai_kind": ai_type,
+        "ai_model": payload.model_name,
+        "ready": True,
+    })
+    manager.save_game(game)
+    return _to_game_summary(game).model_dump()
+
+
+@app.post("/games/{game_id}/start")
+async def start_game(game_id: str) -> Dict[str, Any]:
+    runtime = _get_runtime(game_id)
+    game = runtime.game
+    if game.status != "lobby":
+        raise HTTPException(status_code=400, detail="Game already started")
+    slots = game.slots.get("slots", [])
+    names = [slot.get("name") for slot in slots if slot.get("name")]
+    if len(names) < 2:
+        raise HTTPException(status_code=400, detail="Not enough players")
+    colors = ["red", "blue", "orange", "white"]
+    for slot, color in zip(slots, colors):
+        if slot.get("name"):
+            slot["color"] = color
+    game.slots["slots"] = slots
+    game.status = "running"
+    manager.save_game(game)
+    runtime.env = CatanEnv(GameConfig(player_names=names, colors=colors[: len(names)], seed=game.seed))
+    await _run_ai_turns(runtime)
+    return _build_state(game, runtime).model_dump()
+
+
+@app.get("/games/{game_id}")
+def game_state(game_id: str) -> Dict[str, Any]:
+    runtime = _get_runtime(game_id)
+    game = runtime.game
+    return _build_state(game, runtime).model_dump()
+
+
+@app.post("/games/{game_id}/action")
+async def apply_action(game_id: str, payload: ActionRequest) -> Dict[str, Any]:
+    runtime = _get_runtime(game_id)
+    game = runtime.game
+    if game.status != "running":
+        raise HTTPException(status_code=400, detail="Game not running")
+    action_type = ActionType(payload.action.type)
+    action = Action(type=action_type, payload=payload.action.payload)
+    actor = payload.actor
+    current = runtime.env.game.current_player.name
+    if action.type == ActionType.DISCARD:
+        target = action.payload.get("player")
+        if target != actor:
+            raise HTTPException(status_code=403, detail="Discard only for self")
+    elif actor != current:
+        raise HTTPException(status_code=403, detail="Not your turn")
+    _, _, done, info = runtime.env.step(action)
+    if info.get("invalid"):
+        raise HTTPException(status_code=400, detail=info.get("error", "Invalid action"))
+    manager.record_event(game.id, actor, action, applied=True)
+    if action.type == ActionType.END_TURN:
+        _expire_trades(game.id)
+    if done:
+        game.status = "finished"
+        game.winner = runtime.env.game.winner
+        manager.save_game(game)
+    await _run_ai_turns(runtime)
+    return _build_state(game, runtime).model_dump()
+
+
+@app.post("/games/{game_id}/trade/offer")
+async def offer_trade(game_id: str, payload: TradeOfferRequest) -> Dict[str, Any]:
+    runtime = _get_runtime(game_id)
+    game = runtime.game
+    if game.status != "running":
+        raise HTTPException(status_code=400, detail="Game not running")
+    current = runtime.env.game.current_player.name
+    if payload.from_player != current:
+        raise HTTPException(status_code=403, detail="Only current player can offer trades")
+    if not runtime.env.game.has_rolled:
+        raise HTTPException(status_code=400, detail="Roll dice before trading")
+    trade = manager.create_trade_offer(
+        game.id,
+        payload.from_player,
+        payload.to_player,
+        payload.offer,
+        payload.request,
+    )
+    manager.record_event(
+        game.id,
+        payload.from_player,
+        Action(ActionType.TRADE_PLAYER, {"trade_id": trade.id, "offer": payload.offer, "request": payload.request}),
+        applied=False,
+    )
+    await _run_ai_turns(runtime)
+    return _trade_to_schema(trade).model_dump()
+
+
+@app.post("/games/{game_id}/trade/{trade_id}/respond")
+def respond_trade(game_id: str, trade_id: str, payload: TradeRespondRequest) -> Dict[str, Any]:
+    runtime = _get_runtime(game_id)
+    trade = next((t for t in manager.list_trade_offers(game_id, status="open") if t.id == trade_id), None)
+    if not trade:
+        raise HTTPException(status_code=404, detail="Trade not found")
+    if trade.to_player and trade.to_player != payload.player:
+        raise HTTPException(status_code=403, detail="Not target player")
+    if payload.player == trade.from_player:
+        raise HTTPException(status_code=400, detail="Cannot accept own trade")
+    trade.status = "accepted" if payload.accept else "declined"
+    manager.update_trade_offer(trade)
+    manager.record_event(
+        game_id,
+        payload.player,
+        Action(ActionType.TRADE_PLAYER, {"trade_id": trade.id, "accept": payload.accept}),
+        applied=False,
+    )
+    if payload.accept:
+        action = Action(ActionType.TRADE_PLAYER, {
+            "target": trade.from_player,
+            "offer": trade.offer,
+            "request": trade.request,
+        })
+        _, _, _, info = runtime.env.step(action)
+        if info.get("invalid"):
+            raise HTTPException(status_code=400, detail=info.get("error", "Invalid trade"))
+        manager.record_event(game_id, trade.from_player, action, applied=True)
+    return {"status": trade.status}
+
+
+@app.post("/games/{game_id}/advance")
+async def advance_ai(game_id: str) -> Dict[str, Any]:
+    runtime = _get_runtime(game_id)
+    await _run_ai_turns(runtime)
+    return _build_state(runtime.game, runtime).model_dump()

services/game/models.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import datetime as dt
+from typing import Any, Dict, Optional
+
+from sqlalchemy import Column, JSON
+from sqlmodel import Field, SQLModel
+
+
+class Game(SQLModel, table=True):
+    id: str = Field(primary_key=True)
+    name: str
+    status: str
+    max_players: int
+    created_by: str
+    created_at: dt.datetime
+    updated_at: dt.datetime
+    seed: int
+    slots: Dict[str, Any] = Field(sa_column=Column(JSON))
+    winner: Optional[str] = None
+
+
+class GameEvent(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    game_id: str = Field(index=True)
+    idx: int
+    ts: dt.datetime
+    actor: str
+    action_type: str
+    payload: Dict[str, Any] = Field(sa_column=Column(JSON))
+    applied: bool = True
+    debug_payload: Optional[Dict[str, Any]] = Field(default=None, sa_column=Column(JSON))
+
+
+class TradeOffer(SQLModel, table=True):
+    id: str = Field(primary_key=True)
+    game_id: str = Field(index=True)
+    from_player: str
+    to_player: Optional[str] = None
+    offer: Dict[str, int] = Field(sa_column=Column(JSON))
+    request: Dict[str, int] = Field(sa_column=Column(JSON))
+    status: str
+    created_at: dt.datetime
+    updated_at: dt.datetime

services/game/requirements.txt

@@ -0,0 +1,6 @@
+fastapi>=0.115
+uvicorn[standard]>=0.30
+httpx>=0.27
+sqlmodel>=0.0.16
+pydantic-settings>=2.2
+psycopg[binary]>=3.1

services/game/runtime.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import datetime as dt
+import random
+import uuid
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+from sqlmodel import select
+
+from catan.game import GameConfig
+from catan.sdk import Action, ActionType, CatanEnv
+from services.common.db import session_scope
+from services.game.models import Game, GameEvent, TradeOffer
+
+
+@dataclass
+class GameRuntime:
+    game: Game
+    env: CatanEnv
+    action_index: int = 0
+
+    def next_action_index(self) -> int:
+        self.action_index += 1
+        return self.action_index
+
+
+class GameRuntimeManager:
+    def __init__(self) -> None:
+        self._cache: Dict[str, GameRuntime] = {}
+
+    def get(self, game_id: str) -> GameRuntime:
+        if game_id in self._cache:
+            return self._cache[game_id]
+        runtime = self._load_runtime(game_id)
+        self._cache[game_id] = runtime
+        return runtime
+
+    def drop(self, game_id: str) -> None:
+        self._cache.pop(game_id, None)
+
+    def _load_runtime(self, game_id: str) -> GameRuntime:
+        with session_scope() as session:
+            game = session.get(Game, game_id)
+            if not game:
+                raise KeyError(game_id)
+            slots = game.slots.get("slots", [])
+            names = [slot.get("name") for slot in slots if slot.get("name")]
+            colors = [slot.get("color", "player") for slot in slots if slot.get("name")]
+            config = GameConfig(player_names=names, colors=colors, seed=game.seed)
+            env = CatanEnv(config)
+            events = session.exec(
+                select(GameEvent).where(GameEvent.game_id == game_id, GameEvent.applied == True).order_by(GameEvent.idx)
+            ).all()
+        for event in events:
+            action = Action(ActionType(event.action_type), event.payload)
+            env.step(action)
+        action_index = events[-1].idx if events else 0
+        return GameRuntime(game=game, env=env, action_index=action_index)
+
+    def create_game(self, name: str, max_players: int, created_by: str) -> Game:
+        now = dt.datetime.now(dt.timezone.utc)
+        game_id = str(uuid.uuid4())
+        seed = random.randint(0, 2**31 - 1)
+        slots = {
+            "slots": [
+                {
+                    "slot_id": idx + 1,
+                    "name": None,
+                    "user_id": None,
+                    "is_ai": False,
+                    "ai_kind": None,
+                    "ai_model": None,
+                    "ready": False,
+                    "color": None,
+                }
+                for idx in range(max_players)
+            ]
+        }
+        game = Game(
+            id=game_id,
+            name=name,
+            status="lobby",
+            max_players=max_players,
+            created_by=created_by,
+            created_at=now,
+            updated_at=now,
+            seed=seed,
+            slots=slots,
+        )
+        with session_scope() as session:
+            session.add(game)
+        return game
+
+    def save_game(self, game: Game) -> None:
+        game.updated_at = dt.datetime.now(dt.timezone.utc)
+        with session_scope() as session:
+            session.merge(game)
+
+    def list_games(self) -> List[Game]:
+        with session_scope() as session:
+            return session.exec(select(Game).order_by(Game.created_at.desc())).all()
+
+    def record_event(
+        self,
+        game_id: str,
+        actor: str,
+        action: Action,
+        applied: bool = True,
+        debug: Optional[dict] = None,
+    ) -> GameEvent:
+        with session_scope() as session:
+            last_idx = session.exec(
+                select(GameEvent.idx)
+                .where(GameEvent.game_id == game_id)
+                .order_by(GameEvent.idx.desc())
+                .limit(1)
+            ).first()
+            idx = (last_idx or 0) + 1
+            event = GameEvent(
+                game_id=game_id,
+                idx=idx,
+                ts=dt.datetime.now(dt.timezone.utc),
+                actor=actor,
+                action_type=action.type.value,
+                payload=action.payload,
+                applied=applied,
+                debug_payload=debug,
+            )
+            session.add(event)
+        return event
+
+    def list_events(self, game_id: str) -> List[GameEvent]:
+        with session_scope() as session:
+            return session.exec(
+                select(GameEvent).where(GameEvent.game_id == game_id).order_by(GameEvent.idx)
+            ).all()
+
+    def create_trade_offer(
+        self,
+        game_id: str,
+        from_player: str,
+        to_player: Optional[str],
+        offer: Dict[str, int],
+        request: Dict[str, int],
+    ) -> TradeOffer:
+        now = dt.datetime.now(dt.timezone.utc)
+        offer_id = str(uuid.uuid4())
+        trade = TradeOffer(
+            id=offer_id,
+            game_id=game_id,
+            from_player=from_player,
+            to_player=to_player,
+            offer=offer,
+            request=request,
+            status="open",
+            created_at=now,
+            updated_at=now,
+        )
+        with session_scope() as session:
+            session.add(trade)
+        return trade
+
+    def update_trade_offer(self, trade: TradeOffer) -> None:
+        trade.updated_at = dt.datetime.now(dt.timezone.utc)
+        with session_scope() as session:
+            session.merge(trade)
+
+    def list_trade_offers(self, game_id: str, status: Optional[str] = None) -> List[TradeOffer]:
+        with session_scope() as session:
+            query = select(TradeOffer).where(TradeOffer.game_id == game_id)
+            if status:
+                query = query.where(TradeOffer.status == status)
+            return session.exec(query.order_by(TradeOffer.created_at)).all()
+
+
+manager = GameRuntimeManager()