Upload 5 files

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
 pytorch_directml_cpu_optimized_low_end_pc/dist/pytransform/_pytransform.dll filter=lfs diff=lfs merge=lfs -text
+Workspace/workspace-8ac4a941-39da-4676-a1bb-2758edbb4672 filter=lfs diff=lfs merge=lfs -text

Workspace/Python_Script_Text_based_RPD_Game.py

@@ -0,0 +1,1343 @@
+#!/usr/bin/env python3
+# TextWorld Adventure - A Complete Text-Based RPG Game
+# Author: YSNRFD
+# Version: 1.0.0
+
+import os
+import sys
+import json
+import random
+import time
+import pickle
+import math
+from enum import Enum
+from typing import Dict, List, Tuple, Optional, Any, Callable
+from dataclasses import dataclass, asdict
+import colorama
+from colorama import Fore, Back, Style
+
+# Initialize colorama for cross-platform colored text
+colorama.init()
+
+# Game Constants
+GAME_VERSION = "1.0.0"
+GAME_TITLE = "TextWorld Adventure"
+SAVE_FILE = "textworld_save.pkl"
+CONFIG_FILE = "textworld_config.json"
+
+# Game Enums
+class ItemType(Enum):
+    WEAPON = "weapon"
+    ARMOR = "armor"
+    CONSUMABLE = "consumable"
+    QUEST = "quest"
+    MISC = "misc"
+
+class SkillType(Enum):
+    COMBAT = "combat"
+    MAGIC = "magic"
+    STEALTH = "stealth"
+    SOCIAL = "social"
+
+class DamageType(Enum):
+    PHYSICAL = "physical"
+    FIRE = "fire"
+    ICE = "ice"
+    LIGHTNING = "lightning"
+    POISON = "poison"
+
+class QuestStatus(Enum):
+    NOT_STARTED = "not_started"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+# Game Data Classes
+@dataclass
+class Item:
+    id: str
+    name: str
+    description: str
+    item_type: ItemType
+    value: int
+    rarity: str
+    stats: Dict[str, int]
+    consumable: bool = False
+    stackable: bool = False
+    max_stack: int = 1
+    
+    def use(self, player):
+        if self.consumable:
+            if "heal" in self.stats:
+                player.health = min(player.max_health, player.health + self.stats["heal"])
+                return f"You used {self.name} and restored {self.stats['heal']} health."
+            elif "mana" in self.stats:
+                player.mana = min(player.max_mana, player.mana + self.stats["mana"])
+                return f"You used {self.name} and restored {self.stats['mana']} mana."
+        return f"You can't use {self.name}."
+
+@dataclass
+class Skill:
+    id: str
+    name: str
+    description: str
+    skill_type: SkillType
+    level: int = 1
+    experience: int = 0
+    max_experience: int = 100
+    
+    def add_experience(self, amount):
+        self.experience += amount
+        leveled_up = False
+        while self.experience >= self.max_experience:
+            self.experience -= self.max_experience
+            self.level += 1
+            self.max_experience = int(self.max_experience * 1.5)
+            leveled_up = True
+        return leveled_up
+
+@dataclass
+class Quest:
+    id: str
+    name: str
+    description: str
+    objectives: List[str]
+    rewards: Dict[str, Any]
+    status: QuestStatus = QuestStatus.NOT_STARTED
+    progress: Dict[str, int] = None
+    
+    def __post_init__(self):
+        if self.progress is None:
+            self.progress = {obj: 0 for obj in self.objectives}
+
+@dataclass
+class NPC:
+    id: str
+    name: str
+    description: str
+    dialogue: Dict[str, List[str]]
+    quests: List[str]
+    friendly: bool = True
+    shop_items: List[Item] = None
+    
+    def get_dialogue(self, topic="default"):
+        return self.dialogue.get(topic, self.dialogue.get("default", ["I have nothing to say."]))
+
+@dataclass
+class Location:
+    id: str
+    name: str
+    description: str
+    exits: Dict[str, str]
+    npcs: List[str]
+    items: List[str]
+    enemies: List[str]
+    visited: bool = False
+    
+    def get_description(self, game):
+        desc = f"{self.name}\n{'='*len(self.name)}\n{self.description}\n\n"
+        
+        if self.exits:
+            desc += "Exits: " + ", ".join(self.exits.keys()) + "\n"
+        
+        if self.npcs:
+            npcs = [game.npcs[npc_id] for npc_id in self.npcs]
+            desc += "People here: " + ", ".join([npc.name for npc in npcs]) + "\n"
+        
+        if self.items:
+            items = [game.items[item_id] for item_id in self.items]
+            desc += "Items here: " + ", ".join([item.name for item in items]) + "\n"
+        
+        if self.enemies:
+            enemies = [game.enemies[enemy_id] for enemy_id in self.enemies]
+            desc += "Enemies here: " + ", ".join([enemy.name for enemy in enemies]) + "\n"
+        
+        return desc
+
+@dataclass
+class Enemy:
+    id: str
+    name: str
+    description: str
+    level: int
+    health: int
+    max_health: int
+    attack: int
+    defense: int
+    experience: int
+    gold: int
+    loot: List[str]
+    abilities: List[str]
+    
+    def take_damage(self, damage):
+        actual_damage = max(1, damage - self.defense)
+        self.health -= actual_damage
+        return actual_damage
+    
+    def is_alive(self):
+        return self.health > 0
+
+@dataclass
+class Player:
+    name: str
+    level: int = 1
+    experience: int = 0
+    max_experience: int = 100
+    health: int = 100
+    max_health: int = 100
+    mana: int = 50
+    max_mana: int = 50
+    attack: int = 10
+    defense: int = 5
+    gold: int = 50
+    inventory: List[Dict[str, Any]] = None
+    equipment: Dict[str, str] = None
+    skills: Dict[str, Skill] = None
+    quests: Dict[str, Quest] = None
+    current_location: str = "town_square"
+    
+    def __post_init__(self):
+        if self.inventory is None:
+            self.inventory = []
+        if self.equipment is None:
+            self.equipment = {"weapon": None, "armor": None, "accessory": None}
+        if self.skills is None:
+            self.skills = {
+                "combat": Skill("combat", "Combat", "Your skill in fighting", SkillType.COMBAT),
+                "magic": Skill("magic", "Magic", "Your skill in casting spells", SkillType.MAGIC),
+                "stealth": Skill("stealth", "Stealth", "Your skill in moving unseen", SkillType.STEALTH),
+                "social": Skill("social", "Social", "Your skill in interacting with others", SkillType.SOCIAL)
+            }
+        if self.quests is None:
+            self.quests = {}
+    
+    def add_experience(self, amount):
+        self.experience += amount
+        leveled_up = False
+        while self.experience >= self.max_experience:
+            self.experience -= self.max_experience
+            self.level += 1
+            self.max_experience = int(self.max_experience * 1.5)
+            self.max_health += 10
+            self.health = self.max_health
+            self.max_mana += 5
+            self.mana = self.max_mana
+            self.attack += 2
+            self.defense += 1
+            leveled_up = True
+        return leveled_up
+    
+    def add_item(self, item, quantity=1):
+        for inv_item in self.inventory:
+            if inv_item["item"].id == item.id and item.stackable:
+                inv_item["quantity"] += quantity
+                return True
+        
+        self.inventory.append({"item": item, "quantity": quantity})
+        return True
+    
+    def remove_item(self, item_id, quantity=1):
+        for i, inv_item in enumerate(self.inventory):
+            if inv_item["item"].id == item_id:
+                if inv_item["quantity"] <= quantity:
+                    self.inventory.pop(i)
+                    return True
+                else:
+                    inv_item["quantity"] -= quantity
+                    return True
+        return False
+    
+    def get_item(self, item_id):
+        for inv_item in self.inventory:
+            if inv_item["item"].id == item_id:
+                return inv_item["item"]
+        return None
+    
+    def equip_item(self, item_id):
+        item = self.get_item(item_id)
+        if not item:
+            return False, "You don't have that item."
+        
+        if item.item_type == ItemType.WEAPON:
+            if self.equipment["weapon"]:
+                self.add_item(self.get_item(self.equipment["weapon"]))
+            self.equipment["weapon"] = item_id
+            self.attack += item.stats.get("attack", 0)
+            return True, f"You equipped {item.name}."
+        
+        elif item.item_type == ItemType.ARMOR:
+            if self.equipment["armor"]:
+                self.add_item(self.get_item(self.equipment["armor"]))
+            self.equipment["armor"] = item_id
+            self.defense += item.stats.get("defense", 0)
+            return True, f"You equipped {item.name}."
+        
+        return False, "You can't equip that item."
+    
+    def get_total_attack(self):
+        total = self.attack
+        if self.equipment["weapon"]:
+            weapon = self.get_item(self.equipment["weapon"])
+            if weapon:
+                total += weapon.stats.get("attack", 0)
+        return total
+    
+    def get_total_defense(self):
+        total = self.defense
+        if self.equipment["armor"]:
+            armor = self.get_item(self.equipment["armor"])
+            if armor:
+                total += armor.stats.get("defense", 0)
+        return total
+
+# Game Configuration
+class GameConfig:
+    def __init__(self):
+        self.settings = {
+            "text_speed": 0.03,
+            "auto_save": True,
+            "auto_save_interval": 300,  # seconds
+            "color_scheme": "default",
+            "difficulty": "normal",
+            "debug_mode": False
+        }
+        self.load_config()
+    
+    def load_config(self):
+        try:
+            if os.path.exists(CONFIG_FILE):
+                with open(CONFIG_FILE, 'r') as f:
+                    self.settings.update(json.load(f))
+        except Exception as e:
+            print(f"Error loading config: {e}")
+    
+    def save_config(self):
+        try:
+            with open(CONFIG_FILE, 'w') as f:
+                json.dump(self.settings, f, indent=2)
+        except Exception as e:
+            print(f"Error saving config: {e}")
+    
+    def get_setting(self, key, default=None):
+        return self.settings.get(key, default)
+    
+    def set_setting(self, key, value):
+        self.settings[key] = value
+        self.save_config()
+
+# Plugin System
+class PluginManager:
+    def __init__(self, game):
+        self.game = game
+        self.plugins = {}
+        self.hooks = {
+            "on_command": [],
+            "on_move": [],
+            "on_combat": [],
+            "on_level_up": [],
+            "on_quest_complete": [],
+            "on_item_pickup": []
+        }
+    
+    def load_plugin(self, plugin_name):
+        try:
+            # This is a simplified plugin loader
+            # In a real implementation, you'd load from files
+            if plugin_name == "debug":
+                self.plugins[plugin_name] = DebugPlugin(self.game)
+            elif plugin_name == "hardcore":
+                self.plugins[plugin_name] = HardcorePlugin(self.game)
+            return True
+        except Exception as e:
+            print(f"Error loading plugin {plugin_name}: {e}")
+            return False
+    
+    def register_hook(self, hook_name, callback):
+        if hook_name in self.hooks:
+            self.hooks[hook_name].append(callback)
+    
+    def trigger_hook(self, hook_name, *args, **kwargs):
+        if hook_name in self.hooks:
+            for callback in self.hooks[hook_name]:
+                try:
+                    callback(*args, **kwargs)
+                except Exception as e:
+                    print(f"Error in hook {hook_name}: {e}")
+
+# Base Plugin Class
+class BasePlugin:
+    def __init__(self, game):
+        self.game = game
+        self.name = "Base Plugin"
+        self.version = "1.0.0"
+        self.description = "Base plugin class"
+        self.enabled = True
+    
+    def initialize(self):
+        pass
+    
+    def on_command(self, command, args):
+        pass
+    
+    def on_move(self, from_location, to_location):
+        pass
+    
+    def on_combat(self, player, enemy):
+        pass
+    
+    def on_level_up(self, player):
+        pass
+    
+    def on_quest_complete(self, quest):
+        pass
+    
+    def on_item_pickup(self, item):
+        pass
+
+# Example Plugins
+class DebugPlugin(BasePlugin):
+    def __init__(self, game):
+        super().__init__(game)
+        self.name = "Debug Plugin"
+        self.description = "Adds debug commands to the game"
+    
+    def initialize(self):
+        self.game.register_command("debug", self.debug_command)
+    
+    def debug_command(self, args):
+        if len(args) < 1:
+            return "Usage: debug <command>"
+        
+        cmd = args[0].lower()
+        if cmd == "teleport":
+            if len(args) < 2:
+                return "Usage: debug teleport <location_id>"
+            location_id = args[1]
+            if location_id in self.game.locations:
+                self.game.player.current_location = location_id
+                return f"Teleported to {self.game.locations[location_id].name}"
+            return "Location not found"
+        
+        elif cmd == "give":
+            if len(args) < 2:
+                return "Usage: debug give <item_id>"
+            item_id = args[1]
+            if item_id in self.game.items:
+                self.game.player.add_item(self.game.items[item_id])
+                return f"Gave {self.game.items[item_id].name}"
+            return "Item not found"
+        
+        elif cmd == "level":
+            if len(args) < 2:
+                return "Usage: debug level <amount>"
+            try:
+                amount = int(args[1])
+                if self.game.player.add_experience(amount):
+                    return f"Gained {amount} experience and leveled up!"
+                return f"Gained {amount} experience"
+            except ValueError:
+                return "Invalid amount"
+        
+        elif cmd == "heal":
+            self.game.player.health = self.game.player.max_health
+            self.game.player.mana = self.game.player.max_mana
+            return "Fully healed"
+        
+        return "Unknown debug command"
+
+class HardcorePlugin(BasePlugin):
+    def __init__(self, game):
+        super().__init__(game)
+        self.name = "Hardcore Mode"
+        self.description = "Makes the game more challenging"
+    
+    def initialize(self):
+        self.game.register_hook("on_combat", self.on_combat)
+        self.game.register_hook("on_level_up", self.on_level_up)
+    
+    def on_combat(self, player, enemy):
+        enemy.attack = int(enemy.attack * 1.5)
+        enemy.health = int(enemy.health * 1.5)
+        enemy.max_health = enemy.health
+    
+    def on_level_up(self, player):
+        player.max_health = int(player.max_health * 0.8)
+        player.health = player.max_health
+
+# Main Game Class
+class TextWorldGame:
+    def __init__(self):
+        self.config = GameConfig()
+        self.plugin_manager = PluginManager(self)
+        self.player = None
+        self.locations = {}
+        self.items = {}
+        self.npcs = {}
+        self.enemies = {}
+        self.quests = {}
+        self.running = True
+        self.commands = {}
+        self.combat_active = False
+        self.current_enemy = None
+        
+        self.initialize_game_data()
+        self.register_commands()
+        self.load_plugins()
+    
+    def initialize_game_data(self):
+        # Initialize Items
+        self.items = {
+            "sword": Item("sword", "Iron Sword", "A simple iron sword", ItemType.WEAPON, 50, "common", {"attack": 5}),
+            "shield": Item("shield", "Wooden Shield", "A basic wooden shield", ItemType.ARMOR, 30, "common", {"defense": 3}),
+            "potion": Item("potion", "Health Potion", "A red potion that restores health", ItemType.CONSUMABLE, 10, "common", {"heal": 25}, consumable=True, stackable=True, max_stack=10),
+            "mana_potion": Item("mana_potion", "Mana Potion", "A blue potion that restores mana", ItemType.CONSUMABLE, 15, "common", {"mana": 15}, consumable=True, stackable=True, max_stack=10),
+            "leather_armor": Item("leather_armor", "Leather Armor", "Basic leather armor", ItemType.ARMOR, 40, "common", {"defense": 5}),
+            "magic_scroll": Item("magic_scroll", "Magic Scroll", "A scroll containing a magic spell", ItemType.MISC, 100, "rare", {"magic_power": 10}),
+            "gold_coin": Item("gold_coin", "Gold Coin", "A shiny gold coin", ItemType.MISC, 1, "common", {}, stackable=True, max_stack=999),
+            "dragon_sword": Item("dragon_sword", "Dragon Sword", "A legendary sword forged from dragon scales", ItemType.WEAPON, 1000, "legendary", {"attack": 20, "fire_damage": 10}),
+            "dragon_armor": Item("dragon_armor", "Dragon Armor", "Legendary armor made from dragon scales", ItemType.ARMOR, 1500, "legendary", {"defense": 15, "fire_resistance": 20}),
+        }
+        
+        # Initialize Enemies
+        self.enemies = {
+            "goblin": Enemy("goblin", "Goblin", "A small green creature with sharp teeth", 1, 30, 30, 8, 2, 20, 10, ["potion"], ["bite"]),
+            "orc": Enemy("orc", "Orc", "A large green brute with a club", 3, 60, 60, 15, 5, 50, 25, ["sword", "potion"], ["smash"]),
+            "dragon": Enemy("dragon", "Dragon", "A massive fire-breathing dragon", 10, 200, 200, 30, 15, 200, 500, ["dragon_sword", "dragon_armor"], ["fire_breath", "tail_swipe"]),
+            "skeleton": Enemy("skeleton", "Skeleton", "An undead warrior with rusty armor", 2, 40, 40, 12, 4, 30, 15, ["gold_coin"], ["bone_throw"]),
+            "dark_wizard": Enemy("dark_wizard", "Dark Wizard", "A powerful spellcaster in dark robes", 5, 80, 80, 20, 8, 100, 100, ["magic_scroll", "mana_potion"], ["fireball", "lightning"]),
+        }
+        
+        # Initialize NPCs
+        self.npcs = {
+            "merchant": NPC("merchant", "Merchant", "A friendly merchant selling various items", {
+                "default": ["Welcome to my shop! What can I get for you?", "I have the finest items in town!"],
+                "buy": ["What would you like to buy?"],
+                "sell": ["What would you like to sell?"],
+                "quest": ["I have a quest for you if you're interested."]
+            }, ["merchant_quest"], True, [self.items["potion"], self.items["sword"], self.items["shield"]]),
+            
+            "guard": NPC("guard", "Town Guard", "A brave guard protecting the town", {
+                "default": ["Halt! State your business.", "The town is safe under my watch."],
+                "dragon": ["A dragon has been spotted in the mountains! Be careful if you go there."],
+                "quest": ["We need help dealing with the goblins in the forest."]
+            }, ["goblin_quest"], True),
+            
+            "wizard": NPC("wizard", "Wizard", "A mysterious wizard with powerful magic", {
+                "default": ["Greetings, traveler. I sense great potential in you.", "Magic flows through the world like a river."],
+                "magic": ["Magic is the art of manipulating reality itself.", "Would you like to learn some spells?"],
+                "quest": ["I need someone to retrieve a rare artifact for me."]
+            }, ["wizard_quest"], True),
+        }
+        
+        # Initialize Locations
+        self.locations = {
+            "town_square": Location("town_square", "Town Square", "The central square of the town. People are bustling about.", {
+                "north": "town_gate",
+                "east": "market",
+                "west": "tavern",
+                "south": "temple"
+            }, ["guard"], [], []),
+            
+            "town_gate": Location("town_gate", "Town Gate", "The main entrance to the town. A large wooden gate stands open.", {
+                "south": "town_square",
+                "north": "forest_entrance"
+            }, [], [], []),
+            
+            "market": Location("market", "Market", "A busy market with merchants selling their wares.", {
+                "west": "town_square"
+            }, ["merchant"], [], []),
+            
+            "tavern": Location("tavern", "Tavern", "A cozy tavern with a warm fireplace and friendly patrons.", {
+                "east": "town_square"
+            }, [], ["potion"], []),
+            
+            "temple": Location("temple", "Temple", "A peaceful temple where people come to pray and heal.", {
+                "north": "town_square"
+            }, [], [], []),
+            
+            "forest_entrance": Location("forest_entrance", "Forest Entrance", "The edge of a dark forest. You can hear strange noises from within.", {
+                "south": "town_gate",
+                "north": "deep_forest",
+                "east": "river",
+                "west": "cave_entrance"
+            }, [], [], ["goblin"]),
+            
+            "deep_forest": Location("deep_forest", "Deep Forest", "A dense forest with tall trees and little light.", {
+                "south": "forest_entrance",
+                "north": "mountain_base"
+            }, [], [], ["goblin", "skeleton"]),
+            
+            "river": Location("river", "River", "A wide river flowing from the mountains.", {
+                "west": "forest_entrance",
+                "east": "bridge"
+            }, [], [], []),
+            
+            "bridge": Location("bridge", "Bridge", "An old stone bridge crossing the river.", {
+                "west": "river",
+                "east": "abandoned_tower"
+            }, [], [], ["orc"]),
+            
+            "cave_entrance": Location("cave_entrance", "Cave Entrance", "The entrance to a dark cave. You can feel cold air coming from inside.", {
+                "east": "forest_entrance",
+                "west": "cave_depths"
+            }, [], [], ["skeleton"]),
+            
+            "cave_depths": Location("cave_depths", "Cave Depths", "The deepest part of the cave. It's dark and damp here.", {
+                "east": "cave_entrance"
+            }, [], ["magic_scroll"], ["dark_wizard"]),
+            
+            "mountain_base": Location("mountain_base", "Mountain Base", "The base of a tall mountain. A path leads up.", {
+                "south": "deep_forest",
+                "north": "mountain_path"
+            }, [], [], []),
+            
+            "mountain_path": Location("mountain_path", "Mountain Path", "A narrow path winding up the mountain.", {
+                "south": "mountain_base",
+                "north": "dragon_lair"
+            }, [], [], ["orc"]),
+            
+            "dragon_lair": Location("dragon_lair", "Dragon Lair", "A massive cave where a dragon lives. You can feel the heat.", {
+                "south": "mountain_path"
+            }, [], [], ["dragon"]),
+            
+            "abandoned_tower": Location("abandoned_tower", "Abandoned Tower", "An old tower that was once home to a powerful wizard.", {
+                "west": "bridge"
+            }, ["wizard"], [], []),
+        }
+        
+        # Initialize Quests
+        self.quests = {
+            "merchant_quest": Quest("merchant_quest", "Merchant's Request", "The merchant needs you to deliver a package to the wizard.", 
+                                   ["Deliver package to wizard"], {"experience": 100, "gold": 50}),
+            
+            "goblin_quest": Quest("goblin_quest", "Goblin Problem", "The town guard needs help dealing with goblins in the forest.", 
+                                 ["Defeat 3 goblins"], {"experience": 150, "gold": 75}),
+            
+            "wizard_quest": Quest("wizard_quest", "Wizard's Artifact", "The wizard needs you to retrieve a magic scroll from the cave depths.", 
+                                 ["Find magic scroll in cave depths"], {"experience": 200, "gold": 100, "item": "mana_potion"}),
+            
+            "dragon_quest": Quest("dragon_quest", "Dragon Slayer", "A dragon terrorizes the mountains. Someone needs to defeat it.", 
+                                 ["Defeat the dragon"], {"experience": 500, "gold": 500, "item": "dragon_sword"}),
+        }
+    
+    def register_commands(self):
+        self.commands = {
+            "help": self.cmd_help,
+            "look": self.cmd_look,
+            "go": self.cmd_go,
+            "move": self.cmd_go,
+            "inventory": self.cmd_inventory,
+            "inv": self.cmd_inventory,
+            "equip": self.cmd_equip,
+            "unequip": self.cmd_unequip,
+            "use": self.cmd_use,
+            "take": self.cmd_take,
+            "get": self.cmd_take,
+            "drop": self.cmd_drop,
+            "talk": self.cmd_talk,
+            "attack": self.cmd_attack,
+            "fight": self.cmd_attack,
+            "quests": self.cmd_quests,
+            "status": self.cmd_status,
+            "save": self.cmd_save,
+            "load": self.cmd_load,
+            "quit": self.cmd_quit,
+            "exit": self.cmd_quit,
+            "rest": self.cmd_rest,
+            "skills": self.cmd_skills,
+            "shop": self.cmd_shop,
+            "buy": self.cmd_buy,
+            "sell": self.cmd_sell,
+            "map": self.cmd_map,
+            "clear": self.cmd_clear,
+            "version": self.cmd_version,
+            "config": self.cmd_config,
+        }
+    
+    def load_plugins(self):
+        # Load default plugins
+        if self.config.get_setting("debug_mode", False):
+            self.plugin_manager.load_plugin("debug")
+        
+        # Initialize all loaded plugins
+        for plugin in self.plugin_manager.plugins.values():
+            plugin.initialize()
+    
+    def register_command(self, command, callback):
+        self.commands[command] = callback
+    
+    def register_hook(self, hook_name, callback):
+        self.plugin_manager.register_hook(hook_name, callback)
+    
+    def start(self):
+        self.clear_screen()
+        self.print_title()
+        
+        # Check for save file
+        if os.path.exists(SAVE_FILE):
+            choice = self.get_input("A save file exists. Do you want to load it? (y/n): ").lower()
+            if choice == 'y':
+                self.load_game()
+                self.print_slow("Game loaded successfully!")
+                self.game_loop()
+                return
+        
+        # Character creation
+        self.print_slow("Welcome to TextWorld Adventure!")
+        self.print_slow("Let's create your character...")
+        
+        name = self.get_input("Enter your character's name: ")
+        while not name:
+            name = self.get_input("Please enter a valid name: ")
+        
+        self.player = Player(name)
+        self.player.add_item(self.items["potion"], 3)
+        self.player.add_item(self.items["gold_coin"], 50)
+        
+        self.print_slow(f"\nWelcome, {self.player.name}!")
+        self.print_slow("Your adventure begins in the Town Square.")
+        self.print_slow("Type 'help' for a list of commands.")
+        
+        self.game_loop()
+    
+    def game_loop(self):
+        last_auto_save = time.time()
+        
+        while self.running:
+            # Auto-save check
+            if self.config.get_setting("auto_save", True):
+                if time.time() - last_auto_save > self.config.get_setting("auto_save_interval", 300):
+                    self.save_game(silent=True)
+                    last_auto_save = time.time()
+            
+            # Get player input
+            if self.combat_active:
+                prompt = f"{Fore.RED}[COMBAT]{Style.RESET_ALL} What do you do? > "
+            else:
+                location = self.locations[self.player.current_location]
+                prompt = f"{Fore.GREEN}[{location.name}]{Style.RESET_ALL} What do you do? > "
+            
+            command_input = self.get_input(prompt).strip().lower()
+            
+            # Parse command
+            if not command_input:
+                continue
+            
+            parts = command_input.split()
+            command = parts[0]
+            args = parts[1:] if len(parts) > 1 else []
+            
+            # Trigger command hook
+            self.plugin_manager.trigger_hook("on_command", command, args)
+            
+            # Execute command
+            if command in self.commands:
+                try:
+                    result = self.commands[command](args)
+                    if result:
+                        self.print_slow(result)
+                except Exception as e:
+                    self.print_slow(f"Error executing command: {e}")
+            else:
+                self.print_slow(f"Unknown command: {command}. Type 'help' for available commands.")
+    
+    def cmd_help(self, args):
+        help_text = f"""
+{Fore.CYAN}=== TextWorld Adventure Commands ==={Style.RESET_ALL}
+
+{Fore.YELLOW}Movement:{Style.RESET_ALL}
+  go/move <direction>  - Move in a direction (north, south, east, west)
+  look                 - Look around the current location
+  map                  - Show a simple map of the area
+
+{Fore.YELLOW}Inventory:{Style.RESET_ALL}
+  inventory/inv        - Show your inventory
+  equip <item>         - Equip an item
+  unequip <item>       - Unequip an item
+  use <item>           - Use an item
+  take/get <item>      - Pick up an item
+  drop <item>          - Drop an item
+
+{Fore.YELLOW}Combat:{Style.RESET_ALL}
+  attack/fight <enemy> - Attack an enemy
+  rest                 - Rest to restore health and mana
+
+{Fore.YELLOW}NPCs:{Style.RESET_ALL}
+  talk <npc>           - Talk to an NPC
+  shop                 - Open shop interface (if available)
+  buy <item>           - Buy an item from shop
+  sell <item>          - Sell an item to shop
+
+{Fore.YELLOW}Character:{Style.RESET_ALL}
+  status               - Show your character status
+  skills               - Show your skills
+  quests               - Show your active quests
+
+{Fore.YELLOW}System:{Style.RESET_ALL}
+  save                 - Save the game
+  load                 - Load a saved game
+  config <setting> <value> - Change game settings
+  clear                - Clear the screen
+  version              - Show game version
+  quit/exit            - Quit the game
+"""
+        return help_text
+    
+    def cmd_look(self, args):
+        location = self.locations[self.player.current_location]
+        location.visited = True
+        return location.get_description(self)
+    
+    def cmd_go(self, args):
+        if not args:
+            return "Go where? Specify a direction (north, south, east, west)."
+        
+        direction = args[0].lower()
+        location = self.locations[self.player.current_location]
+        
+        if direction not in location.exits:
+            return f"You can't go {direction} from here."
+        
+        new_location_id = location.exits[direction]
+        new_location = self.locations[new_location_id]
+        
+        # Trigger move hook
+        self.plugin_manager.trigger_hook("on_move", self.player.current_location, new_location_id)
+        
+        self.player.current_location = new_location_id
+        
+        # Check for enemies in new location
+        if new_location.enemies and random.random() < 0.5:
+            enemy_id = random.choice(new_location.enemies)
+            enemy = Enemy(**asdict(self.enemies[enemy_id]))
+            self.start_combat(enemy)
+        
+        return new_location.get_description(self)
+    
+    def cmd_inventory(self, args):
+        if not self.player.inventory:
+            return "Your inventory is empty."
+        
+        inv_text = f"{Fore.CYAN}=== Inventory ==={Style.RESET_ALL}\n"
+        
+        for inv_item in self.player.inventory:
+            item = inv_item["item"]
+            quantity = inv_item["quantity"]
+            if quantity > 1:
+                inv_text += f"{item.name} x{quantity} - {item.description}\n"
+            else:
+                inv_text += f"{item.name} - {item.description}\n"
+        
+        # Show equipped items
+        inv_text += f"\n{Fore.YELLOW}=== Equipped Items ==={Style.RESET_ALL}\n"
+        for slot, item_id in self.player.equipment.items():
+            if item_id:
+                item = self.player.get_item(item_id)
+                if item:
+                    inv_text += f"{slot.capitalize()}: {item.name}\n"
+        
+        return inv_text
+    
+    def cmd_equip(self, args):
+        if not args:
+            return "Equip what? Specify an item name."
+        
+        item_name = " ".join(args).lower()
+        item = None
+        
+        for inv_item in self.player.inventory:
+            if inv_item["item"].name.lower() == item_name:
+                item = inv_item["item"]
+                break
+        
+        if not item:
+            return f"You don't have a {item_name}."
+        
+        success, message = self.player.equip_item(item.id)
+        return message
+    
+    def cmd_unequip(self, args):
+        if not args:
+            return "Unequip what? Specify 'weapon' or 'armor'."
+        
+        slot = args[0].lower()
+        if slot not in self.player.equipment:
+            return "You can only unequip 'weapon' or 'armor'."
+        
+        if not self.player.equipment[slot]:
+            return f"You don't have anything equipped in your {slot} slot."
+        
+        item_id = self.player.equipment[slot]
+        item = self.player.get_item(item_id)
+        
+        if item:
+            self.player.add_item(item)
+            if slot == "weapon":
+                self.player.attack -= item.stats.get("attack", 0)
+            elif slot == "armor":
+                self.player.defense -= item.stats.get("defense", 0)
+        
+        self.player.equipment[slot] = None
+        return f"You unequipped {item.name}."
+    
+    def cmd_use(self, args):
+        if not args:
+            return "Use what? Specify an item name."
+        
+        item_name = " ".join(args).lower()
+        item = None
+        
+        for inv_item in self.player.inventory:
+            if inv_item["item"].name.lower() == item_name:
+                item = inv_item["item"]
+                break
+        
+        if not item:
+            return f"You don't have a {item_name}."
+        
+        if not item.consumable:
+            return f"You can't use {item.name}."
+        
+        result = item.use(self.player)
+        
+        # Trigger item pickup hook (for use as well)
+        self.plugin_manager.trigger_hook("on_item_pickup", item)
+        
+        if item.consumable:
+            self.player.remove_item(item.id)
+        
+        return result
+    
+    def cmd_take(self, args):
+        if not args:
+            return "Take what? Specify an item name."
+        
+        item_name = " ".join(args).lower()
+        location = self.locations[self.player.current_location]
+        
+        for item_id in location.items[:]:
+            item = self.items[item_id]
+            if item.name.lower() == item_name:
+                self.player.add_item(item)
+                location.items.remove(item_id)
+                
+                # Trigger item pickup hook
+                self.plugin_manager.trigger_hook("on_item_pickup", item)
+                
+                return f"You took {item.name}."
+        
+        return f"There's no {item_name} here."
+    
+    def cmd_drop(self, args):
+        if not args:
+            return "Drop what? Specify an item name."
+        
+        item_name = " ".join(args).lower()
+        location = self.locations[self.player.current_location]
+        
+        for inv_item in self.player.inventory[:]:
+            item = inv_item["item"]
+            if item.name.lower() == item_name:
+                self.player.remove_item(item.id)
+                location.items.append(item.id)
+                return f"You dropped {item.name}."
+        
+        return f"You don't have a {item_name}."
+    
+    def cmd_talk(self, args):
+        if not args:
+            return "Talk to whom? Specify an NPC name."
+        
+        npc_name = " ".join(args).lower()
+        location = self.locations[self.player.current_location]
+        
+        for npc_id in location.npcs:
+            npc = self.npcs[npc_id]
+            if npc.name.lower() == npc_name:
+                dialogue = npc.get_dialogue()
+                return f"{npc.name}: {random.choice(dialogue)}"
+        
+        return f"There's no one named {npc_name} here."
+    
+    def cmd_attack(self, args):
+        if not self.combat_active:
+            return "There's nothing to attack here."
+        
+        if not self.current_enemy:
+            self.combat_active = False
+            return "The enemy has disappeared."
+        
+        # Player attacks
+        player_damage = self.player.get_total_attack()
+        actual_damage = self.current_enemy.take_damage(player_damage)
+        
+        result = f"You attack {self.current_enemy.name} for {actual_damage} damage!\n"
+        
+        # Trigger combat hook
+        self.plugin_manager.trigger_hook("on_combat", self.player, self.current_enemy)
+        
+        if not self.current_enemy.is_alive():
+            result += f"You defeated {self.current_enemy.name}!\n"
+            result += f"You gained {self.current_enemy.experience} experience and {self.current_enemy.gold} gold!\n"
+            
+            # Level up check
+            if self.player.add_experience(self.current_enemy.experience):
+                result += f"LEVEL UP! You are now level {self.player.level}!\n"
+                # Trigger level up hook
+                self.plugin_manager.trigger_hook("on_level_up", self.player)
+            
+            self.player.gold += self.current_enemy.gold
+            
+            # Loot
+            if self.current_enemy.loot:
+                loot_item = random.choice(self.current_enemy.loot)
+                if loot_item in self.items:
+                    item = self.items[loot_item]
+                    self.player.add_item(item)
+                    result += f"You found {item.name}!\n"
+            
+            self.combat_active = False
+            self.current_enemy = None
+            
+            # Update quest progress
+            self.update_quest_progress("defeat", self.current_enemy.id if self.current_enemy else "unknown")
+            
+            return result
+        
+        # Enemy attacks
+        enemy_damage = max(1, self.current_enemy.attack - self.player.get_total_defense())
+        self.player.health -= enemy_damage
+        result += f"{self.current_enemy.name} attacks you for {enemy_damage} damage!\n"
+        
+        if self.player.health <= 0:
+            result += f"{Fore.RED}You have been defeated! Game Over.{Style.RESET_ALL}\n"
+            self.running = False
+        
+        return result
+    
+    def cmd_quests(self, args):
+        if not self.player.quests:
+            return "You don't have any active quests."
+        
+        quest_text = f"{Fore.CYAN}=== Active Quests ==={Style.RESET_ALL}\n"
+        
+        for quest_id, quest in self.player.quests.items():
+            if quest.status == QuestStatus.IN_PROGRESS:
+                quest_text += f"{Fore.YELLOW}{quest.name}{Style.RESET_ALL}\n"
+                quest_text += f"  {quest.description}\n"
+                quest_text += "  Objectives:\n"
+                for obj, progress in quest.progress.items():
+                    quest_text += f"    - {obj}: {progress}\n"
+                quest_text += "\n"
+        
+        return quest_text
+    
+    def cmd_status(self, args):
+        status_text = f"""
+{Fore.CYAN}=== Character Status ==={Style.RESET_ALL}
+Name: {self.player.name}
+Level: {self.player.level} ({self.player.experience}/{self.player.max_experience} XP)
+Health: {self.player.health}/{self.player.max_health}
+Mana: {self.player.mana}/{self.player.max_mana}
+Attack: {self.player.get_total_attack()} (Base: {self.player.attack})
+Defense: {self.player.get_total_defense()} (Base: {self.player.defense})
+Gold: {self.player.gold}
+Location: {self.locations[self.player.current_location].name}
+"""
+        return status_text
+    
+    def cmd_save(self, args):
+        return self.save_game()
+    
+    def cmd_load(self, args):
+        return self.load_game()
+    
+    def cmd_quit(self, args):
+        choice = self.get_input("Are you sure you want to quit? (y/n): ").lower()
+        if choice == 'y':
+            self.save_game()
+            self.running = False
+            return "Thanks for playing TextWorld Adventure!"
+        return "Continuing game..."
+    
+    def cmd_rest(self, args):
+        if self.combat_active:
+            return "You can't rest during combat!"
+        
+        location = self.locations[self.player.current_location]
+        
+        # Can only rest in safe locations
+        if location.id in ["town_square", "tavern", "temple"]:
+            self.player.health = self.player.max_health
+            self.player.mana = self.player.max_mana
+            return "You rest and recover your health and mana."
+        
+        # Resting in dangerous locations has a chance of encounter
+        if random.random() < 0.3:
+            if location.enemies:
+                enemy_id = random.choice(location.enemies)
+                enemy = Enemy(**asdict(self.enemies[enemy_id]))
+                self.start_combat(enemy)
+                return "While resting, you were ambushed!"
+        
+        # Partial rest
+        heal_amount = int(self.player.max_health * 0.3)
+        mana_amount = int(self.player.max_mana * 0.3)
+        self.player.health = min(self.player.max_health, self.player.health + heal_amount)
+        self.player.mana = min(self.player.max_mana, self.player.mana + mana_amount)
+        return f"You rest and recover {heal_amount} health and {mana_amount} mana."
+    
+    def cmd_skills(self, args):
+        skills_text = f"{Fore.CYAN}=== Skills ==={Style.RESET_ALL}\n"
+        
+        for skill_id, skill in self.player.skills.items():
+            skills_text += f"{Fore.YELLOW}{skill.name}{Style.RESET_ALL} (Level {skill.level})\n"
+            skills_text += f"  {skill.description}\n"
+            skills_text += f"  Experience: {skill.experience}/{skill.max_experience}\n\n"
+        
+        return skills_text
+    
+    def cmd_shop(self, args):
+        location = self.locations[self.player.current_location]
+        
+        # Find merchant in current location
+        merchant = None
+        for npc_id in location.npcs:
+            npc = self.npcs[npc_id]
+            if npc.shop_items:
+                merchant = npc
+                break
+        
+        if not merchant:
+            return "There's no shop here."
+        
+        shop_text = f"{Fore.CYAN}=== {merchant.name}'s Shop ==={Style.RESET_ALL}\n"
+        shop_text += "Items for sale:\n"
+        
+        for item in merchant.shop_items:
+            shop_text += f"  {item.name} - {item.value} gold\n"
+        
+        shop_text += "\nType 'buy <item>' to purchase or 'sell <item>' to sell."
+        return shop_text
+    
+    def cmd_buy(self, args):
+        if not args:
+            return "Buy what? Specify an item name."
+        
+        item_name = " ".join(args).lower()
+        location = self.locations[self.player.current_location]
+        
+        # Find merchant in current location
+        merchant = None
+        for npc_id in location.npcs:
+            npc = self.npcs[npc_id]
+            if npc.shop_items:
+                merchant = npc
+                break
+        
+        if not merchant:
+            return "There's no shop here."
+        
+        # Find item in shop
+        for item in merchant.shop_items:
+            if item.name.lower() == item_name:
+                if self.player.gold >= item.value:
+                    self.player.gold -= item.value
+                    self.player.add_item(item)
+                    return f"You bought {item.name} for {item.value} gold."
+                else:
+                    return f"You don't have enough gold to buy {item.name}."
+        
+        return f"{merchant.name} doesn't have {item_name} for sale."
+    
+    def cmd_sell(self, args):
+        if not args:
+            return "Sell what? Specify an item name."
+        
+        item_name = " ".join(args).lower()
+        location = self.locations[self.player.current_location]
+        
+        # Find merchant in current location
+        merchant = None
+        for npc_id in location.npcs:
+            npc = self.npcs[npc_id]
+            if npc.shop_items:
+                merchant = npc
+                break
+        
+        if not merchant:
+            return "There's no shop here."
+        
+        # Find item in inventory
+        for inv_item in self.player.inventory[:]:
+            item = inv_item["item"]
+            if item.name.lower() == item_name:
+                sell_price = int(item.value * 0.5)  # Sell for half the value
+                self.player.gold += sell_price
+                self.player.remove_item(item.id)
+                return f"You sold {item.name} for {sell_price} gold."
+        
+        return f"You don't have a {item_name} to sell."
+    
+    def cmd_map(self, args):
+        location = self.locations[self.player.current_location]
+        
+        # Simple ASCII map
+        map_text = f"{Fore.CYAN}=== Map ==={Style.RESET_ALL}\n"
+        map_text += "You are here: *\n\n"
+        
+        # Show connected locations
+        for direction, loc_id in location.exits.items():
+            loc = self.locations[loc_id]
+            map_text += f"{direction.capitalize()}: {loc.name}\n"
+        
+        return map_text
+    
+    def cmd_clear(self, args):
+        self.clear_screen()
+        return ""
+    
+    def cmd_version(self, args):
+        return f"{GAME_TITLE} v{GAME_VERSION}"
+    
+    def cmd_config(self, args):
+        if len(args) < 2:
+            return "Usage: config <setting> <value>"
+        
+        setting = args[0]
+        value = args[1]
+        
+        if setting == "text_speed":
+            try:
+                self.config.set_setting(setting, float(value))
+                return f"Text speed set to {value}"
+            except ValueError:
+                return "Invalid value for text_speed"
+        
+        elif setting == "auto_save":
+            if value.lower() in ["true", "false"]:
+                self.config.set_setting(setting, value.lower() == "true")
+                return f"Auto-save set to {value}"
+            return "Value must be 'true' or 'false'"
+        
+        elif setting == "difficulty":
+            if value in ["easy", "normal", "hard"]:
+                self.config.set_setting(setting, value)
+                return f"Difficulty set to {value}"
+            return "Difficulty must be 'easy', 'normal', or 'hard'"
+        
+        elif setting == "debug_mode":
+            if value.lower() in ["true", "false"]:
+                self.config.set_setting(setting, value.lower() == "true")
+                if value.lower() == "true":
+                    self.plugin_manager.load_plugin("debug")
+                return f"Debug mode set to {value}"
+            return "Value must be 'true' or 'false'"
+        
+        return f"Unknown setting: {setting}"
+    
+    def start_combat(self, enemy):
+        self.combat_active = True
+        self.current_enemy = enemy
+        self.print_slow(f"{Fore.RED}Combat started with {enemy.name}!{Style.RESET_ALL}")
+        self.print_slow(f"{enemy.description}")
+        self.print_slow(f"{enemy.name} - HP: {enemy.health}/{enemy.max_health}")
+    
+    def update_quest_progress(self, action, target):
+        for quest_id, quest in self.player.quests.items():
+            if quest.status == QuestStatus.IN_PROGRESS:
+                for obj in quest.objectives:
+                    if action in obj.lower() and target.lower() in obj.lower():
+                        quest.progress[obj] += 1
+                        
+                        # Check if quest is complete
+                        if all(progress > 0 for progress in quest.progress.values()):
+                            quest.status = QuestStatus.COMPLETED
+                            self.complete_quest(quest)
+    
+    def complete_quest(self, quest):
+        self.print_slow(f"{Fore.GREEN}Quest Completed: {quest.name}{Style.RESET_ALL}")
+        
+        # Give rewards
+        if "experience" in quest.rewards:
+            self.player.add_experience(quest.rewards["experience"])
+            self.print_slow(f"You gained {quest.rewards['experience']} experience!")
+        
+        if "gold" in quest.rewards:
+            self.player.gold += quest.rewards["gold"]
+            self.print_slow(f"You gained {quest.rewards['gold']} gold!")
+        
+        if "item" in quest.rewards:
+            item_id = quest.rewards["item"]
+            if item_id in self.items:
+                self.player.add_item(self.items[item_id])
+                self.print_slow(f"You received {self.items[item_id].name}!")
+        
+        # Trigger quest complete hook
+        self.plugin_manager.trigger_hook("on_quest_complete", quest)
+    
+    def save_game(self, silent=False):
+        try:
+            save_data = {
+                "player": self.player,
+                "locations": self.locations,
+                "config": self.config.settings
+            }
+            
+            with open(SAVE_FILE, 'wb') as f:
+                pickle.dump(save_data, f)
+            
+            if not silent:
+                return "Game saved successfully!"
+        except Exception as e:
+            return f"Error saving game: {e}"
+    
+    def load_game(self):
+        try:
+            with open(SAVE_FILE, 'rb') as f:
+                save_data = pickle.load(f)
+            
+            self.player = save_data["player"]
+            self.locations = save_data["locations"]
+            self.config.settings = save_data["config"]
+            
+            return True
+        except Exception as e:
+            self.print_slow(f"Error loading game: {e}")
+            return False
+    
+    def print_slow(self, text, delay=None):
+        if delay is None:
+            delay = self.config.get_setting("text_speed", 0.03)
+        
+        for char in text:
+            sys.stdout.write(char)
+            sys.stdout.flush()
+            time.sleep(delay)
+        print()
+    
+    def get_input(self, prompt):
+        return input(prompt)
+    
+    def print_title(self):
+        title = f"""
+{Fore.CYAN}
+ _____ _   _ _   _    _    _   _  ____ _____ ____  
+| ____| \ | | | | |  / \  | \ | |/ ___| ____|  _ \ 
+|  _| |  \| | |_| | / _ \ |  \| | |   |  _| | | | |
+| |___| |\  |  _  |/ ___ \| |\  | |___| |___| |_| |
+|_____|_| \_|_| |_/_/   \_\_| \_|\____|_____|____/ 
+{Style.RESET_ALL}
+{Fore.YELLOW}              A Text-Based RPG Adventure{Style.RESET_ALL}
+{Fore.GREEN}                    Version {GAME_VERSION}{Style.RESET_ALL}
+"""
+        print(title)
+        time.sleep(2)
+    
+    def clear_screen(self):
+        os.system('cls' if os.name == 'nt' else 'clear')
+
+# Main execution
+if __name__ == "__main__":
+    game = TextWorldGame()
+    game.start()

