feat: implement game state management

app.py

@@ -11,15 +11,17 @@ import gradio as gr
 import spaces
 
 from unpredictable_lord.chat import chat_with_llm_stream
+from unpredictable_lord.game_state import (
+    PERSONALITY_DESCRIPTIONS,
+    create_session,
+    get_session,
+)
 
 logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
 logger = logging.getLogger(__name__)
 
 logger.info(f"ZeroGPU: {spaces.config.Config.zero_gpu}")
 
-# Global session storage
-game_sessions: dict[str, dict] = {}
-
 
 def init_game(personality: str = "cautious") -> dict:
     """
@@ -38,19 +40,12 @@ def init_game(personality: str = "cautious") -> dict:
     """
     session_id = str(uuid.uuid4())
 
-    # Initial game state
-    game_sessions[session_id] = {
-        "territory": 50,
-        "population": 50,
-        "treasury": 50,
-        "unrest": 50,
-        "royal_trust": 50,
-        "advisor_trust": 50,
-        "turn": 1,
-        "lord_personality": personality,
-        "game_over": False,
-        "result": None,
-    }
+    # Validate personality
+    if personality not in PERSONALITY_DESCRIPTIONS:
+        personality = "cautious"
+
+    # Create game session using game_state module
+    state = create_session(session_id, personality)
 
     logger.info(
         f"New game session created: {session_id} with personality: {personality}"
@@ -59,7 +54,36 @@ def init_game(personality: str = "cautious") -> dict:
     return {
         "session_id": session_id,
         "message": f"New game started! You are now the advisor to a {personality} lord.",
-        "game_state": game_sessions[session_id],
+        "personality_description": PERSONALITY_DESCRIPTIONS[personality],
+        "game_state": state.to_dict(),
+    }
+
+
+def get_game_state(session_id: str) -> dict:
+    """
+    Get the current game state for a session.
+
+    This MCP tool retrieves the current state of a game session,
+    including all parameters, turn number, and game status.
+
+    Args:
+        session_id: The session ID returned from init_game.
+
+    Returns:
+        dict: Current game state or error message if session not found.
+    """
+    state = get_session(session_id)
+
+    if state is None:
+        return {
+            "error": "Session not found",
+            "message": f"No game session found with ID: {session_id}. Please call init_game first.",
+        }
+
+    return {
+        "session_id": session_id,
+        "game_state": state.to_dict(),
+        "status_summary": state.get_status_summary(),
     }
 
 
@@ -147,6 +171,7 @@ Add the following to your MCP settings configuration:
 | Tool | Description |
 |------|-------------|
 | `init_game` | Initialize a new game session. Returns a session_id for subsequent operations. |
+| `get_game_state` | Get the current game state for a session. |
 
 ### Usage Flow
 
@@ -169,6 +194,20 @@ Add the following to your MCP settings configuration:
 
             init_btn.click(fn=init_game, inputs=personality_input, outputs=init_output)
 
+            gr.Markdown("### Test: Get Game State")
+            with gr.Row():
+                session_id_input = gr.Textbox(
+                    label="Session ID",
+                    placeholder="Enter session_id from init_game",
+                )
+                get_state_btn = gr.Button("Get State")
+
+            state_output = gr.JSON(label="Current Game State")
+
+            get_state_btn.click(
+                fn=get_game_state, inputs=session_id_input, outputs=state_output
+            )
+
 
 if __name__ == "__main__":
     demo.launch(mcp_server=True)

src/unpredictable_lord/game_state.py

@@ -0,0 +1,150 @@
+"""
+Game state management for Unpredictable Lord.
+
+This module defines the game state data structure and provides
+functions for managing game sessions.
+"""
+
+from dataclasses import asdict, dataclass, field
+from typing import Literal
+
+LordPersonality = Literal["cautious", "idealist", "populist"]
+
+PERSONALITY_DESCRIPTIONS = {
+    "cautious": "A risk-averse lord who prioritizes stability and financial security above all else.",
+    "idealist": "An emotional idealist who pursues noble goals but reacts harshly to opposition.",
+    "populist": "A popularity-focused lord who prioritizes public approval over long-term planning.",
+}
+
+
+@dataclass
+class GameState:
+    """
+    Represents the current state of a game session.
+
+    All numeric parameters range from 0 to 100.
+    Initial values are set to 50 (balanced state).
+    """
+
+    # Core parameters (0-100, higher is better)
+    territory: int = 50  # Territory size - affects income and population cap
+    population: int = 50  # Population - base for tax revenue
+    treasury: int = 50  # Finances - required for policy execution
+    satisfaction: int = 50  # Public satisfaction - low values risk rebellion
+    royal_trust: int = 50  # Trust from the kingdom - affects diplomacy
+    advisor_trust: int = 50  # Lord's trust in advisor - affects advice acceptance
+
+    # Game progress
+    turn: int = 1
+    lord_personality: LordPersonality = "cautious"
+
+    # Game status
+    game_over: bool = False
+    result: str | None = None  # "victory_territory", "victory_trust", etc.
+
+    # Event tracking
+    current_event: str | None = None
+    event_history: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        """Convert game state to dictionary for JSON serialization."""
+        return asdict(self)
+
+    def get_status_summary(self) -> str:
+        """Generate a human-readable status summary."""
+        status_lines = [
+            f"Turn: {self.turn}",
+            f"Lord Personality: {self.lord_personality}",
+            "",
+            "=== Parameters ===",
+            f"Territory: {self.territory}/100",
+            f"Population: {self.population}/100",
+            f"Treasury: {self.treasury}/100",
+            f"Public Satisfaction: {self.satisfaction}/100",
+            f"Royal Trust: {self.royal_trust}/100",
+            f"Advisor Trust: {self.advisor_trust}/100",
+        ]
+
+        if self.current_event:
+            status_lines.extend(["", f"Current Event: {self.current_event}"])
+
+        if self.game_over:
+            status_lines.extend(["", f"GAME OVER: {self.result}"])
+
+        return "\n".join(status_lines)
+
+    def check_game_over(self) -> tuple[bool, str | None]:
+        """
+        Check if the game has ended.
+
+        Returns:
+            tuple: (is_game_over, result_type)
+        """
+        # Defeat conditions
+        if self.satisfaction <= 0:
+            return True, "defeat_rebellion"
+        if self.royal_trust <= 0:
+            return True, "defeat_exile"
+        if self.treasury <= 0 and self.satisfaction <= 20:
+            return True, "defeat_bankruptcy"
+
+        # Victory conditions
+        if self.territory >= 100:
+            return True, "victory_territory"
+        if self.advisor_trust >= 100 and self.turn >= 10:
+            return True, "victory_trust"
+        if self.treasury >= 100 and self.royal_trust >= 80:
+            return True, "victory_wealth"
+
+        return False, None
+
+
+# Global session storage
+game_sessions: dict[str, GameState] = {}
+
+
+def create_session(
+    session_id: str, personality: LordPersonality = "cautious"
+) -> GameState:
+    """
+    Create a new game session with the given ID.
+
+    Args:
+        session_id: Unique session identifier.
+        personality: The lord's personality type.
+
+    Returns:
+        The newly created GameState.
+    """
+    state = GameState(lord_personality=personality)
+    game_sessions[session_id] = state
+    return state
+
+
+def get_session(session_id: str) -> GameState | None:
+    """
+    Retrieve a game session by ID.
+
+    Args:
+        session_id: The session ID to look up.
+
+    Returns:
+        The GameState if found, None otherwise.
+    """
+    return game_sessions.get(session_id)
+
+
+def delete_session(session_id: str) -> bool:
+    """
+    Delete a game session.
+
+    Args:
+        session_id: The session ID to delete.
+
+    Returns:
+        True if deleted, False if not found.
+    """
+    if session_id in game_sessions:
+        del game_sessions[session_id]
+        return True
+    return False