Waves 1, 2, 3 of Scrabble

.ruby-gemset

@@ -0,0 +1 @@
+scrabble

.ruby-version

@@ -0,0 +1 @@
+2.3.0

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/player.rb

@@ -0,0 +1,66 @@
+#name: returns the value of the @name instance variable
+#play(word): Adds the input word to the plays Array
+  # Returns false if player has already won
+  # Returns the score of the word
+#plays: returns an Array of the words played by the player
+#total_score: Returns the sum of scores of played words
+#won?: If the player has over 100 points, returns true, otherwise returns false
+#highest_scoring_word: Returns the highest scoring played word
+#highest_word_score: Returns the highest_scoring_word score
+
+class Scrabble::Player
+  attr_reader :name, :words_played, :player_tiles
+  attr_writer :player_tiles
+
+  def initialize(name)
+    @name = name
+    @words_played = []
+    @player_tiles = []
+    # @tilebag = Scrabble::TileBag.new
+  end
+
+  def won?
+    total_score >= 100
+  end
+
+  def play(word)
+    # adds word to array of words
+    @words_played << word
+    # Returns false if player has already won
+    word_score = Scrabble::Scoring.score(word)
+    remove_played_letters(word)
+    won? ? false : word_score
+      # scores word & returns score
+  end
+
+  def remove_played_letters(word)
+    # removes played letters from player_tiles
+    word_letters = Scrabble::Scoring.word_letters(word)
+    word_letters.length.times do
+      @player_tiles.delete(word_letters.find { |letter| letter})
+      word_letters.shift
+    end
+  end
+
+  def total_score
+    Scrabble::Scoring.word_scores(words_played).reduce(:+)
+  end
+
+  def highest_scoring_word
+    Scrabble::Scoring.highest_score_from(words_played, Scrabble::RWORD)
+  end
+
+  def highest_word_score
+    p words_played
+    Scrabble::Scoring.highest_score_from(words_played, Scrabble::RPOINTS)
+  end
+
+  def draw_tiles(tile_bag)
+    tile_bag.draw_tiles(7 - player_tiles.length).each do |letter|
+      @player_tiles << letter
+    end
+
+  end
+
+
+end

lib/scoring.rb

