neelthee-mansion 3.20.21__py3-none-any.whl → 3.21.2__py3-none-any.whl

neelthee_mansion/Mansion_of_Amnesia-win2.py

@@ -1,1345 +0,0 @@
-from .Rooms import *
-from .creatures import *
-from .items import *
-from .Quests import *
-from .all_game_utils import *
-
-
-GameState = {
-    "Enemies killed": 0,
-    "collected items": [],
-}
-
-
-"""
-Neel-thee's Mansion of Amnesia
-"""
-
-global player, evil_mage, commands, NOTE_NUM, credits, color_coding, quest_manager, revealer, CHARACTERSLIST, BACKGROUNDS
-
-BACKGROUNDS = {
-    "Adventurer": ["survival", "climbing"],
-    "Artist": ["painting", "sculpting"],
-    "Scholar": ["reading", "research"],
-}
-
-revealer = KeyRevealer()
-
-quest_manager = QuestManager()
-
-color_coding = False
-
-credits = """
-Made by: Alexander.E.F
-AI assisted the creation"""
-
-
-name = ""
-age = 0
-height = Height()
-weight = 0
-
-
-CHARACTERSLIST = [
-    {"name": "Jack", "age": 19, "height": Height("6ft 3"), "weight(LBs)": 213},
-    {"name": "Darcie-Mae", "age": 19, "height": Height("5ft 5"), "weight(LBs)": 150},
-    {"name": "John", "age": 25, "height": Height("5ft 10"), "weight(LBs)": 180},
-    {"name": "Emily", "age": 22, "height": Height("5ft 6"), "weight(LBs)": 135},
-    {"name": "William", "age": 30, "height": Height("6ft 1"), "weight(LBs)": 200},
-    {"name": "Samantha", "age": 28, "height": Height("5ft 8"), "weight(LBs)": 155},
-    {"name": "Mark", "age": 23, "height": Height("5ft 11"), "weight(LBs)": 185},
-    {"name": "Alex", "age": 27, "height": Height("6ft 0"), "weight(LBs)": 190},
-    {"name": "Sarah", "age": 20, "height": Height("5ft 4"), "weight(LBs)": 125},
-    {"name": "Natalie", "age": 24, "height": Height("5ft 7"), "weight(LBs)": 140},
-    {"name": "Michael", "age": 32, "height": Height("6ft 2"), "weight(LBs)": 200},
-    {"name": "Liam", "age": 29, "height": Height("5ft 10"), "weight(LBs)": 180},
-    {"name": "James", "age": 25, "height": Height("6ft 1"), "weight(LBs)": 195},
-    {"name": "Emma", "age": 22, "height": Height("5ft 6"), "weight(LBs)": 130},
-    {"name": "Olivia", "age": 26, "height": Height("5ft 8"), "weight(LBs)": 135},
-    {"name": "Sophia", "age": 28, "height": Height("5ft 5"), "weight(LBs)": 145},
-    {"name": "Daniel", "age": 28, "height": Height("6ft 0"), "weight(LBs)": 180},
-    {"name": "Matthew", "age": 31, "height": Height("5ft 11"), "weight(LBs)": 175},
-    {"name": "Jennifer", "age": 25, "height": Height("5ft 6"), "weight(LBs)": 140},
-    {"name": "Hannah", "age": 23, "height": Height("5ft 4"), "weight(LBs)": 130},
-    {"name": "Isabella", "age": 24, "height": Height("5ft 4"), "weight(LBs)": 132},
-    {"name": "Jake", "age": 29, "height": Height("5ft 6"), "weight(LBs)": 140},
-    {"name": "Zack", "age": 21, "height": Height("5ft 5"), "weight(LBs)": 125},
-    {"name": "Lucy", "age": 27, "height": Height("5ft 7"), "weight(LBs)": 135},
-    {"name": "Mia", "age": 25, "height": Height("5ft 3"), "weight(LBs)": 128},
-    {"name": "Brandon", "age": 30, "height": Height("6ft 1"), "weight(LBs)": 180},
-    {"name": "Ethan", "age": 28, "height": Height("6ft 0"), "weight(LBs)": 175},
-    {"name": "Andrew", "age": 28, "height": Height("6ft 0"), "weight(LBs)": 175},
-    {"name": "Nathan", "age": 26, "height": Height("5ft 10"), "weight(LBs)": 165},
-    {"name": "David", "age": 22, "height": Height("6ft 2"), "weight(LBs)": 185},
-    {"name": "Noah", "age": 25, "height": Height("5ft 11"), "weight(LBs)": 175},
-    {"name": "Aiden", "age": 30, "height": Height("6ft 0"), "weight(LBs)": 180},
-    {"name": "Lucas", "age": 28, "height": Height("5ft 10"), "weight(LBs)": 170},
-    {"name": "Ava", "age": 22, "height": Height("5ft 5"), "weight(LBs)": 130},
-    {"name": "Lily", "age": 26, "height": Height("5ft 6"), "weight(LBs)": 135},
-    {"name": "Grace", "age": 29, "height": Height("5ft 7"), "weight(LBs)": 140},
-    {"name": "Josh", "age": 26, "height": Height("5ft 6"), "weight(LBs)": 135},
-    {"name": "Luka", "age": 29, "height": Height("5ft 7"), "weight(LBs)": 140},
-]
-
-
-evil_mage = PC(
-    "Neel-thee Contozt",
-    19836,
-    "Mage",
-    29,
-    "Evil prince",
-    Height("5ft 7.375"),
-    222,
-    xp=99180,
-)
-
-
-# Function to parse command
-def parse_command(command_str: str, commands: dict):
-    global player
-    # Split the command string into parts
-    parts = command_str.split()
-
-    # Check for multi-word commands
-    for cmd in commands.keys():
-        cmd_parts = cmd.split()
-        if len(cmd_parts) > 1 and parts[: len(cmd_parts)] == cmd_parts:
-            action = " ".join(cmd_parts)
-            targets = parts[len(cmd_parts) :]
-            return action, targets
-
-    # Default single word command
-    action = parts[0]
-    targets = parts[1:] if len(parts) > 1 else []
-    return action, targets
-
-
-def showInstructions():
-    global player
-    # Display the game instructions
-    type_text(
-        """
-===========================
-Commands:
-go [%*GREEN*%direction%*RESET*%/%*GREEN*%teleport%*RESET*%/%*GREEN*%number%*RESET*%] - Move to another location
-get [%*BLUE*%item%*RESET*%] - Pick up an item from your current location
-search [%*RED*%container%*RESET*%] - Search a container in your current location
-use [%*BLUE*%item%*RESET*%] - Use an item from your inventory
-put [%*BLUE*%item%*RESET*%] [in] [%*RED*%container%*RESET*%] - Put an item from your inventory into a container in your current location
-examine [%*GREEN*%direction%*RESET*%/%*RED*%container%*RESET*%/%*BLUE*%item%*RESET*%] - Find out some info about the object
-sleep - Rest for a bit and regain some health
-look - Look around your current location
-quit - Quit the game
-help - Show these instructions
-hint - Get a random hint for your current location
-map - Display the map of places you have been to
-""",
-        colorTrue=color_coding,
-    )
-
-
-def showHint():
-    global player
-    if "Hints" in ROOMS[player.CURRENTROOM]:
-        type_text("You think:", colorTrue=color_coding)
-        hint = choice(ROOMS[player.CURRENTROOM]["Hints"])
-        type_text(hint, colorTrue=color_coding)
-    else:
-        type_text("You can't think of anything", colorTrue=color_coding)
-
-
-def check_direction(var: str, directions: list):
-    global player
-    for direction in directions:
-        if var == direction:
-            return True
-    return False
-
-
-def End(text: str, win: bool = True):
-    global player
-    type_text(text, colorTrue=color_coding)
-    if win:
-        type_text("Do you want to leave the game? Y/N", colorTrue=color_coding)
-        while True:
-            leave = input(">").lower()
-            if leave == "n":
-                type_text("You decide to continue exploring.", colorTrue=color_coding)
-                break
-            elif leave == "y":
-                type_text(
-                    "You escaped the house... %*BOLD*%GAME OVER, YOU WIN!",
-                    colorTrue=color_coding,
-                )
-                commands["quit"]()
-            else:
-                type_text(
-                    "Sorry, that wasn't 'y' or 'n'. Please enter 'y' or 'n'.",
-                    colorTrue=color_coding,
-                )
-    else:
-        type_text("%*BOLD*%GAME OVER, YOU LOSE!", colorTrue=color_coding)
-        commands["quit"]()
-
-
-NOTE_NUM = 0
-
-
-def add_note(note, parchment_index=None):
-    global player, NOTE_NUM
-    player.NOTES.append(note)
-    NOTE_NUM += 1
-    inv_note = "note " + str(NOTE_NUM)
-    try:
-        del player.inventory[parchment_index]
-    except IndexError:
-        pass
-    player.inventory_add([item(inv_note)])
-
-
-def Use_grappling_hook():
-    global player
-
-    def swing_into_forest():
-        global player
-        type_text(
-            "You throw your grappling-hook, it catches a branch of a nearby tree and hooks back onto itself. \nYou can swing into the forest!",
-            colorTrue=color_coding,
-        )
-        if ask_for_consent("Do you want to swing into the forest"):
-            type_text("You swing into the forest", colorTrue=color_coding)
-            Move("Forest Clearing")
-        else:
-            type_text(
-                "You flick the rope and it unhooks. You continue exploring the house.",
-                colorTrue=color_coding,
-            )
-
-    def climb_into_house():
-        global player
-        type_text(
-            "You throw your grappling-hook, it catches the railing of the nearby house and hooks back onto itself. \nYou can climb into the house!",
-            colorTrue=color_coding,
-        )
-        if ask_for_consent("Do you want to climb into the house"):
-            type_text("You climb into the house", colorTrue=color_coding)
-            Move("Balcony")
-        else:
-            type_text(
-                "You flick the rope and it unhooks. You continue exploring the forest",
-                colorTrue=color_coding,
-            )
-
-    if player.CURRENTROOM == "Balcony" and "grappling-hook" in player.inventory:
-        swing_into_forest()
-    elif (
-        player.CURRENTROOM == "Forest Clearing" and "grappling-hook" in player.inventory
-    ):
-        climb_into_house()
-
-
-def Use_quill():
-    global player
-
-    if all(item in player.inventory for item in ["ink-pot", "parchment", "quill"]):
-        parchment_index = player.inventory.index("parchment")
-        type_text("What do you want to write", colorTrue=color_coding)
-        write = str(input(">")).strip()
-
-        if write:
-            add_note(write, parchment_index)
-        else:
-            type_text("You can't write nothing", colorTrue=color_coding)
-    else:
-        type_text(
-            "You need an ink pot, parchment, and a quill to write.",
-            colorTrue=color_coding,
-        )
-
-
-def Use_note(note_number):
-    global player
-    """Reads a specified note from the player's inventory."""
-    note_key = f"note {note_number}"
-    if note_key in player.inventory:
-        note_index = int(note_number) - 1
-        type_text(f"You read:", colorTrue=color_coding)
-        type_text(player.NOTES[note_index], colorTrue=color_coding)
-    else:
-        type_text("You do not have that note", colorTrue=color_coding)
-
-
-def Use(*Args):
-    global player
-    if isinstance(Args[0], list) or isinstance(Args[0], tuple):
-        Args = Args[0]
-    Item = " ".join(Args)
-    """Uses an item from the player's inventory."""
-    if Item in player.inventory:
-        item_obj = player.inventory[player.inventory.index(Item)]
-        if isinstance(item_obj, item):
-            if item_obj.sell(player):
-                type_text(
-                    f"You sell the %*BLUE*%{Item}%*RESET*%", colorTrue=color_coding
-                )
-                player.inventory.remove(item_obj.name)
-            elif Item == "quill":
-                Use_quill()
-            elif Item == "grappling-hook":
-                Use_grappling_hook()
-    elif len(Item) >= 2 and Item[0] == "note" and Item[1]:
-        Use_note(Item[1])
-    elif Item == "0":
-        type_text("You can't use nothing", colorTrue=color_coding)
-    else:
-        type_text("You can't use that", colorTrue=color_coding)
-
-
-def PickKey(locked_obj):
-    keys = player.inventory.keys()
-    if not isinstance(keys, list):
-        keys = [keys]
-
-    if keys:
-        while True:
-            type_text(
-                f"Please pick which key you want to use in the lock. This is what you know about the lock: {locked_obj}. These are your keys:"
-            )
-
-            # Enumerate keys and display them
-            for idx, key in enumerate(keys, 1):  # Starts numbering at 1
-                type_text(f"{idx}. {key.name} - {key.CurentRevealStr}")
-
-            # Use loop_til_valid_input to get a valid integer within the correct range
-            choice = loop_til_valid_input(
-                input_text="Enter the number of the key you'd like to use: ",
-                bad_text="That's not a valid choice, please try again.",
-                Class=int,  # Ensuring input is an integer
-            )
-
-            # Since loop_til_valid_input ensures valid input, just return the selected key
-            if 1 <= choice <= len(keys):
-                return keys[choice - 1]  # Fetch the key using 0-based index
-
-    return Key(KeyCode=None)
-
-
-def Move(move):
-    global player
-
-    def attempt_charter():
-        global player
-        if player.money >= 10:
-            player.money -= 10
-            if "descovered" in ROOMS[newRoom] and not ROOMS[newRoom]["descovered"]:
-                ROOMS[newRoom]["descovered"] = True
-            return ROOMS[player.CURRENTROOM]["directions"][move]
-        else:
-            type_text(
-                "You don't have enough money to charter a ship.", colorTrue=color_coding
-            )
-            return player.CURRENTROOM
-
-    def attempt_move_to_garden():
-        global player
-        key = PickKey(Lock("629.IdnXwnt"))
-        if key.GetKeyCode() == "629.IdnXwnt":
-            End("You unlock the gate to the garden with the key!")
-            return newRoom
-        type_text("The gate is locked.", colorTrue=color_coding)
-        return newRoom
-
-    def move_to_room():
-        global player
-        player.LASTROOM = player.CURRENTROOM
-        if "descovered" in ROOMS[newRoom] and not ROOMS[newRoom]["descovered"]:
-            ROOMS[newRoom]["descovered"] = True
-        if move == "0":
-            return attempt_charter()
-        elif newRoom == "Garden":
-            return attempt_move_to_garden()
-        else:
-            return newRoom
-
-    if move in ROOMS[player.CURRENTROOM]["directions"]:
-        newRoom = "Hall"
-        if isinstance(ROOMS[player.CURRENTROOM]["directions"][move], Door):
-            if isinstance(ROOMS[player.CURRENTROOM]["directions"][move].lock, Lock):
-                key = PickKey(ROOMS[player.CURRENTROOM]["directions"][move].lock)
-                ROOMS[player.CURRENTROOM]["directions"][move].Unlock(key, player)
-            newRoom = ROOMS[player.CURRENTROOM]["directions"][move].GetRoom(
-                player.CURRENTROOM
-            )
-        else:
-            newRoom = ROOMS[player.CURRENTROOM]["directions"][move]
-        newRoom = move_to_room()
-        player.CURRENTROOM = newRoom
-        return
-    elif move in ROOMS:
-        newRoom = move
-        if newRoom == "Garden":
-            newRoom = attempt_move_to_garden()
-        player.LASTROOM = player.CURRENTROOM
-        player.CURRENTROOM = newRoom
-        if "random_events" in ROOMS[player.CURRENTROOM]:
-            for randomEvent in ROOMS[player.CURRENTROOM]["random_events"]:
-                if isinstance(randomEvent, RandomEvent):
-                    randomEvent.check_and_trigger(player)
-        return
-    type_text(f"There is no exit {move}", colorTrue=color_coding)
-
-
-def start():
-    global player
-    # shows the main menu
-    type_text(
-        f"\nHello %*MAGENTA*%{player.name}%*RESET*% and welcome to my Role Playing Game. \nI hope you have fun!",
-        colorTrue=color_coding,
-    )
-    showInstructions()
-
-
-def showStatus():
-    global player
-
-    # Display player's current status
-    text = f"\n---------------------------"
-
-    # Display the current inventory
-    the_inventory = [
-        itemnum.name for itemnum in player.inventory if isinstance(itemnum, item)
-    ]
-    text += f'\nInventory: %*BLUE*%{", ".join(the_inventory)}%*RESET*%; Money: {player.money}; XP: {player.xp}; Level: {player.Level}'
-
-    # Display possible directions of travel
-    text = display_directions(text)
-
-    # Display the map if available
-    if "map" in ROOMS[player.CURRENTROOM]:
-        text += f'\n\nKey: {"; ".join(KEY)}\n'
-        text += f'\n{ROOMS[player.CURRENTROOM]["map"]}\n'
-
-    # Display the description of the current room
-    text += "\n" + str(ROOMS[player.CURRENTROOM]["info"])
-
-    text += f"\n---------------------------"
-
-    type_text(text, colorTrue=color_coding)
-
-    # Optionally display additional room description
-    if "description" in ROOMS[player.CURRENTROOM] and ask_for_consent(
-        "Do you want to observe the area"
-    ):
-        type_text("The area:", colorTrue=color_coding)
-        type_text(ROOMS[player.CURRENTROOM]["description"], colorTrue=color_coding)
-
-
-def display_directions(text):
-    global player
-    directions = ["north", "east", "south", "west", "up", "down", "teleport"]
-    direction_descriptions = {
-        "house": {
-            "north": "There is a door to the",
-            "east": "There is a door to the",
-            "south": "There is a door to the",
-            "west": "There is a door to the",
-            "up": "There is a staircase leading",
-            "down": "There is a staircase leading",
-        },
-        "forest": {
-            "north": "There is a path to the",
-            "east": "There is a path to the",
-            "south": "There is a path to the",
-            "west": "There is a path to the",
-            "up": "There is a ladder going",
-            "down": "There is a hole in the ground leading",
-        },
-        "cavern": {
-            "north": "There is a tunel to the",
-            "east": "There is a tunel to the",
-            "south": "There is a tunel to the",
-            "west": "There is a tunel to the",
-            "up": "There is a shoot with handhold going",
-            "down": "There is a shoot in the ground going",
-        },
-    }
-
-    room_type = ROOMS[player.CURRENTROOM]["room type"]
-    if room_type in direction_descriptions:
-        for direction in directions:
-            if direction in ROOMS[player.CURRENTROOM]["directions"]:
-                if direction != "teleport":
-                    text += f"\n{direction_descriptions[room_type][direction]} %*GREEN*%{direction}%*RESET*%."
-
-    if "teleport" in ROOMS[player.CURRENTROOM]["directions"]:
-        text += "\nThere is a %*GREEN*%teleport%*RESET*%ation circle on the ground."
-
-    return text
-
-
-def Examine(*Args):
-    Name = " ".join(Args)
-    item_index = player.inventory.index(Name)  # Store the result of index in a variable
-
-    if item_index is not None:  # Check explicitly if item_index is valid
-        _ = player.inventory[item_index]
-        if isinstance(_, item):
-            type_text("You look at your item and you figure out this about it:")
-            if not revealer.reveal_key_code(_):
-                if _.type == "weapon":
-                    type_text(f"This item is a weapon that adds {_.value} damage.")
-                elif _.type == "readable":
-                    if "reading" in player.Skills:
-                        type_text(f"You read {_.name} and it contains:")
-                        if isinstance(_, Book):
-                            type_text(_.GetContense())
-                        else:
-                            type_text(_.value)
-    elif Name in ROOMS[player.CURRENTROOM]["directions"]:  # Check exits in the room
-        door = ROOMS[player.CURRENTROOM]["directions"][Name]
-        if isinstance(door, Door):
-            if isinstance(door.lock, Lock):
-                type_text(
-                    (
-                        "The door is locked,"
-                        if door.lock.is_locked
-                        else "The door is not locked,"
-                    ),
-                    "you know this about its key code:",
-                )
-                revealer.reveal_key_code(door)
-            else:
-                type_text(f"The exit {Name} has no lock.")
-        else:
-            type_text(f"There is nothing special about the exit {Name}.")
-    elif (
-        Name in ROOMS[player.CURRENTROOM]["containers"]
-    ):  # Check containers in the room
-        containerins = ROOMS[player.CURRENTROOM]["containers"][Name]
-        if isinstance(containerins, container):
-            if isinstance(containerins.lock, Lock):
-                type_text(
-                    (
-                        "The container is locked,"
-                        if containerins.lock.is_locked
-                        else "The container is not locked,"
-                    ),
-                    "you know this about its key code:",
-                )
-                revealer.reveal_key_code(containerins)
-            else:
-                type_text(f"The container {Name} has no lock.")
-        else:
-            type_text(f"There is no container named {Name} in this room.")
-    elif "creatures stats" in ROOMS[player.CURRENTROOM]:
-        for Creature in ROOMS[player.CURRENTROOM]["creatures stats"]:
-            if isinstance(Creature, creature):
-                if isinstance(Creature, NPC):
-                    if Creature.name.lower() == Name:
-                        Creature.talk()
-                        return
-    else:
-        type_text(f"There is nothing special about the {Name}.")
-
-
-def battle(player: PC, good_guys: list, bad_guys: list, last_room):
-    """
-    Simulate a battle between the player (and allies) and monsters.
-
-    Args:
-        player (PC): The player character.
-        good_guys (list): The list of allies to help the player.
-        bad_guys (list): The list of monsters to battle the player.
-        last_room: The previous room before the battle.
-
-    Returns:
-        None if all bad guys are defeated, else the remaining bad guys.
-    """
-    while player.hp > 0:
-        if all(monster.hp <= 0 for monster in bad_guys):
-            handle_victory(player, bad_guys)
-            return good_guys, None
-
-        if ask_for_consent("Do you want to run away"):
-            Move(last_room)
-            return good_guys, bad_guys
-
-        # Player and good guys' turn
-        for ally in [player] + good_guys:
-            if all(monster.hp <= 0 for monster in bad_guys):
-                handle_victory(player, bad_guys)
-                return good_guys, None
-
-            target = select_target(ally, bad_guys)
-            player_turn(ally, target)
-
-        # Bad guys' turn
-        for monster in bad_guys:
-            if monster.hp > 0:
-                target = select_target(monster, [player] + good_guys)
-                monster_turn(target, monster)
-
-        if player.hp <= 0:
-            End(f"The monsters defeat you!", win=False)
-            return good_guys, bad_guys
-
-    return good_guys, bad_guys
-
-
-def player_turn(player: PC, monster: creature):
-    """
-    Handle a character's turn during the battle.
-
-    Args:
-        player (PC): The player or ally.
-        monster (creature): The monster being fought.
-    """
-    player_action = loop_til_valid_input(
-        "Choose your action: (attack/defend/special): ",
-        "Invalid action. Please enter a valid action.",
-        PC_action,
-    ).value.lower()
-
-    if player_action == "attack":
-        perform_attack(player, monster)
-    elif player_action == "defend":
-        player.defending = True
-        type_text("You brace yourself for the next attack.", colorTrue=color_coding)
-    elif player_action == "special":
-        use_special_ability(player, monster)
-
-
-def monster_turn(player: PC, monster: creature):
-    """
-    Handle a monster's turn during the battle.
-
-    Args:
-        player (PC): The player or ally.
-        monster (creature): The monster attacking.
-    """
-    type_text(f"The %*CYAN*%{monster.name}%*RESET*% attacks!", colorTrue=color_coding)
-    damage = calculate_damage(monster, player)
-    player.take_damage(damage)
-
-
-def perform_attack(attacker: PC, defender: creature):
-    """
-    Perform an attack action.
-
-    Args:
-        attacker (PC): The attacking character.
-        defender (creature): The defending monster.
-    """
-    damage = calculate_damage(attacker, defender)
-    defender.take_damage(damage)
-
-
-def handle_victory(player: PC, monsters: list):
-    """
-    Handle the logic when the player and allies defeat all monsters.
-
-    Args:
-        player (PC): The player character.
-        monsters (list): The list of defeated monsters.
-    """
-    type_text("You have defeated all the enemies!", colorTrue=color_coding)
-    for monster in monsters:
-        if monster.hp <= 0:
-            player.inventory_add(monster.dropped_items)
-
-
-def calculate_damage(attacker, defender) -> int:
-    """
-    Calculate the damage inflicted by the attacker on the defender.
-
-    Args:
-        attacker: The attacking character.
-        defender: The defending character.
-
-    Returns:
-        int: The calculated damage.
-    """
-    damage_min, damage_max = calculate_damage_range(attacker.atpw)
-    damage = randint(damage_min, damage_max)
-
-    if random() < attacker.crit_chance:
-        damage *= 2
-        type_text("Critical hit!", colorTrue=color_coding)
-
-    if hasattr(defender, "defending") and defender.defending:
-        damage //= 2
-        type_text("The attack is defended, reducing damage.", colorTrue=color_coding)
-        defender.defending = False
-
-    return damage
-
-
-def calculate_damage_range(atpw: int) -> tuple[int, int]:
-    """
-    Calculate the damage range based on attack power.
-
-    Args:
-        atpw (int): Attack power of the combatant.
-
-    Returns:
-        tuple[int, int]: Minimum and maximum damage range.
-    """
-    damage_max_range = randint(1, 3)
-    damage_min_range = randint(1, 3)
-    damage_min = max(1, atpw - damage_min_range)  # Ensure minimum damage is at least 1
-    damage_max = atpw + damage_max_range
-    return damage_min, damage_max
-
-
-def use_special_ability(player: PC, monster: creature):
-    """
-    Allow the player to use a special ability during combat.
-
-    Args:
-        player (PC): The player character.
-        monster (creature): The monster being fought.
-    """
-    if player.special_ability.ready:
-        player.special_ability.activate(monster)
-        type_text(
-            f"You use your special ability: {player.special_ability.name}.",
-            colorTrue=color_coding,
-        )
-        player.special_ability.ready = False
-    else:
-        type_text("Your special ability is not ready yet.", colorTrue=color_coding)
-
-
-def select_target(chooser, targets: list):
-    """
-    Select a target from a list of characters.
-
-    Args:
-        chooser: The entity (e.g., player or AI) selecting the target.
-        targets (list): List of characters to select from.
-
-    Returns:
-        The selected target.
-    """
-    if chooser == player:
-        valid_targets = []
-        type_text("Who do you want to attack? The options:")
-        # Enumerate through the targets to get both the index and the enemy.
-        for index, enemy in enumerate(targets):
-            if enemy.hp > 0:
-                type_text(f"{index + 1}: {enemy.name} ({enemy.hp} HP)")
-                valid_targets.append(index)
-
-        # Prompt the player to select a target
-        while True:
-            try:
-                choice = int(input("Enter the number of the target: ")) - 1
-                if choice in valid_targets:
-                    return targets[choice]
-                else:
-                    type_text("Invalid choice. Please select a valid target.")
-            except ValueError:
-                type_text("Invalid input. Please enter a number.")
-    else:
-        # AI or other logic for non-player chooser
-        for target in targets:
-            if target.hp > 0:
-                return target
-
-
-def command():
-    global player
-    # try:
-    ShouldBreak = False
-
-    while True:
-        showStatus()
-        user_input = get_player_input(False)
-
-        if user_input:
-            commands_list = user_input.split(",")
-            for command_str in commands_list:
-                action, targets = parse_command(command_str.strip(), commands)
-
-                if action in commands:
-                    if has_named_arg(commands[action], "player"):
-                        if targets:
-                            commands[action](player, *targets)
-                        else:
-                            commands[action](player)
-                    elif targets:
-                        commands[action](*targets)
-                    else:
-                        commands[action]()
-                else:
-                    type_text(
-                        f"Unknown command '{action}'. Type 'help' for a list of commands.",
-                        colorTrue=color_coding,
-                    )
-                if action in commands:
-                    ShouldBreak = True
-        if ShouldBreak:
-            return
-
-
-# except KeyError as e:
-#    type_text(f"KeyError: {e} - This might be due to an undefined command or incorrect arguments.", colorTrue=color_coding)
-# except ValueError as e:
-#    type_text(f"ValueError: {e} - This might be due to incorrect arguments provided.", colorTrue=color_coding)
-# except Exception as e:
-#    type_text(f"Unexpected Error: {e}", colorTrue=color_coding)
-
-
-def handle_sleep_command(player: PC):
-    type_text("You decide to rest for a while.", colorTrue=color_coding)
-
-    # Simulate some time passing
-    sleep(2)  # Example: sleep for 2 seconds
-
-    # Restore player's health or apply any other effects
-    player.heal(3)  # Example: heal 3 health points during sleep
-
-    # Optional: Print a message or effect that happens during sleep
-    type_text("You feel refreshed after a good rest.", colorTrue=color_coding)
-
-
-def get_player_input(split=True):
-    global player
-    move = ""
-    while move == "":
-        move = str(input(">")).strip().lower()
-    if split:
-        return move.split()
-    return move
-
-
-def handle_go_command(direction):
-    global player
-    Move(direction)
-
-
-def handle_get_command(player: PC, *Args):
-    item_name = " ".join(Args)
-    if "items" in ROOMS[player.CURRENTROOM]:
-        for ItemName in ROOMS[player.CURRENTROOM]["items"].keys():
-            if item_name == ItemName:
-                player.inventory_add([ROOMS[player.CURRENTROOM]["items"][ItemName]])
-                del ROOMS[player.CURRENTROOM]["items"][ItemName]
-                type_text(f"%*BLUE*%{item_name}%*RESET*% got!", colorTrue=color_coding)
-                return
-    type_text(f"Can't get {item_name}!", colorTrue=color_coding)
-
-
-def handle_look_command():
-    global player
-    should_return = False
-    if "items" in ROOMS[player.CURRENTROOM]:
-        type_text(
-            f'The items in the room: %*BLUE*%{", ".join(ROOMS[player.CURRENTROOM]["items"].keys())}%*RESET*%.',
-            colorTrue=color_coding,
-        )
-        should_return = True
-    if "containers" in ROOMS[player.CURRENTROOM]:
-        type_text(
-            f"The containers here are: %*RED*%{', '.join(ROOMS[player.CURRENTROOM]['containers'].keys())}%*RESET*%",
-            colorTrue=color_coding,
-        )
-        should_return = True
-    if should_return:
-        return
-    type_text("There is nothing of interest.", colorTrue=color_coding)
-
-
-def handle_use_command(*Args):
-    global player
-    Use(Args)
-
-
-def handle_search_command(player, *Args):
-    Container = " ".join(Args)
-    if "containers" in ROOMS[player.CURRENTROOM]:
-        if Container in ROOMS[player.CURRENTROOM]["containers"] and not all_same_value(
-            ROOMS[player.CURRENTROOM]["containers"][Container].contents, None
-        ):
-            search_container(player, Container)
-        else:
-            type_text(f"You cannot search the {Container}", colorTrue=color_coding)
-
-
-def search_container(player: PC, Container):
-    ContainerName = Container
-    Container = ROOMS[player.CURRENTROOM]["containers"][Container]
-    if isinstance(Container, container):
-        if isinstance(Container.lock, Lock):
-            key = PickKey(Container.lock)
-            Container.Unlock(key, player)
-        type_text(
-            f"You search the{' secret' if Container.secret else ''} %*RED*%{ContainerName}%*RESET*% and find a ",
-            newline=False,
-            colorTrue=color_coding,
-        )
-        for searchitem in Container.contents:
-            if searchitem:
-                if isinstance(searchitem, item):
-                    end_str = (
-                        " and a "
-                        if Container.contents.index(searchitem)
-                        < last_index(Container.contents)
-                        else "\n"
-                    )
-                    type_text(
-                        f"%*BLUE*%{searchitem.name}%*RESET*%{end_str}",
-                        newline=False,
-                        colorTrue=color_coding,
-                    )
-        Container.take_contents(player)
-
-
-def handle_put_command(player: PC, *Args):
-    arguments = " ".join(Args)
-    Arguments = arguments.split(" in ")
-
-    # Ensure we have exactly two parts
-    if len(Arguments) < 2:
-        type_text(
-            "You need to specify an item and where to put it (e.g., 'put book in drawer').",
-            colorTrue=color_coding,
-        )
-        return
-
-    # Strip whitespace
-    Arguments = [arg.strip() for arg in Arguments]
-    item_name = Arguments[0]
-    container_name = Arguments[1]
-
-    # Check if item is in inventory
-    if item_name not in [item.name for item in player.inventory]:
-        type_text(
-            f"You don't have {item_name} in your inventory.", colorTrue=color_coding
-        )
-        return
-
-    # Retrieve item and container
-    PutItem = player.inventory[
-        [item.name for item in player.inventory].index(item_name)
-    ]
-    if "containers" in ROOMS[player.CURRENTROOM]:
-        put_in_container(player, PutItem, container_name)
-    else:
-        type_text(
-            f"You cannot put the {PutItem.name} in the {container_name}",
-            colorTrue=color_coding,
-        )
-
-
-def put_in_container(player: PC, PutItem=None, container=None):
-    player.inventory.remove(PutItem.name)
-    if not ROOMS[player.CURRENTROOM]["containers"][container].contents:
-        ROOMS[player.CURRENTROOM]["containers"][container].contents = []
-    if not isinstance(
-        ROOMS[player.CURRENTROOM]["containers"][container].contents, list
-    ):
-        ROOMS[player.CURRENTROOM]["containers"][container].contents = [
-            ROOMS[player.CURRENTROOM]["containers"][container].contents
-        ]
-    ROOMS[player.CURRENTROOM]["containers"][container].contents += [PutItem]
-    type_text(
-        f"You put you're %*BLUE*%{PutItem.name}%*RESET*% into the %*RED*%{container}%*RESET*%",
-        colorTrue=color_coding,
-    )
-
-
-def handle_get_quest_command(questnum):
-    global player
-    if "quests" in ROOMS[player.CURRENTROOM]:
-        if questnum in ROOMS[player.CURRENTROOM]["quests"]:
-            quest_manager.add_quest(ROOMS[player.CURRENTROOM]["quests"][questnum])
-            quest_manager.start_quest(ROOMS[player.CURRENTROOM]["quests"][questnum])
-            del ROOMS[player.CURRENTROOM]["quests"][questnum]
-
-
-def PrintMap():
-    global player
-    type_text(ShowMap())
-
-
-# Define handling functions for different types of enemies
-def handle_hungry_bear(player: PC, enemy: creature):
-    enemy_reacting = True
-    if "potion" in player.inventory:
-        if ask_for_consent("Do you want to throw your potion at the bear"):
-            enemy_reacting = False
-            del player.inventory[player.inventory.index("potion")]
-            type_text(
-                f"You throw the potion at the bear and it explodes into a puff of magic smoke that stuns the bear!",
-                colorTrue=color_coding,
-            )
-    if enemy_reacting:
-        return [enemy, enemy_reacting]
-
-
-def handle_grumpy_pig(player: PC, enemy: creature):
-    enemy_reacting = True
-    if "saddle" in player.inventory and "pig-rod" in player.inventory:
-        if ask_for_consent("Do you want to use your saddle and pig-rod on the pig"):
-            enemy_reacting = False
-            type_text(
-                f"You throw a saddle onto the pig and leap on steering it about with a pig fishing rod!",
-                colorTrue=color_coding,
-            )
-            del ROOMS[player.CURRENTROOM]["creatures stats"]
-            del player.inventory[player.inventory.index("saddle")]
-            del player.inventory[player.inventory.index("pig-rod")]
-            player.inventory_add(item["pig-steed"])
-            player.xp += 20
-    if "torch" in player.inventory:
-        if ask_for_consent("Do you want to use your torch to scare the pig away"):
-            enemy_reacting = False
-            type_text(
-                f"You wave your torch at the pig and it runs away through a tiny open window.",
-                colorTrue=color_coding,
-            )
-            del ROOMS[player.CURRENTROOM]["creatures stats"][
-                ROOMS[player.CURRENTROOM]["creatures stats"].index(enemy)
-            ]
-            player.xp += 5
-    if "rations" in player.inventory:
-        if ask_for_consent("Do you want to throw your ration at the pig"):
-            enemy_reacting = False
-            type_text(
-                f"You quickly throw rations at the pig. It still doesn't look happy though.",
-                colorTrue=color_coding,
-            )
-            del player.inventory[player.inventory.index("rations")]
-            player.xp += 15
-
-    if enemy_reacting:
-        return [enemy, enemy_reacting]
-
-
-def handle_greedy_goblin(player: PC, enemy: creature):
-    enemy_reacting = True
-    if player.money >= 15:
-        if ask_for_consent("Do you want to pay the goblin to not attack you"):
-            enemy_reacting = False
-            type_text(
-                f"You pay the {enemy.name} to not attack you for now, but he says you should run.",
-                colorTrue=color_coding,
-            )
-            player.money -= 15
-            enemy.dropped_items[1].value += 15
-    if enemy_reacting:
-        return [enemy, enemy_reacting]
-
-
-commands = {
-    "go": handle_go_command,
-    "get quest": handle_get_quest_command,
-    "get": handle_get_command,
-    "look": handle_look_command,
-    "use": handle_use_command,
-    "search": handle_search_command,
-    "quit": quit,
-    "help": showInstructions,
-    "hint": showHint,
-    "sleep": handle_sleep_command,
-    "put": handle_put_command,
-    "map": PrintMap,
-    "examine": Examine,
-}
-
-
-def quit():
-    exit()
-
-
-guards = [
-    Guard(
-        name="Guard",
-        hp=10,
-        atpw=4,
-        description="A 5'8\" human guard who looks like he doesn't belong here.",
-        flavor_text="A human guard spots you and says: 'You shouldn't be here.'",
-        type=creature_type("humanoid", "human"),
-        current_room="Bedroom",
-        patrol_route=["Bedroom", "Office", "Tower Bottom", "Landing", "Bedroom"],
-        patrol_type="normal",
-    ),
-    Guard(
-        name="Wolf",
-        hp=10,
-        atpw=4,
-        description="A large wolf with blood covering its face.",
-        flavor_text="A wolf spots you and growls.",
-        type=creature_type("beast", "wolf"),
-        current_room="Balcony",
-        patrol_type="random",
-        frendly_text="The wolf nuzzles you",
-    ),
-]
-
-
-def handle_wolf(player: PC, wolf: Guard):
-    enemy_reacting = True
-    if "rations" in player.inventory:
-        if ask_for_consent("Do you want to give your ration to the wolf"):
-            enemy_reacting = False
-            type_text(
-                "You quickly give your rations to the wolf. It looks happy, walks up to you, and nuzzles you.",
-                colorTrue=color_coding,
-            )
-            player.inventory.remove("rations")
-            wolf.patrol_type = "follow"
-            wolf.frendly = True
-            return wolf
-    if enemy_reacting:
-        return [wolf, enemy_reacting]
-
-
-def handle_guard_action(guard):
-    # Dynamically build the function name
-    function_name = f"handle_{guard.name.lower()}"
-
-    # Use globals() to retrieve the function by name
-    function_to_call = globals().get(function_name)
-
-    if function_to_call:
-        # Call the found function
-        guard = function_to_call(player, guard)
-        return [True, guard]  # Function was found and called
-    else:
-        return [False, [guard, True]]  # Function was not found
-
-
-def initializer():
-    global color_coding, player, CHARACTERSLIST
-    df = pd.DataFrame(CHARACTERSLIST)
-    Standord_Player = loop_til_valid_input(
-        "Do you want to use a premade character?", "you didn't answer Y or N.", Y_N
-    ).value
-
-    if Standord_Player:
-        while True:
-            type_text("Who do you want to play as?", colorTrue=False)
-            print(df)
-            selected_character = loop_til_valid_input(
-                "Who do you want to play as? (please select the number to the left of there stats)",
-                "That wasn't one of the characters. Please choose one.",
-                int,
-            )
-            lstIndex = last_index(CHARACTERSLIST)
-            if selected_character <= lstIndex:
-                character_info = CHARACTERSLIST[selected_character]
-                name = character_info["name"]
-                age = character_info["age"]
-                height = character_info["height"]
-                weight = character_info["weight(LBs)"]
-                break
-            else:
-                type_text(colorTrue=False)
-
-    else:
-        type_text(
-            "You will now have to enter a name, age, height, and weight. Please enter the height in this format: _ft _. These will be used throughout the game.",
-            colorTrue=False,
-        )
-
-        name = loop_til_valid_input(
-            "What is your name?",
-            "You didn't enter a string. Please enter a string.",
-            str,
-        )
-        age = loop_til_valid_input(
-            "What is your age (in whole years)?",
-            "You didn't enter an integer. Please enter an integer.",
-            int,
-        )
-        height = loop_til_valid_input(
-            "What is your height?",
-            "You didn't enter your height in the correct format. Please enter your height in the correct format.",
-            Height,
-        )
-        weight = loop_til_valid_input(
-            "What is your weight (in lbs)?",
-            "You didn't enter an integer. Please enter an integer.",
-            int,
-        )
-
-    color_coding = loop_til_valid_input(
-        "Do you want color coding (Y/N)?", "you didn't answer Y or N.", Y_N
-    ).value
-
-    background_name = []
-    background_skills = []
-
-    while True:
-        type_text("")  # Prints an empty line
-        type_text("0. Random")
-
-        # Display each background with its skills formatted correctly.
-        for idx, (background_name, background_skills) in enumerate(BACKGROUNDS.items()):
-            formatted_skills = ", ".join(background_skills)
-            type_text(f"{idx + 1}. {background_name} - {formatted_skills}")
-
-        # Prompt the user to pick a background by number.
-        background = loop_til_valid_input(
-            "What background do you want? (please select the number to the left of them)",
-            "You didn't pick one",
-            int,
-        )
-
-        length = len(BACKGROUNDS)
-        if 1 <= background <= length:
-            # Get the background name and skills based on user choice.
-            background_name = list(BACKGROUNDS.keys())[background - 1]
-            background_skills = BACKGROUNDS[background_name]
-            break
-        elif background == 0:
-            # Randomly select a background and get its associated skills.
-            background_name = choice(list(BACKGROUNDS.keys()))
-            background_skills = BACKGROUNDS[background_name]
-            break
-        else:
-            type_text("You didn't pick one")
-
-    # start the player in the Hall and sets up everything else
-    player = PC(
-        name,
-        age,
-        background,
-        1,
-        "Soldier",
-        height,
-        weight,
-        CURRENTROOM="Hall",
-        Skills=background_skills,
-    )
-
-
-def main():
-    global player, color_coding
-
-    # this is the initializer
-    initializer()
-
-    # shows the instructions
-    start()
-
-    # loop forever while the player wants to play
-    while True:
-        command()
-
-        if "random_events" in ROOMS[player.CURRENTROOM]:
-            for event in ROOMS[player.CURRENTROOM]["random_events"]:
-                if isinstance(event, RandomEvent):
-                    event.check_and_trigger(player)
-
-        # Move guards
-        for guard in guards:
-            if isinstance(guard, Guard):
-                guard.move(ROOMS, player)
-
-        good_guys = []
-        bad_guys = []
-
-        # Check for detection
-        for guard in guards:
-            if isinstance(guard, Guard):
-                if guard.hp > 0:
-                    if guard.check_detection(player.CURRENTROOM):
-                        guard_handled = handle_guard_action(guard)
-                        if not isinstance(guard_handled, list):
-                            guard_handled = [guard_handled]
-
-                        # Get is_reacting from guard_handled
-                        is_reacting = (
-                            guard_handled[1][1]
-                            if isinstance(guard_handled[1], list)
-                            else True
-                        )
-
-                        # Only update guard if the guard is reacting
-                        if is_reacting:
-                            if guard.frendly:
-                                good_guys.append(guard)
-                            else:
-                                bad_guys.append(guard)
-
-                        if guard_handled[0]:
-                            guards[guards.index(guard)] = (
-                                guard_handled[1][0]
-                                if isinstance(guard_handled[1], list)
-                                else guard_handled[1]
-                            )
-
-        # Handle creatures in the current room
-        if "creatures stats" in ROOMS[player.CURRENTROOM]:
-            is_reactings = []
-            enemies = ROOMS[player.CURRENTROOM]["creatures stats"]
-            if not isinstance(enemies, list):
-                enemies = [
-                    enemies
-                ]  # Ensure enemies is a list even if there's only one creature
-
-            for enemy in enemies:
-                if isinstance(enemy, creature):
-                    if enemy.hp > 0:
-                        enemy.type_text_flavor_text()
-                        if ask_for_consent(f"Do you want to examine the {enemy.name}"):
-                            enemy.type_text_description()
-
-                        # Handle specific creatures
-                        if enemy.name == "hungry bear":
-                            enemy_REF = handle_hungry_bear(player, enemy)
-                        elif enemy.name == "grumpy pig":
-                            enemy_REF = handle_grumpy_pig(player, enemy)
-                        elif enemy.name == "greedy goblin":
-                            enemy_REF = handle_greedy_goblin(player, enemy)
-                        else:
-                            enemy_REF = enemy
-
-                        if isinstance(enemy_REF, list):
-                            is_reacting = enemy_REF[1]
-                            enemy_REF = enemy_REF[0]
-                            is_reactings.append(is_reacting)
-
-                        enemies[enemies.index(enemy)] = enemy_REF
-
-                        # Add to good or bad lists if reacting
-                        if is_reacting:
-                            if enemy_REF.frendly:
-                                good_guys.append(enemy_REF)
-                            else:
-                                bad_guys.append(enemy_REF)
-
-            if all_same_value(enemies, False):
-                del ROOMS[player.CURRENTROOM]["creatures stats"]
-            else:
-                ROOMS[player.CURRENTROOM]["creatures stats"] = enemies
-
-        # Execute battle with separated good and bad guys
-        if bad_guys:
-            good_guys, bad_guys = battle(player, good_guys, bad_guys, player.LASTROOM)
-
-        # Handle NPC interactions
-        if "NPCs" in ROOMS[player.CURRENTROOM]:
-            for npcname, npcstats in ROOMS[player.CURRENTROOM]["NPCs"].items():
-                if (
-                    ask_for_consent("Do you want to interact with this NPC")
-                    or npcstats.aggressive
-                ):
-                    npcstats.interact()
-                    if npcstats.aggressive:
-                        ROOMS[player.CURRENTROOM]["NPCs"][npcname] = battle(
-                            player, [], [npcstats], player.LASTROOM
-                        )[1]
-
-        player.special_ability.Tick()
-        quest_manager.update_objective(f"Kill {GameState['Enemies killed']} creatures")
-        for Item in GameState["collected items"]:
-            if isinstance(Item, item):
-                quest_manager.update_objective(f"Collect {Item.name}")
-
-
-if __name__ == "__main__":
-    main()