Session 1: Building Your First NPC Dialogue Agent

"""
NPC Dialogue Agent - Complete Solution
Production-ready implementation with personality system,
context memory, and relationship tracking.
"""

import os
import json
import logging
from typing import Dict, List, Optional
from dataclasses import dataclass, asdict

import anthropic

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Configuration
class Config:
    ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
    MODEL = "claude-3-5-sonnet-20241022"
    MAX_TOKENS = 1024
    TEMPERATURE = 0.8  # Higher for creative dialogue

# NPC Personality Templates
@dataclass
class NPCPersonality:
    name: str
    role: str
    traits: List[str]
    backstory: str
    voice: str
    greeting: str

    def to_dict(self):
        return asdict(self)

# Game State
@dataclass
class GameState:
    player_name: str
    player_level: int
    relationship: int  # -100 (hostile) to 100 (trusted ally)
    previous_interactions: List[str]
    current_quest: Optional[str] = None
    inventory_items: List[str] = None

    def __post_init__(self):
        if self.inventory_items is None:
            self.inventory_items = []

# Personality Factory
def create_npc(name: str, archetype: str) -> NPCPersonality:
    """Create NPC with predefined personality archetypes"""

    archetypes = {
        "friendly_merchant": NPCPersonality(
            name=name,
            role="Traveling Merchant",
            traits=[
                "optimistic",
                "business-minded",
                "helpful",
                "chatty"
            ],
            backstory=(
                f"{name} has traveled the realm for 20 years, "
                "selling rare wares and collecting stories. "
                "Always looking for a good deal and a better tale."
            ),
            voice="casual and enthusiastic",
            greeting=(
                "Ah, welcome friend! I've got just what you need. "
                "Come, come, have a look at my wares!"
            )
        ),

        "suspicious_guard": NPCPersonality(
            name=name,
            role="City Guard Captain",
            traits=[
                "distrustful",
                "duty-bound",
                "formal",
                "observant"
            ],
            backstory=(
                f"Captain {name} has protected the city for a decade. "
                "Seen too many threats to trust strangers easily. "
                "Duty above all else."
            ),
            voice="formal and curt",
            greeting=(
                "State your business, traveler. "
                "We don't tolerate trouble in this city."
            )
        ),

        "wise_elder": NPCPersonality(
            name=name,
            role="Village Elder",
            traits=[
                "wise",
                "patient",
                "cryptic",
                "storyteller"
            ],
            backstory=(
                f"{name} has lived for over 80 years, witnessing "
                "the rise and fall of kingdoms. Speaks in riddles "
                "and ancient wisdom, testing those who seek guidance."
            ),
            voice="slow and contemplative",
            greeting=(
                "Ah, another seeker comes to my door. "
                "Tell me, young one, what brings you to these old bones?"
            )
        )
    }

    if archetype not in archetypes:
        raise ValueError(
            f"Unknown archetype: {archetype}. "
            f"Choose from: {list(archetypes.keys())}"
        )

    return archetypes[archetype]

