Maze Game

Maze Game

A text maze where a mouse navigates a 4x4 grid of rooms to reach the cheese. The program scatters internal walls at random, prints the current room, and reads one move per turn. The game ends when the mouse reaches the cheese room.

Source files: maze/maze.hpp, maze/maze.cpp, maze/game.cpp.

Coordinates

Each room has a row letter and a column number. The row is y_, a char from a to d. The column is x_, an int from 1 to 4. Room::print() writes the letter then the number, so rooms read as a1, b3, d4, and so on.

• Start room: a1 (set by makeStartRoom).
• Cheese room: d4 (set by makeCheeseRoom, which uses x_ = mazeSize_ and y_ = 'a' + mazeSize_ - 1).

mazeSize_ is 4, so the board is 4x4. The maze holds 8 internal walls (numWalls_).

Three classes

• Room holds one room's coordinates and knows how to pick a random room, pick a random adjacent room, ask the user for a move, and report whether a direction stays inside the board.
• RoomPair holds two rooms. It models one internal wall, and it also models a candidate move (current room paired with target room).
• Maze owns the array of 8 wall RoomPairs plus the current mouse room. It builds the walls, prints them, and decides whether a move is blocked.

How the maze is built

The generator places walls. It does not knock them out. Maze::build() loops until it has collected 8 distinct walls:

1. Make an empty RoomPair.
2. RoomPair::pick() picks a random room, then picks a random room adjacent to it.
3. Maze::checkMaze() scans the walls already placed. If this pair matches one (in either order), it is a duplicate.
4. If it is new, store it and increment the count. If it is a duplicate, throw it away and try again.

matchPair() treats r1|r2 and r2|r1 as the same wall, so a wall is never added twice in reversed order.

flowchart TD
    A([build maze]) --> B{placed 8 walls?}
    B -- yes --> Z([done])
    B -- no --> C[pick random room]
    C --> D[pick a random adjacent room]
    D --> E[form RoomPair candidate wall]
    E --> F{already in maze?}
    F -- yes --> B
    F -- no --> G[store wall, count + 1]
    G --> B

Loading

A note on the picking: pickAdjacent() rolls a random direction and accepts it only if that direction stays inside the board. A room on an edge has fewer legal neighbors, so off-board directions get rerolled until one lands inside.

The game loop

game.cpp sets the start and cheese rooms, builds the walls, then offers to print the wall list (answer y to see it, useful for testing). After that it loops until the mouse sits on the cheese:

1. Print the current room.
2. Ask for a move. Room::nextMove() accepts u, d, l, r, or q.
3. Validate the direction. If the move would leave the board, print There is a wall and ask again.
4. Hand the target room to Maze::move(). If a wall sits between the current room and the target, the move is refused and There is a wall prints. Otherwise the mouse moves.
5. Check whether the current room matches the cheese room. If so, print Game Over! and stop.

stateDiagram-v2
    [*] --> Render
    Render --> ReadInput: print current room
    ReadInput --> CheckWin: q pressed (quit)
    ReadInput --> ValidateDirection: u / d / l / r
    ValidateDirection --> ReadInput: off the board (wall)
    ValidateDirection --> CheckWall: inside the board
    CheckWall --> Render: wall between rooms (move refused)
    CheckWall --> CheckWin: no wall (mouse moves)
    CheckWin --> Render: not on cheese yet
    CheckWin --> [*]: on cheese, Game Over

Loading

Controls

Key	Effect
u	move up, toward row a (decreases the row letter)
d	move down, toward row d (increases the row letter)
l	move left, toward column 1
r	move right, toward column 4
q	quit the current move prompt

What blocks a move

Two checks can stop a move:

• The edge of the board. goodDirection() rejects a direction that would leave the 4x4 grid.
• An internal wall. Maze::move() builds a RoomPair from the current room and the target, then compares it against all 8 walls with matchPair(). A match means a wall sits between the two rooms, so the mouse stays put.

Build and run

g++ -std=c++11 maze/*.cpp -o maze
./maze

Known rough edges

The maze never checks that a path from a1 to d4 actually exists, so a random layout can wall the cheese off. Several functions return a value on every branch the program uses but still fall off the end on paths the compiler cannot rule out, which g++ warns about. The Roadmap page lists these.