Make a game in R

The first idea for making this game came to me when I was thinking of exercises for students to practice loops. I feel that building simple games makes it easier for them to grasp the idea behind iteration and while loops than abstract operations on numbers and vectors.

Anyway, I made a simple hot-and-cold game. If you haven’t heard about it (idk, maybe it’s just a polish/Easter European thing?) there rules are simple: you have to find a treasure that is hidden somewhere and others keep telling you if you are getting closer (‘hot’!) or further away (‘cold’!) from the object. That’s it, there’s nothing more to it.

The idea is to play on a rectangular grid, you can move up, down, left or right. After each move the game tells you if you are getting closer or further away from the treasure. You win when you reach the hidden treasure. Also, the fewer moves you need to get there, the better. Sounds simple enough, right? Once we have that we can move on to adding more complex things like obstacles on the grid or messing with the ui.

Before we get to actual coding it’s nice to lay out some plan of what we’ll need:

1. Setting up the initial conditions of the game (make the grid, define starting and treasure position, calculate distance from the treasure). Some initial checks will be useful here as well (e.g. make sure that starting position and treasure position are not the same)
2. Define the movement rules: what happens if we move in any direction? Again, some checks will be necessary here: what happens if we step outside the grid? what happens if we try a nonsensical move?
3. Set up the updating: update the current position, recalculate distance and display appropriate message (‘hotter’ or ‘colder’). If the current position and treasure position overlap - end the game

Ok, so lets do it (please note that I keep most of the code folded because it’s pretty long when taken together!).

Initial conditions

We know that we’ll need a few thing to even start the game: grid on which we will play, position of player and the treasure (that will be random) and the initial distance. We’ll use simple manhattan distance here (sum of distance in rows and columns). Lets create the scaffolding first:

hot_and_cold <- function(nrow, ncol, debug = FALSE) {
  
  # INITIALIZE THE GAME
  
  
  #MOVEMENTS AND UPDATES
  
}

We’ll make a debug argument for now to make it easier to see what is exactly going on in the game (we’ll use it to toggle displaying the treasure). It’s something we’ll probably delete from the final game but it might be useful for debugging. The two other arguments: nrow and ncol will control the size of the grid we want to play on. Now lets fill the function with initial conditions for the game. We start with 2 checks - nrow and ncol need to be numbers. Next we create the game grid as a nrow by ncol matrix of - and define random target coordinates. Then we get starting coordinates. To do it we define a function that automatically checks if starting and target coordinates are the same. If they are the same the function starts from the beginning. If they are not it returns starting coordinates. The rest is pretty straightforward. If we are in debug mode we mark the target coordinates on the grid, we define current coordinates for future use in movements, calculate initial distance, start movement counter and display welcome message and the game grid.

hot_and_cold <- function(nrow, ncol, debug = FALSE) {
  #checks: both arguments need to be numbers
  stopifnot('You did not provide numbers' = is.numeric(nrow))
  stopifnot('You did not provide numbers' = is.numeric(ncol))
  # INITIALIZE THE GAME
  #1 Define grid for the game
  game_grid <- matrix(rep('-', nrow*ncol), nrow = nrow, ncol = ncol)
  
  #2 define target coordinates
  obj_x <- sample(1:nrow, 1)
  obj_y <- sample(1:ncol, 1)
  target_coord <- c(obj_x, obj_y)
  
  
  #3define start coordinates
  get_start_coord <- function() {
    start_x <- sample(1:nrow, 1)
    start_y <- sample(1:ncol, 1)
    start_coord <- c(start_x, start_y)
    
    #check if start coordinates are not target coordinates
    if (setequal(start_coord, target_coord)) {
      get_start_coord()
    }
    return(start_coord)
  }
  
  start_coord <- get_start_coord()
  
  #mark starting position on the grid
  game_grid[start_coord[1], start_coord[2]] <- 'X'
  
  #mark target position on the grid if debug
  if(debug == TRUE) {
    game_grid[target_coord[1], target_coord[2]] <- 'T'
  }
  

  #set current coordinates
  current_coord <- start_coord
  
  #calculate distance as Manhattan
  
  old_distance <- sum(abs(target_coord[1] - current_coord[1]),abs(target_coord[2] - current_coord[2]))
  
  #initiate move counter
  
  n_moves <- 1
  
  #display the first grid and instructions
  print('You have to find the treasure. You can move by typing')
  print('up, down, left or right. X shows your current position')
  print('You cant walk over walls which are shown with #')
  print('after each move the game will tell you if you are getting')
  print('closer (Hot) or further (cold)')
  print(game_grid)
  
  
  #MOVEMENTS AND UPDATES
  
}

