Ana Lisa & Jamila: Octos-C9

lib/player.rb

@@ -0,0 +1,53 @@
+# require 'pry'
+require_relative 'scoring'
+module Scrabble
+  class Player
+    attr_reader :name, :played_words
+    def initialize(player_name)
+      @name = player_name
+      @played_words = []
+    end
+
+    def plays
+      return  @played_words
+    end
+
+    def play(word)
+      @played_words << word
+
+      if won
+        return false
+      else
+        return Scrabble::Scoring.score(word)
+
+      end
+    end
+    # calculates the score of all the words
+    def total_score
+      word_scores = @played_words.map do |word|
+         Scrabble::Scoring.score(word)
+      end
+      # this will allow me to see if something inside a loop is not what I expect
+      # if word_scores.include?(nil)
+      #   binding.pry
+      # end
+      return word_scores.inject(:+)
+    end
+
+    def won
+      if total_score > 100
+        return true
+      else
+        return false
+
+      end
+
+      def highest_scoring_word
+        Scrabble::Scoring.highest_score_from(plays)
+
+      end
+
+
+    end
+  end
+end

lib/scoring.rb

@@ -1,9 +1,100 @@
+require 'pry'
 module Scrabble
   class Scoring
+    LETTER_VALUES =
+    {
+      :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
+    }
+
     def self.score(word)
