buggymonsterpaste

#------ Import Statements-------#
import sys


#--------- Game Classes ------- #
class Player(object):
    inventory = {}

    def __init__(self, name, race, sex, current_location):
        self.name = name
        self.race = race
        self.sex = sex
        self.current_location = current_location

        self.health = 0
        self.max_hp = 0
        self.attack = 0
        self.base_attack = 0
        self.armour = 0
        self.xp = 0
        self.level = 0
        self.status = "Alive"
        self.base_xp = 0

    def level_up(self):
        """
        increases stats to next level.
        currently this assumes that levels scale linearly to infinity.
        """
        new_level_health = 50
        new_level_hp = 50
        new_level_attack = 10
        new_level_base_attack = 10
        new_level_armour = 5

        self.health += new_level_health
        self.max_hp += new_level_hp
        self.attack += new_level_attack
        self.base_attack += new_level_base_attack
        self.armour += new_level_armour
        self.level += 1

    @staticmethod
    def player_status():
        print "Your stats are:\nHealth: %r, Armour: %r, Attack: %r, Level: %r, Experience: %r" % \
              (player.health, player.armour, player.attack, player.level, player.xp)

    @staticmethod
    def player_location():
        print "You are in %r" % player.current_location

    def attack(self, monster):
        monster.health -= (self.attack - monster.armour)
        if monster.health <= 0:
            print "You beat the monster!"
            player.xp += monster.xp
            prompt_levelup()
            return False


class Key(object):
    def __init__(self, name, room, match):
        self.name = name
        self.room = room
        self.match = match


class Door(object):
    def __init__(self, name, number, locked, match):
        self.name = name
        self.number = number
        self.locked = locked
        self.match = match


class Room(object):
    def __init__(self, name, number, victory):
        self.self = self
        self.number = number
        self.name = name
        self.victory = victory


class Hall(object):
    def __init__(self, name, number=0, victory=None):
        self.self = self
        self.number = number
        self.name = name
        self.victory = victory


class Monster(object):
    pass


class Wolf(Monster):
    def __init__(self, name, room):
        self.self = self
        self.room = room
        self.name = name

        self.health = 0
        self.max_hp = 0
        self.attack = 0
        self.base_attack = 0
        self.armour = 0
        self.xp = 0
        self.level = 0
        self.status = "Alive"

    def level_up(self):
        new_level_health = 20
        new_level_hp = 20
        new_level_attack = 5
        new_level_base_attack = 5
        new_level_armour = 0
        new_level_xp = 10

        self.health += new_level_health
        self.max_hp += new_level_hp
        self.attack += new_level_attack
        self.base_attack += new_level_base_attack
        self.armour += new_level_armour
        self.xp += new_level_xp
        self.level += 1

    def attack(self):
        player.health -= (self.attack - player.armour)
        if player.health <= 0:
            print "You have died! Better luck next time!"
            sys.exit()


#----- Various static Values ------#
hallway = Hall("Hallway")

list_of_keys = [Key("Key", "Room 1", 10001),
                Key("Key", "Room 2", 20002),
                Key("Key", "Room 3", 30003)]

list_of_rooms = [Room("Room 1", 1, False),
                 Room("Room 2", 2, False),
                 Room("Room 3", 3, False),
                 Room("Room 4", 4, False)]

list_of_doors = [Door("Door 1", 1, False, None),
                 Door("Door 2", 2, True, 10001),
                 Door("Door 3", 3, True, 20002),
                 Door("Door 4", 4, True, 30003)]

list_of_monsters = [Wolf("wolf", "Room 2"),
                    Wolf("wolf", "Room 3"),
                    Wolf("wolf", "Room 4")]

player = Player("NoName", "Male", "Human", None)
player.level_up()

# Available actions for the loops
list_of_actions_available_room = ["grab", "leave", "stats", "location", "keys", "help"]
list_of_actions_available_true_main = ["enter", "exit", "stats", "location", "help"]