Now if we run the function it should display the grid and initial position

hot_and_cold(10,10)

[1] "You have to find the treasure. You can move by typing"
[1] "up, down, left or right. X shows your current position"
[1] "You cant walk over walls which are shown with #"
[1] "after each move the game will tell you if you are getting"
[1] "closer (Hot) or further (cold)"
      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
 [1,] "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  
 [2,] "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "X"  
 [3,] "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  
 [4,] "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  
 [5,] "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  
 [6,] "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  
 [7,] "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  
 [8,] "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  
 [9,] "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  
[10,] "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  "-"  

Movements and updating

Ok, we have the grid set up! Now, on to movements. There are 4 ways to move on the grid: up, down, left or right. What we’ll need is to make the function listen to the user and depending on which movement they specify make the necessary checks (we don’t want to fall off the grid!) and change the current position and distance. All of this will have to keep going for as long as current coordinates and target coordinates don’t overlap - a while loop will be perfect for this. As long as current coordinates and target coordinates don’t overlap we listen to user movement (readline function) and if the move is “up” we first check if this move will take us out of the grid (if it does we display a message and skip to the next iteration of the loop). If the move is valid we update current coordinates, recalculate distance and display appropriate message. We will need something like this:

while(!setequal(current_coord, target_coord)) {
  movement <- readline('Where do you move: ')
  if (movement == 'up') {
      #check if you get ouside of the grid
      if (current_coord[1] - 1 < 1) {
        print('You cant move there!')
        next # this will force R to move to the next iteration of the loop
      } 
      #update grid and coords
      game_grid[current_coord[1], current_coord[2]] <- '-'
      current_coord[1] = current_coord[1] - 1
      game_grid[current_coord[1], current_coord[2]] <- 'X'
      
      #update distance and number of moves
      new_distance <- sum(abs(target_coord[1] - current_coord[1]),abs(target_coord[2] - current_coord[2]))
      n_moves <- n_moves + 1
      
      #display message
      if(new_distance < old_distance) {
        print('Hotter!')
      } else if (new_distance > old_distance) {
        print('Colder!')
      }
      #update distance
      old_distance <- new_distance
      #print grid and make next move
      print(game_grid)
  }
}

Now, we’ll need four of these: one for each type of movement. This might be tedious to do by hand and might be error-prone. so it should be easier to manage if we put this in a function! The function should take 2 arguments: are we moving on horizontal or vertical axis and whether we should add or subtract.

make_move <- function(h = 1, add = 1) {
    
    if (h == 1 & add == 1) {
      if (current_coord[h] + add > nrow) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
    } else if (h == 1 & add==-1) {
      if (current_coord[h] + add < 1) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
    } else if (h == 2 & add==1) {
      if (current_coord[h] + add > ncol) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
    } else if (h == 2 & add==-1) {
      if (current_coord[h] + add < 1) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
    }
    
    
    #update grid and coords
    game_grid[current_coord[1], current_coord[2]] <<- '-'
    current_coord[h] <<- current_coord[h] + add
    game_grid[current_coord[1], current_coord[2]] <<- 'X'
    
    #update distance and number of moves
    new_distance <<- sum(abs(target_coord[1] - current_coord[1]),abs(target_coord[2] - current_coord[2]))
    n_moves <<- n_moves + 1
    
    #display message
    if(new_distance < old_distance) {
      print('Hotter!')
    } else if (new_distance > old_distance) {
      print('Colder!')
    }
    #update distance
    old_distance <<- new_distance
    #print grid and make next move
    print(game_grid)
  }