+      # Check word for invalid characters
+      if !/[^a-zA-Z]+/.match(word)
+        # Split the word into its indvidual letters and store in array
+        user_word = word.upcase.split(//)
+        # Adds 50 points for 7 letter words
+        word_total = 0
+        # checks if word length is equal to seven and adds 50 pts
+        if user_word.length == 7
+          word_total += 50
+        elsif
+          # checks if word length is greater then 7, and returns nil
+          user_word.length > 7 || user_word.length == 0
+          return nil
+        end
+        # iterate over each letter
+        user_word.each do |letter|
+          letter = letter.to_sym
+          if LETTER_VALUES.has_key?(letter)
+            word_total += LETTER_VALUES[letter]
+          end
+        end
+        return word_total
+      else
+        return nil
+      end
     end
 
+
     def self.highest_score_from(array_of_words)
+      # RETURNS NIL FOR EMPTY ARRAY
+      if array_of_words.length == 0
+        return nil
+        # RETURNS WORD FROM ARRAY LENGTH 1
+      elsif array_of_words.length == 1
+        return array_of_words[0]
+      else
+        scores = []
+        array_of_words.each do |word|
+          scores << Scrabble::Scoring.score(word)
+        end
+        highest_score = scores.max
+        highest_words = []
+        longest_word = nil
+        array_of_words.each do |word|
+          if Scrabble::Scoring.score(word) == highest_score
+            highest_words << word
+          end
+          # binding.pry
+          # sorts through words depending on length
+          longest_word = highest_words.sort_by do |word| word.length
+            if word.length == 7
+              longest_word = word
+              return longest_word
+              # if length is not 7 returns the shortest word
+            elsif word.length < 7
+              longest_word = word
+              return longest_word
+            end
+          end
+        end
+        return scores
+        total_score = scores.inject(0, :+)
+      end
     end
   end
 end

specs/player_spec.rb

@@ -0,0 +1,158 @@
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'minitest/skip_dsl'
+
+require_relative '../lib/player'
+
+
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+
+describe 'Player' do
+  describe 'name' do
+    it 'can return a name' do
+      #Arrange
+      name = 'Gordon'
+      #Act/Assert
+      Scrabble::Player.new(name).name.must_equal 'Gordon'
+    end
+
+    # xit '' do
+    #
+    # end
+  end
+
+  describe 'plays' do
+    it 'it can return an array' do
+      player = Scrabble::Player.new('')
+      player.plays.must_be_instance_of Array
+    end
+
+    # xit '' do
+    #
+    # end
+  end
+
+  describe 'play(word)' do
+    # Feedback mentions testing edge cases for this method
+    it 'takes word and adds it to the plays array' do
+    # arrange
+      word = 'batshit'
+      player = Scrabble::Player.new('')
+
+      # Act
+      player.play(word)
+
+      # Assert
+      player.plays.must_include 'batshit'
+    end
+
+    it 'returns false if player has already won' do
+      # Arrange
+      word = "crazy"
+      word_1 = 'janky'
+      word_2 = 'coding'
+      word_3 = 'dancing'
+      word_4 = 'hah'
+      player = Scrabble::Player.new('')
+
+      # Act
+      player.play(word)
+      player.play(word_1)
+      player.play(word_2)
+      player.play(word_3)
+
+      # Assert
+      player.play(word_4).must_equal false
+
+    end
+
+    it 'returns score of the word' do
+      word = "guano"
+      Scrabble::Player.new('').play(word)
+
+      Scrabble::Scoring.score(word).must_equal 6
+
+      # Scrabble::Player.new('').play(word).score(word).must_equal 7
+    end
+  end
+
+  xdescribe 'total_score' do
+    xit 'Returns the sum of scores of played words' do
+      # Arrange
+      player = Scrabble::Player.new('')
+      word = "crazy"
+      word_1 = 'janky'
+      word_2 = 'coding'
+      word_3 = 'dancing'
+      word_4 = 'hah'
+
+      # Act
+      player.play(word)
+      player.play(word_1)
+      player.play(word_2)
+      player.play(word_3)
+      player.plays
+      player.total_score
+
+      # Assert
+      player.total_score.must_be Integer
+
+
+    end
+
+    xit '' do
+
+    end
+  end
+
+  describe 'won?' do
+    it 'if player has > 100 point score, return true' do
+      word = "crazy"
+      word_1 = 'janky'
+      word_2 = 'coding'
+      word_3 = 'dancing'
+      word_4 = 'hah'
+      player = Scrabble::Player.new('')
+
+      # act
+      player.play(word)
+      player.play(word_1)
+      player.play(word_2)
+      player.play(word_3)
+      player.total_score
+
+      # Assert
+      player.won.must_equal true
+    end
+
+    xit '' do
+
+    end
+  end
+
+  describe 'highest_scoring_word' do
+    it 'Returns highest scoring played_word' do
+      word = "crazy"
+      word_1 = 'janky'
+      # word_2 = 'coding'
+      word_3 = 'dancing'
+      # word_4 = 'hah'
+      player = Scrabble::Player.new('')
+
+      player.play(word)
+      player.play(word_1)
+      # player.play(word_2)
+      player.play(word_3)
+
+      player.highest_scoring_word.must_equal 'dancing'
+
+
+    end
+
+    xit '' do
+
+    end
+  end
+end

specs/scoring_spec.rb

@@ -42,21 +42,35 @@
 
   describe 'highest_score_from' do
     it 'returns nil if no words were passed' do
+      Scrabble::Scoring.highest_score_from('').must_be_nil
     end
 
     it 'returns the only word in a length-1 array' do
+      array_of_words = ['far']
+      Scrabble::Scoring.highest_score_from(array_of_words).must_equal 'far'
     end
 
     it 'returns the highest word if there are two words' do
+      array_of_words = ['cat', 'zoo']
+      Scrabble::Scoring.highest_score_from(array_of_words).must_equal 'zoo'
     end
 
     it 'if tied, prefer a word with 7 letters' do
+      array_of_words = ['dog', 'course', 'lungers']
+      Scrabble::Scoring.highest_score_from(array_of_words).must_equal 'lungers'
     end
 
     it 'if tied and no word has 7 letters, prefers the word with fewer letters' do
+      # arrange
+       array_of_words = ['jot','ploys','cat']
+      # act/assert
+      Scrabble::Scoring.highest_score_from(array_of_words).must_equal 'jot'
+
     end
 
     it 'returns the first word of a tie with same letter count' do
+      array_of_words = ['jot','jet','ploy']
+      Scrabble::Scoring.highest_score_from(array_of_words).must_equal 'jot'
     end
   end
 end