games_bfox 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eea4457891bd6031147b650c010445ea236d8e74
-  data.tar.gz: d37e19b5a8627b9d6b4c7cd5f2214c1c726f8d85
+  metadata.gz: b869fc9dbf4366e974cab29e2e0fec776fcd6f30
+  data.tar.gz: 47921477fd8d4c7d703cc5867a464bd26fac0050
 SHA512:
-  metadata.gz: 9a19f97734b8a705a775424c3d18d52aa7174c379bf89061fd83e92cc2311a355b7650257712fa33f2b96c9751053e79e86b96ce5c52cd506a07921a5b520777
-  data.tar.gz: 97764dfed555860fae880c91bfe2cf73ff2ca6448bf86e85018097329f2cefc9003cacae4a04be1da8104d4f758d1dfa6686d71bbf6fe1f1accb96ca8919ea34
+  metadata.gz: e69728ecffc7184b02c99a33d3d673defac42d8803bf113b2084ae45c6aee9598e11e3c40c536fa296877446541a53798a97baf799bfa507d9b8947c3961f788
+  data.tar.gz: bc49069cd841039d46e369b4276774084bff81f2c10a886eebf033fabda23fa8c83ef026c8d74c0cfe0a75da8298b2a578e94af55d2aff3e19c56c60dfd0e2dd

data/README.md

@@ -1,15 +1,14 @@
-# Games
+# games_bfox
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/games`. To experiment with that code, run `bin/console` for an interactive prompt.
+Welcome to the games_bfox gem!
 
-TODO: Delete this and the text above, and describe your gem
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'games'
+gem 'games_bfox'
 ```
 
 And then execute:
@@ -18,19 +17,16 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install games
+    $ gem install games_bfox
 
 ## Usage
 
-TODO: Write usage instructions here
+To play Mastermind, type the following into your command line to run the game executable :
 
-## Development
+    $ mastermind
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+To play Tic Tac Toe, type the following into your command line to run the game executable :
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+    $ tictactoe
 
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/games.
 

data/config/application.yml

@@ -0,0 +1,5 @@
+#not used. Figaro appears to rely on Rails
+#https://github.com/laserlemon/figaro/issues/77
+
+#POSTGRES_USERNAME: "Brett"
+#POSTGRES_PASSWORD:

data/games.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["brettfox11@gmail.com"]
 
   spec.summary       = %q{Play tic tac toe and mastermind on the command line}