#----- Opening Setup------#
def opening_setup():
    """This opening setup gives us a player name and also provides the opening text"""
    name = raw_input("Whats your name?")
    player.name = name
    player.current_location = "Hallway"
    generate_rooms_dict()
    generate_keys_dict()
    player.player_location()
    # The opening text to give a little story(will change later once we have some actual story)
    opening_text = "Hello and welcome to your adventure %r!\n" \
                   "You must have had one heck of a night last night" \
                   " because you don't know where you are or how you got here!\n" \
                   "Never fear, I'm sure you can figure it out!" % player.name
    print opening_text


#------- Room Populating function ----#
def generate_rooms_dict():
    room_dict = {}
    for room in list_of_rooms:
        room_dict[room] = room.name
    return room_dict


def generate_doors_dict():
    room_dict = generate_rooms_dict()
    dict_of_doors_in_room = {}
    if player.current_location == "Hallway":
        for door in list_of_doors:
            dict_of_doors_in_room[door] = door.name
        return dict_of_doors_in_room
    else:
        room = player.current_location
        for i in room_dict:
            if i.name == room:
                room_number = i.number
                for door in list_of_doors:
                    if room_number == door.number:
                        door_name = door.name
                        dict_of_doors_in_room[door] = door_name
                        return dict_of_doors_in_room


def generate_keys_dict():
    dict_of_keys = {}
    for key in list_of_keys:
        dict_of_keys[key] = key.name
    return dict_of_keys


def generate_room_keys_dict():
    dict_of_keys = generate_keys_dict()
    dict_of_room_keys = {}
    for key in dict_of_keys:
        if key.room == player.current_location:
            dict_of_room_keys[key] = key.name
            return dict_of_room_keys


def generate_monsters_dict():
    dict_of_monsters = {}
    for monster in list_of_monsters:
        dict_of_monsters[monster] = monster.name
    return dict_of_monsters


def populate_room_monster_dict():
    dict_of_room_monsters = {}
    dict_of_monsters = generate_monsters_dict()
    for monster in dict_of_monsters:
        if monster.room == player.current_location:
            dict_of_room_monsters[monster] = monster.name
    return dict_of_room_monsters


# ------- Status Functions ------#
# These functions are there to display the info about the room/player on request
def visible_keys():
    dict_of_room_keys = generate_keys_dict()
    count = 0
    for key in dict_of_room_keys:
        if key.room == player.current_location:
            count += 1
    if count == 0:
        print "There are no keys"
    else:
        print "You can see %r keys." % count


def visible_doors():
    if player.current_location == "Hallway":
        count = len(list_of_doors)
        print "You can see %r doors numbered accordingly." % count
    else:
        print "You can see the door you came through"


def door_status(door):
        if door.locked:
            print "Door number %r is locked!" % door.number
        elif not door.locked:
            print "Door number %r is unlocked!" % door.number


def visible_monsters():
    dict_of_room_monsters = populate_room_monster_dict()
    for monster in dict_of_room_monsters:
        print "You can see a %r!" % monster.name


#-------- Player Functions --------#
def xp_check():
    """Checks player xp and necessary xp and calls the level up function if applicable"""
    global player
    xp_needed = player.level * 10 + 15
    if player.xp >= xp_needed:
        player.level_up()
        player.xp -= xp_needed
        print "You have leveled up!"
    else:
        xp_needed = player.level * 10 + 15
        print "Not enough xp to level up!", "You need %r" % xp_needed, "You have %r" % player.xp


def prompt_levelup():
    check_levelup = raw_input("Would you like to see if you leveled up?")
    if check_levelup == "yes":
        xp_check()


#------Help function ------#

def help_info():
    """Provides a information about the available prompts should the player need it"""
    help_info_dict = {"enter": "This command will move your character into the next room.",
                      "exit": "This command exits the game! Careful!",
                      "stats": "This command provides you with info about your character.",
                      "grab": "This command lets you grab any object. Simply say which one.",
                      "leave": "This command lets you leave through any unlocked door",
                      "doors": "This command shows you what doors are visible.",
                      "keys": "This command show you any keys you can see.",
                      "location": "This command tells you your current location.",
                      "fight": "This command lets you fight the monster"
                      }
    while True:
        info_choice = raw_input("What would you like to know more about?").lower()
        try:
            print help_info_dict[info_choice]
        except KeyError:
            if info_choice == "back":
                return False
            else:
                print "That's not a valid command!"


