# app.py - Fixed 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__) # Load OpenAI API key try: import openai api_key = os.getenv("OPENAI_API_KEY") if api_key: openai.api_key = api_key logger.info("✅ OpenAI API key loaded") else: logger.warning("⚠️ No OpenAI API key found") except ImportError: logger.warning("⚠️ OpenAI package not installed") # ===== 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 gender: str 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 gender: str occupation: str personality: str secret: str voice_description: str relationship_to_party: str @dataclass class Deity: name: str domain: str alignment: Alignment gender: str description: str holy_symbol: str followers: str tenets: List[str] clergy: 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), "content": f"Mock Campaign: {theme} adventure for {player_count} level {level} characters"} 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), "content": f"Mock Session {session_number}: Adventure continues..."} 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, gender: str = "") -> Dict: """Generate a detailed NPC""" try: from openai import OpenAI client = OpenAI(api_key=os.getenv("OPENAI_API_KEY")) gender_text = f"Gender: {gender}" if gender else "Gender: Choose appropriate gender" prompt = f"""Create a detailed NPC for: Context: {context} Role: {role} Importance: {importance} {gender_text} Generate: 1. Name and basic demographics (including gender) 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 with diverse and inclusive representation."}, {"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), "content": f"Mock NPC: {gender if gender else 'Character'} {role} for {context}"} 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), "content": "Mock NPC Response: The character responds appropriately to your action."} 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), "content": f"Mock Location: {theme} {location_type} for {purpose}"} class DeityAgent: """AI agent specialized in creating deities and pantheons""" def __init__(self): self.personality = "Divine architect of mythological systems" self.specializations = ["Mythology", "Religion", "Divine domains", "Pantheon design"] def generate_deity(self, domain: str, alignment: str, gender: str, pantheon_theme: str) -> Dict: """Generate a detailed deity""" try: from openai import OpenAI client = OpenAI(api_key=os.getenv("OPENAI_API_KEY")) prompt = f"""Create a detailed deity for D&D: Domain: {domain} Alignment: {alignment} Gender: {gender} Pantheon Theme: {pantheon_theme} Generate: 1. Name and titles 2. Physical description and manifestation 3. Personality and temperament 4. Core domains and portfolio 5. Holy symbol and sacred items 6. Typical followers and clergy 7. 3-4 key tenets or commandments 8. Relationships with other deities 9. Myths or legends about them 10. How they interact with mortals Make them feel divine and mythologically rich!""" response = client.chat.completions.create( model="gpt-4", messages=[{"role": "system", "content": "You are an expert mythologist and world-builder creating rich, detailed deities for fantasy settings."}, {"role": "user", "content": prompt}], max_tokens=600, temperature=0.8 ) return {"success": True, "content": response.choices[0].message.content} except Exception as e: logger.error(f"Deity generation failed: {e}") return {"success": False, "error": str(e), "content": f"Mock Deity: {gender} deity of {domain} with {alignment} alignment"} def generate_pantheon(self, theme: str, size: str, culture: str) -> Dict: """Generate an entire pantheon""" try: from openai import OpenAI client = OpenAI(api_key=os.getenv("OPENAI_API_KEY")) prompt = f"""Create a complete pantheon for D&D: Theme: {theme} Size: {size} Cultural Influence: {culture} Generate: 1. Pantheon name and overview 2. Creation myth 3. 5-8 major deities with names, domains, and relationships 4. 3-5 lesser deities or demigods 5. Pantheon hierarchy and conflicts 6. How mortals worship them 7. Religious festivals and holy days 8. Sacred sites and temples Make it cohesive and interconnected!""" response = client.chat.completions.create( model="gpt-4", messages=[{"role": "system", "content": "You are creating interconnected pantheons with rich mythological depth."}, {"role": "user", "content": prompt}], max_tokens=800, temperature=0.7 ) return {"success": True, "content": response.choices[0].message.content} except Exception as e: logger.error(f"Pantheon generation failed: {e}") return {"success": False, "error": str(e), "content": f"Mock Pantheon: {size} {theme} pantheon inspired by {culture}"} 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), "content": f"Mock Loot: Level {level} {encounter_type} {rarity} treasures"} 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), "content": f"Mock Magic Item: {power_level} {item_concept} with {campaign_theme} theme"} # ===== 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() deity_agent = DeityAgent() 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 - ⚡ Deity & Pantheon Generator """) 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" ) gender_dropdown = gr.Dropdown( choices=["Male", "Female", "Non-binary", "Transgender Male", "Transgender Female", "Genderfluid", "Agender", "Other"], label="Gender", value="Male" ) 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" ) npc_gender = gr.Dropdown( choices=["", "Male", "Female", "Non-binary", "Transgender Male", "Transgender Female", "Genderfluid", "Agender", "Other"], label="Gender (Optional)", value="" ) 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"]) # ===== DEITY CREATOR TAB ===== with gr.TabItem("⚡ Deity Creator"): gr.Markdown("## ⚡ Divine Pantheon Generator", elem_classes=["agent-card"]) with gr.Tabs(): with gr.TabItem("🌟 Single Deity"): with gr.Row(): with gr.Column(): deity_domain = gr.Dropdown( choices=["War", "Death", "Life", "Knowledge", "Nature", "Tempest", "Trickery", "Light", "Forge", "Grave", "Order", "Peace", "Twilight"], label="Primary Domain", value="Life" ) deity_alignment = gr.Dropdown( choices=[alignment.value for alignment in Alignment], label="Alignment", value="Neutral Good" ) deity_gender = gr.Dropdown( choices=["Male", "Female", "Non-binary", "Genderfluid", "Agender", "Beyond Gender", "Dual-Gendered", "Other"], label="Gender", value="Female" ) pantheon_theme = gr.Textbox(label="Pantheon Theme", placeholder="Greek, Norse, Egyptian, Original, etc.") generate_deity_btn = gr.Button("⚡ Generate Deity", variant="primary") deity_art_btn = gr.Button("🎨 Generate Deity Art") with gr.Column(): deity_image = gr.Image(label="Deity Visual", height=300) deity_output = gr.Textbox(label="Deity Details", lines=15, elem_classes=["output-box"]) with gr.TabItem("🏛️ Full Pantheon"): with gr.Row(): with gr.Column(): pantheon_theme_full = gr.Dropdown( choices=["Greek-inspired", "Norse-inspired", "Egyptian-inspired", "Celtic-inspired", "Hindu-inspired", "Mesopotamian-inspired", "Original Fantasy", "Dark Pantheon", "Nature Pantheon", "Elemental Pantheon"], label="Pantheon Style", value="Original Fantasy" ) pantheon_size = gr.Dropdown( choices=["Small (5-8 deities)", "Medium (9-12 deities)", "Large (13-16 deities)", "Epic (17+ deities)"], label="Pantheon Size", value="Medium (9-12 deities)" ) cultural_influence = gr.Textbox(label="Cultural Influence", placeholder="What mortal culture do they influence?") generate_pantheon_btn = gr.Button("🏛️ Generate Pantheon", variant="primary") with gr.Column(): pantheon_visual_btn = gr.Button("🖼️ Generate Pantheon Art") pantheon_image = gr.Image(label="Pantheon Visual", height=300) pantheon_output = gr.Textbox(label="Pantheon Details", lines=20, 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, gender, alignment): try: from openai import OpenAI client = OpenAI(api_key=os.getenv("OPENAI_API_KEY")) prompt = f"Generate a {gender} {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: # Fallback to simple name generation names = { "Human": { "Male": ["Garrett", "Marcus", "Thomas", "William", "James"], "Female": ["Elena", "Sarah", "Miranda", "Catherine", "Rose"], "Non-binary": ["Alex", "Jordan", "Riley", "Casey", "Taylor"], "Other": ["River", "Sage", "Phoenix", "Ash", "Rowan"] }, "Elf": { "Male": ["Aelar", "Berrian", "Drannor", "Enna", "Galinndan"], "Female": ["Adrie", "Althaea", "Anastrianna", "Andraste", "Antinua"], "Non-binary": ["Aerdyl", "Ahvir", "Aramil", "Aranea", "Berris"], "Other": ["Dayereth", "Enna", "Galinndan", "Hadarai", "Halimath"] }, "Dwarf": { "Male": ["Adrik", "Baern", "Darrak", "Delg", "Eberk"], "Female": ["Amber", "Bardryn", "Diesa", "Eldeth", "Gunnloda"], "Non-binary": ["Alberich", "Balin", "Dain", "Fundin", "Gloín"], "Other": ["Hávar", "Kíli", "Náli", "Ori", "Thorek"] }, "Halfling": { "Male": ["Alton", "Ander", "Cade", "Corrin", "Eldon"], "Female": ["Andry", "Bree", "Callie", "Cora", "Euphemia"], "Non-binary": ["Finnan", "Garret", "Lindal", "Lyle", "Merric"], "Other": ["Nedda", "Paela", "Portia", "Seraphina", "Shaena"] } } # Handle various gender identities gender_key = gender if gender in ["Transgender Male", "Male"]: gender_key = "Male" elif gender in ["Transgender Female", "Female"]: gender_key = "Female" elif gender in ["Non-binary", "Genderfluid", "Agender"]: gender_key = "Non-binary" else: gender_key = "Other" race_names = names.get(race, names["Human"]) return random.choice(race_names.get(gender_key, race_names["Other"])) def generate_character_backstory(name, race, char_class, gender, 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 {gender} {race} {char_class} with {alignment} alignment and {background} background. Write 2-3 paragraphs about their origins, motivations, and key life events. Be respectful and inclusive in your portrayal.""" 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"{name} is a {gender} {race} {char_class} with a {background} background. Their journey began in their homeland, where they learned the skills that would define their path as an adventurer, embracing their identity and forging their own destiny." def generate_character_portrait(character_data): if not character_data: return "Please create a character first" prompt = f"Fantasy portrait of a {character_data.gender.lower()} {character_data.race.lower()} {character_data.character_class.lower()}, professional D&D character art, respectful and inclusive representation" return generate_image(prompt) def update_character_summary(name, race, char_class, level, gender, 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), gender=gender, 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} {gender} {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") 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") # NPC Events def create_npc(context, role, importance, gender): result = npc_agent.generate_npc(context, role, importance, gender) return result.get("content", "Error creating NPC") def generate_npc_portrait(npc_data): if not npc_data: prompt = "Fantasy portrait of a D&D NPC character, detailed face, professional RPG art" else: # Extract key details from NPC description for better portraits prompt = f"Fantasy portrait of a D&D NPC character based on: {npc_data[:200]}..., 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") # 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") def generate_location_art(loc_type, theme): prompt = f"{theme} {loc_type} fantasy location, detailed environment art, D&D setting" return generate_image(prompt) # Deity Events def create_deity(domain, alignment, gender, theme): result = deity_agent.generate_deity(domain, alignment, gender, theme) return result.get("content", "Error creating deity") def generate_deity_art(domain, gender, theme): prompt = f"{gender} deity of {domain}, {theme} mythology style, divine fantasy art, glowing divine aura" return generate_image(prompt) def create_pantheon(theme, size, culture): result = deity_agent.generate_pantheon(theme, size, culture) return result.get("content", "Error creating pantheon") def generate_pantheon_art(theme, culture): prompt = f"{theme} pantheon temple complex, {culture} architectural style, multiple divine statues, epic fantasy art" 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") def create_magic_item(concept, power, theme): result = loot_agent.create_custom_magic_item(concept, power, theme) return result.get("content", "Error creating item") 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"])) # 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, gender_dropdown, alignment_dropdown], outputs=[character_name] ) generate_backstory_btn.click( generate_character_backstory, inputs=[character_name, race_dropdown, class_dropdown, gender_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, gender_dropdown, 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, gender_dropdown, 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, npc_gender], outputs=[npc_output] ) npc_portrait_btn.click( generate_npc_portrait, inputs=[npc_output], # Changed from current_npc_data to npc_output 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] ) # Deity events generate_deity_btn.click( create_deity, inputs=[deity_domain, deity_alignment, deity_gender, pantheon_theme], outputs=[deity_output] ) deity_art_btn.click( generate_deity_art, inputs=[deity_domain, deity_gender, pantheon_theme], outputs=[deity_image] ) generate_pantheon_btn.click( create_pantheon, inputs=[pantheon_theme_full, pantheon_size, cultural_influence], outputs=[pantheon_output] ) pantheon_visual_btn.click( generate_pantheon_art, inputs=[pantheon_theme_full, cultural_influence], outputs=[pantheon_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]) # Additional missing event handlers # Export character functionality def export_character_json(character_data): if not character_data: return None try: # Convert character to dict for JSON export char_dict = { "name": character_data.name, "race": character_data.race, "class": character_data.character_class, "level": character_data.level, "gender": character_data.gender, "alignment": character_data.alignment.value, "abilities": character_data.abilities, "hit_points": character_data.hit_points, "skills": character_data.skills, "background": character_data.background, "backstory": character_data.backstory } # Create temporary file import tempfile import json with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f: json.dump(char_dict, f, indent=2) return f.name except Exception as e: logger.error(f"Character export failed: {e}") return None export_btn.click( export_character_json, inputs=[character_data], outputs=[export_file] ) # Session notes functionality def save_session_notes(session_date, key_events, npc_interactions, player_actions, next_session_prep): try: import tempfile notes_content = f"""# {session_date} ## Key Events {key_events} ## NPC Interactions {npc_interactions} ## Notable Player Actions {player_actions} ## Next Session Preparation {next_session_prep} --- *Generated by D&D Campaign Manager* """ with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False) as f: f.write(notes_content) return f.name except Exception as e: logger.error(f"Session notes save failed: {e}") return None save_notes_btn.click( save_session_notes, inputs=[session_date, key_events, npc_interactions, player_actions, next_session_prep], outputs=[notes_output] ) # Initiative tracker functionality initiative_data = gr.State([]) def add_to_initiative(current_data, char_name, initiative_roll): if not char_name: return current_data if current_data is None: current_data = [] # Add new character new_entry = [char_name, int(initiative_roll), "Full", "10", "Active"] current_data.append(new_entry) # Sort by initiative (descending) current_data.sort(key=lambda x: x[1], reverse=True) return current_data def reset_initiative(): return [] add_btn.click( add_to_initiative, inputs=[initiative_data, add_character, add_initiative], outputs=[initiative_data] ) # Update the dataframe when initiative_data changes initiative_data.change( lambda data: data, inputs=[initiative_data], outputs=[initiative_list] ) reset_combat_btn.click( reset_initiative, outputs=[initiative_data] ) return demo # 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 as a repository secret in HF Spaces settings") demo = create_main_interface() try: # HF Spaces compatible launch demo.launch( share=False, # HF Spaces handles sharing inbrowser=False # Don't try to open browser in cloud environment ) logger.info("🌐 App launched successfully!") except Exception as e: logger.error(f"❌ Launch failed: {e}") # Fallback launch for HF Spaces demo.launch()