Option 1: RStudio Console

• Download and unzip the repo
• Open the project in RStudio double clicking on monster-maze-console.Rproj
• Source the file R/monster-maze-all.R
• The game runs on the RStudio console
• Move to the console to enter the input

Option 2: RStudio Console

• In Github, copy the code from R/monster-maze-all.R
• Open a new file in RStudio
• Paste the contents
• Source the new file
• The game runs on the RStudio console
• Move to the console to enter the input

Option 3: Terminal

• Download and unzip the repo
• Open a terminal
• Run the command Rscript /R/monster-maze-all.R

Mazes

First thing I opted for a matrix of integers to represent the maze rather than strings where:

• 0: represents the walls.
• 1: represents the corridors and rooms.
• 9: represents the exit.

The following code snippet shows the syntax used, the reason for this verbose approach is simply to have a matrix-like representation in the code that I could easily check while coding.

1maze1_data <-            c(0,0,0,0,0,0,0,0,0,0)
2maze1_data <- c(maze1_data,0,1,1,1,1,1,0,1,1,0)
3maze1_data <- c(maze1_data,0,0,1,0,0,1,1,1,0,0)
4maze1_data <- c(maze1_data,0,0,1,1,0,1,0,1,1,0)
5maze1_data <- c(maze1_data,0,1,1,0,1,0,0,1,0,0)
6maze1_data <- c(maze1_data,0,1,1,1,1,1,1,1,0,0)
7maze1_data <- c(maze1_data,0,0,0,0,0,0,0,9,0,0)
8maze1 = matrix(maze1_data,nrow=7,ncol=10,byrow=TRUE);

Extract the rooms and corridors positions from the maze

1require(invctr)
2CORRIDOR <- 1
3corridor_positions <- CORRIDOR %ai% maze1 # gets the indices for all CORRIDOR places in the maze

Extract the exit position from the maze 🏆

1require(invctr)
2EXIT <- 9
3exit_position <- EXIT %ai% maze1 # gets the indeces for all CORRIDOR places in the maze

The steps so far has brought us from the plain matrix to the maze depicted in the figure 2. We have:

• the underlying lattice in a matrix.
• the corridors and rooms positions in a dataframe.
• the exit position in a dataframe.

Figure 2: Maze showing walls, corridors, rooms and exit

Where the player starts 👤

After a few tests I decided to assign the player position randomly to any free corridor cell that is at least 4 cells away from the exit.

The distance between two position in the matrix is calculated accordingly to the following function.

1calc_distance <- function(position_1, position_2) {
2  row_distance <- abs(position_1$row - position_2$row)
3  col_distance <- abs(position_1$col - position_2$col)
4  distance <- row_distance + col_distance
5}

The figure 3 shows the distance of each cell in a corridor or room to the exit.

Figure 3: Maze with each cell showing the distance from the exit

As an example, in figure 4 the player has been placed in the position (row=4, col=3).

Figure 4: Player position in the maze

The player is simply tracked as a position and a direction (North, South, East, West). The latter will become clearer when I explain what the player sees.

Next is determining the positions of the other characters of the game, their initial positions are randomly selected from free cells, corridors and rooms that are not occupied by other characters and that are at least 2 cells away from the player (Figure 5) so that the player stands a chance of reaching the exit.

Figure 5: Distances from player

Ghosts 👻

• appear and disappear at a constant speed.
• only appear on corridor or rooms but they can walk through walls, the position must be a free position but does not need to be connected through a corridor to the previous.
• do not pursue the player.
• if the player looks aside and back, the ghost may disappear.
• if a ghost materialises in a position at distance 1 of the player (front, back or either side) or the player bumps into it, then the player is whisked away to a new random position at least 4 cells from the exit, disoriented not knowing which direction is facing. In practice the game is reset but no life is taken.
• From 0 to as many as you can fit in considering the player and the distance limit.

In the figure 6 2 ghosts are placed in positions (row=2, col=4) and (row=4,col=8).

Figure 6: Ghost positions

The ghost positions are tracked in a list of positions.

Zombies 🧟

• move at a constant speed, usually slower than the player. However, zombies move awkwardly, they do not turn and can move in diagonal.
• cannot walk through walls or other characters.
• do pursue the player, getting closer and closer.
• if a zombie grabs a player, it hurts the player, taking away 1 life before whisking her and resetting he game.
• From 0 to as many as you can fit in considering the player, the ghosts and the distance limit.

In the figure 7 2 zombies are placed in positions (row=1, col=6) and (row=1,col=9).

Figure 7: Zombie positions

The zombie positions are tracked in a list of positions.

So, let’s recap the different elements we have so far.

• the underlying lattice in a matrix.
• the corridors and rooms positions in a dataframe.
• the exit position in a dataframe.
• the player as a position and a direction (North, South, East, West).
• the ghosts as a list of positions, a constant speed, range of effect (distance=1).
• the zombies as a list of positions, a constant speed, range of effect (distance=0).

Print / cat

Print doesn’t work on the terminal, the code uses only cat.

Clear Screen

The game is rendered by cleaning the terminal and re-printing it. Surprisingly the character to clear the screen in the terminal and the console are different. For that reason I used the following function (Code 2022).

1clear_screen <- function() {
2  if (interactive()) {
3    cat("\014") #or cat("\f")
4  } else {
5    cat("\33[2J")
6  }
7}

User Input

I had to resort to different code to capture the user input.

According to the documentation readLine in non-interactive use the result is as if the response was RETURN and the value is ““. I followed the recommended solution in stackoverflow: Make readline wait for input in R

1user_input <- function(prompt) {
2  if (interactive()) {
3    return(readline(prompt))
4  } else {
5    cat(prompt)
6    return(readLines("stdin", n=1))
7  }
8}