Create app.py

app.py

@@ -0,0 +1,773 @@
+# app.py - Game-Based Learning Version
+import streamlit as st
+import os
+import time
+import random
+import base64
+import json
+import requests
+import re
+from PIL import Image
+import io
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+
+# Configure Streamlit page
+st.set_page_config(
+    page_title="StoryCoder - Learn Coding Through Games",
+    page_icon="🧙‍♂️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for colorful UI
+st.markdown("""
+<style>
+    @import url('https://fonts.googleapis.com/css2?family=Comic+Neue:wght@700&display=swap');
+    
+    :root {
+        --primary: #FF6B6B;
+        --secondary: #4ECDC4;
+        --accent: #FFD166;
+        --dark: #1A535C;
+        --light: #F7FFF7;
+    }
+    
+    body {
+        background: linear-gradient(135deg, var(--light) 0%, #E8F4F8 100%);
+        font-family: 'Comic Neue', cursive;
+    }
+    
+    .stApp {
+        background: url('https://www.transparenttextures.com/patterns/cartographer.png');
+    }
+    
+    .story-box {
+        background-color: white;
+        border-radius: 20px;
+        padding: 25px;
+        box-shadow: 0 8px 16px rgba(26, 83, 92, 0.15);
+        border: 3px solid var(--accent);
+        margin-bottom: 25px;
+    }
+    
+    .header {
+        color: var(--dark);
+        text-shadow: 2px 2px 4px rgba(0,0,0,0.1);
+    }
+    
+    .concept-card {
+        background: linear-gradient(145deg, #ffffff, #f0f0f0);
+        border-radius: 15px;
+        padding: 15px;
+        margin: 10px 0;
+        border-left: 5px solid var(--secondary);
+        box-shadow: 0 4px 8px rgba(0,0,0,0.05);
+    }
+    
+    .stButton>button {
+        background: linear-gradient(45deg, var(--primary), var(--secondary));
+        color: white;
+        border-radius: 12px;
+        padding: 10px 24px;
+        font-weight: bold;
+        font-size: 18px;
+        border: none;
+        transition: all 0.3s;
+    }
+    
+    .stButton>button:hover {
+        transform: scale(1.05);
+        box-shadow: 0 6px 12px rgba(0,0,0,0.15);
+    }
+    
+    .stTextInput>div>div>input {
+        border-radius: 12px;
+        padding: 12px;
+        border: 2px solid var(--accent);
+    }
+    
+    .tabs {
+        display: flex;
+        gap: 10px;
+        margin-bottom: 20px;
+        overflow-x: auto;
+    }
+    
+    .tab {
+        padding: 10px 20px;
+        background-color: var(--accent);
+        border-radius: 10px;
+        cursor: pointer;
+        font-weight: bold;
+        white-space: nowrap;
+    }
+    
+    .tab.active {
+        background-color: var(--secondary);
+        color: white;
+    }
+    
+    @media (max-width: 768px) {
+        .tabs {
+            flex-wrap: wrap;
+        }
+    }
+    
+    .game-container {
+        background-color: #1a1a2e;
+        border-radius: 15px;
+        padding: 20px;
+        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
+        margin-bottom: 25px;
+        position: relative;
+        overflow: hidden;
+    }
+    
+    .game-preview {
+        border-radius: 10px;
+        overflow: hidden;
+        margin: 0 auto;
+        display: block;
+        max-width: 100%;
+    }
+    
+    .character {
+        font-size: 48px;
+        text-align: center;
+        margin: 10px 0;
+    }
+    
+    .game-instructions {
+        background-color: #f0f8ff;
+        border-radius: 15px;
+        padding: 15px;
+        margin: 15px 0;
+    }
+    
+    .ai-game {
+        border: 3px solid var(--accent);
+        border-radius: 15px;
+        padding: 15px;
+        background: white;
+        margin: 20px 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Concept database
+CONCEPTS = {
+    "loop": {
+        "name": "Loop",
+        "emoji": "🔄",
+        "description": "Loops repeat actions multiple times",
+        "example": "for i in range(5):\n    print('Hello!')",
+        "color": "#FF9E6D"
+    },
+    "conditional": {
+        "name": "Conditional",
+        "emoji": "❓",
+        "description": "Conditionals make decisions in code",
+        "example": "if sunny:\n    go_outside()\nelse:\n    stay_inside()",
+        "color": "#4ECDC4"
+    },
+    "function": {
+        "name": "Function",
+        "emoji": "✨",
+        "description": "Functions are reusable blocks of code",
+        "example": "def greet(name):\n    print(f'Hello {name}!')",
+        "color": "#FFD166"
+    },
+    "variable": {
+        "name": "Variable",
+        "emoji": "📦",
+        "description": "Variables store information",
+        "example": "score = 10\nplayer = 'Alex'",
+        "color": "#FF6B6B"
+    },
+    "list": {
+        "name": "List",
+        "emoji": "📝",
+        "description": "Lists store collections of items",
+        "example": "fruits = ['apple', 'banana', 'orange']",
+        "color": "#1A535C"
+    }
+}
+
+# Pre-generated game examples
+GAME_EXAMPLES = {
+    "loop": {
+        "image": "https://placehold.co/600x400/orange/white?text=Loop+Game",
+        "description": "Collect coins in a looping maze"
+    },
+    "conditional": {
+        "image": "https://placehold.co/600x400/blue/white?text=Conditional+Game",
+        "description": "Avoid obstacles by making decisions"
+    },
+    "function": {
+        "image": "https://placehold.co/600x400/green/white?text=Function+Game",
+        "description": "Cast spells using reusable functions"
+    }
+}
+
+# Initialize Groq client
+def get_groq_client():
+    api_key = st.secrets.get("GROQ_API_KEY", "")
+    if not api_key:
+        st.warning("Groq API key not found. Using simpler game generation.")
+        return None
+    try:
+        from groq import Groq
+        return Groq(api_key=api_key)
+    except ImportError:
+        st.error("Groq library not installed. Please install with `pip install groq`")
+        return None
+    except Exception as e:
+        st.error(f"Error initializing Groq client: {str(e)}")
+        return None
+
+# Analyze story and identify programming concepts
+def analyze_story(story):
+    story_lower = story.lower()
+    detected_concepts = []
+    
+    # Check for loops
+    if any(word in story_lower for word in ["times", "repeat", "again", "multiple", "many"]):
+        detected_concepts.append("loop")
+    
+    # Check for conditionals
+    if any(word in story_lower for word in ["if", "when", "unless", "whether", "decision"]):
+        detected_concepts.append("conditional")
+    
+    # Check for functions
+    if any(word in story_lower for word in ["make", "create", "do", "perform", "cast", "spell"]):
+        detected_concepts.append("function")
+    
+    # Check for variables
+    if any(word in story_lower for word in ["is", "has", "set to", "value", "store"]):
+        detected_concepts.append("variable")
+    
+    # Check for lists
+    if any(word in story_lower for word in ["and", "many", "several", "collection", "items", "group"]):
+        detected_concepts.append("list")
+    
+    return list(set(detected_concepts))
+
+# Extract entities from story using regex
+def extract_entities(story):
+    entities = {
+        "characters": [],
+        "objects": [],
+        "actions": [],
+        "locations": []
+    }
+    
+    # Extract characters (proper nouns)
+    entities["characters"] = list(set(re.findall(r'\b[A-Z][a-z]+\b', story)))
+    
+    # Extract objects (nouns after "the")
+    entities["objects"] = list(set(re.findall(r'\bthe\s+(\w+)', story, re.I)))
+    
+    # Extract actions (verbs)
+    entities["actions"] = list(set(re.findall(r'\b(\w+ed|\w+ing)\b', story)))
+    
+    # Extract locations (nouns after "in", "on", "at")
+    locations = re.findall(r'\b(in|on|at)\s+the?\s?(\w+)', story)
+    entities["locations"] = list(set([loc[1] for loc in locations]))
+    
+    # Filter out common words
+    common_words = ["the", "a", "an", "and", "or", "but", "if", "then", "when", "where"]
+    for key in entities:
+        entities[key] = [word for word in entities[key] 
+                         if isinstance(word, str) and 
+                         word.lower() not in common_words and 
+                         len(word) > 2]
+    
+    return entities
+
+# Generate game concept using Groq
+def generate_game_concept(story, concepts, entities):
+    groq_client = get_groq_client()
+    if not groq_client:
+        # Fallback concept
+        return {
+            "title": "Adventure Game",
+            "description": "An exciting game based on your story!",
+            "mechanics": "Collect items and avoid obstacles",
+            "code_concepts": ", ".join(concepts),
+            "instructions": "Use arrow keys to move and space to jump"
+        }
+    
+    try:
+        prompt = f"""
+        You are a game designer creating educational games for kids aged 6-12. 
+        Create a simple 2D game concept based on the following story:
+        
+        Story: "{story}"
+        
+        Programming concepts to include: {', '.join(concepts)}
+        
+        Extracted entities:
+        - Characters: {', '.join(entities['characters'])}
+        - Objects: {', '.join(entities['objects'])}
+        - Actions: {', '.join(entities['actions'])}
+        - Locations: {', '.join(entities['locations'])}
+        
+        Respond in JSON format with these keys:
+        - title: Game title (max 5 words)
+        - description: Game description (1-2 sentences)
+        - mechanics: Core game mechanics (1 sentence)
+        - code_concepts: How programming concepts are used in the game
+        - instructions: Simple game controls (max 10 words)
+        """
+        
+        response = groq_client.chat.completions.create(
+            model="llama3-8b-8192",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.7,
+            max_tokens=512,
+            response_format={"type": "json_object"}
+        )
+        
+        game_data = json.loads(response.choices[0].message.content)
+        return game_data
+    
+    except Exception as e:
+        st.error(f"Game concept generation error: {str(e)}")
+        return {
+            "title": "Adventure Game",
+            "description": "An exciting game based on your story!",
+            "mechanics": "Collect items and avoid obstacles",
+            "code_concepts": ", ".join(concepts),
+            "instructions": "Use arrow keys to move and space to jump"
+        }
+
+# Generate game code using Groq
+def generate_game_code(story, game_concept):
+    groq_client = get_groq_client()
+    if not groq_client:
+        # Fallback game code
+        return """# Simple Game Template
+import pygame
+import sys
+
+# Initialize pygame
+pygame.init()
+
+# Set up display
+WIDTH, HEIGHT = 800, 600
+screen = pygame.display.set_mode((WIDTH, HEIGHT))
+pygame.display.set_caption("Your Adventure Game")
+
+# Colors
+WHITE = (255, 255, 255)
+BLUE = (0, 0, 255)
+RED = (255, 0, 0)
+GREEN = (0, 255, 0)
+
+# Player
+player = pygame.Rect(400, 300, 50, 50)
+player_speed = 5
+
+# Game loop
+clock = pygame.time.Clock()
+running = True
+
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+    
+    # Player movement
+    keys = pygame.key.get_pressed()
+    if keys[pygame.K_LEFT]:
+        player.x -= player_speed
+    if keys[pygame.K_RIGHT]:
+        player.x += player_speed
+    if keys[pygame.K_UP]:
+        player.y -= player_speed
+    if keys[pygame.K_DOWN]:
+        player.y += player_speed
+    
+    # Drawing
+    screen.fill(WHITE)
+    pygame.draw.rect(screen, BLUE, player)
+    
+    # Display instructions
+    font = pygame.font.SysFont(None, 36)
+    text = font.render("Your Adventure Game - Move with arrow keys", True, (0, 0, 0))
+    screen.blit(text, (50, 50))
+    
+    pygame.display.flip()
+    clock.tick(60)
+
+pygame.quit()
+sys.exit()
+""", "Success"
+    
+    try:
+        prompt = f"""
+        You are a Python game developer creating educational games for kids using Pygame.
+        Create a simple 2D game based on the following concept:
+        
+        Game Title: {game_concept['title']}
+        Description: {game_concept['description']}
+        Mechanics: {game_concept['mechanics']}
+        Instructions: {game_concept['instructions']}
+        
+        Requirements:
+        - Use Pygame library
+        - Simple graphics (shapes and colors)
+        - Include at least one character the player controls
+        - Include collectible items
+        - Include obstacles to avoid
+        - Score tracking
+        - Game over condition
+        
+        Output ONLY the Python code with no additional text or explanations.
+        """
+        
+        response = groq_client.chat.completions.create(
+            model="llama3-70b-8192",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.5,
+            max_tokens=2048
+        )
+        
+        game_code = response.choices[0].message.content
+        
+        # Clean up the code
+        if "```python" in game_code:
+            game_code = game_code.split("```python")[1].split("```")[0]
+        elif "```" in game_code:
+            game_code = game_code.split("```")[1]
+        
+        return game_code, "Success"
+    
+    except Exception as e:
+        return f"# Error generating game code\nprint('{str(e)}')", str(e)
+
+# Create placeholder game preview
+def generate_game_preview(game_concept):
+    try:
+        # Create a simple placeholder image
+        img = Image.new('RGB', (600, 400), color=(73, 109, 137))
+        
+        # Add text to the image
+        try:
+            from PIL import ImageDraw, ImageFont
+            draw = ImageDraw.Draw(img)
+            
+            # Try to use a default font
+            try:
+                font = ImageFont.truetype("arial.ttf", 30)
+            except:
+                # Fallback to basic font
+                font = ImageFont.load_default()
+            
+            title = f"{game_concept['title']}"
+            draw.text((150, 150), title, fill=(255, 255, 0), font=font)
+            draw.text((100, 200), "Game Preview", fill=(255, 255, 255), font=font)
+        except:
+            pass
+        
+        # Convert to bytes
+        buf = io.BytesIO()
+        img.save(buf, format='PNG')
+        buf.seek(0)
+        return buf
+    
+    except Exception as e:
+        st.error(f"Game preview generation error: {str(e)}")
+        return None
+
+# Create interactive visualization of game mechanics
+def create_game_visualization(game_concept):
+    try:
+        # Create a simple visualization using Plotly
+        fig = go.Figure()
+        
+        # Add player character
+        fig.add_trace(go.Scatter(
+            x=[0.5], y=[0.5],
+            mode='markers+text',
+            marker=dict(size=50, color='blue'),
+            text='Player',
+            textposition='bottom center',
+            name='Player'
+        ))
+        
+        # Add collectibles
+        for i in range(5):
+            fig.add_trace(go.Scatter(
+                x=[random.uniform(0.2, 0.8)], y=[random.uniform(0.2, 0.8)],
+                mode='markers',
+                marker=dict(size=30, color='gold', symbol='star'),
+                name='Collectible'
+            ))
+        
+        # Add obstacles
+        for i in range(3):
+            fig.add_trace(go.Scatter(
+                x=[random.uniform(0.1, 0.9)], y=[random.uniform(0.1, 0.9)],
+                mode='markers',
+                marker=dict(size=40, color='red', symbol='x'),
+                name='Obstacle'
+            ))
+        
+        # Update layout
+        fig.update_layout(
+            title=f"Game Visualization: {game_concept.get('title', 'Your Game')}",
+            xaxis=dict(showgrid=False, zeroline=False, visible=False, range=[0, 1]),
+            yaxis=dict(showgrid=False, zeroline=False, visible=False, range=[0, 1]),
+            showlegend=False,
+            margin=dict(l=20, r=20, t=40, b=20),
+            height=400,
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)'
+        )
+        
+        return fig
+    
+    except Exception as e:
+        st.error(f"Visualization error: {str(e)}")
+        return None
+
+def main():
+    """Main application function"""
+    st.title("🧙‍♂️ StoryCoder - Learn Coding Through Games!")
+    st.subheader("Turn your story into a game and discover coding secrets!")
+    
+    # Initialize session state
+    if 'story' not in st.session_state:
+        st.session_state.story = ""
+    if 'concepts' not in st.session_state:
+        st.session_state.concepts = []
+    if 'entities' not in st.session_state:
+        st.session_state.entities = {}
+    if 'game_concept' not in st.session_state:
+        st.session_state.game_concept = {}
+    if 'game_code' not in st.session_state:
+        st.session_state.game_code = ""
+    if 'game_preview' not in st.session_state:
+        st.session_state.game_preview = None
+    if 'active_tab' not in st.session_state:
+        st.session_state.active_tab = "story"
+    
+    # Create tabs
+    tab_cols = st.columns(5)
+    with tab_cols[0]:
+        if st.button("📖 Create Story"):
+            st.session_state.active_tab = "story"
+    with tab_cols[1]:
+        if st.button("🎮 Game"):
+            st.session_state.active_tab = "game"
+    with tab_cols[2]:
+        if st.button("🔍 Concepts"):
+            st.session_state.active_tab = "concepts"
+    with tab_cols[3]:
+        if st.button("💻 Code"):
+            st.session_state.active_tab = "code"
+    with tab_cols[4]:
+        if st.button("🔄 Reset"):
+            for key in list(st.session_state.keys()):
+                if key != 'active_tab':
+                    del st.session_state[key]
+            st.session_state.active_tab = "story"
+            st.rerun()
+    
+    # Story creation tab
+    if st.session_state.active_tab == "story":
+        with st.container():
+            st.header("📖 Create Your Story")
+            st.write("Write a short story (2-5 sentences) and I'll turn it into a game!")
+            
+            story = st.text_area(
+                "Your story:",
+                height=200,
+                placeholder="Once upon a time, a rabbit named Ruby needed to collect 5 magical carrots in the enchanted forest while avoiding mischievous squirrels...",
+                value=st.session_state.story,
+                key="story_input"
+            )
+            
+            if st.button("Create Game!", use_container_width=True):
+                if len(story) < 20:
+                    st.error("Your story needs to be at least 20 characters long!")
+                else:
+                    st.session_state.story = story
+                    with st.spinner("🧠 Analyzing your story..."):
+                        st.session_state.concepts = analyze_story(story)
+                        st.session_state.entities = extract_entities(story)
+                    
+                    with st.spinner("🎮 Designing your game..."):
+                        st.session_state.game_concept = generate_game_concept(
+                            story, 
+                            st.session_state.concepts, 
+                            st.session_state.entities
+                        )
+                    
+                    with st.spinner("👾 Generating game preview..."):
+                        st.session_state.game_preview = generate_game_preview(
+                            st.session_state.game_concept
+                        )
+                    
+                    with st.spinner("💻 Creating game code..."):
+                        st.session_state.game_code, error = generate_game_code(
+                            story, 
+                            st.session_state.game_concept
+                        )
+                        if error and "Error" in error:
+                            st.error(f"Code generation error: {error}")
+                    
+                    st.session_state.active_tab = "game"
+                    st.rerun()
+            
+            # Show examples
+            st.subheader("✨ Story Examples")
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.caption("Loop Example")
+                st.code('"Ruby the rabbit needs to collect 5 magical carrots that appear every 10 seconds in the enchanted forest"', language="text")
+                st.image(GAME_EXAMPLES["loop"]["image"], 
+                         use_container_width=True, 
+                         caption=GAME_EXAMPLES["loop"]["description"])
+            with col2:
+                st.caption("Conditional Example")
+                st.code('"If Alex the wizard sees a dragon, he casts a fire spell, otherwise he walks forward to find treasures"', language="text")
+                st.image(GAME_EXAMPLES["conditional"]["image"], 
+                         use_container_width=True, 
+                         caption=GAME_EXAMPLES["conditional"]["description"])
+            with col3:
+                st.caption("Function Example")
+                st.code('"Wizard Lily creates magic spells to solve puzzles - each spell is a special function"', language="text")
+                st.image(GAME_EXAMPLES["function"]["image"], 
+                         use_container_width=True, 
+                         caption=GAME_EXAMPLES["function"]["description"])
+    
+    # Game tab
+    elif st.session_state.active_tab == "game":
+        st.header("🎮 Your Story Game")
+        
+        if not st.session_state.get('story'):
+            st.warning("Please create a story first!")
+            st.session_state.active_tab = "story"
+            st.rerun()
+        
+        # Display game concept
+        st.subheader(f"✨ {st.session_state.game_concept.get('title', 'Your Adventure Game')}")
+        st.write(st.session_state.game_concept.get('description', 'An exciting game based on your story!'))
+        
+        # Display game preview
+        st.subheader("🖼️ Game Preview")
+        if st.session_state.game_preview:
+            st.image(st.session_state.game_preview, use_container_width=True)
+        else:
+            concept = st.session_state.concepts[0] if st.session_state.concepts else "loop"
+            st.image(GAME_EXAMPLES[concept]["image"], 
+                     use_container_width=True,
+                     caption="Example game preview")
+        
+        # Game mechanics visualization
+        st.subheader("🎮 Game Mechanics")
+        if st.session_state.game_concept:
+            fig = create_game_visualization(st.session_state.game_concept)
+            if fig:
+                st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.info("Game mechanics visualization would appear here")
+        
+        # Game instructions
+        st.subheader("📜 How to Play")
+        st.markdown(f"""
+        <div class="game-instructions">
+            <h4>Game Controls:</h4>
+            <p>{st.session_state.game_concept.get('instructions', 'Use arrow keys to move and space to jump')}</p>
+            
+            <h4>Game Mechanics:</h4>
+            <p>{st.session_state.game_concept.get('mechanics', 'Collect items and avoid obstacles')}</p>
+            
+            <h4>Coding Concepts:</h4>
+            <p>{st.session_state.game_concept.get('code_concepts', 'Loops, conditionals, and functions')}</p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        if st.button("Show Coding Secrets!", use_container_width=True):
+            st.session_state.active_tab = "concepts"
+            st.rerun()
+    
+    # Concepts tab
+    elif st.session_state.active_tab == "concepts":
+        st.header("🔍 Coding Concepts in Your Game")
+        st.subheader("We used these programming concepts in your game:")
+        
+        if not st.session_state.concepts:
+            st.warning("No concepts detected in your story! Try adding words like '3 times', 'if', or 'make'.")
+        else:
+            for concept in st.session_state.concepts:
+                if concept in CONCEPTS:
+                    details = CONCEPTS[concept]
+                    st.markdown(f"""
+                    <div class="concept-card" style="border-left: 5px solid {details['color']};">
+                        <div style="display:flex; align-items:center; gap:15px;">
+                            <span style="font-size:36px;">{details['emoji']}</span>
+                            <h3 style="color:{details['color']};">{details['name']}</h3>
+                        </div>
+                        <p>{details['description']}</p>
+                        <pre style="background:#f0f0f0; padding:10px; border-radius:8px;">{details['example']}</pre>
+                    </div>
+                    """, unsafe_allow_html=True)
+            
+            st.subheader("🎮 How Concepts Are Used in Your Game")
+            st.write(st.session_state.game_concept.get('code_concepts', 'These concepts power the mechanics of your game'))
+        
+        if st.button("See the Game Code!", use_container_width=True):
+            st.session_state.active_tab = "code"
+            st.rerun()
+    
+    # Code tab
+    elif st.session_state.active_tab == "code":
+        st.header("💻 Game Code")
+        st.write("Here's the Python code for your game. You can run it on your computer!")
+        
+        if st.session_state.game_code:
+            st.subheader("🎮 Game Implementation")
+            st.code(st.session_state.game_code, language="python")
+            
+            # Download button
+            st.download_button(
+                label="Download Game Code",
+                data=st.session_state.game_code,
+                file_name="story_game.py",
+                mime="text/python",
+                use_container_width=True
+            )
+            
+            st.info("💡 How to run your game:")
+            st.markdown("""
+            1. Install Python from [python.org](https://python.org)
+            2. Install Pygame: `pip install pygame`
+            3. Download the code above
+            4. Run it with: `python story_game.py`
+            """)
+            
+            st.success("🎉 When you run this code, you'll see your story come to life as a playable game!")
+            
+            # Game preview
+            st.subheader("🎮 What Your Game Looks Like")
+            concept = st.session_state.concepts[0] if st.session_state.concepts else "loop"
+            st.image(GAME_EXAMPLES[concept]["image"], 
+                    caption="Your game will look similar to this", 
+                    use_container_width=True)
+        else:
+            st.warning("No game code generated yet!")
+        
+        if st.button("Create Another Game!", use_container_width=True):
+            st.session_state.active_tab = "story"
+            st.session_state.story = ""
+            st.rerun()
+
+if __name__ == "__main__":
+    main()