Deploy Gradio app with multiple files

app.py

@@ -0,0 +1,369 @@
+import gradio as gr
+import json
+import random
+import time
+from datetime import datetime
+import pandas as pd
+from utils import (
+    initialize_game_state, 
+    create_box, 
+    calculate_battle_result,
+    get_shop_items,
+    purchase_item,
+    get_leaderboard,
+    save_game_state,
+    load_game_state
+)
+from models import Box, Battle, Shop
+
+# Global game state
+game_state = {}
+
+def authenticate_user(profile):
+    """Handle user authentication"""
+    if profile is None:
+        return None, "❌ Please login to play", gr.update(visible=False)
+    
+    user_id = profile["name"]
+    if user_id not in game_state:
+        game_state[user_id] = initialize_game_state(user_id)
+    
+    return user_id, f"✅ Welcome back, {user_id}!", gr.update(visible=True)
+
+def create_user_box(user_id, box_name):
+    """Create a new box for the user"""
+    if not box_name.strip():
+        return "❌ Please enter a box name", get_user_status(user_id)
+    
+    box = create_box(box_name.strip())
+    game_state[user_id]["box"] = box
+    game_state[user_id]["coins"] = 100  # Starting coins
+    
+    status = get_user_status(user_id)
+    return f"✅ Box '{box_name}' created successfully! Starting with 100 coins.", status
+
+def get_user_status(user_id):
+    """Get current user status as formatted text"""
+    if user_id not in game_state:
+        return "❌ User not found"
+    
+    user_data = game_state[user_id]
+    box = user_data.get("box")
+    
+    if not box:
+        return "❌ No box created yet"
+    
+    status = f"""
+📦 BOX STATUS: {box.name}
+⚔️  Attack: {box.attack}
+🛡️  Defense: {box.defense}
+❤️  Health: {box.health}/{box.max_health}
+⚡ Speed: {box.speed}
+🪙 Coins: {user_data.get('coins', 0)}
+🏆 Wins: {user_data.get('wins', 0)}
+💀 Losses: {user_data.get('losses', 0)}
+📊 Level: {box.level}
+✨ XP: {box.xp}/{box.xp_to_next_level}
+    """
+    return status.strip()
+
+def battle_opponent(user_id, opponent_type="system"):
+    """Battle against an opponent"""
+    if user_id not in game_state or not game_state[user_id].get("box"):
+        return "❌ Create a box first!", get_user_status(user_id)
+    
+    user_box = game_state[user_id]["box"]
+    
+    if opponent_type == "system":
+        # Create system box with level based on user level
+        system_level = max(1, user_box.level + random.randint(-2, 2))
+        opponent = create_box(f"System Bot Lv.{system_level}")
+        opponent.level = system_level
+        opponent.attack = 10 + system_level * 5
+        opponent.defense = 8 + system_level * 4
+        opponent.health = 50 + system_level * 20
+        opponent.max_health = opponent.health
+        opponent.speed = 5 + system_level * 2
+    else:
+        # For multiplayer - create a random opponent for demo
+        opponent = create_box(f"Player Box")
+        opponent.level = random.randint(1, 10)
+        opponent.attack = 15 + opponent.level * 3
+        opponent.defense = 12 + opponent.level * 2
+        opponent.health = 40 + opponent.level * 15
+        opponent.max_health = opponent.health
+        opponent.speed = 3 + opponent.level
+    
+    battle_result = calculate_battle_result(user_box, opponent)
+    
+    # Update user stats
+    if battle_result["winner"] == "user":
+        game_state[user_id]["wins"] = game_state[user_id].get("wins", 0) + 1
+        coins_earned = 20 + opponent.level * 5
+        game_state[user_id]["coins"] = game_state[user_id].get("coins", 0) + coins_earned
+        user_box.gain_xp(10 + opponent.level * 5)
+        result_text = f"""
+🎉 VICTORY!
+🏆 You defeated {opponent.name}!
+🪙 Earned {coins_earned} coins
+✨ Gained {10 + opponent.level * 5} XP
+        """
+    else:
+        game_state[user_id]["losses"] = game_state[user_id].get("losses", 0) + 1
+        coins_earned = 5
+        game_state[user_id]["coins"] = game_state[user_id].get("coins", 0) + coins_earned
+        result_text = f"""
+💀 DEFEAT!
+😔 You were defeated by {opponent.name}
+🪙 Earned {coins_earned} coins (consolation prize)
+        """
+    
+    battle_log = f"""
+⚔️ BATTLE LOG
+{battle_result["log"]}
+    """
+    
+    return result_text.strip(), battle_log.strip(), get_user_status(user_id)
+
+def show_shop(user_id):
+    """Display shop items"""
+    if user_id not in game_state:
+        return "❌ Please login first", ""
+    
+    user_coins = game_state[user_id].get("coins", 0)
+    items = get_shop_items()
+    
+    shop_text = f"🪙 Your Coins: {user_coins}\n\n🛍️ SHOP ITEMS:\n\n"
+    
+    for i, item in enumerate(items, 1):
+        affordable = "✅" if user_coins >= item["cost"] else "❌"
+        shop_text += f"{i}. {item['name']} - {item['cost']} coins {affordable}\n"
+        shop_text += f"   {item['description']}\n"
+        shop_text += f"   Effect: {item['effect']}\n\n"
+    
+    return shop_text, ""
+
+def buy_item(user_id, item_choice):
+    """Purchase an item from the shop"""
+    if user_id not in game_state:
+        return "❌ Please login first", show_shop(user_id)
+    
+    try:
+        item_num = int(item_choice)
+        items = get_shop_items()
+        
+        if item_num < 1 or item_num > len(items):
+            return "❌ Invalid item number", show_shop(user_id)
+        
+        item = items[item_num - 1]
+        result = purchase_item(game_state[user_id], item)
+        
+        if result["success"]:
+            return f"✅ {result['message']}", show_shop(user_id)
+        else:
+            return f"❌ {result['message']}", show_shop(user_id)
+    
+    except ValueError:
+        return "❌ Please enter a valid number", show_shop(user_id)
+
+def show_leaderboard():
+    """Display the global leaderboard"""
+    leaderboard = get_leaderboard(game_state)
+    
+    if not leaderboard:
+        return "🏆 LEADERBOARD\n\nNo players yet. Be the first!"
+    
+    board_text = "🏆 GLOBAL LEADERBOARD\n\n"
+    
+    for i, player in enumerate(leaderboard[:10], 1):
+        medal = "🥇" if i == 1 else "🥈" if i == 2 else "🥉" if i == 3 else "🏅"
+        win_rate = (player['wins'] / (player['wins'] + player['losses']) * 100) if (player['wins'] + player['losses']) > 0 else 0
+        board_text += f"{medal} {i}. {player['name']}\n"
+        board_text += f"   🏆 Wins: {player['wins']} | 💀 Losses: {player['losses']}\n"
+        board_text += f"   📊 Win Rate: {win_rate:.1f}% | 📦 Box: {player['box_name']}\n\n"
+    
+    return board_text
+
+def auto_upgrade_system_boxes():
+    """Automatically upgrade system boxes"""
+    while True:
+        time.sleep(30)  # Every 30 seconds
+        # System boxes upgrade logic would go here
+        # For now, this is a placeholder
+
+def create_interface():
+    """Create the main game interface"""
+    
+    with gr.Blocks(
+        title="Box Battle Arena - Accessible Fighting Game",
+        css="""
+        .accessibility-mode {
+            font-size: 18px;
+            line-height: 1.6;
+        }
+        .game-status {
+            background-color: #f0f0f0;
+            padding: 15px;
+            border-radius: 10px;
+            font-family: monospace;
+        }
+        """,
+        theme=gr.themes.Soft()
+    ) as demo:
+        
+        # Header with accessibility info
+        gr.HTML("""
+        <div style="text-align: center; margin-bottom: 20px;">
+            <h1>🥊 Box Battle Arena 🥊</h1>
+            <p><a href="https://huggingface.co/spaces/akhaliq/anycoder" target="_blank">Built with anycoder</a></p>
+            <p>🔊 This game is fully accessible for screen reader users</p>
+            <p>Use Tab to navigate, Enter to select, and screen reader will announce all actions</p>
+        </div>
+        """)
+        
+        # Login section
+        with gr.Row():
+            with gr.Column(scale=1):
+                login_btn = gr.LoginButton()
+                user_info = gr.HTML("<p>🔐 Please login with Hugging Face to play</p>")
+        
+        # Main game area (hidden until login)
+        with gr.Group(visible=False) as game_area:
+            # Box Creation
+            with gr.Group():
+                gr.Markdown("## 📦 Create Your Box")
+                with gr.Row():
+                    box_name_input = gr.Textbox(
+                        label="Box Name",
+                        placeholder="Enter your box name...",
+                        elem_id="box_name_input"
+                    )
+                    create_box_btn = gr.Button("Create Box", variant="primary")
+                
+                create_result = gr.Textbox(label="Creation Result", interactive=False)
+            
+            # Status Display
+            with gr.Group():
+                gr.Markdown("## 📊 Your Status")
+                user_status = gr.Textbox(
+                    label="Current Status",
+                    value="No box created yet",
+                    interactive=False,
+                    elem_classes=["game-status"]
+                )
+            
+            # Battle Section
+            with gr.Group():
+                gr.Markdown("## ⚔️ Battle Arena")
+                with gr.Row():
+                    battle_system_btn = gr.Button("🤖 Battle System Box", variant="primary")
+                    battle_player_btn = gr.Button("👥 Battle Player Box", variant="secondary")
+                
+                battle_result = gr.Textbox(label="Battle Result", interactive=False)
+                battle_log = gr.Textbox(
+                    label="Battle Log",
+                    lines=10,
+                    interactive=False,
+                    elem_classes=["game-status"]
+                )
+            
+            # Shop Section
+            with gr.Group():
+                gr.Markdown("## 🛍️ Shop")
+                with gr.Row():
+                    shop_btn = gr.Button("View Shop")
+                    refresh_shop_btn = gr.Button("🔄 Refresh")
+                
+                shop_display = gr.Textbox(
+                    label="Shop Items",
+                    lines=15,
+                    interactive=False,
+                    elem_classes=["game-status"]
+                )
+                
+                with gr.Row():
+                    item_choice_input = gr.Number(
+                        label="Item Number",
+                        minimum=1,
+                        maximum=10,
+                        step=1
+                    )
+                    buy_btn = gr.Button("Buy Item", variant="primary")
+                
+                shop_result = gr.Textbox(label="Purchase Result", interactive=False)
+            
+            # Leaderboard
+            with gr.Group():
+                gr.Markdown("## 🏆 Leaderboard")
+                leaderboard_btn = gr.Button("View Leaderboard")
+                leaderboard_display = gr.Textbox(
+                    label="Top Players",
+                    lines=15,
+                    interactive=False,
+                    elem_classes=["game-status"]
+                )
+        
+        # Event handlers
+        def handle_login(profile):
+            if profile:
+                user_id, msg, visibility = authenticate_user(profile)
+                return (
+                    gr.update(value=f"✅ Logged in as: {profile['name']}"),
+                    gr.update(visible=True),
+                    user_status.update(value=get_user_status(user_id) if user_id else "No box created yet")
+                )
+            return gr.update(), gr.update(visible=False), gr.update()
+        
+        login_btn.click(
+            handle_login,
+            inputs=[],
+            outputs=[user_info, game_area, user_status]
+        )
+        
+        create_box_btn.click(
+            create_user_box,
+            inputs=[gr.Textbox()],  # Will be replaced with actual user_id tracking
+            outputs=[create_result, user_status]
+        )
+        
+        battle_system_btn.click(
+            lambda: battle_opponent("demo_user"),  # Demo user
+            outputs=[battle_result, battle_log, user_status]
+        )
+        
+        battle_player_btn.click(
+            lambda: battle_opponent("demo_user", "player"),  # Demo user
+            outputs=[battle_result, battle_log, user_status]
+        )
+        
+        shop_btn.click(
+            lambda: show_shop("demo_user"),  # Demo user
+            outputs=[shop_display, shop_result]
+        )
+        
+        buy_btn.click(
+            lambda x: buy_item("demo_user", x),  # Demo user
+            inputs=[item_choice_input],
+            outputs=[shop_result, shop_display]
+        )
+        
+        leaderboard_btn.click(
+            show_leaderboard,
+            outputs=[leaderboard_display]
+        )
+        
+        refresh_shop_btn.click(
+            lambda: show_shop("demo_user"),  # Demo user
+            outputs=[shop_display, shop_result]
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_api=False
+    )

