feat: implement execute_turn functionality

app.py

@@ -15,6 +15,7 @@ from unpredictable_lord.game_state import (
     ADVICE_DESCRIPTIONS,
     PERSONALITY_DESCRIPTIONS,
     create_session,
+    execute_turn_logic,
     get_available_advice,
     get_session,
 )
@@ -108,6 +109,50 @@ def list_available_advice() -> dict:
     }
 
 
+def execute_turn(session_id: str, advice: str) -> dict:
+    """
+    Execute a turn with the given advice.
+
+    This MCP tool is called by the Lord AI after interpreting the user's suggestion.
+    The lord will decide whether to follow the advice based on personality and trust.
+
+    Args:
+        session_id: The session ID returned from init_game.
+        advice: The advice type to execute. Must be one of:
+                - "increase_tax": Raise taxes (Treasury ↑, Satisfaction ↓)
+                - "decrease_tax": Lower taxes (Treasury ↓, Satisfaction ↑)
+                - "expand_territory": Military expansion (Territory ↑, Treasury ↓, risky)
+                - "improve_diplomacy": Diplomatic efforts (Royal Trust ↑, Treasury ↓)
+                - "public_festival": Hold festival (Satisfaction ↑, Treasury ↓)
+                - "build_infrastructure": Build infrastructure (Population ↑, Treasury ↓)
+                - "do_nothing": Maintain current state
+
+    Returns:
+        dict: Result containing:
+              - adopted: Whether the lord followed the advice
+              - action_taken: The actual action the lord took
+              - parameter_changes: Changes to game parameters
+              - game_over: Whether the game has ended
+              - new_state: Updated game state
+    """
+    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.",
+        }
+
+    result = execute_turn_logic(state, advice)
+
+    logger.info(
+        f"Turn executed for session {session_id}: advice={advice}, "
+        f"adopted={result.get('adopted')}, action={result.get('action_taken')}"
+    )
+
+    return result
+
+
 # Gradio UI
 with gr.Blocks(title="Unpredictable Lord") as demo:
     gr.Markdown("# Unpredictable Lord\nLord Advisor AI Simulation")
@@ -194,12 +239,15 @@ Add the following to your MCP settings configuration:
 | `init_game` | Initialize a new game session. Returns a session_id and available advice options. |
 | `get_game_state` | Get the current game state for a session. |
 | `list_available_advice` | Get all available advice options for execute_turn. |
+| `execute_turn` | Execute a turn with the given advice. Returns whether advice was adopted and results. |
 
 ### Usage Flow
 
 1. Call `init_game(personality)` to start a new game session
-2. Use the returned `session_id` for all subsequent game operations
-3. Game state is managed server-side
+2. User gives free-form advice to the Lord AI
+3. Lord AI interprets advice and calls `execute_turn(session_id, advice)`
+4. Lord AI explains the result to the user (adopted/rejected, action taken, effects)
+5. Repeat from step 2 until game over
 """
             )
 
@@ -238,6 +286,35 @@ Add the following to your MCP settings configuration:
                 fn=list_available_advice, inputs=[], outputs=advice_output
             )
 
+            gr.Markdown("### Test: Execute Turn")
+            with gr.Row():
+                exec_session_id = gr.Textbox(
+                    label="Session ID",
+                    placeholder="Enter session_id",
+                )
+                exec_advice = gr.Dropdown(
+                    choices=[
+                        "increase_tax",
+                        "decrease_tax",
+                        "expand_territory",
+                        "improve_diplomacy",
+                        "public_festival",
+                        "build_infrastructure",
+                        "do_nothing",
+                    ],
+                    value="do_nothing",
+                    label="Advice",
+                )
+                exec_btn = gr.Button("Execute Turn")
+
+            exec_output = gr.JSON(label="Turn Result")
+
+            exec_btn.click(
+                fn=execute_turn,
+                inputs=[exec_session_id, exec_advice],
+                outputs=exec_output,
+            )
+
 
 if __name__ == "__main__":
     demo.launch(mcp_server=True)

src/unpredictable_lord/game_state.py

@@ -5,6 +5,7 @@ This module defines the game state data structure and provides
 functions for managing game sessions.
 """
 
