Back

Activity 4.8 Mini-Project: Escape Room Mini-Game

Introduction

Activity 4.8

Escape Room Mini-Game

What you're building

A one-room escape game with a locked door
One hidden item (a key)
One inventory slot (held item)
A menu loop for actions

OOP Goals

Write multiple classes across files
Use composition (has-a relationships)
Handle null safely
Use encapsulation + methods with logic
Use an AP-style sentinel value method

Composition in this project

Your Room contains (has-a) a Lock and may contain (has-a) a hidden Item.

1
public class Room
2
{
3
    private Lock doorLock;     // Room has-a Lock
4
    private Item hiddenItem;   // Room has-a Item (may become null after pickup)
5
}

Sentinel values (AP style)

When data is "missing," an AP-style approach is to return a special value (a sentinel). In this project, the player uses "none" when no item is held.

1
public class Player
2
{
3
    private Item heldItem; // One-slot inventory (may be null)
4

5
    public String getHeldItemName()
6
    {
7
        if (heldItem == null)
8
        {
9
            return "none"; // sentinel value
10
        }
11

12
        return heldItem.getName();
13
    }
14
}

Rules

Keep it simple: one room, one lock, one hidden item, one inventory slot

'F' → Fullscreen

Objectives

Design a small program using multiple interacting classes
Use composition to model a system
Write safe code reminded by object references and null
Build a game loop with meaningful choices

Activity Tasks

This mini-project is written using stepwise refinement. Complete each task in order. After each task, run the checkpoint program to verify your progress.

Create a new project named 4-8-Escape-Room.
Create these files: Item.java, Lock.java, Room.java, Player.java, Program.java.
Complete the tasks below in order. Don't skip checkpoints.

Task 1: Item (Build the smallest "thing" first)

Create the Item class.
Use a keyCode where -1 means "not a key."
Add getDescription() for debugging and player feedback.

1
public class Item
2
{
3
    private String name;
4
    private int keyCode; // -1 means "not a key" (sentinel value)
5

6
    public Item(String name, int keyCode)
7
    {
8
        this.name = name;
9
        this.keyCode = keyCode;
10
    }
11

12
    public String getName()
13
    {
14
        return name;
15
    }
16

17
    public boolean isKey()
18
    {
19
        return keyCode != -1;
20
    }
21

22
    public int getKeyCode()
23
    {
24
        return keyCode;
25
    }
26

27
    public String getDescription()
28
    {
29
        if (isKey())
30
        {
31
            return name + " (Key)";
32
        }
33

34
        return name + " (Not a key)";
35
    }
36
}

Checkpoint: Run a tiny Main program to verify Items work.

1
public class Program
2
{
3
    public static void main(String[] args)
4
    {
5
        Item key = new Item("Brass Key", 1234);
6
        Item note = new Item("Crumpled Note", -1);
7

8
        System.out.println(key.getDescription());
9
        System.out.println(note.getDescription());
10
    }
11
}

Task 2: Lock (Write the "win condition" logic early)

Create the Lock class.
The lock starts locked.
tryUnlock(item) returns true only for the correct key.
Unlock attempts with null must fail safely.

1
public class Lock
2
{
3
    private boolean locked;
4
    private int requiredKeyCode;
5

6
    public Lock(int requiredKeyCode)
7
    {
8
        locked = true;
9
        this.requiredKeyCode = requiredKeyCode;
10
    }
11

12
    public boolean isLocked()
13
    {
14
        return locked;
15
    }
16

17
    public boolean tryUnlock(Item item)
18
    {
19
        if (item == null)
20
        {
21
            return false;
22
        }
23

24
        if (!item.isKey())
25
        {
26
            return false;
27
        }
28

29
        if (item.getKeyCode() != requiredKeyCode)
30
        {
31
            return false;
32
        }
33

34
        locked = false;
35
        return true;
36
    }
37
}

Checkpoint: Test null, wrong key, and correct key.

1
public class Program
2
{
3
    public static void main(String[] args)
4
    {
5
        Lock doorLock = new Lock(1234);
6

7
        Item wrongKey = new Item("Fake Key", 9999);
8
        Item rightKey = new Item("Brass Key", 1234);
9

10
        System.out.println("Locked? " + doorLock.isLocked());
11

12
        boolean unlocked = doorLock.tryUnlock(null);
13
        System.out.println("Unlock with null: " + unlocked);
14
        System.out.println("Locked? " + doorLock.isLocked());
15

16
        unlocked = doorLock.tryUnlock(wrongKey);
17
        System.out.println("Unlock with wrong key: " + unlocked);
18
        System.out.println("Locked? " + doorLock.isLocked());
19

20
        unlocked = doorLock.tryUnlock(rightKey);
21
        System.out.println("Unlock with correct key: " + unlocked);
22
        System.out.println("Locked? " + doorLock.isLocked());
23
    }
24
}

