Will Fox: Game On!

flashcard_runner.rb

@@ -0,0 +1,92 @@
+require 'pry'
+require './lib/card'
+require './lib/turn'
+require './lib/deck'
+require './lib/round'
+require 'colorize'
+
+colors = [:light_red, :light_green, :yellow, :light_blue, :light_magenta, :light_cyan]
+
+def cputs(message, colors)
+    puts message.colorize(colors.sample)
+end
+
+def cp(message, colors)
+    puts message.inspect.colorize(colors.sample)
+  end
+
+card1 = Card.new("What is the name of the island in the film Jurassic Park?", "Isla Nublar", :Movies)
+card2 = Card.new("What is the title of the Beatles' final album release?", "Let it Be", :Music)
+card3 = Card.new("What is the capital city of Spain?", "Madrid", :Geography)
+card4 = Card.new("Who played the hit-man, Jules in the film Pulp Fiction?", "Samuel L Jackson", :Movies)
+card5 = Card.new("What is the smallest US State?", "Rhode Island", :Geography)
+card6 = Card.new("Who wrote the 1971 hit song, What's Going On?", "Marvin Gaye", :Music)
+card7 = Card.new("Who played Elizabeth, in the film Pirates of the Caribbean?", "Keira Knightley", :Movies)
+card8 = Card.new("What is the largest ski area in Colorado?", "Vail", :Geography)
+
+cards = [card1, card2, card3, card4, card5, card6, card7, card8]
+
+deck = Deck.new(cards)
+
+round = Round.new(deck)
+
+def start_game(round, colors)
+
+    initial_card_count = round.deck.cards.size # added this variable for correct interpolation in Game Over message
+
+    puts ""
+    cputs("Welcome! You're playing Will's Trivia with #{initial_card_count} cards.", colors)
+    puts ""
+    cputs(">>>---- Game On! ----<<<", colors)
+    puts ""
+    # round.deck.cards.each do |card|
+        while !round.deck.cards.empty? do
+            cputs("This is card number #{round.turns.count + 1} out of #{initial_card_count}... 'cue Jeopardy theme song'...", colors)
+            puts ""
+            cp(round.current_card.question, colors)
+            puts ""
+            cputs("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", colors)
+            puts ""
+            guess = gets.chomp
+            round.take_turn(guess)
+            puts ""
+            # puts round.turns.last.feedback 
+            case [round.last_turn.correct?, round.last_turn.card.category] 
+            when [true, :Movies]
+                cp("Film buff huh? I bet you have a Criterion Collection subscription don't you?", colors)
+            when [true, :Music]
+                cp("Yep, wow, you must have an exquisite vinyl collection...", colors)
+            when [true, :Geography]
+                cp("I'm truly jealous of how worldly you are, take me with you next time?", colors)
+            when [false, :Movies] 
+                cp("Nope. You can use my Netflix password if you want.", colors)
+            when [false, :Music]
+                cp("Uh oh, we've got to get you some better headphones!", colors)
+            when[false, :Geography] 
+                cp("Welp! Time to invest in a globe!", colors)
+            end
+            puts ""
+        end
+
+    cputs("****** Game Over! ******", colors)
+    puts ""
+    cputs("You had #{round.number_correct} correct guesses out of #{initial_card_count} for a total score of #{round.percent_correct.round(0)}%", colors)
+    puts ""
+
+    cards_played = round.turns.map do |turn| #must use turns to access card objects, deck is depleted
+        turn.card
+    end
+
+    categories = cards_played.map do |card|
+        card.category
+    end
+
+    unique_categories = categories.uniq 
+
+    unique_categories.each do |category|
+        cputs("#{category} - #{round.percent_correct_by_category(category).round(0)}% correct", colors)
+    end
+    puts ""
+end
+
+start_game(round, colors)

lib/card.rb

@@ -0,0 +1,9 @@
+class Card
+    attr_reader :question, :answer, :category
+
+    def initialize(question, answer, category)
+        @question = question
+        @answer = answer
+        @category = category
+    end
+end

lib/deck.rb

@@ -0,0 +1,17 @@
+class Deck 
+    attr_reader :cards
+
+    def initialize(cards) 
+        @cards = cards
+    end
+
+    def cards_in_category(category)
+        @cards.select do |card|
+        card.category == category 
+        end
+    end
+
+    def card_count
+        @cards.count
+    end
+end

lib/round.rb