+import random
 from dataclasses import asdict, dataclass, field
 from typing import Literal
 
@@ -157,6 +158,212 @@ class GameState:
 
         return False, None
 
+    def clamp(self, value: int, min_val: int = 0, max_val: int = 100) -> int:
+        """Clamp a value to the valid range."""
+        return max(min_val, min(max_val, value))
+
+    def apply_changes(self, changes: dict[str, int]) -> dict[str, int]:
+        """
+        Apply parameter changes and return the actual changes made.
+
+        Args:
+            changes: Dictionary of parameter changes (can be positive or negative).
+
+        Returns:
+            Dictionary of actual changes applied (after clamping).
+        """
+        actual_changes = {}
+        for param, delta in changes.items():
+            if hasattr(self, param):
+                old_value = getattr(self, param)
+                new_value = self.clamp(old_value + delta)
+                setattr(self, param, new_value)
+                actual_changes[param] = new_value - old_value
+        return actual_changes
+
+
+# Personality-based acceptance rates and biases
+PERSONALITY_TRAITS = {
+    "cautious": {
+        "base_acceptance": 0.4,  # Low base acceptance
+        "preferred": ["do_nothing", "improve_diplomacy"],
+        "disliked": ["expand_territory", "decrease_tax"],
+        "trust_weight": 0.6,  # How much advisor_trust affects acceptance
+    },
+    "idealist": {
+        "base_acceptance": 0.5,
+        "preferred": ["build_infrastructure", "public_festival", "decrease_tax"],
+        "disliked": ["increase_tax", "do_nothing"],
+        "trust_weight": 0.4,  # Less influenced by trust, more by ideals
+    },
+    "populist": {
+        "base_acceptance": 0.6,  # Higher base acceptance
+        "preferred": ["decrease_tax", "public_festival"],
+        "disliked": ["increase_tax", "expand_territory"],
+        "trust_weight": 0.5,
+    },
+}
+
+# Effects of each action when adopted
+ACTION_EFFECTS: dict[str, dict[str, int]] = {
+    "increase_tax": {
+        "treasury": 15,
+        "satisfaction": -10,
+    },
+    "decrease_tax": {
+        "treasury": -10,
+        "satisfaction": 15,
+    },
+    "expand_territory": {
+        "territory": 10,
+        "treasury": -15,
+        "population": 5,
+        # royal_trust is handled specially (can go up or down)
+    },
+    "improve_diplomacy": {
+        "royal_trust": 12,
+        "treasury": -8,
+    },
+    "public_festival": {
+        "satisfaction": 15,
+        "treasury": -12,
+    },
+    "build_infrastructure": {
+        "population": 10,
+        "treasury": -10,
+        "satisfaction": 5,
+    },
+    "do_nothing": {},
+}
+
+# Alternative actions when lord rejects advice
+REJECTION_ALTERNATIVES = {
+    "increase_tax": ["do_nothing", "improve_diplomacy"],
+    "decrease_tax": ["do_nothing", "increase_tax"],
+    "expand_territory": ["do_nothing", "improve_diplomacy"],
+    "improve_diplomacy": ["do_nothing", "public_festival"],
+    "public_festival": ["do_nothing", "improve_diplomacy"],
+    "build_infrastructure": ["do_nothing", "improve_diplomacy"],
+    "do_nothing": ["do_nothing"],  # Always accept do_nothing
+}
+
+
+def execute_turn_logic(state: "GameState", advice: str) -> dict:
+    """
+    Execute a turn based on the given advice.
+
+    This function determines whether the lord accepts the advice based on
+    personality and trust, applies the effects, and returns the result.
+
+    Args:
+        state: The current game state.
+        advice: The advice type chosen by the Lord AI.
+
+    Returns:
+        dict: Result containing adoption status, action taken, effects, and messages.
+    """
+    if advice not in ADVICE_DESCRIPTIONS:
+        return {
+            "error": "Invalid advice",
+            "message": f"Unknown advice type: {advice}. Use list_available_advice to see options.",
+        }
+
+    if state.game_over:
+        return {
+            "error": "Game over",
+            "message": f"This game has ended with result: {state.result}",
+            "game_state": state.to_dict(),
+        }
+
+    personality = state.lord_personality
+    traits = PERSONALITY_TRAITS[personality]
+
+    # Calculate acceptance probability
+    base_prob = traits["base_acceptance"]
+    trust_bonus = (state.advisor_trust / 100) * traits["trust_weight"]
+
+    if advice in traits["preferred"]:
+        preference_bonus = 0.2
+    elif advice in traits["disliked"]:
+        preference_bonus = -0.25
+    else:
+        preference_bonus = 0
+
+    acceptance_prob = min(0.95, max(0.1, base_prob + trust_bonus + preference_bonus))
+
+    # Determine if advice is adopted
+    adopted = random.random() < acceptance_prob
+
+    if adopted:
+        action_taken = advice
+        adoption_message = f"The lord has decided to follow your advice: {ADVICE_DESCRIPTIONS[advice]['name']}."
+    else:
+        # Lord rejects and takes alternative action
+        alternatives = REJECTION_ALTERNATIVES.get(advice, ["do_nothing"])
+        action_taken = random.choice(alternatives)
+        if action_taken == advice:
+            action_taken = "do_nothing"
+        adoption_message = (
+            f"The lord has rejected your advice ({ADVICE_DESCRIPTIONS[advice]['name']}) "
+            f"and instead chose: {ADVICE_DESCRIPTIONS[action_taken]['name']}."
+        )
+
+    # Apply effects of the action taken
+    effects = ACTION_EFFECTS.get(action_taken, {}).copy()
+
+    # Special handling for expand_territory (risky)
+    if action_taken == "expand_territory":
+        if random.random() < 0.6:  # 60% success
+            effects["royal_trust"] = 8
+            outcome_message = "The military campaign was successful!"
+        else:
+            effects["royal_trust"] = -10
+            effects["territory"] = 0  # Failed expansion
+            effects["satisfaction"] = -5
+            outcome_message = "The military campaign failed, damaging our reputation."
+    else:
+        outcome_message = None
+
+    # Apply changes to state
+    actual_changes = state.apply_changes(effects)
+
+    # Adjust advisor trust based on whether advice was followed
+    if adopted:
+        trust_change = random.randint(2, 5)
+    else:
+        trust_change = random.randint(-5, -1)
+    state.advisor_trust = state.clamp(state.advisor_trust + trust_change)
+    actual_changes["advisor_trust"] = trust_change
+
+    # Advance turn
+    state.turn += 1
+
+    # Check for game over
+    game_over, result = state.check_game_over()
+    if game_over:
+        state.game_over = True
+        state.result = result
+
+    # Build result message
+    changes_str = ", ".join(
+        f"{k}: {'+' if v > 0 else ''}{v}" for k, v in actual_changes.items() if v != 0
+    )
+
+    return {
+        "adopted": adopted,
+        "advice_given": advice,
+        "action_taken": action_taken,
+        "action_name": ADVICE_DESCRIPTIONS[action_taken]["name"],
+        "adoption_message": adoption_message,
+        "outcome_message": outcome_message,
+        "parameter_changes": actual_changes,
+        "changes_summary": changes_str or "No changes",
+        "game_over": state.game_over,
+        "game_result": state.result,
+        "new_state": state.to_dict(),
+        "status_summary": state.get_status_summary(),
+    }
+
 
 # Global session storage
 game_sessions: dict[str, GameState] = {}