game_code_advanced.py

# define rooms and items


# List of doors
door_a = {
    "name": "door a",
    "type": "door",
}

door_b = {
    "name": "door b",
    "type": "door",
}

door_c = {
    "name": "door c",
    "type": "door",
}

door_d = {
    "name": "door d",
    "type": "door",
}

# List of keys
key_a = {
    "name": "key for door a",
    "type": "key",
    "target": door_a,
}

key_b = {
    "name": "key for door b",
    "type": "key",
    "target": door_b,
}

key_c = {
    "name": "key for door c",
    "type": "key",
    "target": door_c,
}

key_d = {
    "name": "key for door d",
    "type": "key",
    "target": door_d,
}


# List of rooms
game_room = {
    "name": "game room",
    "type": "room",
}

bedroom1 = {
    "name": "bedroom 1",
    "type": "room",
}

bedroom2 = {
    "name": "bedroom 2",
    "type": "room",
}

living_room = {
    "name": "living room",
    "type": "room",
}

# List of items in game room
couch = {
    "name": "couch",
    "type": "furniture",
}

piano = {
    "name": "piano",
    "type": "furniture",
}

# List of items in bedroom 1
queen_bed = {
    "name": "queen bed",
    "type": "furniture",
}

# List of items in bedroom 2
double_bed = {
    "name": "double bed",
    "type": "furniture",
}

dresser = {
    "name": "dresser",
    "type": "furniture",
}

# List of items in living room
dinning_table = {
    "name": "dinning table",
    "type": "furniture",
}


outside = {
  "name": "outside",
}

# List of questions:
question1 = {
    "capital" : "Bandar Seri Begawan",
    "name" : "What is the Capital of Brunei?\n",
}
question2 = {
    "capital" : "Jakarta",
    "name" : "What is the Capital of Indonesia?\n",
}
question3 = {
    "capital" : "Islamabad",
    "name" : "What is the Capital of Pakistan?\n",
}
question4 = {
    "capital" : "Bishkek",
    "name" : "What is the Capital of  Kyrgyzstan?\n"
}

all_rooms = [game_room, bedroom1, bedroom2, living_room, outside]


all_doors = [door_a,door_b,door_c,door_d]

# define which items/rooms are related

object_relations = {
    "game room": [couch, piano, door_a],
    "bedroom 1": [queen_bed, door_b, door_c],
    "bedroom 2": [double_bed, dresser, door_b],
    "living room": [dinning_table, door_c, door_d],
    "piano": [key_a],
    "queen bed": [key_b],
    "double bed": [key_c],
    "dresser": [key_d],
    "outside": [door_d],
    "door a": [game_room, bedroom1],
    "door b": [bedroom1, bedroom2],
    "door c": [bedroom1, living_room],
    "door d": [living_room, outside]
}

# define game state. Do not directly change this dict.
# Instead, when a new game starts, make a copy of this
# dict and use the copy to store gameplay state. This
# way you can replay the game multiple times.

INIT_GAME_STATE = {
    "current_room": game_room,
    "keys_collected": [],
    "target_room": outside,
    "questions" : [question1, question2, question3, question4]
}

from threading import Thread
import time
import sys
import random

def timeout_question():
    for remaining in range(10, 0, -1):
        sys.stdout.write("\r")
        sys.stdout.write("{:2d} seconds remaining.".format(remaining))
        sys.stdout.flush()
        time.sleep(1)
    sys.stdout.write("\rYour time is over!\n")
    t2.stop()

def make_question(next_room, current_room, question):
    answer = input(question["name"])
    if answer == question["capital"]:
        play_room(next_room)
    else:
        game_state["keys_collected"] = []
        print("You lost the last key!")
        play_room(current_room)

def countdown(next_room, current_room, question):

    t1 = Thread(target=timeout_question,args=())
    t2 = Thread(target=make_question ,args=(next_room, current_room, question))
    t1.start()
    t2.start()
    t1.join()
    t2.join()


def linebreak():
    """
    Print a line break
    """
    print("\n\n")

def start_game():
    """
    Start the game
    """
    print("You wake up on a couch and find yourself in a strange house with no windows which you have never been to before. You don't remember why you are here and what had happened before. You feel some unknown danger is approaching and you must get out of the house, NOW!")
    play_room(game_state["current_room"])

def play_room(room):
    """
    Play a room. First check if the room being played is the target room.
    If it is, the game will end with success. Otherwise, let player either
    explore (list all items in this room) or examine an item found here.
    """


    game_state["current_room"] = room
    if(game_state["current_room"] == game_state["target_room"]):
        print("Congrats! You escaped the room!")
    else:
        print("You are now in " + room['name'])
        if len(game_state["keys_collected"]):
            for row_key in game_state["keys_collected"]:
                print("you have the following key: " + str(row_key["name"]))
        else:
            print("you don't have any key yet!")
        intended_action = input("What would you like to do? Type 'explore' or 'examine'?\n").strip()
        if intended_action == "explore":
            explore_room(room)
            play_room(room)
        elif intended_action == "examine":
            examine_item(input("What would you like to examine?\n").strip())
        else:
            print("Not sure what you mean. Type 'explore' or 'examine'.\n")
            play_room(room)
        linebreak()

def explore_room(room):
    """
    Explore a room. List all items belonging to this room.
    """
    items = [i["name"] for i in object_relations[room["name"]]]
    print("You explore the room. This is " + room["name"] + ". You find " + ", ".join(items))

def get_next_room_of_door(door, current_room):
    """
    From object_relations, find the two rooms connected to the given door.
    Return the room that is not the current_room.
    """
    connected_rooms = object_relations[door["name"]]
    for room in connected_rooms:
        if(not current_room == room):
            return room

def examine_item(item_name):
    """
    Examine an item which can be a door or furniture.
    First make sure the intended item belongs to the current room.
    Then check if the item is a door. Tell player if key hasn't been
    collected yet. Otherwise ask player if they want to go to the next
    room. If the item is not a door, then check if it contains keys.
    Collect the key if found and update the game state. At the end,
    play either the current or the next room depending on the game state
    to keep playing.
    """
    current_room = game_state["current_room"]
    next_room = ""
    output = None

    for item in object_relations[current_room["name"]]:
        if(item["name"] == item_name):
            output = "You examine " + item_name + ". "
            if(item["type"] == "door"):
                have_key = False
                for key in game_state["keys_collected"]:
                    if(key["target"] == item):
                        have_key = True
                if(have_key):
                    output = "You unlock it with a key you have."
                    next_room = get_next_room_of_door(item, current_room)
                else:
                    output += "It is locked but you don't have the key."
            else:
                if(item["name"] in object_relations and len(object_relations[item["name"]])>0):
                    item_found = object_relations[item["name"]][0]
                    game_state["keys_collected"].append(item_found)
                    output += "You find " + str(item_found["name"]) + "."
                else:
                    output += "There isn't anything interesting about it."
            print(output)
            break

    if(output is None):
        print("The item you requested is not found in the current room.")

    if(next_room and input("Do you want to go to the next room? 'yes' or 'no'\n").strip() == 'yes'):
        countdown(next_room, current_room, random.choice(game_state["questions"]))
        #make_question(next_room, current_room, random.choice(game_state["questions"]))
        play_room(next_room)
    else:
        play_room(current_room)


game_state = INIT_GAME_STATE.copy()

start_game()