@@ -0,0 +1,103 @@
+class Scrabble::Scoring
+
+  SCORE_CHART = {
+"A" => 1,
+"E" => 1,
+"I" => 1,
+"O" => 1,
+"U" => 1,
+"L" => 1,
+"N" => 1,
+"R" => 1,
+"S" => 1,
+"T" => 1,
+"D" => 2,
+"G" => 2,
+"B" => 3,
+"C" => 3,
+"M" => 3,
+"P" => 3,
+"F" => 4,
+"H" => 4,
+"V" => 4,
+"W" => 4,
+"Y" => 4,
+"K" => 5,
+"J" => 8,
+"X" => 8,
+"Q" => 10,
+"Z" => 10
+}
+
+  # Take a word, upcase it, and return an array of its letters
+  def self.word_letters(word)
+     word.upcase.split(//)
+  end
+
+  # Finds the point value of each letter given
+  def self.letter_points(letter)
+    SCORE_CHART.fetch(letter)
+  end
+
+  # Finds point value of each letter in a word
+  # Creates an array of points for each letter
+  def self.word_points(word)
+    word_letters(word).map { |i| letter_points(i) }
+  end
+
+  # Sums the points from the word_points array
+  def self.score(word)
+    total = 0
+    # Adds a bonus for 7-letter words.
+    if word_points(word).length == 7 then total = 50 end
+    total += word_points(word).reduce(:+)
+    total
+    #=> Fixnum score of word Ex: if word = "dumpling" returns 14
+  end
+
+  def self.word_scores(array_of_words)
+    # word_scores stores the points of each word in the array_of_words
+    array_of_words.map { |word| score(word) }
+    #=> Ex: TEST_WORD_ARRAY3 => [5, 20, 7, 20, 3, 70]
+  end
+
+  def self.word_score_pairs(array_of_words)
+    # scores each word in array_of_words, then zips scores to words, creating subarray pairs - still in original TEST_WORD_ARRAY order.
+    array_of_words.zip(word_scores(array_of_words))
+    #=> Ex: TEST_WORD_ARRAY3 => [["cat", 5], ["jeez", 20], ["foot", 7], ["furzy", 20], ["see", 3], ["bcmpbcg", 70]]
+  end
+
+  def self.sort_pairs(array_of_words)
+    # takes array from word_score_pairs and sorts by points.
+    word_score_pairs(array_of_words).sort_by { |pair| pair[1]}
+    #=> Ex: TEST_WORD_ARRAY3 => [["see", 3], ["cat", 5], ["foot", 7], ["jeez", 20], ["furzy", 20], ["bcmpbcg", 70]]
+  end
+
+  def self.find_ties(array_of_words)
+    # If multiple words have the same highest-score, return the word with the least letters
+    sort_pairs(array_of_words).find_all { |pair| pair[1] == sort_pairs(array_of_words)[-1][1] }
+    #=> Ex: TEST_WORD_ARRAY3 => [["bcmpbcg", 70]]
+    #=> Ex: TEST_WORD_ARRAY2 => [["jeez", 20], ["furzy", 20]]
+  end
+
+  def self.ties_w_seven_letters(array_of_words)
+    find_ties(array_of_words).find_all { |word, points| word.length == 7 }
+    #=> Ex: TEST_WORD_ARRAY5 => [["bgeeeee", 60]]
+  end
+
+  # Returns the highest-valued word in a word_array.
+  def self.highest_score_from(array_of_words, index)
+    if find_ties(array_of_words).length > 1
+      if ties_w_seven_letters(array_of_words).length >= 1
+        return ties_w_seven_letters(array_of_words)[0][index]
+      else
+        least_letters = find_ties(array_of_words).min_by { |pair| pair[0].length}
+        return least_letters[index]
+      end
+    end
+    # Returns the highest-scoring word.
+    p sort_pairs(array_of_words)[-1][index]
+    # "affined"
+    # "bcmpbcg"
+  end
+end

lib/tilebag.rb

@@ -0,0 +1,68 @@
+class Scrabble::TileBag
+
+  attr_reader :tilebag
+
+  def initialize
+    @tilebag = [
+      "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)
+    @tilebag = @tilebag.shuffle
+    tiles_drawn = @tilebag.shift(num)
+  end
+
+  def tiles_remaining
+    @tilebag.length
+  end
+
+end
+
+#
+# # We used this to generate tilebag array :o)
+# #
+# h = {
+#   "A" => 9,
+#   "N" => 6,
+#   "B" => 2,
+#   "O" => 8,
+#   "C" => 2,
+#   "P" => 2,
+#   "D" => 4,
+#   "Q" => 1,
+#   "E" => 12,
+#   "R" => 6,
+#   "F" => 2,
+#   "S" => 4,
+#   "G" => 3,
+#   "T" => 6,
+#   "H" => 2,
+#   "U" => 4,
+#   "I" => 9,
+#   "V" => 2,
+#   "J" => 1,
+#   "W" => 2,
+#   "K" => 1,
+#   "X" => 1,
+#   "L" => 4,
+#   "Y" => 2,
+#   "M" => 2,
+#   "Z" => 1
+# }
+#
+# a = []
+#
+# h.each do |letter, count|
+#   count.times do
+#     a << letter
+#   end
+# end
+#
+# p a

scrabble.rb

@@ -0,0 +1,13 @@
+module Scrabble
+
+# can we put highest_score methods from player and scoring in here and import them in those classes? use super?
+
+  require_relative 'lib/scoring'
+  require_relative 'lib/player'
+  require_relative 'lib/tilebag'
+
+  RWORD = 0 # return word in methods that are double-indexed
+  RPOINTS = 1 # return points in methods that are double-indexed
+
+
+end

specs/player_spec.rb

@@ -0,0 +1,98 @@
+require 'simplecov'
+SimpleCov.start
+
+require_relative 'spec_helper'
+
+describe Scrabble::Player do
+# call Dede! It's time for Scrabble!
+def dede
+  dede = Scrabble::Player.new("Dede")
+end
+
+  it "exists" do
+    Scrabble::Player.wont_be_nil
+  end
+
+  it "should require a name parameter" do
+    dede = Scrabble::Player.new("Dede")
+    assert_equal "Dede", dede.name
+  end
+
+  describe "Scrabble::Player#won?" do
+    it "returns true for a winning score of 100 or more and false for any lower score" do
+      dede = Scrabble::Player.new("Dede")
+      dede.play("kitteh")
+      dede.play("cat")
+      dede.play("ZZZZZZZ")
+      assert_equal true, dede.won?
+    end
+  end
+
+
+  describe "Scrabble::Player#play(word)" do
+    it "should push the played word into the words_played array" do
+      dede = Scrabble::Player.new("Dede")
+      dede.play("dumpling")
+      assert dede.words_played.include?("dumpling")
+    end
+
+    # need to test this method for when won? is true
+    it "returns the correct score for a played word" do
+      dede = Scrabble::Player.new("Dede")
+      assert_equal 14, dede.play("dumpling")
+    end
+
+    it "removes the letters in a played word from player_tiles" do
+      dede = Scrabble::Player.new("Dede")
+      new_tilebag = Scrabble::TileBag.new
+      dede.draw_tiles(new_tilebag)
+      print "HERE #{dede.player_tiles} END"
+      sample_tiles = dede.player_tiles[0..2]
+      dede.play(sample_tiles.join)
+      p dede.player_tiles
+    end
+  end
+
+  describe "Scrabble::Player#total_score" do
+    it "returns the sum of scores in words_played" do
+      dede = Scrabble::Player.new("Dede")
+      dede.play("dumpling") # 14
+      dede.play("donut") # 6
+      dede.play("doodoo") # 8
+      assert_equal 28, dede.total_score
+    end
+  end
+
+  describe "Scrabble::Player#highest_scoring_word" do
+    it "returns the highest-scoring word in words_played" do
+      dede = Scrabble::Player.new("Dede")
+      dede.play("dumpling") # 14
+      dede.play("donut") # 6
+      dede.play("doodoo") # 8
+      assert_equal "dumpling", dede.highest_scoring_word
+    end
+  end
+
+  describe "Scrabble::Player#highest_word_score" do
+    it "returns the highest score from words_played" do
+      dede = Scrabble::Player.new("Dede")
+      dede.play("dumpling") # 14
+      dede.play("donut") # 6
+      dede.play("doodoo") # 8
+      assert_equal 14, dede.highest_word_score
+    end
+  end
+
+  describe "Scrabble::Player#draw_tiles" do
+    it "draws a number of tiles from TileBag to make player_tiles have 7 items" do
+      new_tilebag = Scrabble::TileBag.new
+      doris = Scrabble::Player.new("Doris")
+      doris.player_tiles = ["a", "b", "c"]
+      p doris.player_tiles
+      doris.draw_tiles(new_tilebag)
+      p doris.player_tiles
+    end
+  end
+
+
+end