Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import random | |
| import time | |
| # --- Character Classes --- | |
| class Character: | |
| """Base class for all characters in the game.""" | |
| def __init__(self, name, max_hp, attack, defense, character_type="neutral"): | |
| self.name = name | |
| self.max_hp = max_hp | |
| self.current_hp = max_hp | |
| self.attack = attack | |
| self.defense = defense | |
| self.character_type = character_type # 'player', 'enemy' | |
| def is_alive(self): | |
| """Checks if the character is still alive.""" | |
| return self.current_hp > 0 | |
| def take_damage(self, damage): | |
| """Calculates and applies damage taken.""" | |
| actual_damage = max(0, damage - self.defense) # Defense reduces damage | |
| self.current_hp = max(0, self.current_hp - actual_damage) | |
| return f"{self.name} took {actual_damage} damage!" | |
| def attack_target(self, target): | |
| """Performs an attack on a target.""" | |
| # Add randomness, critical hits, and misses! | |
| miss_chance = 0.05 # 5% chance to miss | |
| if random.random() < miss_chance: | |
| return f"{self.name} swings and MISSES {target.name}!" | |
| damage = random.randint(self.attack - 2, self.attack + 2) | |
| critical_hit = random.random() < 0.1 # 10% chance for a crit | |
| if critical_hit: | |
| damage = int(damage * 1.5) | |
| crit_text = " CRITICAL HIT!" | |
| else: | |
| crit_text = "" | |
| message = f"{self.name} attacks {target.name} for {damage} damage!{crit_text}" | |
| message += "\n" + target.take_damage(damage) | |
| return message | |
| class PlayerCharacter(Character): | |
| """Base class for player characters (Scott or Ramona).""" | |
| def __init__(self, name, max_hp, attack, defense): | |
| super().__init__(name, max_hp, attack, defense, character_type="player") | |
| self.xp = 0 | |
| self.level = 1 | |
| # Start players with a little spending cash | |
| self.money = 25 | |
| def gain_xp(self, amount): | |
| """Awards experience points and checks for level up.""" | |
| self.xp += amount | |
| message = f"You gained {amount} XP!" | |
| # Simple level up system: gain a level every 50 XP | |
| while self.xp >= self.level * 50: | |
| message += "\n" + self.level_up() | |
| return message | |
| def level_up(self): | |
| """Increases player stats upon leveling up.""" | |
| self.level += 1 | |
| self.max_hp += 20 | |
| self.current_hp = self.max_hp # Fully heal on level up | |
| self.attack += 3 | |
| self.defense += 1 | |
| return f"\n--- {self.name} Leveled Up to Level {self.level}! ---\nNew Stats: HP: {self.max_hp}, Attack: {self.attack}, Defense: {self.defense}" | |
| class ScottPilgrim(PlayerCharacter): | |
| """Scott Pilgrim character with his specific stats.""" | |
| def __init__(self): | |
| super().__init__("Scott Pilgrim", 100, 15, 5) | |
| class RamonaFlowers(PlayerCharacter): | |
| """Ramona Flowers character with her specific stats.""" | |
| def __init__(self): | |
| super().__init__("Ramona Flowers", 110, 17, 4) | |
| class EvilEx(Character): | |
| """Base class for enemies (Evil Exes).""" | |
| def __init__(self, name, max_hp, attack, defense, xp_reward, money_drop): | |
| super().__init__(name, max_hp, attack, defense, character_type="enemy") | |
| self.xp_reward = xp_reward | |
| self.money_drop = money_drop | |
| # --- Game State Management --- | |
| class ScottPilgrimGame: | |
| """Manages the entire game state and logic.""" | |
| def __init__(self): | |
| # Initial game state attributes are set to None or default values | |
| self.player = None | |
| self.current_enemy = None | |
| self.game_active = False | |
| self.message_log = [] | |
| self.ex_index = 0 | |
| self.current_ex_list = [] | |
| self.current_game_phase = "start" # "start", "combat", "game_over", "win" | |
| # Define Evil Exes for Scott's storyline | |
| self.scott_exes = [ | |
| ("The Chaos Theater", EvilEx("Matthew Patel", 50, 10, 2, 30, 10)), | |
| ("Casa Loma (outside)", EvilEx("The Twins & Roxy Richter", 70, 12, 3, 50, 20)), | |
| ("Vegan restaurant", EvilEx("Todd Ingram", 90, 15, 4, 70, 30)), | |
| ("The Score at Lee's Palace", EvilEx("Envy Adams", 110, 17, 5, 90, 40)), | |
| ("Final Boss Arena", EvilEx("Gideon Graves", 150, 20, 7, 150, 70)) | |
| ] | |
| # Define Evil Exes for Ramona's storyline (a creative twist!) | |
| self.ramona_exes = [ | |
| ("Scott's Band Practice", EvilEx("Kim Pine", 55, 11, 3, 35, 12)), | |
| ("A Bar on Bloor", EvilEx("Knives Chau", 75, 13, 4, 55, 22)), | |
| ("Scott's Apartment", EvilEx("Lisa Miller", 95, 16, 5, 75, 32)), | |
| ("The Club Scene", EvilEx("Stacey Pilgrim", 115, 18, 6, 95, 42)), # Fictional boss | |
| ("The Subspace Highway", EvilEx("Young Neil", 160, 21, 8, 160, 75)) # Fictional final boss | |
| ] | |
| # --- In-game shop items --- | |
| self.shop_items = { | |
| "Energy Drink": {"cost": 10, "type": "heal", "amount": 20, "desc": "Restore 20 HP"}, | |
| "Protein Bar": {"cost": 15, "type": "attack", "amount": 2, "desc": "+2 Attack"}, | |
| "Armor Patch": {"cost": 15, "type": "defense", "amount": 1, "desc": "+1 Defense"}, | |
| "Max Potion": {"cost": 20, "type": "heal_full", "amount": 0, "desc": "Fully heal"}, | |
| } | |
| def reset_game(self): | |
| """Resets the game state for a new playthrough.""" | |
| self.__init__() # Re-initialize the game object to its default state | |
| def start_new_game(self, character_choice): | |
| """Initializes a new game based on character choice.""" | |
| self.reset_game() # Ensure a clean slate | |
| if character_choice == "Play as Scott Pilgrim": | |
| self.player = ScottPilgrim() | |
| self.current_ex_list = list(self.scott_exes) # Use a copy of the list | |
| self.add_message("You chose to play as Scott Pilgrim! Get ready to face Ramona's Evil Exes!") | |
| # Image assets for Scott | |
| self.image_assets = { | |
| "idle": ["characters/Scott_idle.webp"], | |
| "attack": ["characters/Scott_Attack.webp", "characters/Scott_angry.webp"], | |
| "run": ["characters/Scott_angry.webp"] | |
| } | |
| self.player_image_path = self.image_assets["idle"][0] | |
| # Prepare cycling list | |
| self.image_cycle = self.image_assets["idle"] + self.image_assets["attack"] + self.image_assets["run"] | |
| self.image_cycle_index = 0 | |
| elif character_choice == "Play as Ramona Flowers": | |
| self.player = RamonaFlowers() | |
| self.current_ex_list = list(self.ramona_exes) # Use a copy of the list | |
| self.add_message("You chose to play as Ramona Flowers! It's time to deal with Scott's complicated past!") | |
| # Image assets for Ramona | |
| self.image_assets = { | |
| "idle": ["characters/Ramona_Angry.webp"], | |
| "attack": ["characters/Ramona_attack.webp", "characters/Ramona_attack2.webp"], | |
| "run": ["characters/Ramona_attack2.webp"] | |
| } | |
| self.player_image_path = self.image_assets["idle"][0] | |
| # Prepare cycling list | |
| self.image_cycle = self.image_assets["idle"] + self.image_assets["attack"] + self.image_assets["run"] | |
| self.image_cycle_index = 0 | |
| else: | |
| self.add_message("Invalid character choice. Please select Scott or Ramona.") | |
| return | |
| self.game_active = True | |
| self.current_game_phase = "combat" | |
| self._set_next_enemy() | |
| def _set_next_enemy(self): | |
| """Sets the next enemy from the list for the current battle.""" | |
| if self.ex_index < len(self.current_ex_list): | |
| location, enemy_data = self.current_ex_list[self.ex_index] | |
| # Create a new instance of the enemy so their HP is fresh for each battle | |
| self.current_enemy = EvilEx(enemy_data.name, enemy_data.max_hp, enemy_data.attack, enemy_data.defense, enemy_data.xp_reward, enemy_data.money_drop) | |
| self.add_message(f"\n--- Confronting {self.current_enemy.name} at {location}! ---") | |
| else: | |
| self.current_enemy = None # No more enemies | |
| def add_message(self, message): | |
| """Adds a message to the game log for display.""" | |
| self.message_log.append(message) | |
| # Keep the log from getting too long for the display | |
| if len(self.message_log) > 20: | |
| self.message_log = self.message_log[-20:] | |
| def get_status_text(self): | |
| """Returns a formatted string of current player and enemy status.""" | |
| if not self.player: | |
| return "" | |
| status = f"{self.player.name} (Lvl {self.player.level}) | HP: {self.player.current_hp}/{self.player.max_hp} | XP: {self.player.xp}/{self.player.level * 50}" | |
| status += f" | $: {self.player.money}" | |
| if self.current_enemy: | |
| status += f"\n{self.current_enemy.name} | HP: {self.current_enemy.current_hp}/{self.current_enemy.max_hp}" | |
| return status | |
| def _check_game_over(self): | |
| """Checks for and handles the player's defeat.""" | |
| if not self.player.is_alive(): | |
| self.game_active = False | |
| self.current_game_phase = "game_over" | |
| self.add_message(f"\n{self.player.name} has been defeated by {self.current_enemy.name}!") | |
| self.add_message("Game Over!") | |
| def _handle_victory(self): | |
| """Handles the logic after defeating an enemy.""" | |
| self.add_message(f"\n{self.current_enemy.name} has been defeated!") | |
| self.add_message(self.player.gain_xp(self.current_enemy.xp_reward)) | |
| self.player.money += self.current_enemy.money_drop | |
| self.add_message(f"You found ${self.current_enemy.money_drop}!") | |
| self.ex_index += 1 | |
| # Check for game completion | |
| if self.ex_index >= len(self.current_ex_list): | |
| self.game_active = False | |
| self.current_game_phase = "win" | |
| self.add_message("\nCongratulations! You have defeated all Evil Exes!") | |
| self.add_message("You have truly earned the power of self-respect!") | |
| else: | |
| # Set up the next fight | |
| self._set_next_enemy() | |
| def player_attack_turn(self): | |
| """Handles the full sequence of a player's attack turn.""" | |
| if not self.game_active or not self.player.is_alive() or not self.current_enemy or not self.current_enemy.is_alive(): | |
| return | |
| # Switch to attack animation | |
| self.set_player_image("attack") | |
| # Player attacks the enemy | |
| self.add_message(self.player.attack_target(self.current_enemy)) | |
| # Check if enemy was defeated | |
| if not self.current_enemy.is_alive(): | |
| self._handle_victory() | |
| return # Stop the turn here since the battle is over or a new one is starting | |
| # If the enemy survived, it's their turn to attack | |
| self.enemy_attack_turn() | |
| def enemy_attack_turn(self): | |
| """Handles the enemy's attack turn.""" | |
| if not self.game_active or not self.player.is_alive() or not self.current_enemy or not self.current_enemy.is_alive(): | |
| return | |
| # Enemy attacks the player | |
| self.add_message(self.current_enemy.attack_target(self.player)) | |
| # Check if the player was defeated | |
| self._check_game_over() | |
| def attempt_run(self): | |
| """Handles the player's attempt to run away from a battle.""" | |
| if not self.game_active: | |
| return | |
| # Switch to run/escape animation | |
| self.set_player_image("run") | |
| if random.random() < 0.2: # 20% chance to successfully run | |
| self.add_message("You managed to escape from the battle!") | |
| self.ex_index += 1 # Advance to the next foe after running | |
| if self.ex_index < len(self.current_ex_list): | |
| self._set_next_enemy() | |
| else: # Running from the last boss is still a win condition | |
| self.game_active = False | |
| self.current_game_phase = "win" | |
| self.add_message("\nCongratulations! You ran away from all your problems!") | |
| else: | |
| self.add_message("You couldn't get away!") | |
| # Enemy gets a free hit as a penalty for a failed escape | |
| self.enemy_attack_turn() | |
| # --------- Shop Mechanics --------- | |
| def get_shop_choices(self): | |
| """Return list of item names with price for UI dropdown.""" | |
| return [f"{name} - ${data['cost']}" for name, data in self.shop_items.items()] | |
| def get_shop_description_html(self): | |
| """Return an HTML string listing shop items with cost and effect.""" | |
| lines = ["<b>Shop Items:</b>"] | |
| for name, data in self.shop_items.items(): | |
| lines.append(f"{name} (${data['cost']}) – {data['desc']}") | |
| return "<br>".join(lines) | |
| def buy_item(self, item_display_name): | |
| """Process purchasing an item given the dropdown display string.""" | |
| if not self.player: | |
| return | |
| # Extract item key (before ' - $') | |
| item_name = item_display_name.split(" - $")[0] | |
| if item_name not in self.shop_items: | |
| self.add_message("That item doesn't exist!") | |
| return | |
| item = self.shop_items[item_name] | |
| cost = item["cost"] | |
| if self.player.money < cost: | |
| self.add_message("Not enough money!") | |
| return | |
| # Deduct money | |
| self.player.money -= cost | |
| # Apply item effect | |
| if item["type"] == "heal": | |
| self.player.current_hp = min(self.player.max_hp, self.player.current_hp + item["amount"]) | |
| self.add_message(f"You used {item_name} and healed {item['amount']} HP!") | |
| elif item["type"] == "heal_full": | |
| healed = self.player.max_hp - self.player.current_hp | |
| self.player.current_hp = self.player.max_hp | |
| self.add_message(f"{item_name} fully restored your HP (+{healed})!") | |
| elif item["type"] == "attack": | |
| self.player.attack += item["amount"] | |
| self.add_message(f"{item_name} consumed! Attack increased by {item['amount']}.") | |
| elif item["type"] == "defense": | |
| self.player.defense += item["amount"] | |
| self.add_message(f"{item_name} equipped! Defense increased by {item['amount']}.") | |
| # Confirm purchase | |
| self.add_message(f"You bought {item_name} for ${cost}. Remaining money: ${self.player.money}.") | |
| def get_player_image(self): | |
| """Returns current player image path if set.""" | |
| return getattr(self, "player_image_path", None) | |
| # --------- Image switching ---------- | |
| def set_player_image(self, action="idle"): | |
| """Set player image based on action type ('idle', 'attack', 'run').""" | |
| if hasattr(self, "image_assets") and action in self.image_assets: | |
| choices = self.image_assets[action] | |
| self.player_image_path = random.choice(choices) | |
| def advance_player_image(self): | |
| """Cycle through all available images sequentially.""" | |
| if hasattr(self, "image_cycle") and self.image_cycle: | |
| self.image_cycle_index = (self.image_cycle_index + 1) % len(self.image_cycle) | |
| self.player_image_path = self.image_cycle[self.image_cycle_index] | |
| # --- Gradio Interface Logic --- | |
| # Create a single game instance to be managed by gr.State | |
| game_instance = ScottPilgrimGame() | |
| # New helper to format the message log into color-coded HTML | |
| def _format_log_html(game_state): | |
| """Returns the message log as HTML with basic color-coding.""" | |
| # Early return for fresh page load | |
| if not game_state.message_log: | |
| return "" | |
| player_name = game_state.player.name if game_state.player else "" | |
| enemy_name = game_state.current_enemy.name if game_state.current_enemy else "" | |
| # Show only the last 2 log messages: latest action and its outcome | |
| recent_msgs = game_state.message_log[-2:] | |
| html_lines = [] | |
| for msg in recent_msgs: | |
| color = "#ECF0F1" # default light text for dark mode | |
| if player_name and (msg.startswith(player_name) or msg.startswith("You")): | |
| color = "#2ECC71" # green for player actions | |
| elif enemy_name and msg.startswith(enemy_name): | |
| color = "#E74C3C" # red for enemy actions | |
| elif msg.startswith("---") or "Congratulations" in msg or "GAME OVER" in msg: | |
| color = "#F1C40F" # yellow/gold for system or banner messages | |
| html_lines.append(f"<div style='margin-bottom:4px; color:{color}; white-space:pre-wrap;'>{msg}</div>") | |
| return "".join(html_lines) | |
| # New helper to build a richer status block with progress bars for HP/XP | |
| def _format_status_html(game_state): | |
| if not game_state.player: | |
| return "" | |
| player = game_state.player | |
| status_html = [ | |
| f"<h4 style='margin:4px 0'>{player.name} (Lvl {player.level})</h4>", | |
| f"HP: <progress value='{player.current_hp}' max='{player.max_hp}' style='width:160px;height:14px;'></progress> {player.current_hp}/{player.max_hp}<br>", | |
| f"XP: <progress value='{player.xp}' max='{player.level * 50}' style='width:160px;height:14px;'></progress> {player.xp}/{player.level * 50}<br>", | |
| f"Money: ${player.money}<br><br>" | |
| ] | |
| if game_state.current_enemy: | |
| enemy = game_state.current_enemy | |
| status_html.extend([ | |
| f"<h4 style='margin:4px 0'>{enemy.name}</h4>", | |
| f"HP: <progress value='{enemy.current_hp}' max='{enemy.max_hp}' style='width:160px;height:14px;'></progress> {enemy.current_hp}/{enemy.max_hp}" | |
| ]) | |
| return "".join(status_html) | |
| # Updated update_ui to output HTML instead of plain text | |
| def update_ui(game_state): | |
| """ | |
| Updates all Gradio UI components based on the current game state. | |
| Returns log_html, status_html, and component visibility updates. | |
| """ | |
| phase = game_state.current_game_phase | |
| # Special welcome / end-screen messages | |
| if phase == "start" and not game_state.message_log: | |
| game_state.message_log = [ | |
| "Welcome to Scott Pilgrim vs. The World: The RPG!", | |
| "Choose your hero!" | |
| ] | |
| elif phase == "game_over": | |
| game_state.message_log.append("\nGAME OVER! Better luck next time!") | |
| elif phase == "win": | |
| game_state.message_log.append("\nYOU WON! Thanks for playing!") | |
| # Cycle hero image each UI update | |
| game_state.advance_player_image() | |
| log_html = _format_log_html(game_state) | |
| status_html = _format_status_html(game_state) | |
| hero_img_path = game_state.get_player_image() | |
| hero_visible = hero_img_path is not None | |
| # Configure visibility for each game phase | |
| char_buttons_visible = (phase == "start") | |
| action_buttons_visible = (phase == "combat") | |
| play_again_visible = (phase in ["game_over", "win"]) | |
| shop_visible = (phase == "combat") | |
| preview_visible = (phase == "start") | |
| return ( | |
| log_html, | |
| status_html, | |
| gr.update(value=hero_img_path, visible=hero_visible), | |
| gr.update(visible=preview_visible), # Scott preview | |
| gr.update(visible=preview_visible), # Ramona preview | |
| gr.update(visible=char_buttons_visible), | |
| gr.update(visible=action_buttons_visible), | |
| gr.update(visible=play_again_visible), | |
| gr.update(visible=shop_visible), | |
| game_state | |
| ) | |
| def choose_character(choice, game_state): | |
| """Callback for character selection buttons.""" | |
| game_state.start_new_game(choice) | |
| return update_ui(game_state) | |
| def player_attack(game_state): | |
| """Callback for the 'Attack' button.""" | |
| game_state.player_attack_turn() | |
| return update_ui(game_state) | |
| def player_run(game_state): | |
| """Callback for the 'Run' button.""" | |
| game_state.attempt_run() | |
| return update_ui(game_state) | |
| def play_again(game_state): | |
| """Callback for the 'Play Again' button.""" | |
| game_state.reset_game() | |
| return update_ui(game_state) | |
| # --- Shop callback --- | |
| def buy_item_action(item_choice, game_state): | |
| """Callback for Buy button in the shop.""" | |
| if item_choice: | |
| game_state.buy_item(item_choice) | |
| else: | |
| game_state.add_message("Select an item first!") | |
| return update_ui(game_state) | |
| # --- Gradio UI Layout --- | |
| with gr.Blocks(theme=gr.themes.Soft()) as demo: | |
| gr.Markdown("# Scott Pilgrim vs. The World: The RPG") | |
| gr.Markdown("Choose your fighter and battle through the league of Evil Exes!") | |
| # gr.State is crucial for persisting the game object across user interactions | |
| game_state = gr.State(game_instance) | |
| # UI Components | |
| # Row containing hero image next to the game log | |
| with gr.Row() as log_row: | |
| hero_img = gr.Image(label="Hero", width=120, height=120, visible=False) | |
| game_output = gr.HTML(label="Game Log") | |
| status_output = gr.HTML(label="Current Status") | |
| # Preview images shown before character selection | |
| with gr.Row(visible=True) as preview_row: | |
| scott_preview_img = gr.Image(value="characters/Scott_idle.webp", label="Scott", width=140, height=140, visible=True) | |
| ramona_preview_img = gr.Image(value="characters/Ramona_Angry.webp", label="Ramona", width=140, height=140, visible=True) | |
| with gr.Row(visible=True) as character_selection_buttons: | |
| scott_btn = gr.Button("Play as Scott Pilgrim") | |
| ramona_btn = gr.Button("Play as Ramona Flowers") | |
| with gr.Row(visible=False) as game_action_buttons: | |
| attack_btn = gr.Button("⚔️ Attack") | |
| run_btn = gr.Button("🏃 Run") | |
| play_again_btn = gr.Button("Play Again?", visible=False) | |
| # --- Shop UI Components --- | |
| with gr.Row(visible=False) as shop_row: | |
| shop_desc = gr.HTML(game_instance.get_shop_description_html()) | |
| item_dropdown = gr.Dropdown(choices=game_instance.get_shop_choices(), label="Buy Item") | |
| buy_btn = gr.Button("Buy") | |
| # --- Event Handlers --- | |
| # Define a list of all UI components that need to be updated, including the state | |
| outputs = [game_output, status_output, hero_img, scott_preview_img, ramona_preview_img, character_selection_buttons, game_action_buttons, play_again_btn, shop_row, game_state] | |
| # Connect buttons to their callback functions | |
| scott_btn.click(choose_character, inputs=[scott_btn, game_state], outputs=outputs) | |
| ramona_btn.click(choose_character, inputs=[ramona_btn, game_state], outputs=outputs) | |
| attack_btn.click(player_attack, inputs=[game_state], outputs=outputs) | |
| run_btn.click(player_run, inputs=[game_state], outputs=outputs) | |
| play_again_btn.click(play_again, inputs=[game_state], outputs=outputs) | |
| buy_btn.click(buy_item_action, inputs=[item_dropdown, game_state], outputs=outputs) | |
| # Set the initial UI state when the app loads, ensuring the outputs match the function's return values | |
| demo.load(update_ui, inputs=[game_state], outputs=outputs) | |
| # Launch the Gradio app | |
| if __name__ == "__main__": | |
| demo.launch() | |