phase 0 unit 2 week 1 boggle class challenge

0.2.1-boggle_class_from_methods.rb

class BoggleBoard

  def initialize(new_grid)
    @boggle_board = new_grid
  end

  def inspect #inspects the BoggleBoard object, because BoggleBoard is a BoggleBoard, not an array
    @boggle_board.map { |row| puts row.inspect}
  end

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

  def get_row(row)
    puts @boggle_board[row].inspect
  end

  def get_col(col)
    puts @boggle_board.map { |row| row[col]}.inspect
  end

  def get_diagonal(coord1, coord2)
    raise ArgumentError.new("Coordinates provided are not diagonal") if (coord1.first - coord2.first).abs != (coord1.last - coord2.last).abs
	#puts @boggle_board.map { |row| row[col]}.inspect
  end

  def get_coord(row, col = 0) #this method allows dynamic input. Allows taking in a coordinate, or 2 separate integers that together is a coordinate
    if row.kind_of?(Array)
      col = row.last
      row = row.first
    end
    puts @boggle_board[row][col]
  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)

boggle_board.inspect # => shold print ["b", "r", "a", "e"]
# =>     		              ["i", "o", "d", "t"]
# =>  	   	         	      ["e", "c", "l", "r"]
# =>              		      ["t", "a", "k", "e"]

boggle_board.create_word([0,1], [1,1], [0,2], [1,2]) # => road
boggle_board.create_word([2,1], [1,1], [2,2], [1,2]) # => cold
boggle_board.create_word([1,2], [1,1], [2,1], [3,2]) # => dock

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

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

boggle_board.get_coord(3, 2) # => "k"
boggle_board.get_coord(0, 0) # => "b"
boggle_board.get_coord(2, 3) # => "r"
boggle_board.get_coord([3,2]) # => "k"
boggle_board.get_coord([0,0]) # => "b"
boggle_board.get_coord([2,3]) # => "r"

boggle_board.get_diagonal([0,0],[1,1]) # => 
boggle_board.get_diagonal([0,0],[0,1]) # => raise argument error

=begin
coords are:

	00 01 02 03
	10 11 12 13
	20 21 22 23
	30 31 32 33
	
=end


#5) Review and Reflect
#You just made a transition from procedural programming to object-oriented programming! How is the implementation different? What are the benefits to using the Object Oriented approach (even if it is a bit more code)?
#
#    Object oriented programming is based around a pre-defined object. Whatever you do is all dealing with that object in mind. Class methods allows for less
# input required when you want to refrence to a paricular object, and is much easier to customize your needs on say, statuses, retrieving a particular information,
# etc. It also allows a great amount of code reusability. I can even create a class and use the same class somewhere else, or even further specialize classes into
# subclasses with ease using inheritance!