Now we can put the function into the game:

hot_and_cold <- function(nrow, ncol, debug = FALSE) {
  #checks: both arguments need to be numbers
  stopifnot('You did not provide numbers' = is.numeric(nrow))
  stopifnot('You did not provide numbers' = is.numeric(ncol))
  # INITIALIZE THE GAME
  #1 Define grid for the game
  game_grid <- matrix(rep('-', nrow*ncol), nrow = nrow, ncol = ncol)
  
  #2 define target coordinates
  obj_x <- sample(1:nrow, 1)
  obj_y <- sample(1:ncol, 1)
  target_coord <- c(obj_x, obj_y)
  
  
  #3define start coordinates
  get_start_coord <- function() {
    start_x <- sample(1:nrow, 1)
    start_y <- sample(1:ncol, 1)
    start_coord <- c(start_x, start_y)
    
    #check if start coordinates are not target coordinates
    if (identical(start_coord, target_coord)) {
      get_start_coord()
    }
    return(start_coord)
  }
  
  start_coord <- get_start_coord()
  
  #mark starting position on the grid
  game_grid[start_coord[1], start_coord[2]] <- 'X'
  
  #mark target position on the grid if debug
  if(debug == TRUE) {
    game_grid[target_coord[1], target_coord[2]] <- 'T'
  }
  

  #set current coordinates
  current_coord <- start_coord
  
  #calculate distance as Manhattan
  
  old_distance <- sum(abs(target_coord[1] - current_coord[1]),abs(target_coord[2] - current_coord[2]))
  
  #initiate move counter
  
  n_moves <- 1
  
  #display the first grid and instructions
  print('You have to find the treasure. You can move by typing')
  print('up, down, left or right. X shows your current position')
  print('You cant walk over walls which are shown with #')
  print('after each move the game will tell you if you are getting')
  print('closer (Hot) or further (cold)')
  print(game_grid)
  
  
  #MOVEMENTS AND UPDATES
  # define function for making a move:
  make_move <- function(h = 1, add = 1) {
    
    if (h == 1 & add == 1) {
      if (current_coord[h] + add > nrow) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
    } else if (h == 1 & add==-1) {
      if (current_coord[h] + add < 1) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
    } else if (h == 2 & add==1) {
      if (current_coord[h] + add > ncol) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
    } else if (h == 2 & add==-1) {
      if (current_coord[h] + add < 1) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
    }
    
    
    #update grid and coords
    game_grid[current_coord[1], current_coord[2]] <<- '-'
    current_coord[h] <<- current_coord[h] + add
    game_grid[current_coord[1], current_coord[2]] <<- 'X'
    
    #update distance and number of moves
    new_distance <<- sum(abs(target_coord[1] - current_coord[1]),abs(target_coord[2] - current_coord[2]))
    n_moves <<- n_moves + 1
    
    #display message
    if(new_distance < old_distance) {
      print('Hotter!')
    } else if (new_distance > old_distance) {
      print('Colder!')
    }
    #update distance
    old_distance <<- new_distance
    #print grid and make next move
    print(game_grid)
  }
  
  
  #start the while loop
  while(!identical(current_coord, target_coord)) {
    movement <- readline('Where do you move: ')
    #if movement up
    if (movement == 'up') {
      make_move(1, -1)
    } else if (movement == 'down') {
      make_move(1,1)
    } else if (movement == 'left') {
      make_move(2,-1)
    } else if (movement == 'right') {
      make_move(2,1)
    } else {
      print('this is not a move!') # if the input does not match the possible moves
      
    }
  } # when the coordinates match while loop ends: we won!
  print('Congratulations! You found the treasure')
  print(paste('it took you', n_moves,'moves'))
}