#------- Actions Functions --------#
def take_action(action):
    """This function takes the input of the engine for
    action and completes that action
    Note: This function is only accessible inside the room loop
    """
    room_dict = generate_rooms_dict()
    dict_of_room_keys = generate_room_keys_dict()
    if action == "grab":
        grab_object = raw_input("Grab what?")
        if grab_object == "key":
            for i in dict_of_room_keys:
                if grab_object.lower() == i.name.lower():
                    player.inventory[i] = i.name
                    print "You grabbed it!"
                    del dict_of_room_keys[i]
                    break
        return True
    elif action == "leave":
        for i in room_dict:
            if i.name == player.current_location:
                current_room = i
                if not current_room.victory:
                    room_xp = 25
                    player.xp += room_xp
                    print "Congrats you beat this room!"
                    print "You earned %r xp!" % room_xp
                    print "You exit the room!"
                    prompt_levelup()
                    current_room.victory = True
                    player.current_location = "Hallway"
                    return False
                else:
                    print "You exit the room!"
                    current_room.victory = True
                    player.current_location = "Hallway"
                    return False
    elif action == "stats":
        player.player_status()
        return True
    elif action == "help":
        help_info()
        return True
    elif action == "fight":
        opponent_engine()
        return True
    elif action == "doors":
        visible_doors()
        return True
    elif action == "location":
        player.player_location()
        return True
    return True


def battle_engine(monster):
    while True:
        Wolf.attack(monster)
        Player.attack(player, monster)


def opponent_engine():
    dict_of_room_monsters = populate_room_monster_dict()
    for monster in dict_of_room_monsters:
        battle_engine(monster)
    return False


def game_engine():
    """Game_engine is should maybe be called room_engine
    as its only function is to act as a go between for the main loop
    """
    generate_doors_dict()
    visible_keys()
    while True:
        print "Your available actions while in the room are %s" % list_of_actions_available_room
        action = raw_input("What do you want to do?")
        result = take_action(action)
        if not result:
            return False


#------ Main Loops ---------- #
def hall_room_transition():
    room_choice = raw_input("Which room would you like to enter?(please enter a number)")
    dict_of_doors = generate_doors_dict()
    room_dict = generate_rooms_dict()
    for i in dict_of_doors:
        if i.number == int(room_choice):
            door_choice = i
            door_number = i.number
            if door_choice.locked:
                print "The door seems to be locked. Maybe you need to use a key!"
                use_key = raw_input("Use a key? (yes or no)")
                if use_key.lower() == "yes":
                    for x in player.inventory:
                        if x.match == door_choice.match:
                            door_choice.locked = False
                            print "You used the key!"
                            door_status(door_choice)
                            enter_through_door = raw_input("Enter the room?")
                            if enter_through_door == "yes":
                                print "You entered the room!"
                                for room in room_dict:
                                    if room.number == door_number:
                                        player.current_location = room.name
                                        break
                        else:
                            print "There are no matching keys in your inventory!"
                            break
                elif use_key.lower() == "no":
                    print "OK, but the door is still locked!"
            elif not door_choice.locked:
                print "You entered the room!"
                for room in room_dict:
                    if room.number == door_number:
                        player.current_location = room.name


def action_main():
    """This main function is the secondary loop that is operational while the player is in the room
    """
    while True:
        if player.current_location == "Hallway":
            hall_room_transition()
        else:
            generate_room_keys_dict()
            game_engine()
            return False


def upper_main():
    """This loop should never exit.
    Exception: if the player specifies to exit
    """
    opening_setup()
    while True:
        raw_input("Press <Enter> to continue!")
        print "Your available actions while in the hallway are %s" % list_of_actions_available_true_main
        player.current_location = "Hallway"
        take_action_main = raw_input("What do you want to do?")
        if take_action_main == "enter":
            action_main()
        elif take_action_main == "exit":
            sys.exit()
        elif take_action_main == "stats":
            player.player_status()
        elif take_action_main == "help":
            help_info()
        elif take_action_main == "location":
            player.player_location()
        else:
            print "That's not a valid command!"


#------- Game Operation --------#
upper_main()