Workspace/Python_Script_Text_based_RPD_Game2.py

@@ -0,0 +1,1621 @@
+import os
+import sys
+import json
+import random
+import time
+import math
+import pickle
+import importlib
+from enum import Enum
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple, Callable, Any, Union
+from abc import ABC, abstractmethod
+
+# Color codes for terminal output
+class Colors:
+    RESET = '\033[0m'
+    BLACK = '\033[30m'
+    RED = '\033[31m'
+    GREEN = '\033[32m'
+    YELLOW = '\033[33m'
+    BLUE = '\033[34m'
+    MAGENTA = '\033[35m'
+    CYAN = '\033[36m'
+    WHITE = '\033[37m'
+    BRIGHT_BLACK = '\033[90m'
+    BRIGHT_RED = '\033[91m'
+    BRIGHT_GREEN = '\033[92m'
+    BRIGHT_YELLOW = '\033[93m'
+    BRIGHT_BLUE = '\033[94m'
+    BRIGHT_MAGENTA = '\033[95m'
+    BRIGHT_CYAN = '\033[96m'
+    BRIGHT_WHITE = '\033[97m'
+    BG_BLACK = '\033[40m'
+    BG_RED = '\033[41m'
+    BG_GREEN = '\033[42m'
+    BG_YELLOW = '\033[43m'
+    BG_BLUE = '\033[44m'
+    BG_MAGENTA = '\033[45m'
+    BG_CYAN = '\033[46m'
+    BG_WHITE = '\033[47m'
+
+# Game Enums
+class Direction(Enum):
+    NORTH = "north"
+    SOUTH = "south"
+    EAST = "east"
+    WEST = "west"
+    NORTHEAST = "northeast"
+    NORTHWEST = "northwest"
+    SOUTHEAST = "southeast"
+    SOUTHWEST = "southwest"
+    UP = "up"
+    DOWN = "down"
+
+class SkillType(Enum):
+    COMBAT = "combat"
+    MAGIC = "magic"
+    STEALTH = "stealth"
+    CRAFTING = "crafting"
+    SOCIAL = "social"
+    SURVIVAL = "survival"
+
+class Weather(Enum):
+    CLEAR = "clear"
+    CLOUDY = "cloudy"
+    RAINY = "rainy"
+    STORMY = "stormy"
+    SNOWY = "snowy"
+    FOGGY = "foggy"
+
+class TimeOfDay(Enum):
+    DAWN = "dawn"
+    MORNING = "morning"
+    NOON = "noon"
+    AFTERNOON = "afternoon"
+    DUSK = "dusk"
+    EVENING = "evening"
+    NIGHT = "night"
+    MIDNIGHT = "midnight"
+
+# Data Classes
+@dataclass
+class Position:
+    x: int = 0
+    y: int = 0
+    z: int = 0
+
+@dataclass
+class Stats:
+    health: int = 100
+    max_health: int = 100
+    mana: int = 50
+    max_mana: int = 50
+    stamina: int = 100
+    max_stamina: int = 100
+    hunger: int = 100
+    max_hunger: int = 100
+    thirst: int = 100
+    max_thirst: int = 100
+    experience: int = 0
+    level: int = 1
+    
+    def level_up(self):
+        self.level += 1
+        self.experience = 0
+        self.max_health += 10
+        self.health = self.max_health
+        self.max_mana += 5
+        self.mana = self.max_mana
+        self.max_stamina += 5
+        self.stamina = self.max_stamina
+
+@dataclass
+class Skill:
+    name: str
+    type: SkillType
+    level: int = 1
+    experience: int = 0
+    max_experience: int = 100
+    
+    def gain_experience(self, amount: int):
+        self.experience += amount
+        while self.experience >= self.max_experience:
+            self.experience -= self.max_experience
+            self.level += 1
+            self.max_experience = int(self.max_experience * 1.5)
+            return True  # Leveled up
+        return False
+
+@dataclass
+class Item:
+    id: str
+    name: str
+    description: str
+    value: int = 0
+    weight: float = 1.0
+    consumable: bool = False
+    equippable: bool = False
+    stackable: bool = True
+    max_stack: int = 99
+    effects: Dict[str, Any] = field(default_factory=dict)
+    
+    def use(self, player):
+        if self.consumable:
+            for stat, value in self.effects.items():
+                if hasattr(player.stats, stat):
+                    current = getattr(player.stats, stat)
+                    max_stat = getattr(player.stats, f"max_{stat}")
+                    setattr(player.stats, stat, min(max_stat, current + value))
+            return True
+        return False
+
+@dataclass
+class Weapon(Item):
+    damage: int = 10
+    damage_type: str = "physical"
+    two_handed: bool = False
+    range: int = 1
+    
+    def __post_init__(self):
+        self.equippable = True
+
+@dataclass
+class Armor(Item):
+    defense: int = 5
+    armor_type: str = "light"
+    slot: str = "chest"
+    
+    def __post_init__(self):
+        self.equippable = True
+
+@dataclass
+class Quest:
+    id: str
+    name: str
+    description: str
+    objectives: List[str]
+    rewards: Dict[str, Any]
+    completed: bool = False
+    active: bool = False
+
+@dataclass
+class NPC:
+    id: str
+    name: str
+    description: str
+    dialogue: Dict[str, List[str]]
+    location_id: str
+    hostile: bool = False
+    stats: Stats = field(default_factory=Stats)
+    inventory: List[Item] = field(default_factory=list)
+    quests: List[Quest] = field(default_factory=list)
+    faction: str = "neutral"
+    
+    def talk(self, topic="greeting"):
+        if topic in self.dialogue:
+            return random.choice(self.dialogue[topic])
+        return "I don't have anything to say about that."
+
+@dataclass
+class Location:
+    id: str
+    name: str
+    description: str
+    exits: Dict[Direction, str] = field(default_factory=dict)
+    items: List[Item] = field(default_factory=list)
+    npcs: List[NPC] = field(default_factory=list)
+    discovered: bool = False
+    indoor: bool = False
+    position: Position = field(default_factory=Position)
+    
+    def add_exit(self, direction: Direction, location_id: str):
+        self.exits[direction] = location_id
+    
+    def add_item(self, item: Item):
+        self.items.append(item)
+    
+    def add_npc(self, npc: NPC):
+        self.npcs.append(npc)
+    
+    def remove_item(self, item: Item):
+        if item in self.items:
+            self.items.remove(item)
+            return True
+        return False
+    
+    def remove_npc(self, npc: NPC):
+        if npc in self.npcs:
+            self.npcs.remove(npc)
+            return True
+        return False
+
+# Plugin System
+class Plugin(ABC):
+    @abstractmethod
+    def initialize(self, game):
+        pass
+    
+    @abstractmethod
+    def get_commands(self) -> Dict[str, Callable]:
+        return {}
+
+# Game Classes
+class GameWorld:
+    def __init__(self):
+        self.locations: Dict[str, Location] = {}
+        self.global_time: int = 0  # Game time in minutes
+        self.weather: Weather = Weather.CLEAR
+        self.time_of_day: TimeOfDay = TimeOfDay.MORNING
+        self.day_count: int = 1
+        
+    def add_location(self, location: Location):
+        self.locations[location.id] = location
+    
+    def get_location(self, location_id: str) -> Optional[Location]:
+        return self.locations.get(location_id)
+    
+    def update_time(self, minutes: int = 1):
+        self.global_time += minutes
+        # Update day count (each day is 1440 minutes)
+        self.day_count = (self.global_time // 1440) + 1
+        
+        # Update time of day (each period is 3 hours = 180 minutes)
+        time_periods = list(TimeOfDay)
+        period_index = (self.global_time // 180) % len(time_periods)
+        self.time_of_day = time_periods[period_index]
+        
+        # Randomly change weather
+        if random.random() < 0.05:  # 5% chance of weather change
+            self.weather = random.choice(list(Weather))
+    
+    def get_time_description(self) -> str:
+        return f"Day {self.day_count}, {self.time_of_day.value.capitalize()}, Weather: {self.weather.value.capitalize()}"
+
+class Player:
+    def __init__(self, name: str):
+        self.name: str = name
+        self.location_id: str = "start"
+        self.stats: Stats = Stats()
+        self.inventory: Dict[str, Tuple[Item, int]] = {}  # item_id: (item, quantity)
+        self.equipped: Dict[str, Item] = {}  # slot: item
+        self.skills: Dict[str, Skill] = {
+            "combat": Skill("Combat", SkillType.COMBAT),
+            "magic": Skill("Magic", SkillType.MAGIC),
+            "stealth": Skill("Stealth", SkillType.STEALTH),
+            "crafting": Skill("Crafting", SkillType.CRAFTING),
+            "social": Skill("Social", SkillType.SOCIAL),
+            "survival": Skill("Survival", SkillType.SURVIVAL)
+        }
+        self.quests: List[Quest] = []
+        self.known_locations: List[str] = ["start"]
+        self.faction_reputation: Dict[str, int] = {}
+        
+    def add_item(self, item: Item, quantity: int = 1):
+        if item.id in self.inventory:
+            current_item, current_quantity = self.inventory[item.id]
+            if item.stackable:
+                new_quantity = min(current_quantity + quantity, item.max_stack)
+                self.inventory[item.id] = (current_item, new_quantity)
+                return quantity - (new_quantity - current_quantity)  # Return leftover quantity
+            else:
+                # For non-stackable items, add multiple entries
+                for _ in range(quantity):
+                    self.inventory[f"{item.id}_{len(self.inventory)}"] = (item, 1)
+                return 0
+        else:
+            self.inventory[item.id] = (item, quantity)
+            return 0
+    
+    def remove_item(self, item_id: str, quantity: int = 1) -> bool:
+        if item_id in self.inventory:
+            item, current_quantity = self.inventory[item_id]
+            if current_quantity <= quantity:
+                del self.inventory[item_id]
+                return True
+            else:
+                self.inventory[item_id] = (item, current_quantity - quantity)
+                return True
+        return False
+    
+    def has_item(self, item_id: str, quantity: int = 1) -> bool:
+        if item_id in self.inventory:
+            _, current_quantity = self.inventory[item_id]
+            return current_quantity >= quantity
+        return False
+    
+    def equip_item(self, item_id: str) -> bool:
+        if item_id in self.inventory:
+            item, _ = self.inventory[item_id]
+            if item.equippable:
+                # Determine slot based on item type
+                if isinstance(item, Weapon):
+                    slot = "weapon"
+                elif isinstance(item, Armor):
+                    slot = item.slot
+                else:
+                    slot = "accessory"
+                
+                # Unequip current item if any
+                if slot in self.equipped:
+                    self.add_item(self.equipped[slot])
+                
+                # Equip new item
+                self.equipped[slot] = item
+                self.remove_item(item_id)
+                return True
+        return False
+    
+    def unequip_item(self, slot: str) -> bool:
+        if slot in self.equipped:
+            item = self.equipped[slot]
+            self.add_item(item)
+            del self.equipped[slot]
+            return True
+        return False
+    
+    def get_total_defense(self) -> int:
+        defense = 0
+        for item in self.equipped.values():
+            if isinstance(item, Armor):
+                defense += item.defense
+        return defense
+    
+    def get_total_damage(self) -> int:
+        damage = 5  # Base damage
+        if "weapon" in self.equipped:
+            weapon = self.equipped["weapon"]
+            if isinstance(weapon, Weapon):
+                damage = weapon.damage
+        return damage
+    
+    def gain_experience(self, amount: int):
+        self.stats.experience += amount
+        exp_needed = self.stats.level * 100  # Simple formula
+        while self.stats.experience >= exp_needed:
+            self.stats.experience -= exp_needed
+            self.stats.level_up()
+            exp_needed = self.stats.level * 100
+            return True  # Leveled up
+        return False
+    
+    def add_quest(self, quest: Quest):
+        self.quests.append(quest)
+        quest.active = True
+    
+    def complete_quest(self, quest_id: str) -> bool:
+        for quest in self.quests:
+            if quest.id == quest_id and quest.active and not quest.completed:
+                quest.completed = True
+                # Apply rewards
+                if "experience" in quest.rewards:
+                    self.gain_experience(quest.rewards["experience"])
+                if "items" in quest.rewards:
+                    for item_id, quantity in quest.rewards["items"].items():
+                        # This would need a reference to the game world to get the actual item
+                        pass
+                if "reputation" in quest.rewards:
+                    for faction, amount in quest.rewards["reputation"].items():
+                        if faction in self.faction_reputation:
+                            self.faction_reputation[faction] += amount
+                        else:
+                            self.faction_reputation[faction] = amount
+                return True
+        return False
+    
+    def update_vitals(self):
+        # Decrease hunger and thirst over time
+        self.stats.hunger = max(0, self.stats.hunger - 1)
+        self.stats.thirst = max(0, self.stats.thirst - 1)
+        
+        # Apply effects of hunger and thirst
+        if self.stats.hunger == 0:
+            self.stats.health = max(0, self.stats.health - 2)
+        if self.stats.thirst == 0:
+            self.stats.health = max(0, self.stats.health - 3)
+        
+        # Regenerate health, mana, and stamina slowly
+        if self.stats.health < self.stats.max_health:
+            self.stats.health = min(self.stats.max_health, self.stats.health + 1)
+        if self.stats.mana < self.stats.max_mana:
+            self.stats.mana = min(self.stats.max_mana, self.stats.mana + 1)
+        if self.stats.stamina < self.stats.max_stamina:
+            self.stats.stamina = min(self.stats.max_stamina, self.stats.stamina + 2)
+
+class CombatSystem:
+    @staticmethod
+    def attack(attacker, defender):
+        # Calculate damage
+        base_damage = attacker.get_total_damage() if hasattr(attacker, 'get_total_damage') else 10
+        
+        # Add some randomness
+        damage = max(1, base_damage + random.randint(-2, 2))
+        
+        # Apply defense
+        defense = defender.get_total_defense() if hasattr(defender, 'get_total_defense') else 0
+        damage = max(1, damage - defense // 2)
+        
+        # Apply damage
+        defender.stats.health = max(0, defender.stats.health - damage)
+        
+        return damage
+    
+    @staticmethod
+    def check_flee(player, npc) -> bool:
+        # Base chance to flee is 50%, modified by player's level vs NPC's level
+        base_chance = 0.5
+        level_diff = player.stats.level - npc.stats.level
+        chance = base_chance + (level_diff * 0.1)
+        chance = max(0.1, min(0.9, chance))  # Clamp between 10% and 90%
+        
+        return random.random() < chance
+
+class Game:
+    def __init__(self):
+        self.world = GameWorld()
+        self.player = None
+        self.running = True
+        self.plugins: Dict[str, Plugin] = {}
+        self.commands: Dict[str, Callable] = {}
+        self.combat = CombatSystem()
+        self.in_combat = False
+        self.current_opponent = None
+        
+        # Initialize core commands
+        self.register_command("help", self.cmd_help)
+        self.register_command("quit", self.cmd_quit)
+        self.register_command("look", self.cmd_look)
+        self.register_command("go", self.cmd_go)
+        self.register_command("take", self.cmd_take)
+        self.register_command("inventory", self.cmd_inventory)
+        self.register_command("use", self.cmd_use)
+        self.register_command("equip", self.cmd_equip)
+        self.register_command("unequip", self.cmd_unequip)
+        self.register_command("talk", self.cmd_talk)
+        self.register_command("attack", self.cmd_attack)
+        self.register_command("flee", self.cmd_flee)
+        self.register_command("quests", self.cmd_quests)
+        self.register_command("skills", self.cmd_skills)
+        self.register_command("time", self.cmd_time)
+        self.register_command("save", self.cmd_save)
+        self.register_command("load", self.cmd_load)
+        self.register_command("wait", self.cmd_wait)
+        self.register_command("status", self.cmd_status)
+        self.register_command("drop", self.cmd_drop)
+        self.register_command("examine", self.cmd_examine)
+        self.register_command("map", self.cmd_map)
+        self.register_command("rest", self.cmd_rest)
+        self.register_command("plugins", self.cmd_plugins)
+        
+        # Initialize the game world
+        self.initialize_world()
+    
+    def register_command(self, name: str, func: Callable):
+        self.commands[name] = func
+    
+    def load_plugin(self, plugin_path: str):
+        try:
+            spec = importlib.util.spec_from_file_location("plugin", plugin_path)
+            plugin_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(plugin_module)
+            
+            # Get plugin class (should be named "Plugin")
+            if hasattr(plugin_module, "Plugin"):
+                plugin_class = getattr(plugin_module, "Plugin")
+                plugin = plugin_class()
+                plugin.initialize(self)
+                
+                # Register plugin commands
+                plugin_commands = plugin.get_commands()
+                for name, func in plugin_commands.items():
+                    self.register_command(name, func)
+                
+                self.plugins[plugin_path] = plugin
+                return True
+        except Exception as e:
+            print(f"{Colors.RED}Error loading plugin: {e}{Colors.RESET}")
+        return False
+    
+    def unload_plugin(self, plugin_path: str):
+        if plugin_path in self.plugins:
+            plugin = self.plugins[plugin_path]
+            plugin_commands = plugin.get_commands()
+            
+            # Unregister plugin commands
+            for name in plugin_commands:
+                if name in self.commands:
+                    del self.commands[name]
+            
+            del self.plugins[plugin_path]
+            return True
+        return False
+    
+    def initialize_world(self):
+        # Create starting location
+        start_location = Location(
+            id="start",
+            name="Starting Village",
+            description="A small village surrounded by forests and mountains. There's a path leading north to the forest and east to the mountains.",
+            position=Position(0, 0, 0)
+        )
+        
+        # Create forest location
+        forest_location = Location(
+            id="forest",
+            name="Dark Forest",
+            description="A dense forest with tall trees and little light. You can hear strange sounds in the distance.",
+            position=Position(0, 1, 0)
+        )
+        
+        # Create mountain location
+        mountain_location = Location(
+            id="mountain",
+            name="Mountain Pass",
+            description="A narrow path through the mountains. It's cold and windy here.",
+            position=Position(1, 0, 0)
+        )
+        
+        # Create cave location
+        cave_location = Location(
+            id="cave",
+            name="Mysterious Cave",
+            description="A dark cave with glowing crystals on the walls. You can hear dripping water.",
+            position=Position(0, 0, -1),
+            indoor=True
+        )
+        
+        # Create village shop
+        shop_location = Location(
+            id="shop",
+            name="Village Shop",
+            description="A small shop with various items for sale. The shopkeeper looks friendly.",
+            position=Position(-1, 0, 0),
+            indoor=True
+        )
+        
+        # Connect locations
+        start_location.add_exit(Direction.NORTH, "forest")
+        start_location.add_exit(Direction.EAST, "mountain")
+        start_location.add_exit(Direction.WEST, "shop")
+        
+        forest_location.add_exit(Direction.SOUTH, "start")
+        forest_location.add_exit(Direction.DOWN, "cave")
+        
+        mountain_location.add_exit(Direction.WEST, "start")
+        
+        cave_location.add_exit(Direction.UP, "forest")
+        
+        shop_location.add_exit(Direction.EAST, "start")
+        
+        # Add items to locations
+        # Starting village items
+        start_location.add_item(Item(
+            id="apple",
+            name="Apple",
+            description="A fresh red apple. Looks delicious.",
+            value=5,
+            consumable=True,
+            effects={"hunger": 20}
+        ))
+        
+        start_location.add_item(Item(
+            id="bread",
+            name="Bread",
+            description="A loaf of bread. Still warm.",
+            value=10,
+            consumable=True,
+            effects={"hunger": 40}
+        ))
+        
+        # Forest items
+        forest_location.add_item(Weapon(
+            id="sword",
+            name="Rusty Sword",
+            description="An old rusty sword. Better than nothing.",
+            value=25,
+            damage=15,
+            weight=3.0
+        ))
+        
+        forest_location.add_item(Item(
+            id="herb",
+            name="Healing Herb",
+            description="A green herb with medicinal properties.",
+            value=15,
+            consumable=True,
+            effects={"health": 20}
+        ))
+        
+        # Cave items
+        cave_location.add_item(Item(
+            id="crystal",
+            name="Magic Crystal",
+            description="A glowing crystal that hums with magical energy.",
+            value=100,
+            consumable=True,
+            effects={"mana": 50}
+        ))
+        
+        # Shop items
+        shop_location.add_item(Weapon(
+            id="dagger",
+            name="Dagger",
+            description="A sharp dagger. Good for quick attacks.",
+            value=30,
+            damage=10,
+            weight=1.0
+        ))
+        
+        shop_location.add_item(Armor(
+            id="leather_armor",
+            name="Leather Armor",
+            description="Simple armor made of leather. Provides basic protection.",
+            value=50,
+            defense=10,
+            armor_type="light",
+            slot="chest"
+        ))
+        
+        # Add NPCs
+        # Village elder
+        elder = NPC(
+            id="elder",
+            name="Village Elder",
+            description="An old man with a long white beard and wise eyes.",
+            dialogue={
+                "greeting": [
+                    "Welcome to our humble village, young adventurer.",
+                    "Ah, a new face. What brings you to our village?"
+                ],
+                "quest": [
+                    "We have a problem with wolves in the forest. Could you help us?",
+                    "The forest to the north has become dangerous. Please investigate."
+                ],
+                "help": [
+                    "You can use 'go [direction]' to move around.",
+                    "Try 'talk [npc]' to interact with people."
+                ]
+            },
+            location_id="start"
+        )
+        
+        # Add quest to elder
+        wolf_quest = Quest(
+            id="wolf_problem",
+            name="Wolf Problem",
+            description="Deal with the wolves in the forest.",
+            objectives=["Kill 5 wolves"],
+            rewards={
+                "experience": 100,
+                "items": {"gold": 50}
+            }
+        )
+        elder.quests.append(wolf_quest)
+        
+        # Shopkeeper
+        shopkeeper = NPC(
+            id="shopkeeper",
+            name="Shopkeeper",
+            description="A friendly-looking person with a big smile.",
+            dialogue={
+                "greeting": [
+                    "Welcome to my shop! Feel free to browse.",
+                    "Hello! Looking for something special?"
+                ],
+                "buy": [
+                    "What would you like to buy?",
+                    "Everything here is for sale, just name it."
+                ],
+                "sell": [
+                    "What do you want to sell me?",
+                    "I'll give you a fair price for your items."
+                ]
+            },
+            location_id="shop"
+        )
+        
+        # Forest wolf
+        wolf = NPC(
+            id="wolf",
+            name="Wolf",
+            description="A wild wolf with sharp teeth and hungry eyes.",
+            dialogue={},
+            location_id="forest",
+            hostile=True,
+            stats=Stats(health=50, max_health=50)
+        )
+        
+        # Add NPCs to locations
+        start_location.add_npc(elder)
+        shop_location.add_npc(shopkeeper)
+        forest_location.add_npc(wolf)
+        
+        # Add locations to world
+        self.world.add_location(start_location)
+        self.world.add_location(forest_location)
+        self.world.add_location(mountain_location)
+        self.world.add_location(cave_location)
+        self.world.add_location(shop_location)
+    
+    def start(self):
+        self.clear_screen()
+        self.print_title()
+        
+        # Character creation
+        name = input(f"{Colors.CYAN}Enter your character's name: {Colors.RESET}")
+        self.player = Player(name)
+        
+        # Welcome message
+        self.print_wrapped(f"{Colors.GREEN}Welcome, {self.player.name}!{Colors.RESET}")
+        self.print_wrapped("You find yourself in a small village. Your adventure begins here.")
+        self.print_wrapped("Type 'help' for a list of commands.")
+        self.print_separator()
+        
+        # Main game loop
+        while self.running:
+            if not self.in_combat:
+                # Update game world
+                self.world.update_time()
+                self.player.update_vitals()
+                
+                # Check if player is dead
+                if self.player.stats.health <= 0:
+                    self.game_over()
+                    break
+                
+                # Display location
+                self.display_location()
+            
+            # Get player input
+            try:
+                command_input = input(f"{Colors.YELLOW}> {Colors.RESET}").strip().lower()
+                if not command_input:
+                    continue
+                
+                # Parse command
+                parts = command_input.split()
+                command = parts[0]
+                args = parts[1:] if len(parts) > 1 else []
+                
+                # Execute command
+                if command in self.commands:
+                    self.commands[command](args)
+                else:
+                    print(f"{Colors.RED}Unknown command: {command}{Colors.RESET}")
+                    print(f"{Colors.CYAN}Type 'help' for a list of commands.{Colors.RESET}")
+                
+            except KeyboardInterrupt:
+                print("\nGoodbye!")
+                self.running = False
+            except EOFError:
+                print("\nGoodbye!")
+                self.running = False
+            except Exception as e:
+                print(f"{Colors.RED}Error: {e}{Colors.RESET}")
+    
+    def game_over(self):
+        self.clear_screen()
+        print(f"{Colors.RED}========================================{Colors.RESET}")
+        print(f"{Colors.RED}            GAME OVER{Colors.RESET}")
+        print(f"{Colors.RED}========================================{Colors.RESET}")
+        print(f"{Colors.WHITE}You have died.{Colors.RESET}")
+        print(f"{Colors.WHITE}Level reached: {self.player.stats.level}{Colors.RESET}")
+        print(f"{Colors.WHITE}Experience gained: {self.player.stats.experience}{Colors.RESET}")
+        print(f"{Colors.RED}========================================{Colors.RESET}")
+        self.running = False
+    
+    def clear_screen(self):
+        os.system('cls' if os.name == 'nt' else 'clear')
+    
+    def print_title(self):
+        print(f"{Colors.BRIGHT_CYAN}")
+        print("========================================")
+        print("       ULTIMATE OPEN WORLD GAME        ")
+        print("========================================")
+        print(f"{Colors.RESET}")
+    
+    def print_separator(self):
+        print(f"{Colors.BRIGHT_BLACK}----------------------------------------{Colors.RESET}")
+    
+    def print_wrapped(self, text, width=80):
+        words = text.split()
+        lines = []
+        current_line = []
+        current_length = 0
+        
+        for word in words:
+            if current_length + len(word) + 1 <= width:
+                current_line.append(word)
+                current_length += len(word) + 1
+            else:
+                lines.append(' '.join(current_line))
+                current_line = [word]
+                current_length = len(word)
+        
+        if current_line:
+            lines.append(' '.join(current_line))
+        
+        for line in lines:
+            print(line)
+    
+    def display_location(self):
+        location = self.world.get_location(self.player.location_id)
+        if not location:
+            return
+        
+        # Mark location as discovered
+        if not location.discovered:
+            location.discovered = True
+            if location.id not in self.player.known_locations:
+                self.player.known_locations.append(location.id)
+        
+        # Display location name
+        print(f"{Colors.BRIGHT_GREEN}{location.name}{Colors.RESET}")
+        
+        # Display location description
+        self.print_wrapped(f"{Colors.WHITE}{location.description}{Colors.RESET}")
+        
+        # Display time and weather
+        print(f"{Colors.CYAN}{self.world.get_time_description()}{Colors.RESET}")
+        
+        # Display exits
+        if location.exits:
+            exits = ", ".join([d.value for d in location.exits.keys()])
+            print(f"{Colors.YELLOW}Exits: {exits}{Colors.RESET}")
+        
+        # Display items
+        if location.items:
+            item_names = [f"{item.name} ({quantity})" if item.stackable else item.name 
+                         for item, quantity in [(item, 1) for item in location.items]]
+            print(f"{Colors.GREEN}Items: {', '.join(item_names)}{Colors.RESET}")
+        
+        # Display NPCs
+        if location.npcs:
+            npc_names = [npc.name for npc in location.npcs]
+            print(f"{Colors.MAGENTA}People: {', '.join(npc_names)}{Colors.RESET}")
+        
+        self.print_separator()
+    
+    # Command implementations
+    def cmd_help(self, args):
+        print(f"{Colors.CYAN}Available commands:{Colors.RESET}")
+        for command in sorted(self.commands.keys()):
+            print(f"  {Colors.YELLOW}{command}{Colors.RESET}")
+        print(f"\n{Colors.CYAN}For more information on a command, type: help [command]{Colors.RESET}")
+    
+    def cmd_quit(self, args):
+        print(f"{Colors.YELLOW}Are you sure you want to quit? (y/n){Colors.RESET}")
+        response = input("> ").strip().lower()
+        if response == 'y':
+            self.running = False
+    
+    def cmd_look(self, args):
+        self.display_location()
+    
+    def cmd_go(self, args):
+        if not args:
+            print(f"{Colors.RED}Go where?{Colors.RESET}")
+            return
+        
+        direction_str = args[0]
+        try:
+            direction = Direction(direction_str)
+        except ValueError:
+            print(f"{Colors.RED}Invalid direction: {direction_str}{Colors.RESET}")
+            return
+        
+        location = self.world.get_location(self.player.location_id)
+        if not location:
+            return
+        
+        if direction in location.exits:
+            # Check for hostile NPCs that might block the way
+            for npc in location.npcs:
+                if npc.hostile and npc.stats.health > 0:
+                    print(f"{Colors.RED}{npc.name} blocks your path!{Colors.RESET}")
+                    self.start_combat(npc)
+                    return
+            
+            # Move to the new location
+            self.player.location_id = location.exits[direction]
+            print(f"{Colors.GREEN}You go {direction.value}.{Colors.RESET}")
+            
+            # Update time (movement takes time)
+            self.world.update_time(5)
+            
+            # Consume stamina
+            self.player.stats.stamina = max(0, self.player.stats.stamina - 5)
+            
+            # Check for random encounters
+            if random.random() < 0.1:  # 10% chance of random encounter
+                self.random_encounter()
+        else:
+            print(f"{Colors.RED}You can't go {direction.value} from here.{Colors.RESET}")
+    
+    def cmd_take(self, args):
+        if not args:
+            print(f"{Colors.RED}Take what?{Colors.RESET}")
+            return
+        
+        item_name = ' '.join(args)
+        location = self.world.get_location(self.player.location_id)
+        if not location:
+            return
+        
+        # Find the item
+        for item in location.items:
+            if item.name.lower() == item_name.lower():
+                # Add to player inventory
+                leftover = self.player.add_item(item)
+                if leftover == 0:
+                    location.remove_item(item)
+                    print(f"{Colors.GREEN}You take the {item.name}.{Colors.RESET}")
+                else:
+                    print(f"{Colors.YELLOW}You can only carry {item.max_stack} {item.name}s.{Colors.RESET}")
+                return
+        
+        print(f"{Colors.RED}There is no {item_name} here.{Colors.RESET}")
+    
+    def cmd_inventory(self, args):
+        if not self.player.inventory:
+            print(f"{Colors.YELLOW}Your inventory is empty.{Colors.RESET}")
+            return
+        
+        print(f"{Colors.CYAN}Inventory:{Colors.RESET}")
+        for item_id, (item, quantity) in self.player.inventory.items():
+            if item.stackable:
+                print(f"  {Colors.GREEN}{item.name} x{quantity}{Colors.RESET} - {item.description}")
+            else:
+                print(f"  {Colors.GREEN}{item.name}{Colors.RESET} - {item.description}")
+        
+        # Show equipped items
+        if self.player.equipped:
+            print(f"\n{Colors.CYAN}Equipped:{Colors.RESET}")
+            for slot, item in self.player.equipped.items():
+                print(f"  {Colors.YELLOW}{slot}: {item.name}{Colors.RESET}")
+    
+    def cmd_use(self, args):
+        if not args:
+            print(f"{Colors.RED}Use what?{Colors.RESET}")
+            return
+        
+        item_name = ' '.join(args)
+        
+        # Find the item in inventory
+        for item_id, (item, quantity) in self.player.inventory.items():
+            if item.name.lower() == item_name.lower():
+                if item.use(self.player):
+                    if item.consumable:
+                        if quantity > 1:
+                            self.player.inventory[item_id] = (item, quantity - 1)
+                        else:
+                            self.player.remove_item(item_id)
+                    print(f"{Colors.GREEN}You use the {item.name}.{Colors.RESET}")
+                else:
+                    print(f"{Colors.RED}You can't use the {item.name}.{Colors.RESET}")
+                return
+        
+        print(f"{Colors.RED}You don't have a {item_name}.{Colors.RESET}")
+    
+    def cmd_equip(self, args):
+        if not args:
+            print(f"{Colors.RED}Equip what?{Colors.RESET}")
+            return
+        
+        item_name = ' '.join(args)
+        
+        # Find the item in inventory
+        for item_id, (item, quantity) in self.player.inventory.items():
+            if item.name.lower() == item_name.lower():
+                if self.player.equip_item(item_id):
+                    print(f"{Colors.GREEN}You equip the {item.name}.{Colors.RESET}")
+                else:
+                    print(f"{Colors.RED}You can't equip the {item.name}.{Colors.RESET}")
+                return
+        
+        print(f"{Colors.RED}You don't have a {item_name}.{Colors.RESET}")
+    
+    def cmd_unequip(self, args):
+        if not args:
+            print(f"{Colors.RED}Unequip what?{Colors.RESET}")
+            return
+        
+        slot = args[0].lower()
+        
+        if self.player.unequip_item(slot):
+            print(f"{Colors.GREEN}You unequip your {slot}.{Colors.RESET}")
+        else:
+            print(f"{Colors.RED}You don't have anything equipped in that slot.{Colors.RESET}")
+    
+    def cmd_talk(self, args):
+        if not args:
+            print(f"{Colors.RED}Talk to whom?{Colors.RESET}")
+            return
+        
+        npc_name = ' '.join(args)
+        location = self.world.get_location(self.player.location_id)
+        if not location:
+            return
+        
+        # Find the NPC
+        for npc in location.npcs:
+            if npc.name.lower() == npc_name.lower():
+                # Get dialogue topic
+                topic = "greeting"
+                if len(args) > 1:
+                    topic = ' '.join(args[1:])
+                
+                # Get dialogue
+                dialogue = npc.talk(topic)
+                print(f"{Colors.MAGENTA}{npc.name}: {dialogue}{Colors.RESET}")
+                
+                # Check for quests
+                if topic == "quest" and npc.quests:
+                    for quest in npc.quests:
+                        if not quest.completed and not any(q.id == quest.id for q in self.player.quests):
+                            self.player.add_quest(quest)
+                            print(f"{Colors.GREEN}New quest: {quest.name}{Colors.RESET}")
+                            print(f"{Colors.WHITE}{quest.description}{Colors.RESET}")
+                
+                return
+        
+        print(f"{Colors.RED}There is no one named {npc_name} here.{Colors.RESET}")
+    
+    def cmd_attack(self, args):
+        if not args:
+            print(f"{Colors.RED}Attack whom?{Colors.RESET}")
+            return
+        
+        npc_name = ' '.join(args)
+        location = self.world.get_location(self.player.location_id)
+        if not location:
+            return
+        
+        # Find the NPC
+        for npc in location.npcs:
+            if npc.name.lower() == npc_name.lower():
+                if not npc.hostile:
+                    print(f"{Colors.RED}You can't attack {npc.name}.{Colors.RESET}")
+                    return
+                
+                self.start_combat(npc)
+                return
+        
+        print(f"{Colors.RED}There is no one named {npc_name} here.{Colors.RESET}")
+    
+    def cmd_flee(self, args):
+        if not self.in_combat:
+            print(f"{Colors.RED}You're not in combat.{Colors.RESET}")
+            return
+        
+        if self.combat.check_flee(self.player, self.current_opponent):
+            print(f"{Colors.GREEN}You successfully flee from combat.{Colors.RESET}")
+            self.end_combat()
+            
+            # Move to a random adjacent location
+            location = self.world.get_location(self.player.location_id)
+            if location and location.exits:
+                directions = list(location.exits.keys())
+                random_direction = random.choice(directions)
+                self.player.location_id = location.exits[random_direction]
+                print(f"{Colors.GREEN}You run away to the {random_direction.value}.{Colors.RESET}")
+        else:
+            print(f"{Colors.RED}You fail to flee!{Colors.RESET}")
+            # Enemy gets a free attack
+            damage = self.combat.attack(self.current_opponent, self.player)
+            print(f"{Colors.RED}{self.current_opponent.name} attacks you for {damage} damage!{Colors.RESET}")
+            
+            if self.player.stats.health <= 0:
+                self.game_over()
+    
+    def cmd_quests(self, args):
+        if not self.player.quests:
+            print(f"{Colors.YELLOW}You don't have any active quests.{Colors.RESET}")
+            return
+        
+        print(f"{Colors.CYAN}Active Quests:{Colors.RESET}")
+        for quest in self.player.quests:
+            if quest.active and not quest.completed:
+                print(f"  {Colors.YELLOW}{quest.name}{Colors.RESET}")
+                print(f"    {quest.description}")
+                print(f"    Objectives: {', '.join(quest.objectives)}")
+        
+        print(f"\n{Colors.CYAN}Completed Quests:{Colors.RESET}")
+        for quest in self.player.quests:
+            if quest.completed:
+                print(f"  {Colors.GREEN}{quest.name}{Colors.RESET}")
+    
+    def cmd_skills(self, args):
+        print(f"{Colors.CYAN}Skills:{Colors.RESET}")
+        for skill_name, skill in self.player.skills.items():
+            print(f"  {Colors.YELLOW}{skill.name}: Level {skill.level} ({skill.experience}/{skill.max_experience} XP){Colors.RESET}")
+    
+    def cmd_time(self, args):
+        print(f"{Colors.CYAN}{self.world.get_time_description()}{Colors.RESET}")
+    
+    def cmd_save(self, args):
+        save_name = args[0] if args else "save1"
+        save_data = {
+            "player": self.player,
+            "world": self.world,
+            "in_combat": self.in_combat,
+            "current_opponent": self.current_opponent
+        }
+        
+        try:
+            with open(f"{save_name}.sav", "wb") as f:
+                pickle.dump(save_data, f)
+            print(f"{Colors.GREEN}Game saved as {save_name}.{Colors.RESET}")
+        except Exception as e:
+            print(f"{Colors.RED}Failed to save game: {e}{Colors.RESET}")
+    
+    def cmd_load(self, args):
+        save_name = args[0] if args else "save1"
+        
+        try:
+            with open(f"{save_name}.sav", "rb") as f:
+                save_data = pickle.load(f)
+            
+            self.player = save_data["player"]
+            self.world = save_data["world"]
+            self.in_combat = save_data["in_combat"]
+            self.current_opponent = save_data["current_opponent"]
+            
+            print(f"{Colors.GREEN}Game loaded from {save_name}.{Colors.RESET}")
+        except Exception as e:
+            print(f"{Colors.RED}Failed to load game: {e}{Colors.RESET}")
+    
+    def cmd_wait(self, args):
+        minutes = 30  # Default wait time
+        if args:
+            try:
+                minutes = int(args[0])
+            except ValueError:
+                print(f"{Colors.RED}Invalid time: {args[0]}{Colors.RESET}")
+                return
+        
+        print(f"{Colors.YELLOW}You wait for {minutes} minutes...{Colors.RESET}")
+        self.world.update_time(minutes)
+        self.player.update_vitals()
+        
+        # Random events while waiting
+        if random.random() < 0.2:  # 20% chance of something happening
+            self.random_event()
+    
+    def cmd_status(self, args):
+        print(f"{Colors.CYAN}Character Status:{Colors.RESET}")
+        print(f"  Name: {self.player.name}")
+        print(f"  Level: {self.player.stats.level}")
+        print(f"  Experience: {self.player.stats.experience}")
+        print(f"  Health: {self.player.stats.health}/{self.player.stats.max_health}")
+        print(f"  Mana: {self.player.stats.mana}/{self.player.stats.max_mana}")
+        print(f"  Stamina: {self.player.stats.stamina}/{self.player.stats.max_stamina}")
+        print(f"  Hunger: {self.player.stats.hunger}/{self.player.stats.max_hunger}")
+        print(f"  Thirst: {self.player.stats.thirst}/{self.player.stats.max_thirst}")
+        print(f"  Defense: {self.player.get_total_defense()}")
+        print(f"  Damage: {self.player.get_total_damage()}")
+    
+    def cmd_drop(self, args):
+        if not args:
+            print(f"{Colors.RED}Drop what?{Colors.RESET}")
+            return
+        
+        item_name = ' '.join(args)
+        location = self.world.get_location(self.player.location_id)
+        if not location:
+            return
+        
+        # Find the item in inventory
+        for item_id, (item, quantity) in self.player.inventory.items():
+            if item.name.lower() == item_name.lower():
+                # Remove from player inventory
+                if self.player.remove_item(item_id):
+                    # Add to location
+                    location.add_item(item)
+                    print(f"{Colors.GREEN}You drop the {item.name}.{Colors.RESET}")
+                return
+        
+        print(f"{Colors.RED}You don't have a {item_name}.{Colors.RESET}")
+    
+    def cmd_examine(self, args):
+        if not args:
+            print(f"{Colors.RED}Examine what?{Colors.RESET}")
+            return
+        
+        target_name = ' '.join(args)
+        location = self.world.get_location(self.player.location_id)
+        if not location:
+            return
+        
+        # Check items
+        for item in location.items:
+            if item.name.lower() == target_name.lower():
+                print(f"{Colors.GREEN}{item.name}: {item.description}{Colors.RESET}")
+                if isinstance(item, Weapon):
+                    print(f"  Damage: {item.damage}, Type: {item.damage_type}")
+                elif isinstance(item, Armor):
+                    print(f"  Defense: {item.defense}, Type: {item.armor_type}, Slot: {item.slot}")
+                return
+        
+        # Check NPCs
+        for npc in location.npcs:
+            if npc.name.lower() == target_name.lower():
+                print(f"{Colors.MAGENTA}{npc.name}: {npc.description}{Colors.RESET}")
+                if npc.hostile:
+                    print(f"  {Colors.RED}Hostile{Colors.RESET}")
+                print(f"  Health: {npc.stats.health}/{npc.stats.max_health}")
+                return
+        
+        print(f"{Colors.RED}There is no {target_name} here.{Colors.RESET}")
+    
+    def cmd_map(self, args):
+        print(f"{Colors.CYAN}Map of Known Locations:{Colors.RESET}")
+        
+        # Get all known locations
+        known_locations = [self.world.get_location(loc_id) for loc_id in self.player.known_locations]
+        if not known_locations:
+            print(f"{Colors.YELLOW}You haven't discovered any locations yet.{Colors.RESET}")
+            return
+        
+        # Find min and max coordinates
+        min_x = min(loc.position.x for loc in known_locations)
+        max_x = max(loc.position.x for loc in known_locations)
+        min_y = min(loc.position.y for loc in known_locations)
+        max_y = max(loc.position.y for loc in known_locations)
+        
+        # Create map grid
+        grid_width = max_x - min_x + 1
+        grid_height = max_y - min_y + 1
+        grid = [[' ' for _ in range(grid_width)] for _ in range(grid_height)]
+        
+        # Place locations on grid
+        for loc in known_locations:
+            x = loc.position.x - min_x
+            y = loc.position.y - min_y
+            
+            if loc.id == self.player.location_id:
+                grid[y][x] = 'X'  # Player's current location
+            else:
+                grid[y][x] = 'O'  # Other known locations
+        
+        # Print map
+        print(f"{Colors.BRIGHT_BLACK}+{'-' * grid_width}+{Colors.RESET}")
+        for row in grid:
+            print(f"{Colors.BRIGHT_BLACK}|{Colors.RESET}", end="")
+            for cell in row:
+                if cell == 'X':
+                    print(f"{Colors.GREEN}{cell}{Colors.RESET}", end="")
+                elif cell == 'O':
+                    print(f"{Colors.YELLOW}{cell}{Colors.RESET}", end="")
+                else:
+                    print(cell, end="")
+            print(f"{Colors.BRIGHT_BLACK}|{Colors.RESET}")
+        print(f"{Colors.BRIGHT_BLACK}+{'-' * grid_width}+{Colors.RESET}")
+        print(f"{Colors.GREEN}X = Your location{Colors.RESET}")
+        print(f"{Colors.YELLOW}O = Known location{Colors.RESET}")
+    
+    def cmd_rest(self, args):
+        if self.in_combat:
+            print(f"{Colors.RED}You can't rest during combat!{Colors.RESET}")
+            return
+        
+        location = self.world.get_location(self.player.location_id)
+        if location and not location.indoor:
+            print(f"{Colors.YELLOW}Resting outdoors is not safe. You might be attacked.{Colors.RESET}")
+            response = input("Continue anyway? (y/n) ").strip().lower()
+            if response != 'y':
+                return
+        
+        print(f"{Colors.YELLOW}You rest for a while...{Colors.RESET}")
+        
+        # Restore health, mana, and stamina
+        self.player.stats.health = self.player.stats.max_health
+        self.player.stats.mana = self.player.stats.max_mana
+        self.player.stats.stamina = self.player.stats.max_stamina
+        
+        # Advance time
+        self.world.update_time(60)  # Rest for 1 hour
+        
+        # Random event chance
+        if random.random() < 0.3:  # 30% chance of something happening
+            self.random_event()
+    
+    def cmd_plugins(self, args):
+        if not args:
+            print(f"{Colors.CYAN}Loaded plugins:{Colors.RESET}")
+            for plugin_path in self.plugins:
+                print(f"  {plugin_path}")
+            return
+        
+        command = args[0].lower()
+        
+        if command == "load" and len(args) > 1:
+            plugin_path = args[1]
+            if self.load_plugin(plugin_path):
+                print(f"{Colors.GREEN}Plugin loaded: {plugin_path}{Colors.RESET}")
+            else:
+                print(f"{Colors.RED}Failed to load plugin: {plugin_path}{Colors.RESET}")
+        elif command == "unload" and len(args) > 1:
+            plugin_path = args[1]
+            if self.unload_plugin(plugin_path):
+                print(f"{Colors.GREEN}Plugin unloaded: {plugin_path}{Colors.RESET}")
+            else:
+                print(f"{Colors.RED}Failed to unload plugin: {plugin_path}{Colors.RESET}")
+        else:
+            print(f"{Colors.RED}Usage: plugins [load|unload] [path]{Colors.RESET}")
+    
+    # Combat methods
+    def start_combat(self, opponent):
+        self.in_combat = True
+        self.current_opponent = opponent
+        
+        print(f"{Colors.RED}Combat started with {opponent.name}!{Colors.RESET}")
+        
+        # Combat loop
+        while self.in_combat:
+            # Display combat status
+            print(f"{Colors.RED}{opponent.name}: {opponent.stats.health}/{opponent.stats.max_health} HP{Colors.RESET}")
+            print(f"{Colors.GREEN}You: {self.player.stats.health}/{self.player.stats.max_health} HP{Colors.RESET}")
+            
+            # Get player action
+            try:
+                action = input(f"{Colors.YELLOW}What do you do? (attack/flee/use/item): {Colors.RESET}").strip().lower()
+                
+                if action == "attack":
+                    # Player attacks
+                    damage = self.combat.attack(self.player, opponent)
+                    print(f"{Colors.GREEN}You attack {opponent.name} for {damage} damage!{Colors.RESET}")
+                    
+                    # Check if opponent is defeated
+                    if opponent.stats.health <= 0:
+                        print(f"{Colors.GREEN}You defeated {opponent.name}!{Colors.RESET}")
+                        
+                        # Gain experience
+                        exp_gained = opponent.stats.level * 20
+                        leveled_up = self.player.gain_experience(exp_gained)
+                        print(f"{Colors.GREEN}You gained {exp_gained} experience!{Colors.RESET}")
+                        if leveled_up:
+                            print(f"{Colors.BRIGHT_GREEN}You leveled up! You are now level {self.player.stats.level}.{Colors.RESET}")
+                        
+                        # Loot opponent
+                        if opponent.inventory:
+                            for item in opponent.inventory:
+                                self.player.add_item(item)
+                                print(f"{Colors.GREEN}You looted: {item.name}{Colors.RESET}")
+                        
+                        self.end_combat()
+                        continue
+                    
+                    # Opponent attacks
+                    damage = self.combat.attack(opponent, self.player)
+                    print(f"{Colors.RED}{opponent.name} attacks you for {damage} damage!{Colors.RESET}")
+                    
+                    # Check if player is defeated
+                    if self.player.stats.health <= 0:
+                        self.game_over()
+                        break
+                
+                elif action == "flee":
+                    if self.combat.check_flee(self.player, opponent):
+                        print(f"{Colors.GREEN}You successfully flee from combat.{Colors.RESET}")
+                        self.end_combat()
+                        
+                        # Move to a random adjacent location
+                        location = self.world.get_location(self.player.location_id)
+                        if location and location.exits:
+                            directions = list(location.exits.keys())
+                            random_direction = random.choice(directions)
+                            self.player.location_id = location.exits[random_direction]
+                            print(f"{Colors.GREEN}You run away to the {random_direction.value}.{Colors.RESET}")
+                    else:
+                        print(f"{Colors.RED}You fail to flee!{Colors.RESET}")
+                        # Opponent gets a free attack
+                        damage = self.combat.attack(opponent, self.player)
+                        print(f"{Colors.RED}{opponent.name} attacks you for {damage} damage!{Colors.RESET}")
+                        
+                        if self.player.stats.health <= 0:
+                            self.game_over()
+                            break
+                
+                elif action == "use":
+                    item_name = input(f"{Colors.YELLOW}Use what item? {Colors.RESET}").strip().lower()
+                    
+                    # Find the item in inventory
+                    for item_id, (item, quantity) in self.player.inventory.items():
+                        if item.name.lower() == item_name.lower():
+                            if item.use(self.player):
+                                if item.consumable:
+                                    if quantity > 1:
+                                        self.player.inventory[item_id] = (item, quantity - 1)
+                                    else:
+                                        self.player.remove_item(item_id)
+                                print(f"{Colors.GREEN}You use the {item.name}.{Colors.RESET}")
+                            else:
+                                print(f"{Colors.RED}You can't use the {item.name}.{Colors.RESET}")
+                            break
+                    else:
+                        print(f"{Colors.RED}You don't have a {item_name}.{Colors.RESET}")
+                    
+                    # Opponent attacks
+                    damage = self.combat.attack(opponent, self.player)
+                    print(f"{Colors.RED}{opponent.name} attacks you for {damage} damage!{Colors.RESET}")
+                    
+                    if self.player.stats.health <= 0:
+                        self.game_over()
+                        break
+                
+                elif action == "item":
+                    # Use an item (same as "use")
+                    item_name = input(f"{Colors.YELLOW}Use what item? {Colors.RESET}").strip().lower()
+                    
+                    # Find the item in inventory
+                    for item_id, (item, quantity) in self.player.inventory.items():
+                        if item.name.lower() == item_name.lower():
+                            if item.use(self.player):
+                                if item.consumable:
+                                    if quantity > 1:
+                                        self.player.inventory[item_id] = (item, quantity - 1)
+                                    else:
+                                        self.player.remove_item(item_id)
+                                print(f"{Colors.GREEN}You use the {item.name}.{Colors.RESET}")
+                            else:
+                                print(f"{Colors.RED}You can't use the {item.name}.{Colors.RESET}")
+                            break
+                    else:
+                        print(f"{Colors.RED}You don't have a {item_name}.{Colors.RESET}")
+                    
+                    # Opponent attacks
+                    damage = self.combat.attack(opponent, self.player)
+                    print(f"{Colors.RED}{opponent.name} attacks you for {damage} damage!{Colors.RESET}")
+                    
+                    if self.player.stats.health <= 0:
+                        self.game_over()
+                        break
+                
+                else:
+                    print(f"{Colors.RED}Invalid action!{Colors.RESET}")
+                    # Opponent gets a free attack
+                    damage = self.combat.attack(opponent, self.player)
+                    print(f"{Colors.RED}{opponent.name} attacks you for {damage} damage!{Colors.RESET}")
+                    
+                    if self.player.stats.health <= 0:
+                        self.game_over()
+                        break
+            
+            except KeyboardInterrupt:
+                print("\nGoodbye!")
+                self.running = False
+                break
+            except EOFError:
+                print("\nGoodbye!")
+                self.running = False
+                break
+            except Exception as e:
+                print(f"{Colors.RED}Error: {e}{Colors.RESET}")
+    
+    def end_combat(self):
+        self.in_combat = False
+        self.current_opponent = None
+    
+    def random_encounter(self):
+        encounters = [
+            {
+                "message": "You encounter a wandering merchant.",
+                "type": "npc",
+                "npc": NPC(
+                    id="merchant",
+                    name="Wandering Merchant",
+                    description="A traveling merchant with a cart full of goods.",
+                    dialogue={
+                        "greeting": [
+                            "Hello, traveler! Care to buy something?",
+                            "Greetings! I have many fine wares for sale."
+                        ]
+                    },
+                    location_id=self.player.location_id
+                )
+            },
+            {
+                "message": "You find a treasure chest!",
+                "type": "item",
+                "items": [
+                    Item(
+                        id="gold",
+                        name="Gold",
+                        description="Shiny gold coins.",
+                        value=50,
+                        stackable=True
+                    )
+                ]
+            },
+            {
+                "message": "You are ambushed by bandits!",
+                "type": "combat",
+                "npc": NPC(
+                    id="bandit",
+                    name="Bandit",
+                    description="A dangerous-looking bandit with a weapon.",
+                    dialogue={},
+                    location_id=self.player.location_id,
+                    hostile=True,
+                    stats=Stats(health=40, max_health=40)
+                )
+            },
+            {
+                "message": "You discover a hidden path!",
+                "type": "location",
+                "location": Location(
+                    id="hidden_path",
+                    name="Hidden Path",
+                    description="A secret path that few know about.",
+                    position=Position(0, 0, 0)
+                )
+            }
+        ]
+        
+        encounter = random.choice(encounters)
+        print(f"{Colors.YELLOW}{encounter['message']}{Colors.RESET}")
+        
+        if encounter["type"] == "npc":
+            location = self.world.get_location(self.player.location_id)
+            if location:
+                location.add_npc(encounter["npc"])
+        
+        elif encounter["type"] == "item":
+            location = self.world.get_location(self.player.location_id)
+            if location:
+                for item in encounter["items"]:
+                    location.add_item(item)
+        
+        elif encounter["type"] == "combat":
+            self.start_combat(encounter["npc"])
+        
+        elif encounter["type"] == "location":
+            self.world.add_location(encounter["location"])
+            self.player.known_locations.append(encounter["location"].id)
+    
+    def random_event(self):
+        events = [
+            {
+                "message": "It starts to rain.",
+                "effect": lambda: setattr(self.world, "weather", Weather.RAINY)
+            },
+            {
+                "message": "The clouds part and the sun shines through.",
+                "effect": lambda: setattr(self.world, "weather", Weather.CLEAR)
+            },
+            {
+                "message": "You feel a bit hungry.",
+                "effect": lambda: setattr(self.player.stats, "hunger", max(0, self.player.stats.hunger - 10))
+            },
+            {
+                "message": "You feel a bit thirsty.",
+                "effect": lambda: setattr(self.player.stats, "thirst", max(0, self.player.stats.thirst - 10))
+            },
+            {
+                "message": "You feel refreshed.",
+                "effect": lambda: setattr(self.player.stats, "stamina", min(self.player.stats.max_stamina, self.player.stats.stamina + 20))
+            },
+            {
+                "message": "You find a coin on the ground.",
+                "effect": lambda: self.player.add_item(Item(
+                    id="gold",
+                    name="Gold",
+                    description="A single gold coin.",
+                    value=1,
+                    stackable=True
+                ))
+            }
+        ]
+        
+        event = random.choice(events)
+        print(f"{Colors.YELLOW}{event['message']}{Colors.RESET}")
+        event["effect"]()
+
+# Main function
+def main():
+    game = Game()
+    game.start()
+
+if __name__ == "__main__":
+    main()

Workspace/workspace-8ac4a941-39da-4676-a1bb-2758edbb4672

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3edbcbddeb824e6724d7170c14e3192f743c7288f5848d5754aa7d30ef5d031
+size 1095680

Workspace/workspace-8ac4a941-39da-4676-a1bb-2758edbb4672.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1ad739c5baf939e7c69ebdc679c88ce2c700940e22c894167318cb39ec3eeee
+size 200077