Now you should have a working version of the game! You created the initial conditions to start the game, defined the rules of the game and how it should update according to the moves as well as winning conditions that end the game!

Adding stuff - obstacles

Ok, we have a working version of the game but it’s still pretty boring: all you need to do is find the proper row and then proper column to get to the treasure. Not much to it. So how about we make it a bit more interesting and introduce obstacles on the grid: walls that you can’t walk on. Again, lets start with what we’ll need to do:

1. Create a set of coordinates for the walls
2. Make sure that these do not overlap with the starting or target coordinates
3. Make sure that there is a way from starting position to treasure
4. Define rules that forbid walking on walls

The first two and number 4 are actually pretty easy as they will be very similar to what we have already done. Number 3 is much more tricky as it requires a different distance algorithm but we’ll get to that later (although number 4 proved for some weird reason pretty challenging as well).

In order to create coordinates for walls we want to get a set of pairs of numbers that will indicate the coordinates and then store them (e.g. as a list of vectors). We want to let the user define how many walls they want on the board. We do it by defining all possible coordinates, sampling from them and then performing a check for overlap with starting and target position. The check basically tells R that as long as target or starting coordinates are within the list of wall coordinates, keep regenerating the walls.

#Create walls
  create_walls <- function() {
    #define walls
    
    #create a grid of all coordinates
    all_coords <- expand.grid(1:nrow, 1:ncol)
    
    #sample n_walls coordinates
    walls <- do.call(`rbind`, sample(asplit(all_coords, 1), n_walls))
    
    #save them as a list (makes for  easier checks later)
    walls_coords <- split(walls, seq(nrow(walls)))
    
    return(walls_coords)
  }
  
  walls_coords <- create_walls()
  
  #Check if start or target coords are not on a wall
  while((list(target_coord) %in% walls_coords) | (list(start_coord) %in% walls_coords)) {
    walls_coords <- create_walls()
  }

Next we’ll need to add checks to our make_move() function to include checks if we are stepping on a wall. Essentially they are almost the same as checks for walking outside of the board, we just need to check against all the wall coordinates. The check looks something like this:

if (list(as.integer(c(current_coord[1] -1,current_coord[2]))) %in% walls_coords) {
      #check if you walk on a wall
        print('You cant move there!')
        next
      }

The weird thing is that I needed to add as.integer(). This cost me quite a bit of time actually. Without it the game would not let you walk on some walls but would be totally fine with walking over some other walls. The reason for this is that %in% uses match() which converts to character. And adjacent values (like c(1,2)) become 1:2 which is not the same as c(1,2) when converted to text ( I didn’t come up with this, I asked a question and got an answer here). Anyway, we just need to put that code into our make_move() function and adjust accordingly to the type of move we make. Our updated function will look like this

make_move <- function(h = 1, add = 1) {
    
    #if h == 1: check walls, if add = 1 - check outside bounds else check other bounds
    # same for h == 2
    
    if (h == 1 & add == 1) {
      if (current_coord[h] + add > nrow) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
      if (list(as.integer(c(current_coord[1]+ add,current_coord[2] ))) %in% walls_coords) {
        #check if you walk on a wall
        print('You cant move there!')
        return()
      }
    } else if (h == 1 & add==-1) {
      if (current_coord[h] + add < 1) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
      if (list(as.integer(c(current_coord[1] + add,current_coord[2]))) %in% walls_coords) {
        #check if you walk on a wall
        print('You cant move there!')
        return()
      }
      
    } else if (h == 2 & add==1) {
      if (current_coord[h] + add > ncol) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
      if (list(as.integer(c(current_coord[1],current_coord[2]+ add))) %in% walls_coords) {
        #check if you walk on a wall
        print('You cant move there!')
        return()
      }
      
    } else if (h == 2 & add==-1) {
      if (current_coord[h] + add < 1) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
      if (list(as.integer(c(current_coord[1] ,current_coord[2]+ add))) %in% walls_coords) {
        #check if you walk on a wall
        print('You cant move there!')
        return()
      }
    }
    
    
    #update grid and coords
    game_grid[current_coord[1], current_coord[2]] <<- '-'
    current_coord[h] <<- current_coord[h] + add
    game_grid[current_coord[1], current_coord[2]] <<- 'X'
    
    #update distance and number of moves
    new_distance <<- sum(abs(target_coord[1] - current_coord[1]),abs(target_coord[2] - current_coord[2]))
    n_moves <<- n_moves + 1
    
    #display message
    if(new_distance < old_distance) {
      print('Hotter!')
    } else if (new_distance > old_distance) {
      print('Colder!')
    }
    #update distance
    old_distance <<- new_distance
    #print grid and make next move
    print(game_grid)
  }