Task 3: Room (Composition begins here)

Create the Room class.
The Room has-a Lock and has-a hidden Item.
The player must search before taking the item.
After the item is taken, the hidden item becomes null.

1
public class Room
2
{
3
    private String name;
4
    private String clue;
5

6
    private Lock doorLock;
7
    private Item hiddenItem;
8

9
    private boolean searched;
10

11
    public Room(String name, String clue, Lock doorLock, Item hiddenItem)
12
    {
13
        this.name = name;
14
        this.clue = clue;
15
        this.doorLock = doorLock;
16
        this.hiddenItem = hiddenItem;
17
        searched = false;
18
    }
19

20
    public String getName()
21
    {
22
        return name;
23
    }
24

25
    public String search()
26
    {
27
        if (!searched)
28
        {
29
            searched = true;
30
            return "You search the room... " + clue;
31
        }
32

33
        return "You already searched. Nothing new stands out.";
34
    }
35

36
    public Item takeItem()
37
    {
38
        if (!searched)
39
        {
40
            return null;
41
        }
42

43
        if (hiddenItem == null)
44
        {
45
            return null;
46
        }
47

48
        Item found = hiddenItem;
49
        hiddenItem = null;
50
        return found;
51
    }
52

53
    public boolean tryUnlockDoor(Item item)
54
    {
55
        return doorLock.tryUnlock(item);
56
    }
57

58
    public boolean isDoorLocked()
59
    {
60
        return doorLock.isLocked();
61
    }
62
}

Checkpoint: Search → take item → print what you found.

1
public class Program
2
{
3
    public static void main(String[] args)
4
    {
5
        Lock doorLock = new Lock(1234);
6
        Item key = new Item("Brass Key", 1234);
7

8
        Room room = new Room(
9
            "Locked Lab",
10
            "You notice scratch marks near a loose floor tile.",
11
            doorLock,
12
            key
13
        );
14

15
        System.out.println(room.search());
16

17
        Item found = room.takeItem();
18

19
        if (found == null)
20
        {
21
            System.out.println("No item found.");
22
        }
23
        else
24
        {
25
            System.out.println("Found: " + found.getDescription());
26
        }
27
    }
28
}

Task 4: Player (One-slot inventory + sentinel method)

Create the Player class.
The player can hold exactly one item.
Add getHeldItemName() that returns "none" if nothing is held.
Add pickUp(item), dropItem(), and inspectHeldItem().

1
public class Player
2
{
3
    private Item heldItem;
4

5
    public Player()
6
    {
7
        heldItem = null;
8
    }
9

10
    // AP-style sentinel method (String sentinel)
11
    public String getHeldItemName()
12
    {
13
        if (heldItem == null)
14
        {
15
            return "none";
16
        }
17

18
        return heldItem.getName();
19
    }
20

21
    public boolean hasItem()
22
    {
23
        return heldItem != null;
24
    }
25

26
    public Item getHeldItem()
27
    {
28
        return heldItem;
29
    }
30

31
    public boolean pickUp(Item item)
32
    {
33
        if (item == null)
34
        {
35
            return false;
36
        }
37

38
        if (heldItem != null)
39
        {
40
            return false;
41
        }
42

43
        heldItem = item;
44
        return true;
45
    }
46

47
    public Item dropItem()
48
    {
49
        Item dropped = heldItem;
50
        heldItem = null;
51
        return dropped;
52
    }
53

54
    public String inspectHeldItem()
55
    {
56
        if (heldItem == null)
57
        {
58
            return "You are holding nothing.";
59
        }
60

61
        return "Held item: " + heldItem.getDescription();
62
    }
63
}

Checkpoint: Pick up an item, inspect it, drop it, and confirm the sentinel value.

1
public class Program
2
{
3
    public static void main(String[] args)
4
    {
5
        Player player = new Player();
6
        System.out.println("Held: " + player.getHeldItemName());
7

8
        Item note = new Item("Crumpled Note", -1);
9

10
        boolean pickedUp = player.pickUp(note);
11
        System.out.println("Picked up? " + pickedUp);
12
        System.out.println(player.inspectHeldItem());
13

14
        Item dropped = player.dropItem();
15
        System.out.println("Dropped: " + dropped.getName());
16
        System.out.println("Held: " + player.getHeldItemName());
17
    }
18
}

Task 5: Main Game Loop (Put it all together)

Create fixed objects: one Room, one Lock, one hidden key Item, one Player.
Build a menu loop with the required actions.
Win condition: unlock the door.
Make sure you can attempt unlock with no item (null) safely.

1
import java.util.Scanner;
2

