Create app.py

app.py

@@ -0,0 +1,630 @@
+# app.py - Flask D&D Campaign Manager for HuggingFace Spaces
+
+import os
+import logging
+from flask import Flask, render_template, request, jsonify, send_file
+import json
+import tempfile
+import random
+from datetime import datetime
+from typing import Dict, List, Optional
+from dataclasses import dataclass, asdict
+from enum import Enum
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ===== D&D 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 Character:
+    name: str
+    race: str
+    character_class: str
+    level: int
+    gender: str
+    alignment: str
+    abilities: Dict[str, int]
+    hit_points: int
+    background: str
+    backstory: str
+
+# ===== AI AGENT CLASSES =====
+class DungeonMasterAgent:
+    def generate_campaign_concept(self, theme: str, level: int, players: int) -> Dict:
+        try:
+            if os.getenv("OPENAI_API_KEY"):
+                from openai import OpenAI
+                client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+                
+                prompt = f"""Create a {theme} D&D campaign for {players} level {level} characters.
+                Include: Campaign name, plot hook, main antagonist, 3 key locations, central conflict."""
+                
+                response = client.chat.completions.create(
+                    model="gpt-4",
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=500
+                )
+                
+                return {"success": True, "content": response.choices[0].message.content}
+            else:
+                # Fallback content
+                return {
+                    "success": True, 
+                    "content": f"**{theme} Campaign**\n\nA thrilling adventure awaits {players} brave heroes starting at level {level}. Ancient mysteries, dangerous foes, and legendary treasures lie ahead in this epic campaign designed to challenge and inspire."
+                }
+        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:
+        try:
+            if os.getenv("OPENAI_API_KEY"):
+                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. Cliffhanger ending options"""
+                
+                response = client.chat.completions.create(
+                    model="gpt-4",
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=600
+                )
+                
+                return {"success": True, "content": response.choices[0].message.content}
+            else:
+                return {
+                    "success": True,
+                    "content": f"**Session {session_number}**\n\nThe adventure continues with new challenges, mysterious NPCs, and exciting encounters designed to test the heroes' resolve."
+                }
+        except Exception as e:
+            logger.error(f"Session generation failed: {e}")
+            return {"success": False, "error": str(e)}
+
+class NPCAgent:
+    def generate_npc(self, context: str, role: str, importance: str, gender: str = "") -> Dict:
+        try:
+            if os.getenv("OPENAI_API_KEY"):
+                from openai import OpenAI
+                client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+                
+                prompt = f"""Create a {importance} {role} NPC for: {context}
+                Gender: {gender if gender else 'Choose appropriate'}
+                Include: Name, personality, background, motivation, physical description, speech patterns."""
+                
+                response = client.chat.completions.create(
+                    model="gpt-4",
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=400
+                )
+                
+                return {"success": True, "content": response.choices[0].message.content}
+            else:
+                return {
+                    "success": True,
+                    "content": f"**{gender if gender else 'Character'} {role}**\n\nA {importance.lower()} NPC perfect for your campaign context: {context}. This character brings depth and intrigue to your world."
+                }
+        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:
+        try:
+            if os.getenv("OPENAI_API_KEY"):
+                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)"""
+                
+                response = client.chat.completions.create(
+                    model="gpt-4",
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=200
+                )
+                
+                return {"success": True, "content": response.choices[0].message.content}
+            else:
+                return {
+                    "success": True,
+                    "content": f"The NPC responds thoughtfully to your action: '{player_input}'. Their reaction fits their personality and the current situation."
+                }
+        except Exception as e:
+            logger.error(f"NPC roleplay failed: {e}")
+            return {"success": False, "error": str(e)}
+
+class WorldBuilderAgent:
+    def generate_location(self, location_type: str, theme: str, purpose: str) -> Dict:
+        try:
+            if os.getenv("OPENAI_API_KEY"):
+                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"""
+                
+                response = client.chat.completions.create(
+                    model="gpt-4",
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=500
+                )
+                
+                return {"success": True, "content": response.choices[0].message.content}
+            else:
+                return {
+                    "success": True,
+                    "content": f"**{theme} {location_type}**\n\nA {theme.lower()} {location_type.lower()} designed for {purpose}. This location features multiple areas to explore, interesting NPCs to meet, and secrets to uncover."
+                }
+        except Exception as e:
+            logger.error(f"Location generation failed: {e}")
+            return {"success": False, "error": str(e)}
+
+class LootMasterAgent:
+    def generate_loot_table(self, level: int, encounter_type: str, rarity: str) -> Dict:
+        try:
+            if os.getenv("OPENAI_API_KEY"):
+                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"""
+                
+                response = client.chat.completions.create(
+                    model="gpt-4",
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=300
+                )
+                
+                return {"success": True, "content": response.choices[0].message.content}
+            else:
+                return {
+                    "success": True,
+                    "content": f"**Level {level} {encounter_type} Loot ({rarity})**\n\nGold: {level * 10}-{level * 20} gp\nItems: Health potions, basic equipment\nSpecial: One rare item appropriate for the encounter"
+                }
+        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:
+        try:
+            if os.getenv("OPENAI_API_KEY"):
+                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"""
+                
+                response = client.chat.completions.create(
+                    model="gpt-4",
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=400
+                )
+                
+                return {"success": True, "content": response.choices[0].message.content}
+            else:
+                return {
+                    "success": True,
+                    "content": f"**{item_concept.title()} of {campaign_theme}**\n\nRarity: {power_level}\nA magical {item_concept} imbued with the essence of {campaign_theme}. This item grants special abilities and carries ancient power."
+                }
+        except Exception as e:
+            logger.error(f"Magic item creation failed: {e}")
+            return {"success": False, "error": str(e)}
+
+class CharacterCreator:
+    def __init__(self):
+        self.classes = {
+            "Fighter": {"hit_die": 10},
+            "Wizard": {"hit_die": 6},
+            "Rogue": {"hit_die": 8},
+            "Cleric": {"hit_die": 8},
+            "Barbarian": {"hit_die": 12},
+            "Bard": {"hit_die": 8},
+            "Druid": {"hit_die": 8},
+            "Monk": {"hit_die": 8},
+            "Paladin": {"hit_die": 10},
+            "Ranger": {"hit_die": 10},
+            "Sorcerer": {"hit_die": 6},
+            "Warlock": {"hit_die": 8}
+        }
+    
+    def roll_ability_scores(self) -> Dict[str, int]:
+        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])
+        return abilities
+
+def generate_image(prompt: str) -> str:
+    """Generate image URL (placeholder for AI image generation)"""
+    try:
+        if os.getenv("OPENAI_API_KEY"):
+            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
+        else:
+            # Placeholder image
+            return "https://via.placeholder.com/512x512/7c3aed/ffffff?text=AI+Image"
+    except Exception as e:
+        logger.error(f"Image generation failed: {e}")
+        return "https://via.placeholder.com/512x512/dc2626/ffffff?text=Image+Generation+Failed"
+
+# ===== FLASK APP SETUP =====
+app = Flask(__name__)
+app.secret_key = os.getenv('SECRET_KEY', 'your-secret-key-for-hf-spaces')
+
+# Initialize components
+dm_agent = DungeonMasterAgent()
+npc_agent = NPCAgent()
+world_agent = WorldBuilderAgent()
+loot_agent = LootMasterAgent()
+character_creator = CharacterCreator()
+
+@app.route('/')
+def index():
+    """Serve the main page"""
+    return render_template('index.html')
+
+# ===== API ROUTES =====
+
+@app.route('/api/character/roll-abilities', methods=['POST'])
+def roll_abilities():
+    try:
+        abilities = character_creator.roll_ability_scores()
+        return jsonify({'success': True, 'abilities': abilities})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/character/generate-name', methods=['POST'])
+def generate_character_name():
+    try:
+        data = request.json
+        race = data.get('race', 'Human')
+        gender = data.get('gender', 'Male')
+        
+        # Try AI generation first
+        if os.getenv("OPENAI_API_KEY"):
+            try:
+                from openai import OpenAI
+                client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+                
+                prompt = f"Generate a {gender} {race} 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
+                )
+                
+                name = response.choices[0].message.content.strip()
+                return jsonify({'success': True, 'name': name})
+            except:
+                pass  # Fall through to fallback
+        
+        # Fallback name generation
+        names = {
+            "Human": {"Male": ["Garrett", "Marcus", "Thomas"], "Female": ["Elena", "Sarah", "Miranda"]},
+            "Elf": {"Male": ["Aelar", "Berrian", "Drannor"], "Female": ["Adrie", "Althaea", "Anastrianna"]},
+            "Dwarf": {"Male": ["Adrik", "Baern", "Darrak"], "Female": ["Amber", "Bardryn", "Diesa"]}
+        }
+        
+        race_names = names.get(race, names["Human"])
+        gender_key = "Male" if gender in ["Male", "Transgender Male"] else "Female"
+        name_list = race_names.get(gender_key, race_names["Male"])
+        
+        return jsonify({'success': True, 'name': random.choice(name_list)})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/character/generate-backstory', methods=['POST'])
+def generate_character_backstory():
+    try:
+        data = request.json
+        name = data.get('name', 'Character')
+        race = data.get('race', 'Human')
+        char_class = data.get('class', 'Fighter')
+        background = data.get('background', 'Folk Hero')
+        
+        # Try AI generation first
+        if os.getenv("OPENAI_API_KEY"):
+            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 a {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
+                )
+                
+                backstory = response.choices[0].message.content.strip()
+                return jsonify({'success': True, 'backstory': backstory})
+            except:
+                pass  # Fall through to fallback
+        
+        # Fallback backstory
+        backstory = f"{name} is a {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 destiny with courage and determination."
+        
+        return jsonify({'success': True, 'backstory': backstory})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/character/generate-portrait', methods=['POST'])
+def generate_character_portrait():
+    try:
+        data = request.json
+        race = data.get('race', 'Human')
+        char_class = data.get('class', 'Fighter')
+        gender = data.get('gender', 'Male')
+        
+        prompt = f"Fantasy portrait of a {gender.lower()} {race.lower()} {char_class.lower()}, professional D&D character art"
+        image_url = generate_image(prompt)
+        
+        return jsonify({'success': True, 'image_url': image_url})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/campaign/generate-concept', methods=['POST'])
+def generate_campaign_concept():
+    try:
+        data = request.json
+        theme = data.get('theme', 'High Fantasy')
+        level = data.get('level', 5)
+        players = data.get('players', 4)
+        
+        result = dm_agent.generate_campaign_concept(theme, level, players)
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/campaign/generate-session', methods=['POST'])
+def generate_session_content():
+    try:
+        data = request.json
+        campaign_context = data.get('campaign_context', 'General D&D campaign')
+        session_number = data.get('session_number', 1)
+        
+        result = dm_agent.generate_session_content(campaign_context, session_number)
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/campaign/generate-art', methods=['POST'])
+def generate_campaign_art():
+    try:
+        data = request.json
+        theme = data.get('theme', 'High Fantasy')
+        level = data.get('level', 5)
+        
+        prompt = f"{theme} D&D campaign art for level {level} adventurers, epic fantasy illustration"
+        image_url = generate_image(prompt)
+        
+        return jsonify({'success': True, 'image_url': image_url})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/npc/create', methods=['POST'])
+def create_npc():
+    try:
+        data = request.json
+        context = data.get('context', '')
+        role = data.get('role', 'Neutral')
+        importance = data.get('importance', 'Moderate')
+        gender = data.get('gender', '')
+        
+        result = npc_agent.generate_npc(context, role, importance, gender)
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/npc/roleplay', methods=['POST'])
+def npc_roleplay():
+    try:
+        data = request.json
+        npc_description = data.get('npc_description', '')
+        player_input = data.get('player_input', '')
+        context = data.get('context', '')
+        
+        result = npc_agent.roleplay_npc(npc_description, player_input, context)
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/world/create-location', methods=['POST'])
+def create_location():
+    try:
+        data = request.json
+        location_type = data.get('type', 'Tavern')
+        theme = data.get('theme', 'Standard Fantasy')
+        purpose = data.get('purpose', '')
+        
+        result = world_agent.generate_location(location_type, theme, purpose)
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/loot/generate-table', methods=['POST'])
+def generate_loot_table():
+    try:
+        data = request.json
+        level = data.get('level', 5)
+        encounter_type = data.get('encounter_type', 'Standard Combat')
+        rarity = data.get('rarity', 'Standard')
+        
+        result = loot_agent.generate_loot_table(level, encounter_type, rarity)
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/loot/create-magic-item', methods=['POST'])
+def create_magic_item():
+    try:
+        data = request.json
+        concept = data.get('concept', '')
+        power_level = data.get('power_level', 'Uncommon')
+        theme = data.get('theme', '')
+        
+        result = loot_agent.create_custom_magic_item(concept, power_level, theme)
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/random/name', methods=['POST'])
+def generate_random_name():
+    try:
+        data = request.json
+        name_type = data.get('type', 'Human Male')
+        
+        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"],
+            "Fantasy Place": ["Ravenshollow", "Goldbrook", "Thornfield", "Mistral Keep"],
+            "Tavern": ["The Prancing Pony", "Dragon's Rest", "The Silver Tankard"]
+        }
+        
+        selected_names = names.get(name_type, ["Unknown"])
+        random_name = random.choice(selected_names)
+        
+        return jsonify({'success': True, 'name': random_name})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/random/encounter', methods=['POST'])
+def generate_random_encounter():
+    try:
+        data = request.json
+        level = data.get('level', 5)
+        difficulty = data.get('difficulty', 'Medium')
+        
+        encounters = [
+            f"Bandit ambush (adapted for level {level})",
+            f"Wild animal encounter (CR {max(1, level//4)})",
+            "Mysterious traveler with a quest",
+            f"Ancient ruins with {difficulty.lower()} traps",
+            "Rival adventuring party",
+            "Magical phenomenon requiring investigation"
+        ]
+        
+        random_encounter = random.choice(encounters)
+        return jsonify({'success': True, 'encounter': random_encounter})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/random/plot-hook', methods=['POST'])
+def generate_plot_hook():
+    try:
+        data = request.json
+        theme = data.get('theme', 'Adventure')
+        
+        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."
+        }
+        
+        hook = hooks.get(theme, "A mysterious stranger approaches with an urgent request.")
+        return jsonify({'success': True, 'hook': hook})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/api/random/weather', methods=['POST'])
+def generate_weather():
+    try:
+        data = request.json
+        climate = data.get('climate', 'Temperate')
+        
+        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"]
+        }
+        
+        weathers = weather_options.get(climate, ["Pleasant weather"])
+        random_weather = random.choice(weathers)
+        
+        return jsonify({'success': True, 'weather': random_weather})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/health')
+def health_check():
+    """Health check endpoint for HF Spaces"""
+    return jsonify({"status": "healthy", "service": "D&D Campaign Manager"})
+
+if __name__ == '__main__':
+    # HuggingFace Spaces requires port 7860
+    port = int(os.environ.get('PORT', 7860))
+    app.run(host='0.0.0.0', port=port, debug=False)