phase 0 unit 2 week 1 boggle class challenge

0.2.1-boggle_class_from_methods.rb

class BoggleBoard
  attr_reader :dice_grid

  def initialize(dice_grid)
    @dice_grid = dice_grid
  end

  def create_word(*coords)
    coords.map { |coord| @dice_grid[coord.first][coord.last]}.join("")
  end

  def get_row(row)
    @dice_grid[row]
  end

  def get_col(col)
    @dice_grid.collect{|i| i[col]}
  end

  def get_diagonal(start_coord, end_coord)
    diagonal_words = []
    x = start_coord[0]
    y = start_coord[1]
    left_coord_distance = (start_coord[0] - end_coord[0]).abs
    right_coord_distance = (start_coord[1] - end_coord[1]).abs
    if left_coord_distance == right_coord_distance
      diagonal_words.push(@dice_grid[x][y])
      case true
        when start_coord[0] < end_coord[0] && start_coord[1] < end_coord[1] #(s/e) diag
          left_coord_distance.times{
            x += 1
            y += 1
            diagonal_words.push(@dice_grid[x][y])
          }
        when start_coord[0] < end_coord[0] && start_coord[1] > end_coord[1] #(s/w) diag
          left_coord_distance.times{
            x += 1
            y -= 1
            diagonal_words.push(@dice_grid[x][y])
          }
        when start_coord[0] > end_coord[0] && start_coord[1] > end_coord[1] #(n/w) diag
          left_coord_distance.times{
            x -= 1
            y -= 1
            diagonal_words.push(@dice_grid[x][y])
          }
        when start_coord[0] > end_coord[0] && start_coord[1] < end_coord[1] #(n/e) diag
          left_coord_distance.times{
            x -= 1
            y += 1
            diagonal_words.push(@dice_grid[x][y])
          }
      end
      diagonal_words
    else
      "Not a diagonal!"
    end
  end
end

dice_grid = [["b", "r", "a", "e"],
             ["i", "o", "d", "t"],
             ["e", "c", "l", "r"],
             ["t", "a", "k", "e"]]

boggle_board = BoggleBoard.new(dice_grid)

# # implement tests for each of the methods here:
p boggle_board.create_word([2,1], [1,1], [1,2], [0,3])  #=> returns "code"
p boggle_board.create_word([0,1], [0,2], [1,2])         #=> returns "rad"
p boggle_board.create_word([2,2], [1,1], [2,1], [3,2])  #=> returns "lock"
p boggle_board.create_word([1,3], [2,3], [3,3], [3,2])  #=> returns "trek"

p boggle_board.get_row(0) #=>  ["b", "r", "a", "e"]
p boggle_board.get_row(1) #=>  ["i", "o", "d", "t"]
p boggle_board.get_row(2) #=>  ["e", "c", "l", "r"]
p boggle_board.get_row(3) #=>  ["t", "a", "k", "e"]

p boggle_board.get_col(0)  #=>  ["b", "i", "e", "t",]
p boggle_board.get_col(1)  #=>  ["r", "o", "c", "a"]
p boggle_board.get_col(2)  #=>  ["a", "d", "l", "k"]
p boggle_board.get_col(3)  #=>  ["e", "t", "r", "e"]

# # create driver test code to retrieve a value at a coordinate here:
p (boggle_board.dice_grid[3][2] == 'k') == true #==> returns true if working

# Bonus: create a #get_diagonal method
#long diagonal test
p boggle_board.get_diagonal([0,0],[3,3]) #==> ["b", "o", "l", "e"]
p boggle_board.get_diagonal([0,3],[3,0]) #==> ["e", "d", "c", "t"]
p boggle_board.get_diagonal([3,3],[0,0]) #==> ["e", "l", "o", "b"]
p boggle_board.get_diagonal([3,0],[0,3]) #==> ["t", "c", "d", "e"]

#short diagonal test
p boggle_board.get_diagonal([1,0],[3,2]) #==> ["i", "c", "k"]
p boggle_board.get_diagonal([0,2],[2,0]) #==> ["a", "o", "e"]
p boggle_board.get_diagonal([2,3],[0,1]) #==> ["r", "d", "r"]
p boggle_board.get_diagonal([3,1],[1,3]) #==> ["a", "l", "t"]

#not a diagonal test
p boggle_board.get_diagonal([0,0],[3,2]) #==> "Not a diagonal!"
p boggle_board.get_diagonal([1,0],[2,3]) #==> "Not a diagonal!"
p boggle_board.get_diagonal([0,2],[3,0]) #==> "Not a diagonal!"
p boggle_board.get_diagonal([3,1],[0,2]) #==> "Not a diagonal!"

#Review and Reflect
# The object oriented aspect vs. procedural part wasn't difficult. Figuring out how to return the 
# diagonals was!!!
# I know there is probably a more succinct way of doing what I did with the diagonal method I made,
# but I'm proud of myself for thinking it out logically and finding a way to do it. Where my mind 
# is already going with refactoring is the correlation between the signs on the distance... 
# I had a lot of fun with this one mostly because it took a lot of time and was the most challenging yet.