Crafting a Text-Based Adventure Game: Storylines and Gameplay with Python

In my previous post, My Journey Into Game Development with Godot, I shared my excitement about jumping into game development with Godot. I had visions of creating visually stunning worlds and dynamic gameplay. But as I started exploring, I realized something: crafting a great game isn’t just about the tools or the engine—it’s about the story, the mechanics, and the gameplay.

That’s when I decided to start smaller, with a text-based adventure game. Not because it’s “simpler,” but because it gives me the perfect canvas to:

Design immersive storylines without distractions.
Experiment with game logic in a structured, approachable way that I already understand.
Code in Python, a language I’m already very proficient in, to focus on gameplay mechanics and problem-solving.

Text-based games strip everything down to the essentials—just you, your code, and your imagination. That is exactly what I needed to clear my mind and finally get started.

Why Start with a Text-Based Adventure Game?

For me, the idea of creating a text adventure game wasn’t just a stepping stone; it was an exciting opportunity to hone my skills as both a storyteller and a developer. Here's why:

Fleshing out the Story: Every game begins with an idea, but I couldn't organize the ideas in my head while thinking of taking on an entire game at one time. A text-based game allows me to flesh out the narrative, build characters, and experiment with player interactions before worrying about graphics or animations. So, I was able to get the thoughts out in an organized and easy way while still getting the game started.
Focusing on Mechanics: I can practice designing puzzles, managing inventory systems, creating an engaging progression, and even some simple character development—all things that will definitely be needed to design a more complex games. Starting out with the text-based game before the full animated game feels like the wireframing process before creating an entire app.
Leveraging Python: Since I’m already proficient in Python, I could dive straight into the gameplay and logic without having to learn a new language. This is important since GDScript, the programming language used in Godot, is so similar to Python.

Shattered Peaks Text Adventure Game Welcome Screen

The World of Shattered Peaks

When I decided to build a text-based adventure game, I wanted the story to feel immersive and intriguing. I turned to my trusty AI assistant for help crafting a storyline, and they delivered an idea that captured my imagination: Shattered Peaks. Set in a mysterious land haunted by the remnants of an ancient relic, the game challenges players to explore, solve puzzles, and piece together the truth about the Whispering Heart, a shattered artifact of immeasurable power. With this storyline as my foundation, I was ready to start coding! I started to code based on the story line I had, but I plan to build on the story line as I go to keep things interesting too. So far, in this game players can:

Explore different locations, from mysterious forests to serene lakes and treacherous mountains.
Solve puzzles to unlock secrets.
Interact with NPCs for clues and guidance.
Collect items to help them on their journey.

Here’s a look at the game's Forest location so that you can get a better idea of what I am talking about here.

locations = {
    "Forest": {
        "title": "The forest looms around you, its ancient trees whispering secrets.",
        "description": (
            "You feel a cold wind, as if there may be a ghost. "
            "A strange marking on a tree catches your eye—a winding spiral with an arrow pointing north."
        ),
        "items": ["Journal"],
        "connections": {"north": "Village", "south": None, "east": None, "west": None},
        "characters": {
            "Ghost": "A translucent figure hovers in the air. It seems to beckon you closer."
        },
        "puzzle": {
            "question": "What has roots as nobody sees, is taller than trees, up, up it goes, and yet it never grows?",
            "answer": "mountain",
            "reward": "Amulet",
        },
    },
}

Each location in the game is built as a dictionary, containing:

Title and Description to set the scene.
Items that players can collect.
Connections to other locations.
Characters who provide clues or interactions.
Puzzles to challenge players and grant rewards.

Building Gameplay Mechanics

To make the game interactive, I wrote Python functions for each player action:

move_player: Handles navigation between locations.
look_around: Displays the current location’s description.
talk_to_character: Cycles through NPC dialogs.
solve_puzzle: Checks player answers and grants rewards.

Here’s how movement works:

def move_player(direction, current_location, inventory, update_gui):
    """Move the player in the specified direction."""
    connections = locations[current_location]["connections"]
    next_location = connections.get(direction)
    
    if next_location:
        update_gui(f"You move {direction} to the {next_location}.")
        return next_location
    else:
        update_gui("You can't go that direction from here.")
        return current_location

Players can move using commands like n (north), s (south), and so on. Each command updates the player’s location and reveals new areas to explore.

Adding a Graphical Interface

Although text games traditionally run in the console, I wanted to add a graphical user interface (GUI) to make the game more approachable. Using Python’s tkinter, I created:

A main text area to display messages and game updates.
An input box where players can type commands.
A scrollable interface for longer texts.

Here’s how the layout is initialized:

root = tk.Tk()
root.title("Shattered Peaks Adventure")
root.geometry("650x550")

game_text = tk.Text(root, wrap=tk.WORD, height=15, width=70, state=tk.DISABLED)
game_text.pack()

command_input = tk.Entry(root)
command_input.pack()

The GUI makes it easier to present story elements while keeping the game interactive and engaging.

Lessons Learned So Far

Creating Shattered Peaks has already taught me valuable lessons that will carry over to more complex projects:

Focus on Core Gameplay: Strip away distractions and ensure the mechanics and logic work well. I wanted to make sure that the game tells a cohesive story.
Iterate Quickly: Building small, testable features (like movement or puzzles) makes development manageable and rewarding.
Story is Key: Whether it’s a text game or a 3D masterpiece, the narrative will always be the heart of the experience for me.

What’s Next?

This is just the beginning of my journey. In the next post, I’ll guide you through setting up your own text-based adventure game from scratch, starting with the foundational structure and movement mechanics. Eventually, I’ll bring these lessons back to Godot, where I’ll be ready to tackle graphics, animations, and more complex systems. To be honest, I am really enjoying being able to dive into the storylines in this text-based way. So, I'm not sure how quickly I will get back to Godot.