@@ -0,0 +1,65 @@
+require 'pry'
+
+class Round
+    attr_reader :deck, :turns
+
+    def initialize(deck)
+        @deck = deck 
+        @turns = []
+    end
+
+    def current_card
+        @deck.cards.first
+    end 
+
+    def take_turn(guess)
+        new_turn = Turn.new(guess, current_card)
+        @turns << new_turn
+        @deck.cards.shift 
+        new_turn 
+    end
+
+    def turn_count #refactored these names for clarity and consistency, I believe this is an example of Law of Demeter 
+        @turns.count # was def count, @rounds.turns.count (in spec file)
+    end
+
+    def last_turn #previously was def last, @round.turns.last (in spec file)
+        @turns.last
+    end
+
+    def number_correct #need to test for more options, even if it's working in runner
+        correct_count = 0
+
+        @turns.each do |turn|
+          if turn.correct?
+            correct_count += 1
+          end 
+        end
+        correct_count
+    end
+
+    def correct_by_category(category)
+        correct_by_cat_count = 0
+
+        @turns.each do |turn|
+            if turn.correct? && turn.card.category == category
+                correct_by_cat_count += 1
+            end
+        end
+        correct_by_cat_count
+    end
+
+    def percent_correct
+       (number_correct / turn_count.to_f) * 100
+    end
+
+    def percent_correct_by_category(category)
+        count_by_cat = 0
+        @turns.each do |turn|
+            if turn.card.category == category 
+                count_by_cat += 1
+            end
+        end
+        (correct_by_category(category) / count_by_cat.to_f) * 100
+    end
+end

lib/turn.rb

@@ -0,0 +1,20 @@
+class Turn 
+    attr_reader :guess, :card
+
+    def initialize(guess, card)
+        @guess = guess
+        @card = card 
+    end
+
+    def correct? 
+        @guess.strip.upcase == @card.answer.strip.upcase #case and whitespace insensitivity
+    end
+
+    def feedback # technically not using this method in game because I wanted to customize the feedback based on category
+        if correct? 
+            "Correct!"
+        else 
+            "Incorrect."
+        end
+    end
+end

spec/card_spec.rb

@@ -1,27 +1,30 @@
+require 'pry'
 require './lib/card'
 
 RSpec.describe Card do
   it 'exists' do
     card = Card.new("What is the capital of Alaska?", "Juneau", :Geography)
-
     expect(card).to be_instance_of(Card)
   end
 
-  it 'has a question' do
-    card = Card.new("What is the capital of Alaska?", "Juneau", :Geography)
-
-    expect(card.question).to eq("What is the capital of Alaska?")
+  describe '#question' do
+    it 'has a question' do
+      card = Card.new("What is the capital of Alaska?", "Juneau", :Geography)
+      expect(card.question).to eq("What is the capital of Alaska?")
+    end
   end
 
-  it 'has an answer' do
-    card = Card.new("What is the capital of Alaska?", "Juneau", :Geography)
-
-    expect(card.answer).to eq("Juneau")
+  describe '#answer' do
+    it 'has an answer' do
+      card = Card.new("What is the capital of Alaska?", "Juneau", :Geography)
+      expect(card.answer).to eq("Juneau")
+    end
   end
 
-  it 'has a category' do
-    card = Card.new("What is the capital of Alaska?", "Juneau", :Geography)
-
-    expect(card.category).to eq(:Geography)
+  describe '#category' do
+    it 'has a category' do
+      card = Card.new("What is the capital of Alaska?", "Juneau", :Geography)
+      expect(card.category).to eq(:Geography)
+    end
   end
 end

spec/deck_spec.rb

@@ -0,0 +1,33 @@
+require 'pry'
+require './lib/card'
+require './lib/deck'
+
+RSpec.describe Deck do 
+    before(:each) do
+        @card1 = Card.new("What is the capital of Alaska?", "Juneau", :Geography)
+        @card2 = Card.new("Which planet is closest to the sun?", "Mercury", :STEM)
+        @card3 = Card.new("Describe in words the exact direction that is 697.5° clockwise from due north?", "North north west", :STEM)
+        @cards = [@card1, @card2, @card3]
+        @deck1 = Deck.new(@cards) 
+    end
+
+    it 'exists' do
+        expect(@deck1).to be_a(Deck)
+    end
+
+    it '#cards returns the collection of cards' do
+        expect(@deck1.cards).to eq([@card1, @card2, @card3]) 
+    end 
+
+    describe '#cards_in_category' do
+      it 'checks what category a card belongs to' do 
+          expect(@deck1.cards_in_category(:STEM)).to eq([@card2, @card3])
+          expect(@deck1.cards_in_category(:Geography)).to eq([@card1])
+          expect(@deck1.cards_in_category("Pop Culture")).to eq([])
+        end
+    end
+
+    it '#card_count returns the number of cards in the deck' do
+        expect(@deck1.card_count).to eq(3)
+    end 
+end