3
public class Program
4
{
5
    public static void main(String[] args)
6
    {
7
        Scanner input = new Scanner(System.in);
8

9
        int requiredKeyCode = 1234;
10

11
        Lock doorLock = new Lock(requiredKeyCode);
12

13
        // Change these two lines if you want a different theme.
14
        String roomName = "Locked Lab";
15
        String clue = "You notice scratch marks near a loose floor tile.";
16

17
        // Hidden item (the key). You can swap this to a decoy to test failure cases.
18
        Item hiddenKey = new Item("Brass Key", requiredKeyCode);
19

20
        Room room = new Room(roomName, clue, doorLock, hiddenKey);
21
        Player player = new Player();
22

23
        System.out.println("--- ESCAPE ROOM ---");
24
        System.out.println("You wake up in a locked room. The door is sealed.");
25
        System.out.println("Room: " + room.getName());
26

27
        boolean running = true;
28

29
        while (running)
30
        {
31
            System.out.println();
32
            System.out.println("Held item: " + player.getHeldItemName());
33
            System.out.println("1) Search room");
34
            System.out.println("2) Take item");
35
            System.out.println("3) Inspect held item");
36
            System.out.println("4) Try unlock door");
37
            System.out.println("5) Drop held item");
38
            System.out.println("6) Quit");
39
            System.out.print("> ");
40

41
            String choice = input.nextLine();
42

43
            if (choice.equals("1"))
44
            {
45
                System.out.println(room.search());
46
            }
47
            else if (choice.equals("2"))
48
            {
49
                Item found = room.takeItem();
50

51
                if (found == null)
52
                {
53
                    System.out.println("You don't find anything you can take.");
54
                }
55
                else
56
                {
57
                    boolean pickedUp = player.pickUp(found);
58

59
                    if (pickedUp)
60
                    {
61
                        System.out.println("You picked up: " + found.getName());
62
                    }
63
                    else
64
                    {
65
                        // Player already holding something; put it back by "re-hiding" in the simplest way:
66
                        // For this mini-project, we will just tell the player to drop first.
67
                        System.out.println("Your hands are full. Drop your item first.");
68
                    }
69
                }
70
            }
71
            else if (choice.equals("3"))
72
            {
73
                System.out.println(player.inspectHeldItem());
74
            }
75
            else if (choice.equals("4"))
76
            {
77
                boolean unlocked = room.tryUnlockDoor(player.getHeldItem());
78

79
                if (unlocked)
80
                {
81
                    System.out.println("Click! The lock opens.");
82
                    System.out.println("YOU ESCAPED!");
83
                    running = false;
84
                }
85
                else
86
                {
87
                    if (player.hasItem())
88
                    {
89
                        System.out.println("That didn't work. The door remains locked.");
90
                    }
91
                    else
92
                    {
93
                        System.out.println("You try the door... It won't budge. (You have no key.)");
94
                    }
95
                }
96
            }
97
            else if (choice.equals("5"))
98
            {
99
                Item dropped = player.dropItem();
100

101
                if (dropped == null)
102
                {
103
                    System.out.println("You have nothing to drop.");
104
                }
105
                else
106
                {
107
                    System.out.println("You dropped: " + dropped.getName());
108
                }
109
            }
110
            else if (choice.equals("6"))
111
            {
112
                running = false;
113
            }
114
            else
115
            {
116
                System.out.println("Invalid choice.");
117
            }
118

119
            // Optional: if the door is unlocked for any reason, end the game.
120
            if (!room.isDoorLocked())
121
            {
122
                running = false;
123
            }
124
        }
125

126
        System.out.println("\nGame over.");
127
    }
128
}

Required Tests (Before you submit)

Try unlocking the door before picking up anything (must not crash).
Search, then take the item.
Inspect held item (should display item description).
Unlock the door and win.
Verify the hidden item cannot be taken twice (should fail after it becomes null).

Sample Output

Your program output should look similar to the sample below (your story text can differ).

--- ESCAPE ROOM ---
You wake up in a locked room. The door is sealed.
Room: Locked Lab

Held item: none
1) Search room
2) Take item
3) Inspect held item
4) Try unlock door
5) Drop held item
6) Quit
> 4
You try the door... It won't budge. (You have no key.)

Held item: none
> 1
You search the room... You notice scratch marks near a loose floor tile.

Held item: none
> 2
You picked up: Brass Key

Held item: Brass Key
> 4
Click! The lock opens.
YOU ESCAPED!

Game over.

Reflection Questions

You may write your reflection answers as comments at the bottom of Program.java.

Where did you use composition (has-a relationships)? List at least two examples from your classes.
In this game, where can null occur? Give at least two situations.
What sentinel value did you use in getHeldItemName()? Why is that useful in a menu program?
Which class "owns" the unlocking logic? Why is that a good design?
If you were allowed to use arrays to store multiple items later, what part of this game could you expand first? (Answer conceptually—do not implement.)

Submission

Submit: Item.java, Lock.java, Room.java, Player.java, Program.java
Include your reflection answers as comments at the bottom of Program.java