models.py

@@ -0,0 +1,214 @@
+import random
+
+class Box:
+    """Box character class"""
+    
+    def __init__(self, name="Unnamed Box"):
+        self.name = name
+        self.attack = 10
+        self.defense = 8
+        self.health = 50
+        self.max_health = 50
+        self.speed = 5
+        self.level = 1
+        self.xp = 0
+        self.xp_to_next_level = 100
+        self.ability = None
+    
+    def gain_xp(self, amount):
+        """Add XP and check for level up"""
+        self.xp += amount
+        
+        while self.xp >= self.xp_to_next_level:
+            self.level_up()
+    
+    def level_up(self):
+        """Level up the box"""
+        self.level += 1
+        self.xp -= self.xp_to_next_level
+        self.xp_to_next_level = int(self.xp_to_next_level * 1.5)
+        
+        # Increase stats
+        self.attack += 2
+        self.defense += 2
+        self.max_health += 10
+        self.health = self.max_health  # Full heal on level up
+        self.speed += 1
+        
+        # Upgrade ability
+        if self.ability and "level" in self.ability:
+            self.ability["level"] += 1
+    
+    def heal(self, amount):
+        """Heal the box"""
+        self.health = min(self.max_health, self.health + amount)
+    
+    def take_damage(self, damage):
+        """Apply damage to the box"""
+        self.health = max(0, self.health - damage)
+    
+    def is_alive(self):
+        """Check if box is alive"""
+        return self.health > 0
+    
+    def get_status_string(self):
+        """Get formatted status string"""
+        return f"""
+📦 {self.name} (Level {self.level})
+⚔️  Attack: {self.attack}
+🛡️  Defense: {self.defense}
+❤️  Health: {self.health}/{self.max_health}
+⚡ Speed: {self.speed}
+✨ XP: {self.xp}/{self.xp_to_next_level}
+🎯 Ability: {self.ability['name'] if self.ability else 'None'}
+        """.strip()
+
+class Battle:
+    """Battle class for managing fights"""
+    
+    def __init__(self, attacker, defender):
+        self.attacker = attacker
+        self.defender = defender
+        self.rounds = 0
+        self.battle_log = []
+        self.winner = None
+    
+    def start_battle(self):
+        """Start the battle"""
+        self.rounds = 0
+        self.battle_log = []
+        
+        # Determine who goes first
+        attacker_first = self.attacker.speed >= self.defender.speed
+        
+        self.battle_log.append(f"⚔️ Battle Start: {self.attacker.name} vs {self.defender.name}!")
+        self.battle_log.append(f"{self.attacker.name} goes first!" if attacker_first else f"{self.defender.name} goes first!")
+        
+        max_rounds = 20
+        
+        while self.attacker.is_alive() and self.defender.is_alive() and self.rounds < max_rounds:
+            self.rounds += 1
+            self.battle_log.append(f"\n--- Round {self.rounds} ---")
+            
+            if attacker_first:
+                self.execute_round(self.attacker, self.defender)
+                if self.defender.is_alive():
+                    self.execute_round(self.defender, self.attacker)
+            else:
+                self.execute_round(self.defender, self.attacker)
+                if self.attacker.is_alive():
+                    self.execute_round(self.attacker, self.defender)
+        
+        # Determine winner
+        if self.attacker.is_alive() and not self.defender.is_alive():
+            self.winner = self.attacker
+            self.battle_log.append(f"\n🎉 {self.attacker.name} WINS!")
+        elif self.defender.is_alive() and not self.attacker.is_alive():
+            self.winner = self.defender
+            self.battle_log.append(f"\n💀 {self.defender.name} WINS!")
+        else:
+            # Draw or max rounds
+            if self.attacker.health > self.defender.health:
+                self.winner = self.attacker
+                self.battle_log.append(f"\n⏰ Time's up! {self.attacker.name} wins by health!")
+            elif self.defender.health > self.attacker.health:
+                self.winner = self.defender
+                self.battle_log.append(f"\n⏰ Time's up! {self.defender.name} wins by health!")
+            else:
+                self.winner = None
+                self.battle_log.append(f"\n🤝 It's a DRAW!")
+        
+        return {
+            "winner": self.winner,
+            "rounds": self.rounds,
+            "log": "\n".join(self.battle_log)
+        }
+    
+    def execute_round(self, attacker, defender):
+        """Execute a single round"""
+        damage = max(1, attacker.attack - defender.defense + random.randint(-2, 3))
+        
+        # Apply ability effects
+        if attacker.ability:
+            if "damage_bonus" in attacker.ability:
+                damage += attacker.ability["damage_bonus"]
+                self.battle_log.append(f"{attacker.name} uses {attacker.ability['name']}!")
+            
+            if "crit_chance" in attacker.ability and random.random() < attacker.ability["crit_chance"]:
+                damage *= 2
+                self.battle_log.append(f"💥 CRITICAL HIT!")
+        
+        defender.take_damage(damage)
+        self.battle_log.append(f"{attacker.name} deals {damage} damage to {defender.name}")
+        self.battle_log.append(f"{defender.name} health: {defender.health}/{defender.max_health}")
+
+class Shop:
+    """Shop class for managing items"""
+    
+    def __init__(self):
+        self.items = self.generate_shop_items()
+    
+    def generate_shop_items(self):
+        """Generate shop items"""
+        return [
+            {
+                "id": 1,
+                "name": "Power Boost",
+                "cost": 50,
+                "description": "Increase attack by 3",
+                "type": "stat_boost",
+                "stat": "attack",
+                "value": 3
+            },
+            {
+                "id": 2,
+                "name": "Defense Shield",
+                "cost": 40,
+                "description": "Increase defense by 3",
+                "type": "stat_boost",
+                "stat": "defense",
+                "value": 3
+            },
+            {
+                "id": 3,
+                "name": "Health Potion",
+                "cost": 30,
+                "description": "Restore 20 health",
+                "type": "heal",
+                "value": 20
+            },
+            {
+                "id": 4,
+                "name": "Speed Boots",
+                "cost": 60,
+                "description": "Increase speed by 2",
+                "type": "stat_boost",
+                "stat": "speed",
+                "value": 2
+            },
+            {
+                "id": 5,
+                "name": "Mystery Box",
+                "cost": 100,
+                "description": "Random stat boost",
+                "type": "random"
+            }
+        ]
+    
+    def get_item(self, item_id):
+        """Get item by ID"""
+        for item in self.items:
+            if item["id"] == item_id:
+                return item
+        return None
+    
+    def purchase_item(self, user_coins, item_id):
+        """Purchase an item"""
+        item = self.get_item(item_id)
+        if not item:
+            return {"success": False, "message": "Item not found"}
+        
+        if user_coins < item["cost"]:
+            return {"success": False, "message": "Not enough coins"}
+        
+        return {"success": True, "item": item, "message": f"Purchased {item['name']}"}