# Main NPC Agent
class NPCAgent:
    def __init__(self, npc: NPCPersonality, config: Config):
        self.npc = npc
        self.config = config
        self.client = anthropic.Anthropic(
            api_key=config.ANTHROPIC_API_KEY
        )
        self.conversation_history = []

        logger.info(f"Initialized NPC: {npc.name} ({npc.role})")

    def _build_system_prompt(self, game_state: GameState) -> str:
        """Build comprehensive system prompt with personality"""

        # Relationship interpretation
        if game_state.relationship >= 50:
            relationship_desc = "trusted friend and ally"
        elif game_state.relationship >= 20:
            relationship_desc = "friendly acquaintance"
        elif game_state.relationship >= -20:
            relationship_desc = "neutral stranger"
        elif game_state.relationship >= -50:
            relationship_desc = "suspicious individual"
        else:
            relationship_desc = "known troublemaker"

        # Build context
        context_parts = []
        if game_state.current_quest:
            context_parts.append(
                f"Current quest: {game_state.current_quest}"
            )
        if game_state.previous_interactions:
            recent = game_state.previous_interactions[-3:]
            context_parts.append(
                f"Recent interactions: {'; '.join(recent)}"
            )

        context_str = "\n".join(context_parts) if context_parts else "First meeting"

        # Build system prompt
        system_prompt = f"""You are {self.npc.name}, a {self.npc.role}.

PERSONALITY TRAITS: {', '.join(self.npc.traits)}

BACKSTORY: {self.npc.backstory}

VOICE STYLE: Speak in a {self.npc.voice} manner. Stay in character at all times.

PLAYER INFORMATION:
- Name: {game_state.player_name}
- Level: {game_state.player_level}
- Relationship: {game_state.relationship}/100 (you view them as a {relationship_desc})

CONTEXT:
{context_str}

INSTRUCTIONS:
1. Respond naturally as {self.npc.name} would, based on your personality traits
2. Reference your backstory when relevant
3. Adjust tone based on relationship level (warmer if positive, colder if negative)
4. Keep responses concise (2-3 sentences typically)
5. Remember previous interactions mentioned in context
6. Stay consistent with your character's voice and motivations

Respond only as {self.npc.name}. Do not break character or explain your reasoning."""

        return system_prompt

    def chat(
        self,
        player_input: str,
        game_state: GameState,
        max_history: int = 6
    ) -> str:
        """Generate NPC response with context awareness"""

        logger.info(f"Player input: {player_input}")

        # Build system prompt
        system_prompt = self._build_system_prompt(game_state)

        # Add player input to history
        self.conversation_history.append({
            "role": "user",
            "content": player_input
        })

        # Keep only recent history to stay under token limits
        recent_history = self.conversation_history[-max_history:]

        try:
            # Call Claude API
            response = self.client.messages.create(
                model=self.config.MODEL,
                max_tokens=self.config.MAX_TOKENS,
                temperature=self.config.TEMPERATURE,
                system=system_prompt,
                messages=recent_history
            )

            # Extract response
            npc_response = response.content[0].text

            # Add to history
            self.conversation_history.append({
                "role": "assistant",
                "content": npc_response
            })

            # Track interaction
            game_state.previous_interactions.append(
                f"Player: {player_input[:50]}..."
            )

            logger.info(f"NPC response: {npc_response}")

            return npc_response

        except Exception as e:
            logger.error(f"Error generating response: {e}")
            return (
                f"{self.npc.name} seems distracted and "
                "doesn't respond clearly."
            )

    def update_relationship(
        self,
        game_state: GameState,
        action_type: str,
        magnitude: int = 10
    ) -> int:
        """Update relationship based on player actions"""

        action_modifiers = {
            "quest_complete": 20,
            "gift_given": 15,
            "helpful_dialogue": 10,
            "neutral_dialogue": 0,
            "rude_dialogue": -10,
            "aggressive_action": -25,
            "betrayal": -50
        }

        change = action_modifiers.get(action_type, 0)
        old_rel = game_state.relationship
        game_state.relationship = max(-100, min(100, old_rel + change))

        logger.info(
            f"Relationship: {old_rel} -> {game_state.relationship} "
            f"({action_type})"
        )

        return game_state.relationship

    def reset_conversation(self):
        """Clear conversation history"""
        self.conversation_history = []
        logger.info("Conversation history cleared")

# Demo Script
if __name__ == "__main__":
    print("=== NPC Dialogue Agent Demo ===\n")

    # Create NPCs
    npcs = {
        "merchant": create_npc("Gareth", "friendly_merchant"),
        "guard": create_npc("Captain Thorne", "suspicious_guard"),
        "elder": create_npc("Elder Miriam", "wise_elder")
    }

    # Choose NPC
    print("Available NPCs:")
    for key, npc in npcs.items():
        print(f"  {key}: {npc.name} ({npc.role})")

    npc_choice = input("\nChoose NPC (merchant/guard/elder): ").strip()
    chosen_npc = npcs.get(npc_choice, npcs["merchant"])

    # Initialize game state
    game_state = GameState(
        player_name="Hero",
        player_level=5,
        relationship=0,
        previous_interactions=[]
    )

    # Create agent
    agent = NPCAgent(chosen_npc, Config)

    # Greeting
    print(f"\n{chosen_npc.name}: {chosen_npc.greeting}\n")

    # Interactive dialogue loop
    while True:
        player_input = input("You: ").strip()

        if not player_input:
            continue

        if player_input.lower() in ["exit", "quit", "bye"]:
            print(f"\n{chosen_npc.name}: Farewell!")
            break

        # Generate response
        response = agent.chat(player_input, game_state)
        print(f"\n{chosen_npc.name}: {response}\n")

        # Relationship tracking (simplified)
        if "thank" in player_input.lower():
            agent.update_relationship(game_state, "helpful_dialogue")
        elif any(word in player_input.lower() for word in ["idiot", "stupid", "fool"]):
            agent.update_relationship(game_state, "rude_dialogue")

    print("\n=== Demo Complete ===")
    print(f"Final relationship: {game_state.relationship}/100")