Update app.py

app.py

@@ -1,7 +1,1217 @@
+# app.py - Expanded D&D Campaign and Character Creator with AI Agents
+
 import gradio as gr
+import logging
+from typing import Dict, List, Tuple, Optional
+import json
+import os
+from dotenv import load_dotenv
+from dataclasses import dataclass
+from enum import Enum
+import random
+
+# Load environment variables
+load_dotenv()
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ===== DATA MODELS =====
+class Alignment(Enum):
+    LAWFUL_GOOD = "Lawful Good"
+    NEUTRAL_GOOD = "Neutral Good" 
+    CHAOTIC_GOOD = "Chaotic Good"
+    LAWFUL_NEUTRAL = "Lawful Neutral"
+    TRUE_NEUTRAL = "True Neutral"
+    CHAOTIC_NEUTRAL = "Chaotic Neutral"
+    LAWFUL_EVIL = "Lawful Evil"
+    NEUTRAL_EVIL = "Neutral Evil"
+    CHAOTIC_EVIL = "Chaotic Evil"
+
+@dataclass
+class CharacterClass:
+    name: str
+    hit_die: int
+    primary_ability: List[str]
+    saving_throws: List[str]
+    skills: List[str]
+
+@dataclass 
+class Race:
+    name: str
+    ability_modifiers: Dict[str, int]
+    traits: List[str]
+    languages: List[str]
+
+@dataclass
+class Character:
+    name: str
+    race: str
+    character_class: str
+    level: int
+    alignment: Alignment
+    abilities: Dict[str, int]
+    hit_points: int
+    skills: List[str]
+    background: str
+    backstory: str
+    portrait_url: Optional[str] = None
+
+@dataclass
+class Campaign:
+    name: str
+    theme: str
+    level_range: str
+    description: str
+    locations: List[str]
+    npcs: List[str]
+    plot_hooks: List[str]
+
+@dataclass
+class NPC:
+    name: str
+    race: str
+    occupation: str
+    personality: str
+    secret: str
+    voice_description: str
+    relationship_to_party: str
+
+# ===== AI AGENT CLASSES =====
+class DungeonMasterAgent:
+    """AI agent that acts as a Dungeon Master"""
+    
+    def __init__(self):
+        self.personality = "Creative, fair, and engaging storyteller"
+        self.knowledge_areas = ["D&D rules", "storytelling", "world-building", "character development"]
+    
+    def generate_campaign_concept(self, theme: str, level: int, player_count: int) -> Dict:
+        """Generate a complete campaign concept"""
+        try:
+            from openai import OpenAI
+            client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+            
+            prompt = f"""As an experienced D&D Dungeon Master, create a campaign concept for:
+            Theme: {theme}
+            Player Level: {level}
+            Number of Players: {player_count}
+            
+            Provide:
+            1. Campaign Name
+            2. Core Plot Hook (2-3 sentences)
+            3. Main Antagonist
+            4. 3 Key Locations
+            5. Central Conflict
+            6. Estimated Campaign Length
+            7. Unique Elements/Mechanics
+            
+            Make it engaging and ready to play!"""
+            
+            response = client.chat.completions.create(
+                model="gpt-4",
+                messages=[{"role": "system", "content": "You are an expert D&D Dungeon Master with 20 years of experience creating memorable campaigns."},
+                         {"role": "user", "content": prompt}],
+                max_tokens=500,
+                temperature=0.8
+            )
+            
+            content = response.choices[0].message.content
+            return {"success": True, "content": content}
+            
+        except Exception as e:
+            logger.error(f"Campaign generation failed: {e}")
+            return {"success": False, "error": str(e)}
+
+    def generate_session_content(self, campaign_context: str, session_number: int) -> Dict:
+        """Generate content for a specific session"""
+        try:
+            from openai import OpenAI
+            client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+            
+            prompt = f"""Create session {session_number} content for this campaign:
+            {campaign_context}
+            
+            Generate:
+            1. Session Opening (scene description)
+            2. 3 Potential Encounters (combat, social, exploration)
+            3. Key NPCs for this session
+            4. Skill challenges or puzzles
+            5. Potential plot developments
+            6. Cliffhanger ending options
+            
+            Make it detailed enough for a DM to run immediately."""
+            
+            response = client.chat.completions.create(
+                model="gpt-4",
+                messages=[{"role": "system", "content": "You are a D&D Dungeon Master preparing detailed session content."},
+                         {"role": "user", "content": prompt}],
+                max_tokens=600,
+                temperature=0.7
+            )
+            
+            return {"success": True, "content": response.choices[0].message.content}
+            
+        except Exception as e:
+            logger.error(f"Session generation failed: {e}")
+            return {"success": False, "error": str(e)}
+
+class NPCAgent:
+    """AI agent specialized in creating and roleplaying NPCs"""
+    
+    def __init__(self):
+        self.personality = "Versatile character actor with deep understanding of motivations"
+        self.specializations = ["Character creation", "Dialogue", "Motivations", "Voice acting"]
+    
+    def generate_npc(self, context: str, role: str, importance: str) -> Dict:
+        """Generate a detailed NPC"""
+        try:
+            from openai import OpenAI
+            client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+            
+            prompt = f"""Create a detailed NPC for:
+            Context: {context}
+            Role: {role}
+            Importance: {importance}
+            
+            Generate:
+            1. Name and basic demographics
+            2. Personality traits (3-4 key traits)
+            3. Background and motivation
+            4. Speech patterns/accent description
+            5. Physical description
+            6. Secret or hidden agenda
+            7. How they react to different party approaches
+            8. Potential quest hooks they could provide
+            
+            Make them memorable and three-dimensional!"""
+            
+            response = client.chat.completions.create(
+                model="gpt-4",
+                messages=[{"role": "system", "content": "You are an expert at creating memorable, three-dimensional NPCs for D&D campaigns."},
+                         {"role": "user", "content": prompt}],
+                max_tokens=400,
+                temperature=0.8
+            )
+            
+            return {"success": True, "content": response.choices[0].message.content}
+            
+        except Exception as e:
+            logger.error(f"NPC generation failed: {e}")
+            return {"success": False, "error": str(e)}
+    
+    def roleplay_npc(self, npc_description: str, player_input: str, context: str) -> Dict:
+        """Roleplay as an NPC in response to player actions"""
+        try:
+            from openai import OpenAI
+            client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+            
+            prompt = f"""You are roleplaying as this NPC:
+            {npc_description}
+            
+            Context: {context}
+            Player says/does: {player_input}
+            
+            Respond in character with:
+            1. Dialogue (in quotes)
+            2. Actions/body language (in italics)
+            3. Internal thoughts/motivations (in parentheses)
+            
+            Stay true to the character's personality and motivations!"""
+            
+            response = client.chat.completions.create(
+                model="gpt-4",
+                messages=[{"role": "system", "content": "You are a skilled voice actor and D&D player, staying in character as NPCs."},
+                         {"role": "user", "content": prompt}],
+                max_tokens=200,
+                temperature=0.9
+            )
+            
+            return {"success": True, "content": response.choices[0].message.content}
+            
+        except Exception as e:
+            logger.error(f"NPC roleplay failed: {e}")
+            return {"success": False, "error": str(e)}
+
+class WorldBuilderAgent:
+    """AI agent focused on creating consistent world elements"""
+    
+    def __init__(self):
+        self.personality = "Detail-oriented architect of fictional worlds"
+        self.specializations = ["Geography", "Politics", "Culture", "History", "Economics"]
+    
+    def generate_location(self, location_type: str, theme: str, purpose: str) -> Dict:
+        """Generate a detailed location"""
+        try:
+            from openai import OpenAI
+            client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+            
+            prompt = f"""Create a detailed {location_type} with:
+            Theme: {theme}
+            Purpose in campaign: {purpose}
+            
+            Generate:
+            1. Name and general description
+            2. Key areas/rooms (at least 5)
+            3. Notable inhabitants
+            4. Hidden secrets or mysteries
+            5. Potential dangers or challenges
+            6. Valuable resources or rewards
+            7. Connections to broader world/campaign
+            8. Sensory details (sights, sounds, smells)
+            
+            Make it feel lived-in and realistic!"""
+            
+            response = client.chat.completions.create(
+                model="gpt-4",
+                messages=[{"role": "system", "content": "You are a master world-builder creating immersive D&D locations."},
+                         {"role": "user", "content": prompt}],
+                max_tokens=500,
+                temperature=0.7
+            )
+            
+            return {"success": True, "content": response.choices[0].message.content}
+            
+        except Exception as e:
+            logger.error(f"Location generation failed: {e}")
+            return {"success": False, "error": str(e)}
+
+class LootMasterAgent:
+    """AI agent specialized in creating balanced loot and magic items"""
+    
+    def __init__(self):
+        self.personality = "Meticulous curator of magical treasures"
+        self.specializations = ["Game balance", "Magic item design", "Treasure distribution"]
+    
+    def generate_loot_table(self, level: int, encounter_type: str, rarity: str) -> Dict:
+        """Generate a balanced loot table"""
+        try:
+            from openai import OpenAI
+            client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+            
+            prompt = f"""Create a balanced loot table for:
+            Party Level: {level}
+            Encounter Type: {encounter_type}
+            Rarity Level: {rarity}
+            
+            Generate:
+            1. Gold/Currency amounts
+            2. Common items (consumables, gear)
+            3. Uncommon magical items (if appropriate)
+            4. Rare items (if high level)
+            5. Unique/plot-relevant items
+            6. Alternative treasures (information, allies, etc.)
+            
+            Ensure balance and appropriateness for the level!"""
+            
+            response = client.chat.completions.create(
+                model="gpt-4",
+                messages=[{"role": "system", "content": "You are an expert at D&D game balance and treasure design."},
+                         {"role": "user", "content": prompt}],
+                max_tokens=300,
+                temperature=0.6
+            )
+            
+            return {"success": True, "content": response.choices[0].message.content}
+            
+        except Exception as e:
+            logger.error(f"Loot generation failed: {e}")
+            return {"success": False, "error": str(e)}
+
+    def create_custom_magic_item(self, item_concept: str, power_level: str, campaign_theme: str) -> Dict:
+        """Create a custom magic item"""
+        try:
+            from openai import OpenAI
+            client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+            
+            prompt = f"""Design a custom magic item:
+            Concept: {item_concept}
+            Power Level: {power_level}
+            Campaign Theme: {campaign_theme}
+            
+            Provide:
+            1. Item name and basic description
+            2. Mechanical effects (stats, abilities)
+            3. Activation requirements
+            4. Rarity and attunement needs
+            5. Physical appearance
+            6. Historical background/lore
+            7. Potential drawbacks or limitations
+            8. How it fits the campaign theme
+            
+            Make it balanced and interesting!"""
+            
+            response = client.chat.completions.create(
+                model="gpt-4",
+                messages=[{"role": "system", "content": "You are a master craftsperson of magical items for D&D, balancing power with narrative interest."},
+                         {"role": "user", "content": prompt}],
+                max_tokens=400,
+                temperature=0.7
+            )
+            
+            return {"success": True, "content": response.choices[0].message.content}
+            
+        except Exception as e:
+            logger.error(f"Magic item creation failed: {e}")
+            return {"success": False, "error": str(e)}
+
+# ===== CHARACTER CREATOR CLASS =====
+class CharacterCreator:
+    """Enhanced character creator with AI integration"""
+
+    def __init__(self):
+        self.classes = self._get_default_classes()
+        self.races = self._get_default_races()
+        self.backgrounds = self._get_backgrounds()
+
+    def _get_default_classes(self) -> Dict[str, CharacterClass]:
+        return {
+            "Fighter": CharacterClass(
+                name="Fighter", hit_die=10, 
+                primary_ability=["Strength", "Dexterity"], 
+                saving_throws=["Strength", "Constitution"], 
+                skills=["Acrobatics", "Animal Handling", "Athletics", "History", "Insight", "Intimidation", "Perception", "Survival"]
+            ),
+            "Wizard": CharacterClass(
+                name="Wizard", hit_die=6, 
+                primary_ability=["Intelligence"], 
+                saving_throws=["Intelligence", "Wisdom"], 
+                skills=["Arcana", "History", "Insight", "Investigation", "Medicine", "Religion"]
+            ),
+            "Rogue": CharacterClass(
+                name="Rogue", hit_die=8, 
+                primary_ability=["Dexterity"], 
+                saving_throws=["Dexterity", "Intelligence"], 
+                skills=["Acrobatics", "Athletics", "Deception", "Insight", "Intimidation", "Investigation", "Perception", "Performance", "Persuasion", "Sleight of Hand", "Stealth"]
+            ),
+            "Cleric": CharacterClass(
+                name="Cleric", hit_die=8, 
+                primary_ability=["Wisdom"], 
+                saving_throws=["Wisdom", "Charisma"], 
+                skills=["History", "Insight", "Medicine", "Persuasion", "Religion"]
+            ),
+            "Barbarian": CharacterClass(
+                name="Barbarian", hit_die=12, 
+                primary_ability=["Strength"], 
+                saving_throws=["Strength", "Constitution"], 
+                skills=["Animal Handling", "Athletics", "Intimidation", "Nature", "Perception", "Survival"]
+            ),
+            "Bard": CharacterClass(
+                name="Bard", hit_die=8, 
+                primary_ability=["Charisma"], 
+                saving_throws=["Dexterity", "Charisma"], 
+                skills=["Any three of your choice"]
+            ),
+            "Druid": CharacterClass(
+                name="Druid", hit_die=8, 
+                primary_ability=["Wisdom"], 
+                saving_throws=["Intelligence", "Wisdom"], 
+                skills=["Arcana", "Animal Handling", "Insight", "Medicine", "Nature", "Perception", "Religion", "Survival"]
+            ),
+            "Monk": CharacterClass(
+                name="Monk", hit_die=8, 
+                primary_ability=["Dexterity", "Wisdom"], 
+                saving_throws=["Strength", "Dexterity"], 
+                skills=["Acrobatics", "Athletics", "History", "Insight", "Religion", "Stealth"]
+            ),
+            "Paladin": CharacterClass(
+                name="Paladin", hit_die=10, 
+                primary_ability=["Strength", "Charisma"], 
+                saving_throws=["Wisdom", "Charisma"], 
+                skills=["Athletics", "Insight", "Intimidation", "Medicine", "Persuasion", "Religion"]
+            ),
+            "Ranger": CharacterClass(
+                name="Ranger", hit_die=10, 
+                primary_ability=["Dexterity", "Wisdom"], 
+                saving_throws=["Strength", "Dexterity"], 
+                skills=["Animal Handling", "Athletics", "Insight", "Investigation", "Nature", "Perception", "Stealth", "Survival"]
+            ),
+            "Sorcerer": CharacterClass(
+                name="Sorcerer", hit_die=6, 
+                primary_ability=["Charisma"], 
+                saving_throws=["Constitution", "Charisma"], 
+                skills=["Arcana", "Deception", "Insight", "Intimidation", "Persuasion", "Religion"]
+            ),
+            "Warlock": CharacterClass(
+                name="Warlock", hit_die=8, 
+                primary_ability=["Charisma"], 
+                saving_throws=["Wisdom", "Charisma"], 
+                skills=["Arcana", "Deception", "History", "Intimidation", "Investigation", "Nature", "Religion"]
+            )
+        }
+
+    def _get_default_races(self) -> Dict[str, Race]:
+        return {
+            "Human": Race(
+                name="Human", 
+                ability_modifiers={"All": 1}, 
+                traits=["Extra Language", "Extra Skill", "Versatile"], 
+                languages=["Common", "One other"]
+            ),
+            "Elf": Race(
+                name="Elf", 
+                ability_modifiers={"Dexterity": 2}, 
+                traits=["Darkvision", "Keen Senses", "Fey Ancestry", "Trance"], 
+                languages=["Common", "Elvish"]
+            ),
+            "Dwarf": Race(
+                name="Dwarf", 
+                ability_modifiers={"Constitution": 2}, 
+                traits=["Darkvision", "Dwarven Resilience", "Stonecunning"], 
+                languages=["Common", "Dwarvish"]
+            ),
+            "Halfling": Race(
+                name="Halfling", 
+                ability_modifiers={"Dexterity": 2}, 
+                traits=["Lucky", "Brave", "Halfling Nimbleness"], 
+                languages=["Common", "Halfling"]
+            ),
+            "Dragonborn": Race(
+                name="Dragonborn", 
+                ability_modifiers={"Strength": 2, "Charisma": 1}, 
+                traits=["Draconic Ancestry", "Breath Weapon", "Damage Resistance"], 
+                languages=["Common", "Draconic"]
+            ),
+            "Gnome": Race(
+                name="Gnome", 
+                ability_modifiers={"Intelligence": 2}, 
+                traits=["Darkvision", "Gnome Cunning"], 
+                languages=["Common", "Gnomish"]
+            ),
+            "Half-Elf": Race(
+                name="Half-Elf", 
+                ability_modifiers={"Charisma": 2, "Choice": 1}, 
+                traits=["Darkvision", "Fey Ancestry", "Two Skills"], 
+                languages=["Common", "Elvish", "One other"]
+            ),
+            "Half-Orc": Race(
+                name="Half-Orc", 
+                ability_modifiers={"Strength": 2, "Constitution": 1}, 
+                traits=["Darkvision", "Relentless Endurance", "Savage Attacks"], 
+                languages=["Common", "Orc"]
+            ),
+            "Tiefling": Race(
+                name="Tiefling", 
+                ability_modifiers={"Intelligence": 1, "Charisma": 2}, 
+                traits=["Darkvision", "Hellish Resistance", "Infernal Legacy"], 
+                languages=["Common", "Infernal"]
+            )
+        }
+
+    def _get_backgrounds(self) -> List[str]:
+        return [
+            "Acolyte", "Criminal", "Folk Hero", "Noble", "Sage", "Soldier",
+            "Charlatan", "Entertainer", "Guild Artisan", "Hermit", "Outlander", "Sailor"
+        ]
+
+    def roll_ability_scores(self) -> Dict[str, int]:
+        """Roll 4d6, drop lowest, for each ability score"""
+        abilities = {}
+        for ability in ["Strength", "Dexterity", "Constitution", "Intelligence", "Wisdom", "Charisma"]:
+            rolls = [random.randint(1, 6) for _ in range(4)]
+            rolls.sort(reverse=True)
+            abilities[ability] = sum(rolls[:3])  # Take top 3
+        return abilities
+
+    def calculate_ability_modifier(self, score: int) -> int:
+        """Calculate ability modifier from score"""
+        return (score - 10) // 2
+
+    def calculate_hit_points(self, char_class: str, level: int, constitution_modifier: int) -> int:
+        """Calculate hit points based on class, level, and CON modifier"""
+        hit_die = self.classes[char_class].hit_die
+        base_hp = hit_die + constitution_modifier  # Max HP at level 1
+        
+        # Add average HP for additional levels
+        for _ in range(level - 1):
+            base_hp += (hit_die // 2 + 1) + constitution_modifier
+            
+        return max(1, base_hp)  # Minimum 1 HP
+
+    def apply_racial_modifiers(self, base_abilities: Dict[str, int], race: str) -> Dict[str, int]:
+        """Apply racial ability score modifiers"""
+        modified_abilities = base_abilities.copy()
+        race_data = self.races[race]
+        
+        for ability, modifier in race_data.ability_modifiers.items():
+            if ability == "All":
+                for ability_name in modified_abilities:
+                    modified_abilities[ability_name] += modifier
+            elif ability == "Choice":
+                # For simplicity, add to lowest score
+                lowest_ability = min(modified_abilities, key=modified_abilities.get)
+                modified_abilities[lowest_ability] += modifier
+            else:
+                modified_abilities[ability] += modifier
+                
+        return modified_abilities
+
+# ===== IMAGE GENERATION =====
+def generate_image(prompt: str) -> str:
+    """Generate image using OpenAI DALL-E"""
+    try:
+        from openai import OpenAI
+        client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        
+        response = client.images.generate(
+            model="dall-e-3",
+            prompt=prompt,
+            size="1024x1024",
+            quality="standard",
+            n=1,
+        )
+        
+        return response.data[0].url
+        
+    except Exception as e:
+        logger.error(f"Image generation failed: {e}")
+        return "https://via.placeholder.com/512x512/dc2626/ffffff?text=Image+Generation+Failed"
+
+# ===== MAIN INTERFACE =====
+def create_main_interface():
+    """Create the main D&D Campaign Manager interface"""
+    
+    # Initialize agents
+    dm_agent = DungeonMasterAgent()
+    npc_agent = NPCAgent()
+    world_agent = WorldBuilderAgent()
+    loot_agent = LootMasterAgent()
+    character_creator = CharacterCreator()
+    
+    custom_css = """
+    .agent-card {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 20px;
+        border-radius: 15px;
+        margin: 10px 0;
+        color: white;
+    }
+    
+    .output-box {
+        background: #f8f9fa;
+        border: 1px solid #dee2e6;
+        border-radius: 10px;
+        padding: 15px;
+        margin: 10px 0;
+    }
+    """
+    
+    with gr.Blocks(css=custom_css, title="D&D Campaign Manager") as demo:
+        gr.Markdown("""
+        # 🏰 Advanced D&D Campaign Manager
+        
+        *Your AI-powered toolkit for epic adventures*
+        
+        **Features:**
+        - 🎭 AI Dungeon Master Assistant
+        - 👥 Intelligent NPC Creator & Roleplay
+        - 🗺️ World Builder Agent
+        - 💰 Loot Master & Magic Item Designer
+        - 🐉 Enhanced Character Creator
+        """)
+        
+        with gr.Tabs():
+            # ===== CHARACTER CREATOR TAB =====
+            with gr.TabItem("🐉 Character Creator"):
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        gr.Markdown("## 📝 Character Details")
+                        
+                        character_name = gr.Textbox(label="Character Name", placeholder="Enter name...")
+                        
+                        with gr.Row():
+                            race_dropdown = gr.Dropdown(
+                                choices=list(character_creator.races.keys()),
+                                label="Race", value="Human"
+                            )
+                            class_dropdown = gr.Dropdown(
+                                choices=list(character_creator.classes.keys()),
+                                label="Class", value="Fighter"
+                            )
+                        
+                        with gr.Row():
+                            level_slider = gr.Slider(minimum=1, maximum=20, step=1, value=1, label="Level")
+                            alignment_dropdown = gr.Dropdown(
+                                choices=[alignment.value for alignment in Alignment],
+                                label="Alignment", value=Alignment.LAWFUL_GOOD.value
+                            )
+                        
+                        background_dropdown = gr.Dropdown(
+                            choices=character_creator._get_backgrounds(),
+                            label="Background", value="Folk Hero"
+                        )
+                        
+                        # AI Enhancement Buttons
+                        with gr.Row():
+                            generate_name_btn = gr.Button("✨ AI Generate Name", variant="secondary")
+                            generate_backstory_btn = gr.Button("📚 AI Generate Backstory", variant="secondary")
+                        
+                        backstory = gr.Textbox(label="Backstory", lines=4, placeholder="Character background...")
+                        
+                        # Ability Scores
+                        gr.Markdown("## 🎲 Ability Scores")
+                        roll_btn = gr.Button("🎲 Roll Ability Scores", variant="primary")
+                        
+                        with gr.Row():
+                            str_score = gr.Number(label="Strength", value=10, precision=0)
+                            dex_score = gr.Number(label="Dexterity", value=10, precision=0)
+                            con_score = gr.Number(label="Constitution", value=10, precision=0)
+                        
+                        with gr.Row():
+                            int_score = gr.Number(label="Intelligence", value=10, precision=0)
+                            wis_score = gr.Number(label="Wisdom", value=10, precision=0)
+                            cha_score = gr.Number(label="Charisma", value=10, precision=0)
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("## 📊 Character Summary")
+                        character_summary = gr.Markdown("*Create character to see summary*")
+                        
+                        gr.Markdown("## 🎨 Character Portrait")
+                        portrait_btn = gr.Button("🎨 Generate AI Portrait", variant="primary")
+                        character_portrait = gr.Image(label="Portrait", height=300)
+                        
+                        gr.Markdown("## 💾 Export")
+                        export_btn = gr.Button("📥 Export Character")
+                        export_file = gr.File(label="Character JSON")
+                
+                # Hidden state
+                character_data = gr.State()
+            
+            # ===== CAMPAIGN CREATOR TAB =====
+            with gr.TabItem("🎭 AI Dungeon Master"):
+                gr.Markdown("## 🎯 Campaign Generation", elem_classes=["agent-card"])
+                
+                with gr.Row():
+                    with gr.Column():
+                        campaign_theme = gr.Dropdown(
+                            choices=["High Fantasy", "Dark Fantasy", "Urban Fantasy", "Steampunk", "Horror", "Comedy", "Political Intrigue", "Exploration"],
+                            label="Campaign Theme", value="High Fantasy"
+                        )
+                        campaign_level = gr.Slider(minimum=1, maximum=20, value=5, label="Starting Level")
+                        player_count = gr.Slider(minimum=1, maximum=8, value=4, label="Number of Players")
+                        
+                        generate_campaign_btn = gr.Button("🎲 Generate Campaign Concept", variant="primary", size="lg")
+                    
+                    with gr.Column():
+                        campaign_visual_btn = gr.Button("🖼️ Generate Campaign Art")
+                        campaign_image = gr.Image(label="Campaign Visual", height=300)
+                
+                campaign_output = gr.Textbox(label="Campaign Concept", lines=10, elem_classes=["output-box"])
+                
+                gr.Markdown("## 📅 Session Planning")
+                with gr.Row():
+                    session_number = gr.Number(label="Session Number", value=1, precision=0)
+                    generate_session_btn = gr.Button("📝 Generate Session Content", variant="secondary")
+                
+                session_output = gr.Textbox(label="Session Content", lines=8, elem_classes=["output-box"])
+            
+            # ===== NPC CREATOR TAB =====
+            with gr.TabItem("👥 NPC Agent"):
+                gr.Markdown("## 🎭 NPC Creator & Roleplay Assistant", elem_classes=["agent-card"])
+                
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Create New NPC")
+                        npc_context = gr.Textbox(label="Campaign/Scene Context", placeholder="Describe the setting or situation...")
+                        npc_role = gr.Dropdown(
+                            choices=["Ally", "Neutral", "Antagonist", "Quest Giver", "Merchant", "Authority Figure", "Mysterious Stranger"],
+                            label="NPC Role", value="Neutral"
+                        )
+                        npc_importance = gr.Dropdown(
+                            choices=["Minor", "Moderate", "Major", "Recurring"],
+                            label="Importance Level", value="Moderate"
+                        )
+                        
+                        create_npc_btn = gr.Button("🎭 Generate NPC", variant="primary")
+                        
+                        npc_portrait_btn = gr.Button("🎨 Generate NPC Portrait")
+                        npc_portrait = gr.Image(label="NPC Portrait", height=300)
+                    
+                    with gr.Column():
+                        npc_output = gr.Textbox(label="Generated NPC", lines=12, elem_classes=["output-box"])
+                
+                gr.Markdown("### 💬 NPC Roleplay")
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        player_input = gr.Textbox(label="Player Action/Dialogue", placeholder="What does the player say or do?")
+                        roleplay_context = gr.Textbox(label="Scene Context", placeholder="Describe the current situation...")
+                    
+                    with gr.Column(scale=1):
+                        roleplay_btn = gr.Button("🎭 NPC Response", variant="secondary", size="lg")
+                
+                npc_response = gr.Textbox(label="NPC Response", lines=4, elem_classes=["output-box"])
+                
+                # Hidden states for NPC
+                current_npc_data = gr.State()
+            
+            # ===== WORLD BUILDER TAB =====
+            with gr.TabItem("🗺️ World Builder"):
+                gr.Markdown("## 🏗️ Location & World Generator", elem_classes=["agent-card"])
+                
+                with gr.Row():
+                    with gr.Column():
+                        location_type = gr.Dropdown(
+                            choices=["Tavern", "Dungeon", "City", "Forest", "Castle", "Temple", "Shop", "Wilderness", "Mansion", "Cave System"],
+                            label="Location Type", value="Tavern"
+                        )
+                        location_theme = gr.Dropdown(
+                            choices=["Standard Fantasy", "Dark/Gothic", "Mystical", "Abandoned/Ruined", "Luxurious", "Dangerous", "Peaceful", "Mysterious"],
+                            label="Theme", value="Standard Fantasy"
+                        )
+                        location_purpose = gr.Textbox(label="Purpose in Campaign", placeholder="How will this location be used?")
+                        
+                        generate_location_btn = gr.Button("🏗️ Generate Location", variant="primary")
+                        location_art_btn = gr.Button("🖼️ Generate Location Art")
+                    
+                    with gr.Column():
+                        location_image = gr.Image(label="Location Visual", height=300)
+                
+                location_output = gr.Textbox(label="Location Details", lines=12, elem_classes=["output-box"])
+            
+            # ===== LOOT MASTER TAB =====
+            with gr.TabItem("💰 Loot Master"):
+                gr.Markdown("## 💎 Treasure & Magic Item Generator", elem_classes=["agent-card"])
+                
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### 🎲 Loot Table Generator")
+                        loot_level = gr.Slider(minimum=1, maximum=20, value=5, label="Party Level")
+                        encounter_type = gr.Dropdown(
+                            choices=["Boss Fight", "Mini-boss", "Standard Combat", "Exploration Reward", "Quest Completion", "Treasure Hoard"],
+                            label="Encounter Type", value="Standard Combat"
+                        )
+                        loot_rarity = gr.Dropdown(
+                            choices=["Poor", "Standard", "Rich", "Legendary"],
+                            label="Treasure Quality", value="Standard"
+                        )
+                        
+                        generate_loot_btn = gr.Button("💰 Generate Loot Table", variant="primary")
+                        
+                    with gr.Column():
+                        gr.Markdown("### ✨ Custom Magic Item")
+                        item_concept = gr.Textbox(label="Item Concept", placeholder="What kind of item? (sword, ring, staff, etc.)")
+                        power_level = gr.Dropdown(
+                            choices=["Common", "Uncommon", "Rare", "Very Rare", "Legendary", "Artifact"],
+                            label="Power Level", value="Uncommon"
+                        )
+                        campaign_theme_item = gr.Textbox(label="Campaign Theme", placeholder="How should it fit your campaign?")
+                        
+                        create_item_btn = gr.Button("✨ Create Magic Item", variant="secondary")
+                        item_art_btn = gr.Button("🎨 Generate Item Art")
+                
+                with gr.Row():
+                    loot_output = gr.Textbox(label="Loot Table", lines=8, elem_classes=["output-box"])
+                    magic_item_output = gr.Textbox(label="Magic Item Details", lines=8, elem_classes=["output-box"])
+                
+                item_image = gr.Image(label="Magic Item Visual", height=250)
+            
+            # ===== CAMPAIGN TOOLS TAB =====
+            with gr.TabItem("🛠️ Campaign Tools"):
+                gr.Markdown("## 🎯 Advanced Campaign Management")
+                
+                with gr.Tabs():
+                    with gr.TabItem("📊 Initiative Tracker"):
+                        gr.Markdown("### ⚔️ Combat Management")
+                        
+                        with gr.Row():
+                            add_character = gr.Textbox(label="Character Name", placeholder="Add to initiative...")
+                            add_initiative = gr.Number(label="Initiative Roll", value=10)
+                            add_btn = gr.Button("➕ Add to Initiative")
+                        
+                        initiative_list = gr.Dataframe(
+                            headers=["Name", "Initiative", "HP", "AC", "Status"],
+                            label="Initiative Order",
+                            interactive=True
+                        )
+                        
+                        with gr.Row():
+                            next_turn_btn = gr.Button("⏭️ Next Turn", variant="primary")
+                            reset_combat_btn = gr.Button("🔄 Reset Combat")
+                    
+                    with gr.TabItem("📝 Session Notes"):
+                        gr.Markdown("### 📖 Session Management")
+                        
+                        session_date = gr.Textbox(label="Session Date", value="Session 1")
+                        
+                        with gr.Row():
+                            with gr.Column():
+                                key_events = gr.Textbox(label="Key Events", lines=4, placeholder="What happened this session?")
+                                npc_interactions = gr.Textbox(label="NPC Interactions", lines=3, placeholder="Who did they meet?")
+                            
+                            with gr.Column():
+                                player_actions = gr.Textbox(label="Notable Player Actions", lines=4, placeholder="What did the players do?")
+                                next_session_prep = gr.Textbox(label="Next Session Prep", lines=3, placeholder="What to prepare for next time?")
+                        
+                        save_notes_btn = gr.Button("💾 Save Session Notes", variant="primary")
+                        notes_output = gr.File(label="Session Notes File")
+                    
+                    with gr.TabItem("🎲 Random Generators"):
+                        gr.Markdown("### 🎯 Quick Generators")
+                        
+                        with gr.Row():
+                            with gr.Column():
+                                gr.Markdown("**Name Generators**")
+                                name_type = gr.Dropdown(
+                                    choices=["Human Male", "Human Female", "Elven", "Dwarven", "Orcish", "Fantasy Place", "Tavern", "Shop"],
+                                    value="Human Male"
+                                )
+                                gen_name_btn = gr.Button("🎲 Generate Name")
+                                random_name = gr.Textbox(label="Generated Name")
+                            
+                            with gr.Column():
+                                gr.Markdown("**Quick Encounters**")
+                                encounter_level = gr.Slider(1, 20, value=5, label="Party Level")
+                                encounter_difficulty = gr.Dropdown(
+                                    choices=["Easy", "Medium", "Hard", "Deadly"],
+                                    value="Medium"
+                                )
+                                gen_encounter_btn = gr.Button("⚔️ Generate Encounter")
+                                random_encounter = gr.Textbox(label="Encounter", lines=3)
+                        
+                        with gr.Row():
+                            with gr.Column():
+                                gr.Markdown("**Plot Hooks**")
+                                hook_theme = gr.Dropdown(
+                                    choices=["Mystery", "Adventure", "Political", "Personal", "Rescue", "Exploration"],
+                                    value="Adventure"
+                                )
+                                gen_hook_btn = gr.Button("🎣 Generate Plot Hook")
+                                plot_hook = gr.Textbox(label="Plot Hook", lines=2)
+                            
+                            with gr.Column():
+                                gr.Markdown("**Weather & Atmosphere**")
+                                climate = gr.Dropdown(
+                                    choices=["Temperate", "Tropical", "Arctic", "Desert", "Mountainous"],
+                                    value="Temperate"
+                                )
+                                gen_weather_btn = gr.Button("🌤️ Generate Weather")
+                                weather = gr.Textbox(label="Weather & Mood", lines=2)
+
+        # ===== EVENT HANDLERS =====
+        
+        # Character Creator Events
+        def roll_abilities():
+            abilities = character_creator.roll_ability_scores()
+            return (
+                abilities["Strength"], abilities["Dexterity"], abilities["Constitution"],
+                abilities["Intelligence"], abilities["Wisdom"], abilities["Charisma"]
+            )
+        
+        def generate_character_name(race, char_class, alignment):
+            try:
+                from openai import OpenAI
+                client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+                
+                prompt = f"Generate a {race} {char_class} name appropriate for D&D. Return only the name."
+                
+                response = client.chat.completions.create(
+                    model="gpt-4",
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=30
+                )
+                
+                return response.choices[0].message.content.strip()
+            except Exception as e:
+                return f"Error: {str(e)}"
+        
+        def generate_character_backstory(name, race, char_class, alignment, background):
+            try:
+                from openai import OpenAI
+                client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+                
+                prompt = f"""Create a compelling backstory for {name}, a {race} {char_class} with {alignment} alignment and {background} background. 
+                Write 2-3 paragraphs about their origins, motivations, and key life events."""
+                
+                response = client.chat.completions.create(
+                    model="gpt-4",
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=300
+                )
+                
+                return response.choices[0].message.content.strip()
+            except Exception as e:
+                return f"Error generating backstory: {str(e)}"
+        
+        def generate_character_portrait(character_data):
+            if not character_data:
+                return "Please create a character first"
+            
+            prompt = f"Fantasy portrait of a {character_data.race.lower()} {character_data.character_class.lower()}, professional D&D character art"
+            return generate_image(prompt)
+        
+        def update_character_summary(name, race, char_class, level, alignment, 
+                                   str_val, dex_val, con_val, int_val, wis_val, cha_val, background, backstory):
+            if not all([str_val, dex_val, con_val, int_val, wis_val, cha_val]):
+                return "*Roll ability scores to see summary*", None
+            
+            base_abilities = {
+                "Strength": int(str_val), "Dexterity": int(dex_val), "Constitution": int(con_val),
+                "Intelligence": int(int_val), "Wisdom": int(wis_val), "Charisma": int(cha_val)
+            }
+            
+            final_abilities = character_creator.apply_racial_modifiers(base_abilities, race)
+            con_modifier = character_creator.calculate_ability_modifier(final_abilities["Constitution"])
+            hit_points = character_creator.calculate_hit_points(char_class, int(level), con_modifier)
+            
+            character = Character(
+                name=name or "Unnamed Character", race=race, character_class=char_class,
+                level=int(level), alignment=Alignment(alignment), abilities=final_abilities,
+                hit_points=hit_points, skills=character_creator.classes[char_class].skills[:2],
+                background=background, backstory=backstory
+            )
+            
+            summary = f"""**{character.name}**
+*Level {level} {race} {char_class} ({alignment})*
+
+**Ability Scores:**
+- STR: {final_abilities['Strength']} ({character_creator.calculate_ability_modifier(final_abilities['Strength']):+d})
+- DEX: {final_abilities['Dexterity']} ({character_creator.calculate_ability_modifier(final_abilities['Dexterity']):+d})
+- CON: {final_abilities['Constitution']} ({character_creator.calculate_ability_modifier(final_abilities['Constitution']):+d})
+- INT: {final_abilities['Intelligence']} ({character_creator.calculate_ability_modifier(final_abilities['Intelligence']):+d})
+- WIS: {final_abilities['Wisdom']} ({character_creator.calculate_ability_modifier(final_abilities['Wisdom']):+d})
+- CHA: {final_abilities['Charisma']} ({character_creator.calculate_ability_modifier(final_abilities['Charisma']):+d})
+
+**Combat Stats:**
+- Hit Points: {hit_points}
+- Hit Die: d{character_creator.classes[char_class].hit_die}
+
+**Background:** {background}"""
+            
+            return summary, character
+        
+        # Campaign Events
+        def generate_campaign_concept(theme, level, players):
+            result = dm_agent.generate_campaign_concept(theme, level, players)
+            return result.get("content", "Error generating campaign") if result["success"] else f"Error: {result['error']}"
+        
+        def generate_campaign_art(theme, level):
+            prompt = f"{theme} D&D campaign art for level {level} adventurers, epic fantasy illustration"
+            return generate_image(prompt)
+        
+        def generate_session_content(campaign_output, session_num):
+            if not campaign_output:
+                return "Please generate a campaign concept first"
+            result = dm_agent.generate_session_content(campaign_output, session_num)
+            return result.get("content", "Error generating session") if result["success"] else f"Error: {result['error']}"
+        
+        # NPC Events
+        def create_npc(context, role, importance):
+            result = npc_agent.generate_npc(context, role, importance)
+            return result.get("content", "Error creating NPC") if result["success"] else f"Error: {result['error']}"
+        
+        def generate_npc_portrait(npc_data):
+            if not npc_data:
+                return "Create an NPC first"
+            prompt = "Fantasy portrait of a D&D NPC character, detailed face, professional RPG art"
+            return generate_image(prompt)
+        
+        def npc_roleplay_response(npc_data, player_input, context):
+            if not npc_data or not player_input:
+                return "Please create an NPC and enter player input"
+            result = npc_agent.roleplay_npc(npc_data, player_input, context)
+            return result.get("content", "Error in roleplay") if result["success"] else f"Error: {result['error']}"
+        
+        # World Builder Events
+        def create_location(loc_type, theme, purpose):
+            result = world_agent.generate_location(loc_type, theme, purpose)
+            return result.get("content", "Error creating location") if result["success"] else f"Error: {result['error']}"
+        
+        def generate_location_art(loc_type, theme):
+            prompt = f"{theme} {loc_type} fantasy location, detailed environment art, D&D setting"
+            return generate_image(prompt)
+        
+        # Loot Events
+        def create_loot_table(level, encounter, rarity):
+            result = loot_agent.generate_loot_table(level, encounter, rarity)
+            return result.get("content", "Error creating loot") if result["success"] else f"Error: {result['error']}"
+        
+        def create_magic_item(concept, power, theme):
+            result = loot_agent.create_custom_magic_item(concept, power, theme)
+            return result.get("content", "Error creating item") if result["success"] else f"Error: {result['error']}"
+        
+        def generate_item_art(concept, power):
+            prompt = f"{power} magical {concept}, fantasy item illustration, glowing magical effects"
+            return generate_image(prompt)
+        
+        # Random Generator Events
+        def generate_random_name(name_type):
+            names = {
+                "Human Male": ["Garrett", "Marcus", "Thomas", "William", "James"],
+                "Human Female": ["Elena", "Sarah", "Miranda", "Catherine", "Rose"],
+                "Elven": ["Aelar", "Berrian", "Drannor", "Enna", "Galinndan"],
+                "Dwarven": ["Adrik", "Baern", "Darrak", "Delg", "Eberk"],
+                "Orcish": ["Grul", "Thark", "Dench", "Feng", "Gell"],
+                "Fantasy Place": ["Ravenshollow", "Goldbrook", "Thornfield", "Mistral Keep"],
+                "Tavern": ["The Prancing Pony", "Dragon's Rest", "The Silver Tankard"],
+                "Shop": ["Magical Mysteries", "Fine Blades & More", "Potions & Remedies"]
+            }
+            return random.choice(names.get(name_type, ["Unknown"]))
+        
+        def generate_random_encounter(level, difficulty):
+            encounters = [
+                f"Bandit ambush (adapted for level {level})",
+                f"Wild animal encounter (CR {max(1, level//4)})",
+                f"Mysterious traveler with a quest",
+                f"Ancient ruins with {difficulty.lower()} traps",
+                f"Rival adventuring party",
+                f"Magical phenomenon requiring investigation"
+            ]
+            return random.choice(encounters)
+        
+        def generate_plot_hook(theme):
+            hooks = {
+                "Mystery": "A beloved local figure has vanished without a trace, leaving behind only cryptic clues.",
+                "Adventure": "Ancient maps surface pointing to a legendary treasure thought lost forever.",
+                "Political": "A diplomatic envoy requests secret protection during dangerous negotiations.",
+                "Personal": "A character's past catches up with them in an unexpected way.",
+                "Rescue": "Innocent people are trapped in a dangerous situation and need immediate help.",
+                "Exploration": "Uncharted territories beckon with promises of discovery and danger."
+            }
+            return hooks.get(theme, "A mysterious stranger approaches with an urgent request.")
+        
+        def generate_weather(climate):
+            weather_options = {
+                "Temperate": ["Sunny and mild", "Light rain showers", "Overcast skies", "Gentle breeze"],
+                "Tropical": ["Hot and humid", "Sudden thunderstorm", "Sweltering heat", "Monsoon rains"],
+                "Arctic": ["Bitter cold winds", "Heavy snowfall", "Blizzard conditions", "Icy fog"],
+                "Desert": ["Scorching sun", "Sandstorm approaching", "Cool desert night", "Rare rainfall"],
+                "Mountainous": ["Mountain mist", "Alpine winds", "Rocky terrain", "Sudden weather change"]
+            }
+            return random.choice(weather_options.get(climate, ["Pleasant weather"]))
 
-def greet(name):
-    return "Hello " + name + "!!"
+        # Wire up all events
+        roll_btn.click(roll_abilities, outputs=[str_score, dex_score, con_score, int_score, wis_score, cha_score])
+        
+        generate_name_btn.click(
+            generate_character_name,
+            inputs=[race_dropdown, class_dropdown, alignment_dropdown],
+            outputs=[character_name]
+        )
+        
+        generate_backstory_btn.click(
+            generate_character_backstory,
+            inputs=[character_name, race_dropdown, class_dropdown, alignment_dropdown, background_dropdown],
+            outputs=[backstory]
+        )
+        
+        portrait_btn.click(
+            generate_character_portrait,
+            inputs=[character_data],
+            outputs=[character_portrait]
+        )
+        
+        # Update character summary when inputs change
+        for component in [character_name, race_dropdown, class_dropdown, level_slider, alignment_dropdown, 
+                         str_score, dex_score, con_score, int_score, wis_score, cha_score, background_dropdown, backstory]:
+            component.change(
+                update_character_summary,
+                inputs=[character_name, race_dropdown, class_dropdown, level_slider, alignment_dropdown,
+                       str_score, dex_score, con_score, int_score, wis_score, cha_score, background_dropdown, backstory],
+                outputs=[character_summary, character_data]
+            )
+        
+        # Campaign events
+        generate_campaign_btn.click(
+            generate_campaign_concept,
+            inputs=[campaign_theme, campaign_level, player_count],
+            outputs=[campaign_output]
+        )
+        
+        campaign_visual_btn.click(
+            generate_campaign_art,
+            inputs=[campaign_theme, campaign_level],
+            outputs=[campaign_image]
+        )
+        
+        generate_session_btn.click(
+            generate_session_content,
+            inputs=[campaign_output, session_number],
+            outputs=[session_output]
+        )
+        
+        # NPC events
+        create_npc_btn.click(
+            create_npc,
+            inputs=[npc_context, npc_role, npc_importance],
+            outputs=[npc_output]
+        )
+        
+        npc_portrait_btn.click(
+            generate_npc_portrait,
+            inputs=[current_npc_data],
+            outputs=[npc_portrait]
+        )
+        
+        roleplay_btn.click(
+            npc_roleplay_response,
+            inputs=[npc_output, player_input, roleplay_context],
+            outputs=[npc_response]
+        )
+        
+        # World builder events
+        generate_location_btn.click(
+            create_location,
+            inputs=[location_type, location_theme, location_purpose],
+            outputs=[location_output]
+        )
+        
+        location_art_btn.click(
+            generate_location_art,
+            inputs=[location_type, location_theme],
+            outputs=[location_image]
+        )
+        
+        # Loot events
+        generate_loot_btn.click(
+            create_loot_table,
+            inputs=[loot_level, encounter_type, loot_rarity],
+            outputs=[loot_output]
+        )
+        
+        create_item_btn.click(
+            create_magic_item,
+            inputs=[item_concept, power_level, campaign_theme_item],
+            outputs=[magic_item_output]
+        )
+        
+        item_art_btn.click(
+            generate_item_art,
+            inputs=[item_concept, power_level],
+            outputs=[item_image]
+        )
+        
+        # Random generator events
+        gen_name_btn.click(generate_random_name, inputs=[name_type], outputs=[random_name])
+        gen_encounter_btn.click(generate_random_encounter, inputs=[encounter_level, encounter_difficulty], outputs=[random_encounter])
+        gen_hook_btn.click(generate_plot_hook, inputs=[hook_theme], outputs=[plot_hook])
+        gen_weather_btn.click(generate_weather, inputs=[climate], outputs=[weather])
+    
+    return demo
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+# Main entry point
+if __name__ == "__main__":
+    logger.info("🏰 Starting Advanced D&D Campaign Manager...")
+    
+    # Check for OpenAI API key
+    api_key = os.getenv("OPENAI_API_KEY")
+    if api_key:
+        logger.info("✅ OpenAI API key found - All AI features enabled!")
+    else:
+        logger.warning("⚠️ No OpenAI API key found - AI features will be limited")
+        logger.info("💡 Add OPENAI_API_KEY=your_key to a .env file to enable all AI features")
+    
+    demo = create_main_interface()
+    
+    try:
+        demo.launch(
+            share=True,
+            server_name="0.0.0.0",
+            server_port=7860,
+            inbrowser=True
+        )
+        logger.info("🌐 App launched successfully!")
+        logger.info("🔗 Local URL: http://localhost:7860")
+        
+    except Exception as e:
+        logger.error(f"❌ Launch failed: {e}")
+        logger.info("💡 Try: pip install --upgrade gradio")