Stage 1: Create Rooms¶

How we plan¶

When we work with computers, we need to break problems into clear, logical steps that a computer can follow exactly. Humans can rely on shortcuts, guesses and experience to fill in gaps, but computers can't. A computer only does exactly what it's told, so every step must be precise, ordered and unambiguous.

This computational thinking helps us turn a messy real-world problem into a series of simple, complete instructions that a computer can carry out without ever needing to "figure things out" on its own.

To help with this planning we will use pseudocode. Pseudocode is a simple way of writing out the steps of a program in plain English instead of real code, so we can focus on the logic without worrying about exact syntax. It shows what the program should do, in order, using clear instructions like IF, ELSE, REPEAT and OUTPUT.

Pseudocode doesn't run on a computer, but it helps us plan our thinking before we write real code. That makes mistakes easier to spot and the final program easier to build.

Planning¶

In this stage we want to create three rooms and link them together. Below is a rough map of our dungeon.

To do this we need two files:

• main.py → runs the program
• room.py → stores the Room class

Pseudocode¶

- Define the Room class
- Create Room objects
- Describe Room objects
- Link the Room objects
- Include the linked Rooms when each Room object is described

Class diagram¶

UML class diagrams are a simple way to show what a class looks like and how it works with other classes.

In UML, a class is drawn as a table with three rows.

• The class name goes in row 1.
• The class attributes go in row 2, along with their data types.
• The class methods go in row 3, along with their arguments and the data type of any returned value.

The class diagram for the Room class is:

From the diagram we can tell:

• The class name is Room.
• The attributes are:
  • name, which is a string
  • description, which is a string
  • linked_rooms, which is a dictionary
• The methods are:
  • describe, which takes no arguments and returns nothing
  • link_rooms, which returns nothing and takes two arguments:
    • room_to_link
    • direction

Define the Room class¶

Open Thonny and create a new file. Then type the code below into it.

1
2
3

# room.py

class Room():

The first line, # room.py, is a comment with the file name. Our game is split across several files, so this helps us keep track of which file we're working on.

Dunder init method¶

Every Python class has a special method called the dunder init. Its real name is __init__. The "double underscores" are why we call it dunder.

The dunder init runs automatically every time we create a new object from a class. It sets up the object's attributes and gets it ready to use. We can also use it to run any other set-up the object needs.

Let's make a dunder init for our Room class.

1
2
3
4
5
6
7
8
9

# room.py

class Room():

    def __init__(self, room_name):
        # initialise the room object

        self.name = room_name.lower()
        self.description = None

Save room.py¶

Save the file as room.py in the deepest_dungeon folder we made in the Introduction for Students.

Create Room objects¶

Create a new file and save it as main.py in the deepest_dungeon folder. This file controls our game.

Type the following code into main.py.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# main.py

from room import Room

# create rooms
cavern = Room("Cavern")

armoury = Room("Armoury")

lab = Room("Laboratory")

print(cavern.name)

We're about to run our program for the first time. Throughout this course we'll use the PRIMM process to learn from each piece of code. PRIMM stands for:

• Predict: before we run the code, we predict what we think will happen.
• Run: we run the program and see how accurate our prediction was. If it was wrong, how was the result different?
• Investigate: we go through the code and work out what each line does.
• Modify: we change the code and see what results we get.
• Make: we use our new understanding to make something new.

Let's try it now.

Describe Room objects¶

If we look at the Room class, we'll notice that the description attribute currently stores None.

1
2
3
4
5
6
7
8
9

# room.py

class Room():

    def __init__(self, room_name):
        # initialise the room object

        self.name = room_name.lower()
        self.description = None

We want our rooms to have descriptions, so let's give them some values in main.py.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# main.py

from room import Room

# create rooms
cavern = Room("Cavern")
cavern.description = "A room so big that the light of your torch doesn’t reach the walls."

armoury = Room("Armoury")
armoury.description = "The walls are lined with racks that once held weapons and armour."

lab = Room("Laboratory")
lab.description = "A strange odour hangs in a room filled with unknowable contraptions."