-  spec.description   = %q{In order to play, download the gem, and type \"tictactoe\" or \"mastermind\" at your terminal.}
+  spec.description   = %q{In order to play, download the gem, and type "tictactoe" or "mastermind" at your terminal. Type "exit" to quit the game.}
   spec.homepage      = "https://github.com/brett11/games"
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
@@ -33,4 +33,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.6"
   spec.add_development_dependency 'pry', '~> 0.10.4'
   spec.add_development_dependency 'logging', '~> 2.2', '>= 2.2.2'
+  spec.add_development_dependency 'paint', '~> 2.0'
 end

data/lib/games/mastermind/board_builder.rb

@@ -1,9 +1,13 @@
 require_relative 'pegs_factory'
+require_relative 'board'
 
 module MM
   class BoardBuilder
-    def generate_empty_board(config)
-      Board.new(number_of_rows: config.number_of_rows, number_of_cols: config.number_of_cols, pegs: PegsFactory.build_empty_pegs(config.number_of_rows, config.number_of_cols), result_pegs: PegsFactory.build_empty_pegs(config.number_of_rows, config.number_of_cols) )
+    def generate_empty_board(number_of_rows = 12, number_of_cols = 4)
+      MM::Board.new(number_of_rows: number_of_rows,
+                    number_of_cols: number_of_cols,
+                    pegs: MM::PegsFactory.build_empty_pegs(number_of_rows, number_of_cols),
+                    result_pegs: MM::PegsFactory.build_empty_pegs(number_of_rows, number_of_cols) )
     end
   end
 end

data/lib/games/mastermind/computer_player_expert.rb

@@ -0,0 +1,31 @@
+require_relative '../shared/player'
+
+module MM
+  class ComputerPlayerExpert < Shared::Player
+    def make_move(game)
+      @game = game
+      computer_choosing_graphic
+      smart_move
+    end
+
+    def smart_move
+      secret_code = current_result_partial_match_values.concat(current_result_exact_match_values)
+      (4-(secret_code.size)).times do
+        secret_code.push((1..6).to_a.sample)
+      end
+      secret_code.shuffle
+    end
+
+    def computer_choosing_graphic
+      @game.computer_choosing_graphic
+    end
+
+    def current_result_partial_match_values
+      @game.current_result_partial_match_values
+    end
+
+    def current_result_exact_match_values
+      @game.current_result_exact_match_values
+    end
+  end
+end

data/lib/games/mastermind/computer_player_novice.rb

@@ -0,0 +1,18 @@
+require_relative '../shared/player'
+
+module MM
+  class ComputerPlayerNovice < Shared::Player
+    def make_move(game)
+      game.computer_choosing_graphic
+      random_move
+    end
+
+    def random_move
+      guess = []
+      4.times do
+        guess.push((1..6).to_a.sample)
+      end
+      guess
+    end
+  end
+end

data/lib/games/mastermind/game.rb

@@ -3,26 +3,61 @@ require 'logger'
 
 module MM
   class Game < Shared::Game
-    attr_accessor :code_setter, :secret_code, :guess_evaluator, :current_guess, :current_result, :won_flag
+    attr_accessor :secret_code, :current_result
 
-    def local_setup
-      self.code_setter = config.code_setter
-      self.secret_code = config.secret_code
+    def one_time_setup
+      self.players = players_factory.generate_players
+      self.board = board_builder.generate_empty_board
+    end
+
+    def every_time_setup
+      self.number_of_turns_taken = 0
+      self.won_flag = false
+      self.secret_code = set_secret_code
+      self.current_result = MM::GuessEvaluatorResult.new
       logger = Logger.new(STDOUT)
       logger.level = Logger::DEBUG
       logger.debug("The secret code is #{secret_code.join(",")}.")
-      self.guess_evaluator = MM::GuessEvaluator.new
-      self.current_guess = []
-      self.current_result = []
+    end
+
+
+    def set_secret_code
+      is_code_guesser_human = (players[0].kind_of?(MM::HumanPlayer))
+      MM::SecretCode.generate(io_helpers, is_code_guesser_human)
+    end
+
+    def change_game_state(move)
+      self.current_result = evaluate_guess(secret_code, move)
+      change_pegs(move)
+      if !won?
+        move_forward_one_turn
+      end
+    end
+
+    def current_result_partial_match_values
+      current_result.partial_match_values
+    end
+
+    def current_result_exact_match_values
+      current_result.exact_match_values
+    end
+
+    def reset_game
+      reset_board
+      self.number_of_turns_taken = 0
       self.won_flag = false
     end
 
-    def over?
-      won? || over_with_no_winner?
+    def reset_board
+      self.board = generate_empty_board
     end
 
-    def over_with_no_winner?
-      number_of_turns_taken >= 12
+    def generate_empty_board
+      board_builder.generate_empty_board
+    end
+
+    def over?
+      won? || no_more_turns?
     end
 
     def won?
@@ -31,7 +66,7 @@ module MM
         return true
       end
 
-      if current_result == ("X" * number_of_cols).chars
+      if self.current_result.is_won
         self.won_flag = true
         true
       else
@@ -39,12 +74,27 @@ module MM
       end
     end
 
+    def no_more_turns?
+      number_of_turns_taken >= 12
+    end
+
+    def change_pegs(guess)
+      pegs_current_row.each_with_index do |peg, index|
+        peg.change_value(guess[index])
+      end
+
+      result_pegs_current_row.each_with_index do |result_peg, index|
+        result_peg.change_value(current_result.xo_key[index])
+      end
+    end
+
     def change_peg(row, col, new_value)
       board.change_peg(row, col, new_value)
     end
 
+    #below returns result object
     def evaluate_guess(secret_code, guess)
-      guess_evaluator.evaluate_guess(secret_code, guess)
+      MM::GuessEvaluator.evaluate_guess(secret_code, guess)
     end
 
     def pegs_current_row
@@ -55,12 +105,16 @@ module MM
       board.result_pegs_current_row(number_of_turns_taken)
     end
 
+    def number_of_rows
+      board.number_of_rows
+    end
+
     def number_of_cols
       board.number_of_cols
     end
 
-    def set_secret_code
-      config.set_secret_code
+    def get_player_choice(current_player_name)
+      io_helpers.get_player_choice(current_player_name)
     end
   end
 end

data/lib/games/mastermind/guess_evaluator.rb

@@ -1,85 +1,122 @@
-require_relative '../shared/array_iterator'
-require 'set.rb'
+require_relative "../../../lib/games/mastermind/guess_evaluator_result"
 
 module MM
   class GuessEvaluator
-    attr_accessor :secret_code
-    attr_accessor :guess
-    attr_accessor :result
-
-    # returns "XXXX" if perfect guess. returns XXO, for example, if two perfect guesses and one right digit but wrong place
-    def evaluate_guess(secret_code, guess)
-      @secret_code = Marshal.load(Marshal.dump(secret_code))
-      @guess = Marshal.load(Marshal.dump(guess))
-      #default when game starts is to have empty current_guess array
-      if guess.empty?
-        return []
+    # below returns a Result object that summarizes the XO key, partial matches, exact matches, and if the guess was correct/won
+    # xo_key returns "XXXX" if perfect guess. returns XXO, for example, if two perfect guesses and one right digit but wrong place
+    def self.evaluate_guess(secret_code, guess)
+      #make arguments immutable
+      secret_code.freeze
+      guess.freeze
+
+      result = MM::GuessEvaluatorResult.new
+
+      resX = generate_Xs_for_exact_matches(secret_code, guess, [])
+      result.exact_match_values = find_exact_matches_from_secret_code(secret_code, guess, [])
+      secret_code_remaining = trim_exact_matches_from_secret_code(secret_code, guess, [])
+      guess_remaining = trim_exact_matches_from_guess(secret_code, guess, [])
+      resO = generate_Os_for_partial_matches(secret_code_remaining, guess_remaining)
+      result.xo_key = resX.concat resO
+      result.partial_match_values = values_of_partial_matches(secret_code_remaining, guess_remaining)
+      result.is_won = (result.xo_key == ("X" * secret_code.size).chars)
+      result
+    end
+
+    def self.generate_Xs_for_exact_matches(secret_code, guess, accum)
+      return accum if secret_code.empty? || guess.empty?
+      head_code, *tail_code = secret_code
+      head_guess, *tail_guess = guess
+
+      if head_code == head_guess
+        generate_Xs_for_exact_matches(tail_code, tail_guess, accum.push("X"))
+      else
+        generate_Xs_for_exact_matches(tail_code, tail_guess, accum)
       end
-      @result = find_result
     end
 
-    def find_result
-      resX = find_exact_matches
-      resO = find_partial_matches
-      resX.concat resO
+    def self.find_exact_matches_from_secret_code(secret_code, guess, accum)
+      return accum if secret_code.empty? || guess.empty?
+      head_code, *tail_code = secret_code
+      head_guess, *tail_guess = guess
+
+      if head_code == head_guess
+        find_exact_matches_from_secret_code(tail_code, tail_guess, accum.push(head_code))
+      else
+        find_exact_matches_from_secret_code(tail_code, tail_guess, accum)
+      end
     end
 
-    def find_exact_matches
-      resX = []
-      set_of_matched_indexes = Set.new
-      guess.each_with_index do |element, index|
-        if element == secret_code[index]
-          resX.push ("X")
-          set_of_matched_indexes.add(index)
-        end
+    def self.trim_exact_matches_from_secret_code(secret_code, guess, accum)
+      return accum if secret_code.empty? || guess.empty?
+      head_code, *tail_code = secret_code
+      head_guess, *tail_guess = guess
+
+      if head_code == head_guess
+        trim_exact_matches_from_secret_code(tail_code, tail_guess, accum)
+      else
+        trim_exact_matches_from_secret_code(tail_code, tail_guess, accum.push(head_code))
       end
-      delete_elements_already_matched(set_of_matched_indexes)
-      resX
     end
 
-    def delete_elements_already_matched(set_of_matched_indexes)
-      secret_code.delete_if.with_index { |_, index| set_of_matched_indexes.include? index }
-      guess.delete_if.with_index { |_, index| set_of_matched_indexes.include? index }
+    def self.trim_exact_matches_from_guess(secret_code, guess, accum)
+      return accum if secret_code.empty? || guess.empty?
+      head_code, *tail_code = secret_code
+      head_guess, *tail_guess = guess
+
+      if head_code == head_guess
+        trim_exact_matches_from_guess(tail_code, tail_guess, accum)
+      else
+        trim_exact_matches_from_guess(tail_code, tail_guess, accum.push(head_guess))
+      end
     end
 
-    def find_partial_matches
-      resO = []
-      return resO if secret_code.empty? || guess.empty?
-      secret_code.sort!
-      guess.sort!
-
-      secret_code_iterator = Shared::ArrayIterator.new(secret_code)
-      guess_iterator = Shared::ArrayIterator.new(guess)
-
-      #get first elements from enums
-      code_element = secret_code_iterator.next_item
-      guess_element = guess_iterator.next_item
-
-
-      while true
-        if guess_element == code_element
-          resO.push("O")
-          if secret_code_iterator.has_next? && guess_iterator.has_next?
-            code_element = secret_code_iterator.next_item
-            guess_element = guess_iterator.next_item
-          else
-            break
-          end
-        elsif guess_element > code_element
-          if secret_code_iterator.has_next?
-            code_element = secret_code_iterator.next_item
-          else
-            break
-          end
-        else
-          if guess_iterator.has_next?
-            guess_element = guess_iterator.next_item
-          else
-            break
-          end
-        end
+    def self.generate_Os_for_partial_matches(secret_code, guess)
+      secret_code.freeze
+      guess.freeze
+
+      secret_code_copy = secret_code.sort
+      guess_copy = guess.sort
+      find_partial_matches_helper(secret_code_copy, guess_copy, [])
+    end
+
+    def self.find_partial_matches_helper(secret_code, guess, accum)
+      return accum if secret_code.empty? || guess.empty?
+
+      head_code, *tail_code = secret_code
+      head_guess, *tail_guess = guess
+
+      if head_code == head_guess
+        find_partial_matches_helper(tail_code, tail_guess, accum.push("O"))
+      elsif head_code > head_guess
+        find_partial_matches_helper(secret_code, tail_guess, accum)
+      elsif head_code < head_guess
+        find_partial_matches_helper(tail_code, guess, accum)
+      end
+    end
+
+    def self.values_of_partial_matches(secret_code, guess)
+      secret_code.freeze
+      guess.freeze
+
+      secret_code_copy = secret_code.sort
+      guess_copy = guess.sort
+      values_of_partial_matches_helper(secret_code_copy, guess_copy, [])
+    end
+
+    def self.values_of_partial_matches_helper(secret_code, guess, accum)
+      return accum if secret_code.empty? || guess.empty?
+
+      head_code, *tail_code = secret_code
+      head_guess, *tail_guess = guess
+
+      if head_code == head_guess
+        #could push either head_code or guess, won't matter since equal
+        values_of_partial_matches_helper(tail_code, tail_guess, accum.push(head_guess))
+      elsif head_code > head_guess
+        values_of_partial_matches_helper(secret_code, tail_guess, accum)
+      elsif head_code < head_guess
+        values_of_partial_matches_helper(tail_code, guess, accum)
       end
-      resO
     end
   end
 end

data/lib/games/mastermind/guess_evaluator_result.rb

@@ -0,0 +1,11 @@
+module MM
+  class GuessEvaluatorResult
+    attr_accessor :xo_key, :partial_match_values, :exact_match_values, :is_won
+    def initialize
+      @xo_key = []
+      @exact_match_values = []
+      @partial_match_values = []
+      @is_won = false
+    end
+  end
+end

data/lib/games/mastermind/human_player.rb

@@ -0,0 +1,9 @@
+require_relative '../shared/player'
+
+module MM
+  class HumanPlayer < Shared::Player
+    def make_move(game)
+      game.get_player_choice(game.current_player_name)
+    end
+  end
+end

data/lib/games/mastermind/io_helpers.rb

@@ -0,0 +1,65 @@
+require_relative '../shared/io_helpers'
+require 'paint'
+
+module MM
+  class IOHelpers < Shared::IOHelpers
+    def custom_final_message(game)
+      io.present_with_new_line("The secret code was #{game.secret_code.join(",")}")
+    end
+
+    def initial_instructions
+      io.present_with_new_line(Paint["-" * 60 + "MASTERMIND" + "-" * 60, :blue, :bold, :bright, :underline])
+      io.present_with_new_line(Paint["INSTRUCTIONS: ", :green] + "Try to guess a 4 digit code that consists of only numbers 1-6 (\"3164\", for example).\n\n")
+      io.present_with_new_line("After each guess, the \"Result\" section will generate an "+ Paint["\"X\" ", :bold, :magenta] + "for each digit in the guess that is perfect(correct number and correct spot) and an "+ Paint["\"O\" ", :bold, :magenta] + "for each digit that is the correct number but in the wrong spot.")
+      io.present_with_new_line("-" * 130)
+      io.present_with_new_line(Paint["Type ",:red] + Paint["\"Exit\" ", :red, :bold] + Paint["to quit the game.", :red])
+      io.present_with_new_line("-" * 130)
+    end
+
+    def no_winner_prompt(game)
+      if game.players[0].kind_of?(MM::HumanPlayer)
+        io.present_with_new_line(Paint["No such luck! Please try again.", :red, :bold])
+      else
+        io.present_with_new_line(Paint["The computer has been stumped!", :green, :bold])
+      end
+
+    end
+
+    def computer_or_human_guesser_inquiry
+      user_choice = get_user_input("Please enter " + Paint["\"1\" ", :blue, :bold] + "if you would like to be the code-guesser. Enter " + Paint["\"2\" ", :blue, :bold] + "if you would like to set the code and have the computer guess.", "Invalid entry. Please enter either 1(computer picks code) or 2 (you pick code)") do |input|
+        input == 1 || input == 2
+      end
+      if user_choice == 1
+        return :human
+      elsif user_choice == 2
+        return :computer
+      end
+    end
+
+    def get_secret_code_from_user
+      user_choice = get_user_input("Please enter a secret code consisting of four numbers that each correspond to a color. Do not separate with punctuation. The computer will try to guess this code.", "Please re-enter a secret code, using only 4 numbers, 1 through 6.") do |input|
+        input.to_s =~ /^[1-6]{4}$/
+      end
+      user_choice.to_s.chars.map(&:to_i)
+    end
+
+    def get_player_choice(current_player_name)
+      user_choice = get_user_input("#{current_player_name}, please enter a secret code consisting of 4 numbers that correspond to the color of your guess. Do not separate with punctuation.", "Please re-enter a secret code guess, using exactly 4 numbers, each being a digit 1 through 6.") do |input|
+        input.to_s =~ /^[1-6]{4}$/
+      end
+      user_choice.to_s.chars.map(&:to_i)
+    end
+
+    def get_computer_knowledge_level
+      user_choice = get_user_input("Please enter " + Paint["\"D\" ", :blue, :bold] + "if you would like the computer to be kinda dumb. Enter " + Paint["\"S\" ", :blue, :bold] + "if you would like the computer to be pretty smart.", "Invalid character. Please enter either D (dumb) or S (Smart).") do |input|
+        input == 's' || input == 'S' || input == 'd' || input == 'D'
+      end
+      user_choice = user_choice.upcase
+      if user_choice == "S"
+        :expert
+      elsif user_choice == "D"
+        :novice
+      end
+    end
+  end
+end

data/lib/games/mastermind/peg.rb

@@ -1,11 +1,9 @@
 module MM
   class Peg
-    attr_accessor :display_value, :row, :col
+    attr_accessor :display_value
 
-    def initialize(args)
+    def initialize(args = {})
       @display_value = args.fetch(:display_value, nil)
-      @row = args[:row]
-      @col = args[:col]
     end
 
     def change_value(new_value)

data/lib/games/mastermind/pegs.rb

@@ -5,7 +5,7 @@ module MM
     #collection_of_pegs is a multi-dimensional array
 
     def initialize(args)
-      @collection_of_pegs = args[:collection_of_pegs]
+      @collection_of_pegs = args.fetch(:collection_of_pegs)
     end
 
     def retrieve_peg(row, col)
@@ -29,14 +29,6 @@ module MM
       end
     end
 
-    def result_values
-      collection_of_pegs.reverse.map do |row|
-        row.map do |peg|
-          peg.result_value
-        end
-      end
-    end
-
     private
       def number_of_rows
         collection_of_pegs.length

data/lib/games/mastermind/pegs_factory.rb

@@ -10,17 +10,15 @@ module MM
 
       pegs.each_with_index do |element, row|
         element.each_index do |col|
-          pegs[row][col] = create_empty_peg(row, col)
+          pegs[row][col] = create_empty_peg
         end
       end
 
       pegs_class.new(collection_of_pegs: pegs)
     end
 
-    def self.create_empty_peg(row, col, display_value = nil, peg_class = Peg)
-      peg_class.new(display_value: display_value,
-                       row: row,
-                       col: col )
+    def self.create_empty_peg( peg_class = Peg)
+      peg_class.new
     end
   end
 end

data/lib/games/mastermind/players_factory.rb

@@ -1,15 +1,39 @@
-require_relative '../shared/player'
+require_relative 'human_player'
+require_relative 'computer_player_expert'
+require_relative 'computer_player_novice'
 
 module MM
-  class PlayersFactory
-    #returns an array in case we would like to extend the game to allow for multiple players
-    def generate_players(config)
-      if config.code_setter == :computer
-        player_1 = Shared::Player.new(name: config.player_1_name)
+  class PlayersFactory < Shared::PlayersFactory
+    def generate_players
+      player_1 = generate_player_1
+      [player_1]
+    end
+
+    def generate_player_1
+      code_guesser = io_helpers.computer_or_human_guesser_inquiry
+      if code_guesser == :human
+        generate_player_1_new
       else
-        player_1 = Shared::Player.new(name: config.player_1_name, type: :computer)
+        computer_knowledge_level = io_helpers.get_computer_knowledge_level
+        if computer_knowledge_level == :novice
+          generate_player_1_computer_novice
+        else
+          generate_player_1_computer_expert
+        end
       end
-      [player_1]
+    end
+
+    def generate_player_1_new
+      player_name = io_helpers.get_player_1_name
+      MM::HumanPlayer.new(name: player_name)
+    end
+
+    def generate_player_1_computer_novice
+      MM::ComputerPlayerNovice.new(name: "Computer")
+    end
+
+    def generate_player_1_computer_expert
+      MM::ComputerPlayerExpert.new(name: "Computer")
     end
   end
 end