Py Text-Based RPG

Creating a simple text-based RPG game in Python using Pyglet is a fun way to explore basic programming concepts such as variables, arrays (lists in Python), functions, loops, and conditional statements. This example will create a framework for a game where the player can move through different rooms, collect items, and interact with the environment.

Setting Up Your Game Environment

1. Install Pyglet: If you haven’t installed Pyglet yet, you can do so using pip:

   pip install pyglet

2. Create a Python file: Name it something like text_rpg.py.

Writing the Game Code

Here’s the code for a basic text-based RPG in Pyglet. The game will include multiple rooms and allow the player to move between them and pick up items.

import pyglet
from pyglet.window import key

# Game window setup
window = pyglet.window.Window(width=800, height=600, caption='Simple Text RPG')

# Game data
rooms = {
    'Hall': {'description': 'You are in a hall. There is a door to the east.', 'east': 'Bedroom', 'item': 'key'},
    'Bedroom': {'description': 'You are in a bedroom. There is a door to the west.', 'west': 'Hall', 'item': 'sword'}
}
current_room = 'Hall'
inventory = []

# Display text
label = pyglet.text.Label('',
                          font_name='Times New Roman',
                          font_size=12,
                          x=window.width // 2, y=window.height // 2,
                          anchor_x='center', anchor_y='center')


def update_text():
    """Update the text displayed on the screen."""
    global label
    text = rooms[current_room]['description'] + "\n" + "Inventory: " + ", ".join(inventory)
    label.text = text


update_text()  # Initialize text


@window.event
def on_key_press(symbol, modifiers):
    """Handle key presses for navigation and item collection."""
    global current_room
    if symbol == key.LEFT and 'west' in rooms[current_room]:  # Use key.LEFT for moving west
        current_room = rooms[current_room]['west']
    elif symbol == key.RIGHT and 'east' in rooms[current_room]:  # Use key.RIGHT for moving east
        current_room = rooms[current_room]['east']

    # Check for item in the room
    if 'item' in rooms[current_room] and rooms[current_room]['item'] not in inventory:
        inventory.append(rooms[current_room]['item'])
        del rooms[current_room]['item']  # Remove the item from the room

    update_text()


@window.event
def on_draw():
    """Clear the window and draw the label."""
    window.clear()
    label.draw()


pyglet.app.run()

Explanation of the Game Code

• Window and Event Setup: Initializes a Pyglet window and sets up key press handling.
• Game Data:
• rooms: A dictionary representing the rooms. Each room has a description, possible directions to move, and items to pick up.
• current_room: Tracks the current location of the player.
• inventory: A list that holds the items the player has collected.
• Functions:
• update_text(): Updates the text displayed in the window based on the current room and the player’s inventory.
• on_key_press(): Handles navigation between rooms and picking up items based on key presses.
• on_draw(): Redraws the window and text label.

Key Programming Concepts Demonstrated

• Variables: Used to store game state, such as current_room and inventory.
• Arrays (Lists in Python): Used for inventory to hold multiple items.
• Dictionaries: Used for rooms to store complex data about each room.
• Functions: update_text(), on_key_press(), and on_draw() encapsulate functionality for reusability and organization.
• Loops and Conditional Statements: Not explicitly looped here, but the logic within on_key_press() acts on conditions (if a certain key is pressed, if an item exists in the room).
• Event Handling: Using Pyglet’s event system to handle user input and window drawing.

Running Your Game

Save the script and run it in your Python environment. Use the arrow keys to navigate between the rooms and watch as the room description and your inventory update based on your actions.

This simple framework lays the foundation for a text-based RPG and can be expanded with more rooms, items, and interactions. It serves as a practical introduction to programming fundamentals in the context of game development.