Update app.py

app.py

@@ -85,12 +85,25 @@ class Campaign:
 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"""
@@ -176,19 +189,22 @@ class NPCAgent:
         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:
+    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
+            1. Name and basic demographics (including gender)
             2. Personality traits (3-4 key traits)
             3. Background and motivation
             4. Speech patterns/accent description
@@ -201,7 +217,7 @@ class NPCAgent:
             
             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."},
+                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
@@ -211,7 +227,7 @@ class NPCAgent:
             
         except Exception as e:
             logger.error(f"NPC generation failed: {e}")
-            return {"success": False, "error": str(e), "content": f"Mock NPC: {role} character for {context}"}
+            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"""
@@ -289,6 +305,90 @@ class WorldBuilderAgent:
             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"""
     
@@ -588,6 +688,7 @@ def create_main_interface():
     dm_agent = DungeonMasterAgent()
     npc_agent = NPCAgent()
     world_agent = WorldBuilderAgent()
+    deity_agent = DeityAgent()
     loot_agent = LootMasterAgent()
     character_creator = CharacterCreator()
     
@@ -621,6 +722,7 @@ def create_main_interface():
         - 🗺️ World Builder Agent
         - 💰 Loot Master & Magic Item Designer
         - 🐉 Enhanced Character Creator
+        - ⚡ Deity & Pantheon Generator
         """)
         
         with gr.Tabs():
@@ -738,6 +840,10 @@ def create_main_interface():
                             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")
                         
@@ -785,6 +891,57 @@ def create_main_interface():
                 
                 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"])
@@ -1052,14 +1209,16 @@ def create_main_interface():
             return result.get("content", "Error generating session")
         
         # NPC Events
-        def create_npc(context, role, importance):
-            result = npc_agent.generate_npc(context, role, importance)
+        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:
-                return "Create an NPC first"
-            prompt = "Fantasy portrait of a D&D NPC character, detailed face, professional RPG art"
+                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):
@@ -1077,6 +1236,23 @@ def create_main_interface():
             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)
@@ -1189,13 +1365,13 @@ def create_main_interface():
         # NPC events
         create_npc_btn.click(
             create_npc,
-            inputs=[npc_context, npc_role, npc_importance],
+            inputs=[npc_context, npc_role, npc_importance, npc_gender],
             outputs=[npc_output]
         )
         
         npc_portrait_btn.click(
             generate_npc_portrait,
-            inputs=[current_npc_data],
+            inputs=[npc_output],  # Changed from current_npc_data to npc_output
             outputs=[npc_portrait]
         )
         
@@ -1218,6 +1394,31 @@ def create_main_interface():
             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,
@@ -1242,6 +1443,124 @@ def create_main_interface():
         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
 
@@ -1270,4 +1589,4 @@ if __name__ == "__main__":
     except Exception as e:
         logger.error(f"❌ Launch failed: {e}")
         # Fallback launch for HF Spaces
-        demo.launch()
+        demo.launch()