minesweeper.rb

# @param {Character[][]} board
# @param {Integer[]} click
# @return {Character[][]}
# def update_board(board, click)
#   y = click[0]
#   x = click[1]
#   total_x = board[0].length
#   total_y = board.length

#   board[y][x] = 'X' if board[y][x] == 'M'

#   reveal_block(board, y, x, total_y, total_x, false)

#   # bottom right
#   (y...total_y).each do |i|
#     (x...total_x).each do |j|
#       reveal_block(board, i, j, total_y, total_x, true)
#     end
#   end

#   # bottom left
#   (y...total_y).reverse_each do |i|
#     (0..x - 1).reverse_each do |j|
#       reveal_block(board, i, j, total_y, total_x, true)
#     end
#   end

#   # top right
#   (0..y - 1).reverse_each do |i|
#     (x...total_x).each do |j|
#       # p "i-j: #{i}-#{j}   board[#{i}][#{j}]: #{board[i][j]}"
#       reveal_block(board, i, j, total_y, total_x, true)
#     end
#   end

#   # top left
#   (0..y - 1).reverse_each do |i|
#     (0..x - 1).reverse_each do |j|
#       reveal_block(board, i, j, total_y, total_x, true)
#     end
#   end

#   board
# end

def update_board(board, click)
  y = click[0]
  x = click[1]
  total_x = board[0].length
  total_y = board.length
    
  if board[y][x] == 'M'
    board[y][x] = 'X'
    return board
  end

  recursive_reveal_block(board, y, x, total_y, total_x)
  board
end

def recursive_reveal_block(board, y, x, total_y, total_x)
  #p "y, x, value: #{y}, #{x}, #{board[y][x]}"
  reveal_block(board, y, x, total_y, total_x)
  return if board[y][x].to_i > 0

  valid_adjacent_blocks = valid_adjacent_blocks(board, y, x, total_y, total_x)
  #p "next check blocks:"
  #p valid_adjacent_blocks
  valid_adjacent_blocks.each do |block|
    recursive_reveal_block(board, block[0], block[1], total_y, total_x)
  end
end

def valid_adjacent_blocks(board, y, x, total_y, total_x)
  valid_adjacent_blocks = []
  valid_adjacent_blocks << [y - 1, x - 1] if y - 1 >= 0 && x - 1 >= 0 && (board[y-1][x-1] == 'E' || board[y-1][x-1] == 'M')
  valid_adjacent_blocks << [y - 1, x] if y - 1 >= 0 && x >= 0 && (board[y-1][x] == 'E' || board[y-1][x] == 'M')
  valid_adjacent_blocks << [y - 1, x + 1] if y - 1 >= 0 && x + 1 >= 0 && x + 1 <= total_x - 1 && (board[y-1][x+1] == 'E' || board[y-1][x+1] == 'M')
  valid_adjacent_blocks << [y, x + 1] if y >= 0 && x + 1 >= 0 && x + 1 <= total_x - 1 && (board[y][x+1] == 'E' || board[y][x+1] == 'M')
  valid_adjacent_blocks << [y + 1, x + 1] if y + 1 >= 0 && y + 1 <= total_y - 1 && x + 1 >= 0 && x + 1 <= total_x - 1 && (board[y+1][x+1] == 'E' || board[y+1][x+1] == 'M')
  valid_adjacent_blocks << [y + 1, x] if y + 1 >= 0 && y + 1 <= total_y - 1 && x >= 0 && (board[y+1][x] == 'E' || board[y+1][x] == 'M')
  valid_adjacent_blocks << [y + 1, x - 1] if y + 1 >= 0 && y + 1 <= total_y - 1 && x - 1 >= 0 && (board[y+1][x-1] == 'E' || board[y+1][x-1] == 'M')
  valid_adjacent_blocks << [y, x - 1] if y >= 0 && x - 1 >= 0 && (board[y][x-1] == 'E' || board[y][x-1] == 'M')

  valid_adjacent_blocks
end

def reveal_block(board, y, x, total_y, total_x)
  valid_adjacent_blocks = valid_adjacent_blocks(board, y, x, total_y, total_x)

  if board[y][x] == 'M' || board[y][x] == 'X'

    # p "board[y][x]: #{board[y][x]}"
    return board
  end

  valid_b_block = true
  valid_adjacent_blocks.each do |position|
    if board[position[0]][position[1]] == 'M' || board[position[0]][position[1]] == 'X'
      valid_b_block = false
      break
    end
  end
  if valid_b_block
    board[y][x] = 'B'
    # p "board[y][x]: #{board[y][x]}"

    return board
  end

  adjacent_mine_count = 0
  valid_adjacent_blocks.each do |position|
    adjacent_mine_count += 1 if board[position[0]][position[1]] == 'M' || board[position[0]][position[1]] == 'X'
  end
  board[y][x] = adjacent_mine_count.to_s
  # p "board[y][x]: #{board[y][x]}"
  board
end

# def print board
#   board.each do |row|
#     puts "#{row}\n"
#   end
# end

# def revealable_block(board, valid_adjacent_blocks, y, x)
#   revealable = false

#   return true if board[y][x] == 'M'

#   valid_adjacent_blocks.each do |position|
#     # p board[position[0]][position[1]]
#     if board[position[0]][position[1]] == 'B'
#       revealable = true
#       break
#     end
#   end

#   revealable
# end