print(cavern.name)
print(cavern.description)

Describe method¶

It's better programming practice to use methods than to grab an object's attributes directly. In the class diagram, the Room class has a describe() method for this.

Using a method like describe() is a cleaner and safer way to show a room's details, so let's add it. Go back to room.py and add the highlighted code below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# room.py

class Room():

    def __init__(self,room_name):
        # initialises the room object
        self.name = room_name.lower()
        self.description = None

    def describe(self):
        # displays a description of the room in the UI
        print(f"\nYou are in the {self.name}")
        print(self.description)

Then go back to main.py and replace lines 15 and 16 with the highlighted code below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# main.py

from room import Room

# create rooms
cavern = Room("Cavern")
cavern.description = "A room so big that the light of your torch doesn’t reach the walls."

armoury = Room("Armoury")
armoury.description = "The walls are lined with racks that once held weapons and armour."

lab = Room("Laboratory")
lab.description = "A strange odour hangs in a room filled with unknowable contraptions."

# describe rooms
cavern.describe()
armoury.describe()
lab.describe()

Link rooms¶

If we look at our map, we'll notice that the rooms are linked, so our adventurer can move between them.

• Cavern ↓ Armoury
• Armoury ↑ Cavern
• Armoury → Lab
• Lab ← Armoury

The class diagram shows that each room uses an attribute called linked_rooms and a method called link_rooms to connect rooms together.

linked_rooms is a dictionary. A dictionary stores information in key:value pairs.

• The key will be a direction like north, south, east or west.
• The value will be the Room object in that direction.

For example, the Armoury's linked_rooms dictionary will look like this:

{
  "north" : cavern,
  "east" : lab
}

The link_rooms method takes two pieces of information: the room we want to connect and the direction it's in. It adds this to the linked_rooms dictionary, so the room knows what's next to it.

Let's build it. First go back to room.py and add the highlighted code below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# room.py

class Room():

    def __init__(self,room_name):
        # initialises the room object
        self.name = room_name.lower()
        self.description = None
        self.linked_rooms = {}

    def describe(self):
        # displays a description of the room in the UI
        print(f"\nYou are in the {self.name}")
        print(self.description)

    def link_rooms(self, room_to_link, direction):
        # links the provided room, in the provided direction
        self.linked_rooms[direction.lower()] = room_to_link

Then open main.py and add the highlighted code below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# main.py

from room import Room

# create rooms
cavern = Room("Cavern")
cavern.description = "A room so big that the light of your torch doesn’t reach the walls."

armoury = Room("Armoury")
armoury.description = "The walls are lined with racks that once held weapons and armour."

lab = Room("Laboratory")
lab.description = "A strange odour hangs in a room filled with unknowable contraptions."

# link rooms
cavern.link_rooms(armoury,"south")
armoury.link_rooms(cavern,"north")
armoury.link_rooms(lab,"east")
lab.link_rooms(armoury,"west")

# describe the rooms
cavern.describe()
armoury.describe()
lab.describe()

Did you predict that nothing would change? The rooms are linked, but we aren't showing the links yet. Notice that each connection needs two calls to link_rooms, one for each direction.

Include linked rooms in the description¶

Now let's show the linked rooms in each room's description. Go to room.py and add the highlighted code below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# room.py

class Room():

    def __init__(self,room_name):
        # initialises the room object
        self.name = room_name.lower()
        self.description = None
        self.linked_rooms = {}

    def describe(self):
        # displays a description of the room in the UI
        print(f"\nYou are in the {self.name}")
        print(self.description)
        for direction in self.linked_rooms:
            print(f"To the {direction} is the {self.linked_rooms[direction].name}")

    def link_rooms(self, room_to_link, direction):
        # links the provided room, in the provided direction
        self.linked_rooms[direction.lower()] = room_to_link

Exercises¶

So far we've used the first four steps of PRIMM. Now it's time to make.

Exercise 1¶

Can you add one or more rooms to the dungeon? It should:

• create one or more new Room objects with a description
• link each new room to at least one of the existing rooms, in both directions