requirements.txt

@@ -0,0 +1,3 @@
+gradio[mcp]
+pandas
+numpy

utils.py

@@ -0,0 +1,322 @@
+import random
+import json
+from datetime import datetime
+from models import Box
+
+def initialize_game_state(user_id):
+    """Initialize game state for a new user"""
+    return {
+        "user_id": user_id,
+        "box": None,
+        "coins": 0,
+        "wins": 0,
+        "losses": 0,
+        "inventory": [],
+        "created_at": datetime.now().isoformat(),
+        "last_login": datetime.now().isoformat()
+    }
+
+def create_box(name):
+    """Create a new box with random stats"""
+    box = Box(name=name)
+    
+    # Random base stats
+    box.attack = random.randint(8, 15)
+    box.defense = random.randint(6, 12)
+    box.health = random.randint(40, 60)
+    box.max_health = box.health
+    box.speed = random.randint(3, 8)
+    
+    # Random ability
+    abilities = [
+        {"name": "Power Strike", "damage_bonus": 5, "description": "Extra damage on attacks"},
+        {"name": "Iron Shield", "defense_bonus": 3, "description": "Better defense"},
+        {"name": "Quick Attack", "speed_bonus": 2, "description": "Faster attacks"},
+        {"name": "Regeneration", "heal_bonus": 2, "description": "Heals over time"},
+        {"name": "Critical Hit", "crit_chance": 0.2, "description": "Chance for double damage"}
+    ]
+    box.ability = random.choice(abilities)
+    
+    return box
+
+def calculate_battle_result(attacker, defender):
+    """Calculate battle result between two boxes"""
+    battle_log = []
+    rounds = 0
+    max_rounds = 20
+    
+    attacker_health = attacker.health
+    defender_health = defender.health
+    
+    # Determine who goes first
+    attacker_first = attacker.speed >= defender.speed
+    
+    while attacker_health > 0 and defender_health > 0 and rounds < max_rounds:
+        rounds += 1
+        battle_log.append(f"\n--- Round {rounds} ---")
+        
+        if attacker_first:
+            # Attacker's turn
+            damage = max(1, attacker.attack - defender.defense + random.randint(-2, 3))
+            
+            # Apply ability bonus
+            if "damage_bonus" in attacker.ability:
+                damage += attacker.ability["damage_bonus"]
+                battle_log.append(f"{attacker.name} uses {attacker.ability['name']}!")
+            
+            # Critical hit chance
+            if "crit_chance" in attacker.ability and random.random() < attacker.ability["crit_chance"]:
+                damage *= 2
+                battle_log.append(f"💥 CRITICAL HIT!")
+            
+            defender_health -= damage
+            battle_log.append(f"{attacker.name} deals {damage} damage to {defender.name}")
+            battle_log.append(f"{defender.name} health: {max(0, defender_health)}/{defender.max_health}")
+            
+            if defender_health <= 0:
+                break
+            
+            # Defender's turn
+            damage = max(1, defender.attack - attacker.defense + random.randint(-2, 3))
+            
+            # Apply ability bonus
+            if "damage_bonus" in defender.ability:
+                damage += defender.ability["damage_bonus"]
+                battle_log.append(f"{defender.name} uses {defender.ability['name']}!")
+            
+            # Critical hit chance
+            if "crit_chance" in defender.ability and random.random() < defender.ability["crit_chance"]:
+                damage *= 2
+                battle_log.append(f"💥 CRITICAL HIT!")
+            
+            attacker_health -= damage
+            battle_log.append(f"{defender.name} deals {damage} damage to {attacker.name}")
+            battle_log.append(f"{attacker.name} health: {max(0, attacker_health)}/{attacker.max_health}")
+        else:
+            # Defender goes first (same logic as above but reversed)
+            damage = max(1, defender.attack - attacker.defense + random.randint(-2, 3))
+            
+            if "damage_bonus" in defender.ability:
+                damage += defender.ability["damage_bonus"]
+                battle_log.append(f"{defender.name} uses {defender.ability['name']}!")
+            
+            if "crit_chance" in defender.ability and random.random() < defender.ability["crit_chance"]:
+                damage *= 2
+                battle_log.append(f"💥 CRITICAL HIT!")
+            
+            attacker_health -= damage
+            battle_log.append(f"{defender.name} deals {damage} damage to {attacker.name}")
+            battle_log.append(f"{attacker.name} health: {max(0, attacker_health)}/{attacker.max_health}")
+            
+            if attacker_health <= 0:
+                break
+            
+            damage = max(1, attacker.attack - defender.defense + random.randint(-2, 3))
+            
+            if "damage_bonus" in attacker.ability:
+                damage += attacker.ability["damage_bonus"]
+                battle_log.append(f"{attacker.name} uses {attacker.ability['name']}!")
+            
+            if "crit_chance" in attacker.ability and random.random() < attacker.ability["crit_chance"]:
+                damage *= 2
+                battle_log.append(f"💥 CRITICAL HIT!")
+            
+            defender_health -= damage
+            battle_log.append(f"{attacker.name} deals {damage} damage to {defender.name}")
+            battle_log.append(f"{defender.name} health: {max(0, defender_health)}/{defender.max_health}")
+    
+    # Determine winner
+    if attacker_health > 0 and defender_health <= 0:
+        winner = "attacker"
+        battle_log.append(f"\n🎉 {attacker.name} WINS!")
+    elif defender_health > 0 and attacker_health <= 0:
+        winner = "defender"
+        battle_log.append(f"\n💀 {defender.name} WINS!")
+    else:
+        # Draw or max rounds reached
+        winner = "draw"
+        if attacker_health > defender_health:
+            winner = "attacker"
+            battle_log.append(f"\n⏰ Time's up! {attacker.name} wins by health!")
+        elif defender_health > attacker_health:
+            winner = "defender"
+            battle_log.append(f"\n⏰ Time's up! {defender.name} wins by health!")
+        else:
+            battle_log.append(f"\n🤝 It's a DRAW!")
+    
+    return {
+        "winner": "user" if winner == "attacker" else "opponent" if winner == "defender" else "draw",
+        "log": "\n".join(battle_log),
+        "rounds": rounds
+    }
+
+def get_shop_items():
+    """Get available shop items"""
+    return [
+        {
+            "name": "Power Boost",
+            "cost": 50,
+            "description": "Increase attack by 3",
+            "effect": "attack +3",
+            "type": "attack"
+        },
+        {
+            "name": "Defense Shield",
+            "cost": 40,
+            "description": "Increase defense by 3",
+            "effect": "defense +3",
+            "type": "defense"
+        },
+        {
+            "name": "Health Potion",
+            "cost": 30,
+            "description": "Restore 20 health",
+            "effect": "health +20",
+            "type": "health"
+        },
+        {
+            "name": "Speed Boots",
+            "cost": 60,
+            "description": "Increase speed by 2",
+            "effect": "speed +2",
+            "type": "speed"
+        },
+        {
+            "name": "Mystery Box",
+            "cost": 100,
+            "description": "Random stat boost",
+            "effect": "random +5",
+            "type": "mystery"
+        },
+        {
+            "name": "XP Boost",
+            "cost": 80,
+            "description": "Gain 50 XP instantly",
+            "effect": "xp +50",
+            "type": "xp"
+        },
+        {
+            "name": "Coin Pouch",
+            "cost": 20,
+            "description": "Get 30 coins",
+            "effect": "coins +30",
+            "type": "coins"
+        },
+        {
+            "name": "Ability Upgrade",
+            "cost": 150,
+            "description": "Upgrade your ability",
+            "effect": "ability ++",
+            "type": "ability"
+        },
+        {
+            "name": "Max Health Boost",
+            "cost": 70,
+            "description": "Increase max health by 15",
+            "effect": "max_health +15",
+            "type": "max_health"
+        },
+        {
+            "name": "Lucky Charm",
+            "cost": 90,
+            "description": "Increase critical hit chance",
+            "effect": "crit +10%",
+            "type": "crit"
+        }
+    ]
+
+def purchase_item(user_data, item):
+    """Purchase an item from the shop"""
+    if user_data["coins"] < item["cost"]:
+        return {"success": False, "message": "Not enough coins!"}
+    
+    box = user_data.get("box")
+    if not box:
+        return {"success": False, "message": "Create a box first!"}
+    
+    user_data["coins"] -= item["cost"]
+    
+    # Apply item effect
+    if item["type"] == "attack":
+        box.attack += 3
+        message = f"Attack increased to {box.attack}!"
+    elif item["type"] == "defense":
+        box.defense += 3
+        message = f"Defense increased to {box.defense}!"
+    elif item["type"] == "health":
+        box.health = min(box.max_health, box.health + 20)
+        message = f"Health restored to {box.health}!"
+    elif item["type"] == "speed":
+        box.speed += 2
+        message = f"Speed increased to {box.speed}!"
+    elif item["type"] == "mystery":
+        stat = random.choice(["attack", "defense", "speed"])
+        if stat == "attack":
+            box.attack += 5
+            message = f"Mystery box gave +5 attack!"
+        elif stat == "defense":
+            box.defense += 5
+            message = f"Mystery box gave +5 defense!"
+        else:
+            box.speed += 5
+            message = f"Mystery box gave +5 speed!"
+    elif item["type"] == "xp":
+        box.gain_xp(50)
+        message = f"Gained 50 XP! Current level: {box.level}"
+    elif item["type"] == "coins":
+        user_data["coins"] += 30
+        message = f"Received 30 coins! Total: {user_data['coins']}"
+    elif item["type"] == "ability":
+        box.ability["level"] = box.ability.get("level", 1) + 1
+        message = f"Ability upgraded to level {box.ability['level']}!"
+    elif item["type"] == "max_health":
+        box.max_health += 15
+        box.health += 15
+        message = f"Max health increased to {box.max_health}!"
+    elif item["type"] == "crit":
+        if "crit_chance" not in box.ability:
+            box.ability["crit_chance"] = 0.1
+        else:
+            box.ability["crit_chance"] = min(0.5, box.ability["crit_chance"] + 0.1)
+        message = f"Critical hit chance increased to {box.ability['crit_chance']*100:.0f}%!"
+    
+    user_data["inventory"].append(item["name"])
+    
+    return {"success": True, "message": message}
+
+def get_leaderboard(game_state):
+    """Get the global leaderboard"""
+    players = []
+    
+    for user_id, data in game_state.items():
+        if data.get("box"):
+            players.append({
+                "name": user_id,
+                "box_name": data["box"].name,
+                "level": data["box"].level,
+                "wins": data.get("wins", 0),
+                "losses": data.get("losses", 0),
+                "total_battles": data.get("wins", 0) + data.get("losses", 0)
+            })
+    
+    # Sort by wins, then by win rate
+    players.sort(key=lambda x: (x["wins"], x["wins"]/(x["losses"]+1) if x["losses"] > 0 else x["wins"]), reverse=True)
+    
+    return players
+
+def save_game_state(game_state, filename="game_state.json"):
+    """Save game state to file"""
+    try:
+        with open(filename, 'w') as f:
+            json.dump(game_state, f, default=str)
+        return True
+    except:
+        return False
+
+def load_game_state(filename="game_state.json"):
+    """Load game state from file"""
+    try:
+        with open(filename, 'r') as f:
+            return json.load(f)
+    except:
+        return {}