Scrabble Waves 1-3, One Optional

Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs = ["lib"]
+  t.warning = true
+  t.test_files = FileList['specs/*_spec.rb']
+end
+
+task default: :test

lib/board.rb

@@ -0,0 +1,65 @@
+require 'pp'
+module Scrabble
+class Board
+  attr_accessor :board
+  def initialize()
+    @board = create_board
+  end
+
+  def create_board
+    fill = "_ " * 7
+    fill = fill.split
+    board = []
+    7.times do
+      duplicate = fill.dup
+      board << duplicate
+    end
+    return board
+  end
+
+  #Call check placement first, if return true call place tiles
+  def place_tiles(word, direction, row, column)
+    characters = word.chars
+    i = 0
+    if direction.downcase == "across"
+      characters.each do |letter|
+        @board[row][column+i] = letter
+        i += 1
+      end
+    else
+      characters.each do |letter|
+        @board[row+i][column] = letter
+        i += 1
+      end
+    end
+    return @board
+  end
+
+  def check_placement(word, direction, row, column) # [row, row]
+    characters = word.chars
+    i = 0
+    if direction.downcase == "across"
+      characters.each do |letter|
+        if (@board[row][column+ i] == "_") || (@board[row][column + i] == letter)
+          i += 1
+        else
+          puts "Invalid placement"
+          return false
+        end
+      end
+    else
+      characters.each do |letter|
+        if (@board[row+i][column] == "_") || (@board[row+i][column] == letter)
+          i += 1
+        else
+          puts "Invalid placement"
+          return false
+        end
+      end
+    end
+    pp @board
+    return true
+  end
+end
+
+end

lib/player.rb

@@ -0,0 +1,53 @@
+module Scrabble
+  class Player
+    attr_reader :name
+    attr_accessor :plays, :tiles, :tile_bag
+    def initialize(name)
+      @name = name
+      @plays = []
+      @tile_bag = TileBag.new()
+      @tiles = tile_bag.draw_tiles(MAXIMUM_NUMBER_OF_LETTERS)
+    end
+
+
+    def draw_tiles(tile_bag_arg = tile_bag)
+      tiles_drawn = tile_bag_arg.draw_tiles(MAXIMUM_NUMBER_OF_LETTERS -   tiles.length)
+      tiles.concat(tiles_drawn)
+    end
+
+    def play(word) #everytime we play we also have to call remove tiles. Not part   of this method because it breaks tests (we don't know what random array is  generated for tests, so there are lots of nil errors)
+      if won?
+        return false
+      else
+        plays << word
+        this = Scoring.score(word)
+        return this
+      end
+    end
+
+    def remove_tiles(word) #would have to remove letters from player's tiles when   word is played.
+      played_tiles = word.chars
+      played_tiles.each do |tile|
+        tiles.delete_at(tiles.find_index(tile))
+      end
+    end
+
+    def total_score
+      return 0 if plays.empty?
+      score_array = plays.collect { |word| Scoring.score(word) }
+      score_array.reduce(:+)
+    end
+
+    def won?
+      total_score > 100 ? true : false
+    end
+
+    def highest_scoring_word
+      Scoring.highest_score_from(plays)
+    end
+
+    def highest_word_score
+      Scoring.score(highest_scoring_word)
+    end
+  end
+end

lib/scoring.rb

@@ -0,0 +1,82 @@
+module Scrabble
+  class Scoring
+    LETTER_SCORES = {"a"=>1, "b"=>3, "c"=>3, "d"=>2, "e"=>1, "f"=>4, "g"=>2,
+      "h"=>4, "i"=>1, "j"=>8, "k"=>5, "l"=>1, "m"=>3, "n"=>1, "o"=>1, "p"=>3,
+      "q"=>10, "r"=>1, "s"=>1, "t"=>1, "u"=>1, "v"=>4, "w"=>4, "x"=>8, "y"=>4,
+      "z"=>10}
+
+
+      def self.score(word) # takes a string
+        return 0 if word.empty? # empty string/pass
+
+        score = 0
+
+        #Add bonus for word_length corner case.
+        score = 50 if word.length == Scrabble::MAXIMUM_NUMBER_OF_LETTERS
+
+        split_word = word.downcase.split('') # downcase for comparing
+
+        split_word.each do |letter|
+          score += LETTER_SCORES[letter]
+        end
+
+        return score
+      end
+
+      def self.highest_score_from(array_of_words)
+
+        score_array = array_of_words.collect { |word| self.score(word) }
+
+        number_of_highest_scores =  self.get_number_of_duplicates(score_array.sort.reverse)
+        # sort gives ascending
+        # reverse for descending to compare HIGHEST scores
+
+        highest_scoring_words  = array_of_words.max_by(number_of_highest_scores) {  |word| self.score(word) }
+
+        return highest_scoring_words[0].to_s if highest_scoring_words.length == 1
+
+        words_by_length = highest_scoring_words.min_by(number_of_highest_scores) {  |word| word.length }
+        #shortest first - sorting WORDS by length (to analyze ties)
+
+        lengths_of_words = words_by_length.collect { |word| word.length }
+
+        if lengths_of_words.last == MAXIMUM_NUMBER_OF_LETTERS
+          if self.has_duplicates?(lengths_of_words.reverse) # reverse to change   ascending to descending because WORD_LENGTH_MAXIMUM is the longest we   expect
+            winning_word =  self.get_first_word_for_length_and_score(lengths_of_words.reverse,  words_by_length, array_of_words)
+            return winning_word
+          end
+
+          return words_by_length.last
+
+        elsif self.has_duplicates?(lengths_of_words) # we do want this in ascending   order because normally smaller words win (based on rules)
+          winning_word = self.get_first_word_for_length_and_score(lengths_of_words,   words_by_length, array_of_words)
+          return winning_word
+        else
+          words_by_length.first
+        end
+      end
+
+      def self.has_duplicates?(array_of_words)
+        self.get_number_of_duplicates(array_of_words) > 1 ? true : false
+      end
+
+      def self.get_first_word_for_length_and_score(array_of_equal_lengths,  high_scores_array, original_array)
+
+        number_of_ties_same_length =  self.get_number_of_duplicates(array_of_equal_lengths)
+        potential_winners = high_scores_array.first(number_of_ties_same_length)
+        winning_word = original_array.find { |word| potential_winners.include? word   }
+        return winning_word
+      end
+
+      def self.get_number_of_duplicates(array_of_words)
+        i = 1
+        array_of_words_x = array_of_words.dup # prevents mutation of array_of_words   from shift
+        while (array_of_words_x[0] == array_of_words_x[1]) &&   (array_of_words_x.length > 1)
+          array_of_words_x.shift
+          i +=1
+        end
+        return i
+      end
+
+  end
+end