Now if we change the make_move() function in our game, we’ll get a game with a random set of walls! There is one last check to make: make sure that the game is winnable - there needs to be a path from starting position to treasure position. If the path is blocked by walls then there is no way to win the game. This one is actually a bit more complicated because we need some kind of algorithm that checks if such a path exists. A way to do it is to calculate the shortest path from start to target position while taking into account the walls. If such path exists - the game is winnable. We can use what is called breadth first search to do this.

Breadth first search

Basically what the algorithm does is it starts from a certain node in a graph (our starting position) and visits all neighbour nodes connected to the initial node, then it moves to all neighbours of the neighbours and so on until all possible routes from the initial node have been explored. In our game only the cells that are adjacent and are not walls are connected. If the position of the treasure shows up in the BFS then the game is winnable! There’s plenty of resources on this algorithm online if you want to learn more about it (just some example here).

The implementation of BFS in R is not straightforward. First of all we are not working with a nice graph structure (I wanted to keep this game without using any additional packages like igraph) but with a matrix. This means we don’t have anything like adjacency matrix to work with (that’s a matrix that would give us information about which cells are connected to each other). The solution below is probably not the nicest one but it works so it’ll have to suffice. You can see the entire function (actually 2) here:

#First we need to define valid moves in the grid for the algorithm
is_valid_move <- function(row, col, n, p, visited) {
      # Check if the cell is within the bounds of the matrix
      if (row < 1 || row > n || col < 1 || col > p) {
        return(FALSE)
      }
      
      # Check if the cell has already been visited
      if (visited[row, col]) {
        return(FALSE)
      }
      
      # Check if the cell is valid (i.e., contains "-", "X", or "T")
      if (!(game_grid[row, col] %in% c("-", "X", "T"))) {
        return(FALSE)
      }
      
      # If all conditions are satisfied, the move is valid
      return(TRUE)
    }
    
    # Define the function to find a path between "X" and "T"
    find_path <- function(game_grid) {
      # Define the start and end cells
      start_row <- which(game_grid == "X", arr.ind = TRUE)[1]
      start_col <- which(game_grid == "X", arr.ind = TRUE)[2]
      end_row <- which(game_grid == "T", arr.ind = TRUE)[1]
      end_col <- which(game_grid == "T", arr.ind = TRUE)[2]
      
      # Define the queue and visited matrix
      queue <- list()
      visited <- matrix(FALSE, nrow = nrow(game_grid), ncol = ncol(game_grid))
      
      # Add the start cell to the queue
      queue[[1]] <- c(start_row, start_col, 0)
      
      # Loop until the queue is empty
      while (length(queue) > 0) {
        # Get the first cell in the queue
        curr_cell <- unlist(queue[[1]])
        curr_row <- curr_cell[1]
        curr_col <- curr_cell[2]
        curr_dist <- curr_cell[3]
        
        # Remove the first cell from the queue
        queue <- queue[-1]
        
        # Mark the cell as visited
        visited[curr_row, curr_col] <- TRUE
        
        # Check if the current cell is the end cell
        if (curr_row == end_row && curr_col == end_col) {
          # Return the distance from the start cell to the end cell
          return(curr_dist)
        }
        
        # Check the neighboring cells
        neighbor_cells <- list(c(curr_row - 1, curr_col), c(curr_row + 1, curr_col), 
                               c(curr_row, curr_col - 1), c(curr_row, curr_col + 1))
        for (neighbor_cell in neighbor_cells) {
          neighbor_row <- neighbor_cell[1]
          neighbor_col <- neighbor_cell[2]
          
          if (is_valid_move(neighbor_row, neighbor_col, nrow(game_grid), ncol(game_grid), visited)) {
            # Add the neighboring cell to the queue
            queue[[length(queue) + 1]] <- c(neighbor_row, neighbor_col, curr_dist + 1)
          }
        }
      }
      
      # If no path is found, return FALSE
      return(FALSE)
    }

