A Text Adventure Game in Python

Worlds made of words

Before games had graphics, they had words. You'd read a description — "You are in a damp cave. Passages lead north and east." — and type what you wanted to do: go north, take torch, look. These text adventures are still wonderful to build, because the entire game is logic you can read and change. And they teach the heart of game programming: a world, a loop, and state that changes over time.

In this lesson you'll build a complete, playable adventure. You'll need to be comfortable with dictionaries and while loops — those two ideas do almost all the heavy lifting.

The big idea: data plus a loop

Every text adventure has two parts:

1. The world data — a description of every room and how they connect. This is just information, so we store it in a dictionary.
2. The game loop — a while loop that, each turn, shows where you are, reads what you type, and updates the game.

Keeping the world (data) separate from the engine (loop) is the design secret. Add a room and the loop never changes.

Describing a room

Let's store each room as a dictionary holding a description and its exits. The exits are themselves a small dictionary mapping a direction to the name of the room it leads to:

hall = {
    "description": "a grand entrance hall with a dusty chandelier",
    "exits": {"north": "library", "east": "kitchen"},
}

Reading hall["exits"]["north"] gives "library" — the room you reach by going north. This nested structure is exactly what we need to move around.

The whole map

Now we collect every room into one big dictionary, keyed by room name:

rooms = {
    "hall": {
        "description": "a grand entrance hall with a dusty chandelier",
        "exits": {"north": "library", "east": "kitchen"},
    },
    "library": {
        "description": "a quiet library lined with old books",
        "exits": {"south": "hall"},
        "item": "key",
    },
    "kitchen": {
        "description": "a cold kitchen; a locked door leads east",
        "exits": {"west": "hall", "east": "treasure"},
    },
    "treasure": {
        "description": "a glittering treasure vault — you win!",
        "exits": {},
    },
}

Notice the library has an extra "item": "key". We'll let the player pick that up. The treasure room has no exits — reaching it is the goal.

Tracking the player

The player's situation is held in plain variables: where they are, and what they're carrying.

current = "hall"        # the room the player is in
inventory = []          # things the player has picked up

To move, we change current. To collect an item, we append to inventory. That's all "state" really is — variables that change as the game unfolds.

Reading and understanding commands

Each turn we read a command and tidy it up so the game is forgiving about capitals and spacing:

command = input("> ").strip().lower()
words = command.split()      # "go north" -> ["go", "north"]

.strip().lower() turns " GO North " into "go north", and .split() breaks it into a list of words. Now we can check words[0] (the action) and words[1] (the direction or item).

Moving safely

When the player types go north, we must check that direction exists before moving — otherwise we'd crash:

exits = rooms[current]["exits"]
direction = words[1]

if direction in exits:
    current = exits[direction]      # move!
else:
    print("You can't go that way.")

if direction in exits: is the key safety check. Only valid directions move the player; anything else gets a polite refusal.

Worked example: the complete game

Here's the whole thing — map, state, and game loop — in one runnable program. Read the comments to see how each piece connects.

rooms = {
    "hall": {
        "description": "a grand entrance hall with a dusty chandelier",
        "exits": {"north": "library", "east": "kitchen"},
    },
    "library": {
        "description": "a quiet library lined with old books",
        "exits": {"south": "hall"},
        "item": "key",
    },
    "kitchen": {
        "description": "a cold kitchen; a locked door leads east",
        "exits": {"west": "hall", "east": "treasure"},
    },
    "treasure": {
        "description": "a glittering treasure vault",
        "exits": {},
    },
}

def play():
    current = "hall"
    inventory = []
    print("=== The Locked Vault ===")
    print("Commands: go <direction>, take, look, quit\n")

    while True:
        room = rooms[current]
        print(f"\nYou are in {room['description']}.")

        # Win check: reaching the treasure ends the game
        if current == "treasure":
            print("You found the treasure. You win!")
            break

        # Show what you can do
        print("Exits:", ", ".join(room["exits"]) or "none")
        if "item" in room and room["item"] not in inventory:
            print(f"You see a {room['item']} here.")

        command = input("> ").strip().lower()
        words = command.split()
        if not words:
            continue
        action = words[0]

        if action == "quit":
            print("Thanks for playing!")
            break

        elif action == "look":
            continue   # the loop will redraw the room

        elif action == "take":
            if "item" in room and room["item"] not in inventory:
                inventory.append(room["item"])
                print(f"You picked up the {room['item']}.")
            else:
                print("There's nothing to take.")

        elif action == "go" and len(words) > 1:
            direction = words[1]
            exits = room["exits"]
            if direction not in exits:
                print("You can't go that way.")
            # The kitchen's east door needs the key
            elif current == "kitchen" and direction == "east" \
                    and "key" not in inventory:
                print("The door is locked. You need a key.")
            else:
                current = exits[direction]

        else:
            print("I don't understand that. Try: go north, take, quit.")

play()

How the pieces work together:

1. The map is pure data at the top. The engine below never hard-codes a room layout, so you can redesign the world freely.
2. The loop redraws the room each turn, then checks the win condition (current == "treasure") and breaks if met.
3. ", ".join(room["exits"]) lists the available directions neatly; or "none" handles a room with no exits.
4. The take action moves an item from the room into inventory, but only if it's there and not already held.
5. The go action has a twist: the kitchen's east door is locked until "key" is in the inventory. The player must visit the library, take the key, then return — a real puzzle! The backslash \ just continues that long elif condition onto the next line.

Play it: from the hall, go north to the library, take the key, go south, east to the kitchen, then east to win.

Try it yourself

Expand your adventure:

• Add a room. Give the library a hidden "east" exit to a new "tower" room. You only edit the rooms dictionary — the engine needs no changes, which proves the design works.
• Add a monster. Put a "monster": True flag in a room and end the game (a loss) if the player enters it without a "sword" in their inventory.
• Add an inventory command that prints what the player is carrying.
• Challenge: add randomness with the random module — for example, a 1-in-3 chance that a draught blows out the player's torch, requiring matches found elsewhere.

You've now built a real, stateful program with a world, a loop, and puzzles — the same architecture behind far bigger games. To strengthen the logic skills underneath it, revisit building a quiz app in Python.