lib/tilebag.rb

@@ -0,0 +1,38 @@
+module Scrabble
+  class TileBag
+
+    attr_accessor :default_tiles
+
+    def initialize
+      @default_tiles = ["a", "a", "a", "a", "a", "a", "a", "a",
+        "a", "n", "n", "n", "n", "n", "n", "b", "b", "o", "o", "o", "o", "o",
+        "o", "o", "o", "c", "c", "p", "p", "d", "d", "d", "d", "q", "e", "e",
+        "e", "e", "e", "e", "e", "e", "e", "e", "e", "e", "r", "r", "r", "r",
+        "r", "r", "f", "f", "s", "s", "s", "s", "g", "g", "g", "t", "t", "t",
+        "t", "t", "t", "h", "h", "u", "u", "u", "u", "i", "i", "i", "i", "i",
+        "i", "i", "i", "i", "v", "v", "j", "w", "w", "k", "x", "l", "l", "l",
+        "l", "y", "y", "m", "m", "z"]
+
+    end
+
+    def draw_tiles(num)
+      # num number of random tiles
+      random_tiles = default_tiles.sample(num)
+
+
+      # remove these tiles from the default set
+      random_tiles.each do |tile|
+        default_tiles.delete_at(default_tiles.find_index(tile))
+        # delete_at mutates array like slice
+      end
+
+      return random_tiles
+
+    end
+
+    def tiles_remaining
+      default_tiles.length
+    end
+
+  end
+end

scrabble.rb

@@ -0,0 +1,8 @@
+require './lib/scoring'
+require './lib/player'
+require './lib/tilebag'
+require './lib/board'
+
+module Scrabble
+  MAXIMUM_NUMBER_OF_LETTERS = 7
+end

specs/board_spec.rb

@@ -0,0 +1,79 @@
+require_relative './spec_helper'
+
+describe Scrabble::Board do
+  it "is an object we have access to" do
+    Scrabble::Board.wont_be_nil
+  end
+
+  describe "Board#board" do
+    it "has a board consisting of an array" do
+      game = Scrabble::Board.new
+      game.board.must_be_kind_of Array
+    end
+  end
+
+  describe "Board#place_tiles" do
+    it "places first tile in given position" do
+      game = Scrabble::Board.new
+      game.place_tiles("cat", "down", 2, 0)
+      game.board[2][0].must_equal "c"
+    end
+
+    it "places second tile in given position" do
+      game = Scrabble::Board.new
+      game.place_tiles("cat", "down", 2, 0)
+      game.board[3][0].must_equal "a"
+    end
+
+    it "places third tile in given position" do
+      game = Scrabble::Board.new
+      game.place_tiles("cat", "down", 2, 0)
+      game.board[4][0].must_equal "t"
+    end
+
+    it "returns true if 'trogdor' placed accurately, 'r' in expected position" do
+      game = Scrabble::Board.new
+      game.place_tiles("cat", "down", 2, 0)
+      game.check_placement("cold", "across", 2, 0)
+      game.place_tiles("cold", "across", 2, 0)
+      game.check_placement("dog", "down", 2, 3)
+      game.place_tiles("dog", "down", 2, 3)
+      game.check_placement("trogdor", "across", 4, 0)
+      game.place_tiles("trogdor", "across", 4, 0)
+      game.board[4][6].must_equal "r"
+    end
+  end
+
+  describe "Board#check_placement" do
+    it "returns false if invalid tile placement given" do
+      game = Scrabble::Board.new
+      game.place_tiles("cat", "down", 2, 0)
+      game.check_placement("dog", "across", 2, 0).must_equal false
+    end
+
+    it "returns true if valid placement" do
+      game = Scrabble::Board.new
+      game.place_tiles("cat", "down", 2, 0)
+      game.check_placement("cold", "across", 2, 0).must_equal true
+    end
+
+    it "returns true if valid placement on third word play" do
+      game = Scrabble::Board.new
+      game.place_tiles("cat", "down", 2, 0)
+      game.check_placement("cold", "across", 2, 0)
+      game.place_tiles("cold", "across", 2, 0)
+      game.check_placement("dog", "down", 2, 3).must_equal true
+    end
+
+    it "returns true if valid placement on trogdor across, intersecting cat and dog" do
+      game = Scrabble::Board.new
+      game.place_tiles("cat", "down", 2, 0)
+      game.check_placement("cold", "across", 2, 0)
+      game.place_tiles("cold", "across", 2, 0)
+      game.check_placement("dog", "down", 2, 3)
+      game.place_tiles("dog", "down", 2, 3)
+      game.check_placement("trogdor", "across", 4, 0).must_equal true
+    end
+
+end
+end