What this solution gives us is:

1. Give rules to define connections between cells in a matrix (so how to “turn” the matrix into a graph). This is done with the is_valid_move() function. It allows us to check if it is possible to make a given move and if a given cell that we want to move to has already been visited.

2. Implement BFS. This is what the find_path() function does. It gets the starting and target coordinates, queue of cells to visit and matrix of visited cells and then starts moving through the grid. If it gets to target coordinates it returns current distance, if it doesn’t (after visiting all possible cells) it returns false.

   Thanks to this we can make sure that the game can be won (and regenerate walls if it is not). The last thing we need to do is put the BFS to good use inside our hot_and_cold() function. We just need to modify the code that sets the initial conditions before the game begins:

 for(i in walls_coords) {
    game_grid[i[1],i[2]] <- '#'
  }
  
  game_grid[start_coord[1], start_coord[2]] <- 'X'
  game_grid[target_coord[1], target_coord[2]] <- 'T'
  
  bfs_result <- find_path(game_grid)
  
  while(!bfs_result) {
    #regenerate walls
    walls_coords <- create_walls()
    game_grid <- matrix(rep('-', nrow*ncol), nrow = nrow, ncol = ncol)
    for(i in walls_coords) {
      game_grid[i[1],i[2]] <- '#'
    }
    
    game_grid[start_coord[1], start_coord[2]] <- 'X'
    game_grid[target_coord[1], target_coord[2]] <- 'T'
    bfs_result <- find_path(game_grid)
    
  }
  
  
  if(debug == FALSE) {
    game_grid[target_coord[1], target_coord[2]] <- '-'
  }

The entire game now looks like this (that’s quite a few lines of code):

