Upload 4 files

LICENSE

@@ -0,0 +1,26 @@
+Proprietary License
+
+Copyright (c) 2024 [Jesse Stucker aka "ghost logic."]
+
+All Rights Reserved.
+
+This AI gaming platform, including all code, prompts, algorithms, 
+documentation, and associated files, is proprietary intellectual property.
+
+RESTRICTIONS:
+- Commercial use prohibited without separate license
+- No redistribution, modification, or derivative works
+- No reverse engineering or decompilation
+- All rights reserved by copyright holder
+
+PERMITTED USE:
+Personal, non-commercial evaluation and educational use only.
+
+COMMERCIAL LICENSING:
+Gaming studios, educational institutions, and commercial users must obtain 
+a separate commercial license.
+
+For commercial licensing inquiries:
+Email: [email protected]
+LinkedIn: https://www.linkedin.com/in/jesse-stucker-49839a90/
+This software is provided "as is" without warranty of any kind.

README.md

@@ -1,14 +1,126 @@
 ---
-title: Dungeon Smasher Lite
-emoji: 🏃
-colorFrom: indigo
-colorTo: purple
+title: Dungeon Smasher
+emoji: "👁"
+colorFrom: yellow
+colorTo: pink
 sdk: gradio
-sdk_version: 5.35.0
+sdk_version: 5.33.1
 app_file: app.py
-pinned: false
-license: afl-3.0
-short_description: Create PCs and NPCs
+pinned: true
+tags:
+  - agent-demo-track
+  - AI dungeon master
+  - procedural generation
+  - worldbuilding
+  - intelligent NPCs
+  - storytelling
+  - RPG
+  - multi-agent
+thumbnail: >-
+  https://cdn-uploads.huggingface.co/production/uploads/683d2ec2540df93aae2532f4/Xagf2XzjnOEUZB-a1ofXZ.png
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+🧠 Dungeon Smasher
+
+An Agentic Toolkit for Dynamic RPG Storytelling
+Built for the Hugging Face AI Agent Hackathon — Agent Demo Track
+🌟 Overview
+
+Dungeon Smasher is an experimental AI toolkit for building intelligent, reactive RPG environments. Rather than a finished game, this is a modular agent demo showcasing five core systems:
+
+    🎭 DM Assistant · 👥 NPC Generator · 🗺️ World Builder · 💰 Loot Designer · 🐉 Character Creator
+
+Each module uses LLM reasoning and symbolic world logic to help GMs and players co-create immersive adventures—no prep required.
+⚙️ Core Features
+Feature	Description
+🎭 AI Dungeon Master	Orchestrates scenes, conflicts, and roleplay hooks with dramatic tone
+👥 NPC Generator	Builds named characters with secrets, flaws, goals, and voice
+🗺️ World Builder	Assembles regions, ruins, factions, and mythic histories
+💰 Loot Master	Designs magical items that reflect player actions and narrative symbols
+🐉 Character Creator	Generates heroes with stats, backstories, class synergy, and emotional arcs
+🧪 Demo Capabilities
+
+✅ Procedural setting, NPC, and loot generation
+✅ Modular agent logic with memory and context threading
+✅ Gradio-based interactive frontend for testing each system
+✅ Rich character builder with storytelling-first logic
+✅ Configurable, extensible, and fully open source
+🧭 Demo Suggestions
+
+Explore the toolkit using these suggested flows:
+🧙 Dungeon Master Agent
+
+    Prompt with: "The players enter a ruined cathedral during a thunderstorm"
+
+    Watch it generate narrative tension, scene tone, and roleplay threads.
+
+👥 NPC Generator
+
+    Prompt with: "a cursed knight guarding forgotten ruins"
+
+    Get a complex NPC with motives, secrets, and drama potential.
+
+🗺️ World Builder
+
+    Prompt with: "a coastal nation obsessed with prophecy"
+
+    Generates factions, politics, threats, and lore.
+
+💰 Loot Master
+
+    Prompt with: "a cursed artifact from a sunken temple"
+
+    Produces symbolic, story-linked loot tied to in-game values.
+
+🐉 Character Creator
+
+    Prompt with: "A storm sorcerer who fears their own power"
+
+    Returns stat blocks, class alignment, flaws, and heroic potential.
+
+🛠️ Technologies
+
+    Gradio 5.33.1 — Live demo interface
+
+    OpenAI GPT-4 — Agent reasoning and generation
+
+    Python (modular) — Custom agent scaffolding and game logic
+
+🚀 How to Run
+
+git clone https://huggingface.co/spaces/YOUR_USERNAME/DungeonSmasher
+cd DungeonSmasher
+
+pip install -r requirements.txt
+python app.py
+
+Or view the live app at:
+🌐 https://huggingface.co/spaces/YOUR_USERNAME/DungeonSmasher
+🎯 Future Plans
+
+    Playable dungeon mode with live turn-based flow
+
+    AI narrator voice + dialogue puppeteering
+
+    Campaign memory and recurring characters
+
+    Dynamic player reputation, fear, and legacy
+
+    Fully voiced roleplay loop via multimodal input
+
+📄 License
+
+MIT License – Use freely, remix bravely.
+💬 Final Note to Judges
+
+On Friday June 6th, I was unexpectedly terminated from my job. This wasn’t just a professional setback. It triggered a cascade of urgent and high-stakes responsibilities and I’ve spent the past several days filing legal responses and preparing to escalate claims of retaliation, IP theft, and unlawful recording. I’ve had to act as my own advocate, researcher, and legal strategist, at present.
+
+This sudden derailment had a significant impact on my ability to finalize my hackathon submission. While I still submitted something, it reflects only a fraction of what I’d intended to build. I wanted to share this contextas an honest explanation of why my submission may seem incomplete or rushed and not as an excuse.
+
+I’m grateful for the opportunity to bring this to life and for the space to create, even amidst personal crisis.
+
+
+Sincerely,
+
+— Jesse W. Stucker (ghost logic.)

app.py

@@ -0,0 +1,473 @@
+"""
+Copyright (c) 2024 Jesse Stucker aka "ghost logic"
+All rights reserved. Proprietary and confidential.
+
+This AI gaming platform is proprietary software.
+Commercial use requires separate license.
+Contact: [email protected]
+
+For commercial licensing inquiries, visit: linkedin.com/in/jessetucker
+"""
+
+# app.py - 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 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
+
+# ===== AI AGENT CLASSES =====
+class DungeonMasterAgent:
+    """AI agent that acts as a Dungeon Master"""
+    
+    def __init__(self):
+        self.personality = "Creative, fair, and engaging storyteller"
+    
+    def _get_proprietary_prompt(self, **kwargs):
+        """
+        Proprietary prompt engineering system - DEMONSTRATION VERSION
+        Commercial version includes advanced optimization and techniques.
+        Contact: [email protected]
+        """
+        theme = kwargs.get('theme', 'High Fantasy')
+        level = kwargs.get('level', 1)
+        player_count = kwargs.get('player_count', 4)
+        
+        return f"""As an experienced D&D Dungeon Master, create a campaign concept for:
+Theme: {theme}
+Starting 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
+
+Make it engaging and ready to play!"""
+
+    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 = self._get_proprietary_prompt(theme=theme, level=level, player_count=player_count)
+            
+            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."},
+                         {"role": "user", "content": prompt}],
+                max_tokens=500,
+                temperature=0.8
+            )
+            
+            return {"success": True, "content": response.choices[0].message.content}
+            
+        except Exception as e:
+            logger.error(f"Campaign generation failed: {e}")
+            return {"success": False, "error": str(e), "content": f"Demo Campaign: {theme} adventure for {player_count} level {level} characters"}
+
+class NPCAgent:
+    """AI agent specialized in creating NPCs"""
+    
+    def __init__(self):
+        self.personality = "Versatile character actor"
+    
+    def _get_proprietary_prompt(self, **kwargs):
+        """
+        Proprietary NPC generation system - DEMONSTRATION VERSION
+        Commercial version includes advanced personality algorithms.
+        Contact: [email protected]
+        """
+        context = kwargs.get('context', 'fantasy tavern')
+        role = kwargs.get('role', 'neutral')
+        gender = kwargs.get('gender', '')
+        
+        gender_text = f"Gender: {gender}" if gender else "Gender: Choose appropriate gender"
+        
+        return f"""Create a detailed NPC for D&D:
+Setting: {context}
+Role: {role}
+{gender_text}
+
+Generate:
+1. Name and demographics
+2. Personality traits (3-4 key traits)
+3. Background and motivation
+4. Physical description
+5. Speech patterns
+6. Secret or hidden agenda
+
+Make them memorable and three-dimensional!"""
+
+    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"))
+            
+            prompt = self._get_proprietary_prompt(context=context, role=role, gender=gender)
+            
+            response = client.chat.completions.create(
+                model="gpt-4",
+                messages=[{"role": "system", "content": "You are an expert at creating memorable NPCs for D&D campaigns."},
+                         {"role": "user", "content": prompt}],
+                max_tokens=400,
+                temperature=0.8
+            )
+            
+            return {"success": True, "content": response.choices[0].message.content}
+            
+        except Exception as e:
+            logger.error(f"NPC generation failed: {e}")
+            return {"success": False, "error": str(e), "content": f"Demo NPC: {gender if gender else 'Character'} {role} for {context}"}
+
+# ===== CHARACTER CREATOR =====
+class CharacterCreator:
+    """Character creator with basic D&D functionality"""
+
+    def __init__(self):
+        self.classes = ["Fighter", "Wizard", "Rogue", "Cleric", "Barbarian", "Bard", "Druid", "Monk", "Paladin", "Ranger", "Sorcerer", "Warlock"]
+        self.races = ["Human", "Elf", "Dwarf", "Halfling", "Dragonborn", "Gnome", "Half-Elf", "Half-Orc", "Tiefling"]
+        self.backgrounds = ["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])
+        return 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()
+    character_creator = CharacterCreator()
+    
+    with gr.Blocks(title="D&D Campaign Manager") as demo:
+        gr.Markdown("""
+        # 🏰 Advanced D&D Campaign Manager
+
+⚠️ **PROPRIETARY SOFTWARE - Demo Version**
+
+*Professional AI gaming platform available for commercial licensing*
+
+📧 **Commercial License:** [email protected]  
+🔒 **Copyright:** © 2024 Jesse Tucker - All Rights Reserved  
+💼 **LinkedIn:** linkedin.com/in/jessetucker
+
+**Platform Features:**
+- 🎭 AI Dungeon Master Assistant
+- 👥 Intelligent NPC Creator & Roleplay
+- 🗺️ World Builder Agent
+- 💰 Loot Master & Magic Item Designer
+- 🐉 Enhanced Character Creator
+- ⚡ Deity & Pantheon Generator
+
+*This demonstration showcases proprietary AI coordination technology*
+
+**Note:** This is a demonstration version. Commercial version includes advanced optimization, enhanced algorithms, and enterprise features.
+        """)
+        
+        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=character_creator.races, label="Race", value="Human")
+                            class_dropdown = gr.Dropdown(choices=character_creator.classes, label="Class", value="Fighter")
+                            gender_dropdown = gr.Dropdown(
+                                choices=["Male", "Female", "Non-binary", "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.backgrounds, label="Background", value="Folk Hero")
+                        
+                        # 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("*Roll ability scores to see summary*")
+                        
+                        gr.Markdown("## 🎨 Character Portrait")
+                        portrait_btn = gr.Button("🎨 Generate AI Portrait", variant="primary")
+                        character_portrait = gr.Image(label="Portrait", height=300)
+            
+            # ===== CAMPAIGN CREATOR TAB =====
+            with gr.TabItem("🎭 AI Dungeon Master"):
+                gr.Markdown("## 🎯 Campaign Generation")
+                
+                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)
+            
+            # ===== NPC CREATOR TAB =====
+            with gr.TabItem("👥 NPC Agent"):
+                gr.Markdown("## 🎭 NPC Creator")
+                
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Create New NPC")
+                        npc_context = gr.Textbox(label="Campaign/Scene Context", placeholder="Describe the setting...")
+                        npc_role = gr.Dropdown(
+                            choices=["Ally", "Neutral", "Antagonist", "Quest Giver", "Merchant", "Authority Figure"],
+                            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", "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)
+
+        # ===== EVENT HANDLERS =====
+        
+        def roll_abilities():
+            abilities = character_creator.roll_ability_scores()
+            return (
+                abilities["Strength"], abilities["Dexterity"], abilities["Constitution"],
+                abilities["Intelligence"], abilities["Wisdom"], abilities["Charisma"]
+            )
+        
+        def update_character_summary(name, race, char_class, level, gender, alignment, 
+                                   str_val, dex_val, con_val, int_val, wis_val, cha_val, background):
+            if not all([str_val, dex_val, con_val, int_val, wis_val, cha_val]):
+                return "*Roll ability scores to see summary*"
+            
+            summary = f"""**{name or "Unnamed Character"}**
+*Level {level} {gender} {race} {char_class} ({alignment})*
+
+**Ability Scores:**
+- STR: {int(str_val)} ({(int(str_val) - 10) // 2:+d})
+- DEX: {int(dex_val)} ({(int(dex_val) - 10) // 2:+d})
+- CON: {int(con_val)} ({(int(con_val) - 10) // 2:+d})
+- INT: {int(int_val)} ({(int(int_val) - 10) // 2:+d})
+- WIS: {int(wis_val)} ({(int(wis_val) - 10) // 2:+d})
+- CHA: {int(cha_val)} ({(int(cha_val) - 10) // 2:+d})
+
+**Background:** {background}"""
+            
+            return summary
+        
+        def generate_character_portrait(name, race, char_class, gender):
+            if not name:
+                return "Please enter a character name first"
+            
+            prompt = f"Fantasy portrait of a {gender.lower()} {race.lower()} {char_class.lower()}, professional D&D character art"
+            return generate_image(prompt)
+        
+        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 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:
+                prompt = f"Fantasy portrait of a D&D NPC character, detailed face, professional RPG art"
+            return generate_image(prompt)
+
+        # Wire up events
+        roll_btn.click(roll_abilities, outputs=[str_score, dex_score, con_score, int_score, wis_score, cha_score])
+        
+        # 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]:
+            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],
+                outputs=[character_summary]
+            )
+        
+        portrait_btn.click(
+            generate_character_portrait,
+            inputs=[character_name, race_dropdown, class_dropdown, gender_dropdown],
+            outputs=[character_portrait]
+        )
+        
+        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]
+        )
+        
+        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],
+            outputs=[npc_portrait]
+        )
+    
+    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:
+        demo.launch(
+            share=False,
+            inbrowser=False
+        )
+        logger.info("🌐 App launched successfully!")
+        
+    except Exception as e:
+        logger.error(f"❌ Launch failed: {e}")
+        demo.launch()

requirements.txt

@@ -0,0 +1,3 @@
+
+gradio>=4.44.0
+openai>=1.0.0