hot_and_cold <- function(nrow, ncol, n_walls, debug = FALSE) {
  #checks: both arguments need to be numbers
  stopifnot('You did not provide numbers' = is.numeric(nrow))
  stopifnot('You did not provide numbers' = is.numeric(ncol))
  # INITIALIZE THE GAME
  #1 Define grid for the game
  game_grid <- matrix(rep('-', nrow*ncol), nrow = nrow, ncol = ncol)
  
  #2 define target coordinates
  obj_x <- sample(1:nrow, 1)
  obj_y <- sample(1:ncol, 1)
  target_coord <- c(obj_x, obj_y)
  
  
  #3define start coordinates
  get_start_coord <- function() {
    start_x <- sample(1:nrow, 1)
    start_y <- sample(1:ncol, 1)
    start_coord <- c(start_x, start_y)
    
    #check if start coordinates are not target coordinates
    if (target_coord[1] == start_coord[1] & target_coord[2] == start_coord[2]) {
      get_start_coord()
    }
    return(start_coord)
  }
  
  start_coord <- get_start_coord()
  
  #Create walls
  create_walls <- function() {
    #define walls
    
    #create a grid of all coordinates
    all_coords <- expand.grid(1:nrow, 1:ncol)
    
    walls <- do.call(`rbind`, sample(asplit(all_coords, 1), n_walls))
    
    walls_coords <- split(walls, seq(nrow(walls)))
    
    return(walls_coords)
  }
  
  walls_coords <- create_walls()
  
  #Check if start or target coords are not on a wall
  while((list(target_coord) %in% walls_coords) | (list(start_coord) %in% walls_coords)) {
    walls_coords <- create_walls()
  }
  
  #BFS ALGORITHM TO CHECK IF GAME IS WINNABLE
  is_valid_move <- function(row, col, n, p, visited) {
    # Check if the cell is within the bounds of the matrix
    if (row < 1 || row > n || col < 1 || col > p) {
      return(FALSE)
    }
    
    # Check if the cell has already been visited
    if (visited[row, col]) {
      return(FALSE)
    }
    
    # Check if the cell is valid (i.e., contains "-", "X", or "T")
    if (!(game_grid[row, col] %in% c("-", "X", "T"))) {
      return(FALSE)
    }
    
    # If all conditions are satisfied, the move is valid
    return(TRUE)
  }
  
  # Define the function to find a path between "X" and "T"
  find_path <- function(game_grid) {
    # Define the start and end cells
    start_row <- which(game_grid == "X", arr.ind = TRUE)[1]
    start_col <- which(game_grid == "X", arr.ind = TRUE)[2]
    end_row <- which(game_grid == "T", arr.ind = TRUE)[1]
    end_col <- which(game_grid == "T", arr.ind = TRUE)[2]
    
    # Define the queue and visited matrix
    queue <- list()
    visited <- matrix(FALSE, nrow = nrow(game_grid), ncol = ncol(game_grid))
    
    # Add the start cell to the queue
    queue[[1]] <- c(start_row, start_col, 0)
    
    # Loop until the queue is empty
    while (length(queue) > 0) {
      # Get the first cell in the queue
      curr_cell <- unlist(queue[[1]])
      curr_row <- curr_cell[1]
      curr_col <- curr_cell[2]
      curr_dist <- curr_cell[3]
      
      # Remove the first cell from the queue
      queue <- queue[-1]
      
      # Mark the cell as visited
      visited[curr_row, curr_col] <- TRUE
      
      # Check if the current cell is the end cell
      if (curr_row == end_row && curr_col == end_col) {
        # Return the distance from the start cell to the end cell
        return(curr_dist)
      }
      
      # Check the neighboring cells
      neighbor_cells <- list(c(curr_row - 1, curr_col), c(curr_row + 1, curr_col), 
                             c(curr_row, curr_col - 1), c(curr_row, curr_col + 1))
      for (neighbor_cell in neighbor_cells) {
        neighbor_row <- neighbor_cell[1]
        neighbor_col <- neighbor_cell[2]
        
        if (is_valid_move(neighbor_row, neighbor_col, nrow(game_grid), ncol(game_grid), visited)) {
          # Add the neighboring cell to the queue
          queue[[length(queue) + 1]] <- c(neighbor_row, neighbor_col, curr_dist + 1)
        }
      }
    }
    
    # If no path is found, return FALSE
    return(FALSE)
  }
  #add a check that there exists a path! We'll need the BFS for this
  
  
  #display the first grid and instructions
  #change elements of grid to walls:
  for(i in walls_coords) {
    game_grid[i[1],i[2]] <- '#'
  }
  
  game_grid[start_coord[1], start_coord[2]] <- 'X'
  game_grid[target_coord[1], target_coord[2]] <- 'T'
  
  bfs_result <- find_path(game_grid)
  
  while(!bfs_result | (list(target_coord) %in% walls_coords) | (list(start_coord) %in% walls_coords)) {
    #regenerate walls
    walls_coords <- create_walls()
    game_grid <- matrix(rep('-', nrow*ncol), nrow = nrow, ncol = ncol)
    for(i in walls_coords) {
      game_grid[i[1],i[2]] <- '#'
    }
    
    game_grid[start_coord[1], start_coord[2]] <- 'X'
    game_grid[target_coord[1], target_coord[2]] <- 'T'
    bfs_result <- find_path(game_grid)
    
  }
  
  
  
  if(debug == FALSE) {
    game_grid[target_coord[1], target_coord[2]] <- '-'
  }
  
  
  #set current coordinates
  current_coord <- start_coord
  
  #calculate distance as Manhattan
  
  old_distance <- sum(abs(target_coord[1] - current_coord[1]),abs(target_coord[2] - current_coord[2]))
  
  #initiate move counter
  
  n_moves <- 1
  
  #display the first grid and instructions
  print('You have to find the treasure. You can move by typing')
  print('up, down, left or right. X shows your current position')
  print('You cant walk over walls which are shown with #')
  print('after each move the game will tell you if you are getting')
  print('closer (Hot) or further (cold)')
  print(game_grid)
  
  
  #MOVEMENTS AND UPDATES
  # define function for making a move:
  make_move <- function(h = 1, add = 1) {
    
    #if h == 1: check walls, if add = 1 - check outside bounds else check other bounds
    # same for h == 2
    
    if (h == 1 & add == 1) {
      if (current_coord[h] + add > nrow) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
      if (list(as.integer(c(current_coord[1]+ add,current_coord[2] ))) %in% walls_coords) {
        #check if you walk on a wall
        print('You cant move there!')
        return()
      }
    } else if (h == 1 & add==-1) {
      if (current_coord[h] + add < 1) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
      if (list(as.integer(c(current_coord[1] + add,current_coord[2]))) %in% walls_coords) {
        #check if you walk on a wall
        print('You cant move there!')
        return()
      }
      
    } else if (h == 2 & add==1) {
      if (current_coord[h] + add > ncol) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
      if (list(as.integer(c(current_coord[1],current_coord[2]+ add))) %in% walls_coords) {
        #check if you walk on a wall
        print('You cant move there!')
        return()
      }
      
    } else if (h == 2 & add==-1) {
      if (current_coord[h] + add < 1) {
        print('You cant move there!')
        print(game_grid)
        return() # this will force R to move to the next iteration of the loop
      } 
      if (list(as.integer(c(current_coord[1] ,current_coord[2]+ add))) %in% walls_coords) {
        #check if you walk on a wall
        print('You cant move there!')
        return()
      }
    }
    
    
    #update grid and coords
    game_grid[current_coord[1], current_coord[2]] <<- '-'
    current_coord[h] <<- current_coord[h] + add
    game_grid[current_coord[1], current_coord[2]] <<- 'X'
    
    #update distance and number of moves
    new_distance <<- sum(abs(target_coord[1] - current_coord[1]),abs(target_coord[2] - current_coord[2]))
    n_moves <<- n_moves + 1
    
    #display message
    if(new_distance < old_distance) {
      print('Hotter!')
    } else if (new_distance > old_distance) {
      print('Colder!')
    }
    #update distance
    old_distance <<- new_distance
    #print grid and make next move
    print(game_grid)
  }
  
  
  #start the while loop
  while(!(target_coord[1] == current_coord[1] & target_coord[2] == current_coord[2])) {
    movement <- readline('Where do you move: ')
    #if movement up
    if (movement == 'up') {
      make_move(1, -1)
    } else if (movement == 'down') {
      make_move(1,1)
    } else if (movement == 'left') {
      make_move(2,-1)
    } else if (movement == 'right') {
      make_move(2,1)
    } else {
      print('this is not a move!') # if the input does not match the possible moves
      
    }
  } # when the coordinates match while loop ends: we won!
  print('Congratulations! You found the treasure')
  print(paste('it took you', n_moves,'moves'))
}

Yay, we have a game! In the next installment we’ll try to work on the appearance of the game - now it’s just a R console game that shows a bunch of # and -. We’ll try to make it look better. Also please note that this is not really optimized code so for large grids and very high number of walls it may take a while for the game to generate the game grid. However, this post has already gotten really long and I won’t try to make the code faster for now.

The image used in the post thumbnail is taken from https://unsplash.com/photos/A_Z–0ey4HQ.