games_bfox 0.3.0 → 0.4.0

data/lib/games/mastermind/secret_code.rb

@@ -0,0 +1,19 @@
+module MM
+  class SecretCode
+    def self.generate(io_helpers, is_code_guesser_human)
+      if is_code_guesser_human
+        set_secret_code
+      else
+        io_helpers.get_secret_code_from_user
+      end
+    end
+
+    def self.set_secret_code
+      secret_code = []
+      4.times do
+        secret_code.push((1..6).to_a.sample)
+      end
+      secret_code
+    end
+  end
+end

data/lib/games/mastermind.rb

@@ -4,10 +4,17 @@ Dir[File.join(File.expand_path(File.dirname(__FILE__)), 'mastermind', '*.rb')].e
 class Mastermind
   def self.run
     io = Shared::IOTerminal.new
+    io_helpers = MM::IOHelpers.new(io)
     board_presenter = MM::BoardPresenterTerminal.new
+    board_builder = MM::BoardBuilder.new
+    players_factory = MM::PlayersFactory.new(io_helpers)
 
-    game = MM::Game.new(game_module: MM, io: io, board_presenter: board_presenter)
-    # game.setup
+    game = MM::Game.new(
+                         io_helpers: io_helpers,
+                         board_presenter: board_presenter,
+                         board_builder: board_builder,
+                         players_factory: players_factory
+    )
     game.play
   end
 end

data/lib/games/shared/game.rb

@@ -1,4 +1,5 @@
 Dir[File.join(File.dirname(__FILE__), '*.rb')].each {|file| require file }
+# note the below exclude the game subclasses, because these classes inherit from this class, so if we require these before the parent class is read, an error will be generated.
 Dir[File.join(File.expand_path("..", File.dirname(__FILE__)), 'tictactoe', '*.rb')].each {|file| require file unless file == File.join(File.expand_path("..", File.dirname(__FILE__)), 'tictactoe', 'game.rb')}
 Dir[File.join(File.expand_path("..", File.dirname(__FILE__)), 'mastermind', '*.rb')].each {|file| require file unless file == File.join(File.expand_path("..", File.dirname(__FILE__)), 'mastermind', 'game.rb')}
 
@@ -6,60 +7,29 @@ module Shared
   class Game
     attr_accessor :board, :board_presenter, :board_builder
     attr_accessor :players, :players_factory
-    attr_accessor :config, :game_state_changer
-    attr_accessor :number_of_turns_taken
-    attr_accessor :game_resetter
-    attr_accessor :move_generator
-    attr_reader :io, :input_helper,  :game_module
+    attr_accessor :number_of_turns_taken, :won_flag
+    attr_reader :io_helpers
 
-    def initialize(args = {})
-      @game_module = args.fetch(:game_module, nil)
-      @io = args.fetch(:io, IOTerminal.new)
-      @board_presenter = args.fetch(:board_presenter, nil)
-
-      @input_helper = game_module::InputHelper.new(@io)
-      @board_builder = game_module::BoardBuilder.new
-      @game_state_changer = game_module::GameStateChanger.new
-      @game_resetter = game_module::GameResetter.new
-      @move_generator = game_module::MoveGenerator.new
-      @players_factory = game_module::PlayersFactory.new
-      @config = game_module::GameConfig.new(@input_helper)
-
-      @number_of_turns_taken = 0
-    end
 
-    def one_time_setup
-      #setup gets necessary info from user and stores it in config object
-      config.one_time_setup
-    end
-
-    def every_time_setup
-      #setup gets necessary info from user and stores it in config object
-      config.every_time_setup
-      self.players = players_factory.generate_players(config)
-      self.board = board_builder.generate_empty_board(config)
-      local_setup
-    end
+    def initialize(args = {})
+      @board_presenter = args.fetch(:board_presenter)
 
-    #to be implemented by subclasses
-    def local_setup
-    end
+      @io_helpers = args.fetch(:io_helpers)
+      @board_builder = args.fetch(:board_builder)
+      @players_factory = args.fetch(:players_factory)
 
-    #overriding so that io and input_helper always in harmony
-    def io=(new_io)
-      @io = new_io
-      self.input_helper = game_module::InputHelper.new(new_io)
+      @number_of_turns_taken = 0
     end
 
     def play
       initial_instructions
       one_time_setup
-      while true
+      loop do
         every_time_setup
         while !over?
           print_board
-          move = move_generator.get_player_choice(self)
-          game_state_changer.change_game_state(move, self)
+          move = current_player.make_move(self)
+          change_game_state(move)
         end
 
         #need to print_final_iteration of board
@@ -67,12 +37,12 @@ module Shared
 
         if won?
           winning_prompt
-        elsif over_with_no_winner?
-          no_winner_prompt
+        elsif no_more_turns?
+          no_winner_prompt(self)
           custom_final_message(self)
         end
 
-        game_resetter.reset_game(self)
+        reset_game
         new_game_starting_graphic
       end
     end
@@ -85,26 +55,10 @@ module Shared
       current_player.name
     end
 
-    def current_player_human?
-      current_player.type == :human
-    end
-
-    def current_player_computer?
-      current_player.type == :computer
-    end
-
     def move_forward_one_turn
       self.number_of_turns_taken += 1
     end
 
-    def generate_empty_board(config)
-      board_builder.generate_empty_board(config)
-    end
-
-    def change_game_state(available_choice, game)
-      game_state_changer.change_game_state(available_choice, game)
-    end
-
     def winner
       #each move is immediately proceeded by an increment to number_of_selections_made; therefore, need to rewind won to find winner
       if !won?
@@ -117,22 +71,50 @@ module Shared
       board.display_values
     end
 
+
+    def computer_choosing_graphic
+      io_helpers.computer_choosing_graphic
+    end
+
     private
 
+    #hook
+    def one_time_setup
+    end
+
+    #hook
+    def every_time_setup
+    end
+
+
+    def second_player_expert_computer?
+      players[1].kind_of?(TTT::ComputerPlayerExpert)
+    end
+
+    #overriding so that io and io_helpers always in harmony
+
     def over?
       raise 'Called abstract method: over?'
     end
 
-    def over_with_no_winner?
-      raise 'Called abstract method: draw?'
+    def no_more_turns?
+      raise 'Called abstract method: no_more_turns?'
     end
 
     def won?
       raise 'Called abstract method: won?'
     end
 
-    def custom_final_message(game)
-      input_helper.custom_final_message(game)
+    def change_game_state(move)
+      raise 'Called abstract method: change_game_state'
+    end
+
+    def reset_game
+      raise 'Called abstract method: reset_game'
+    end
+
+    def reset_board
+      raise 'Called abstract method: reset_board'
     end
 
     def print_board
@@ -147,20 +129,24 @@ module Shared
       (number_of_turns_taken % number_of_players)
     end
 
+    def custom_final_message(game)
+      io_helpers.custom_final_message(game)
+    end
+
     def initial_instructions
-      input_helper.initial_instructions
+      io_helpers.initial_instructions
     end
 
     def winning_prompt
-      input_helper.winning_prompt(current_player_name)
+      io_helpers.winning_prompt(current_player_name)
     end
 
-    def no_winner_prompt
-      input_helper.no_winner_prompt
+    def no_winner_prompt(game)
+      io_helpers.no_winner_prompt(game)
     end
 
     def new_game_starting_graphic
-      input_helper.new_game_starting_graphic
+      io_helpers.new_game_starting_graphic
     end
   end
 end

data/lib/games/shared/{input_helper.rb → io_helpers.rb}

@@ -1,46 +1,24 @@
+require 'paint'
+
 module Shared
-  class InputHelper
+  class IOHelpers
     attr_accessor :io
 
     def initialize(io)
       @io = io
     end
 
-    def get_game
-      user_choice = get_user_input("Please enter \"M\" if you would like to play Mastermind. Enter \"T\" if you would like to play Tic Tac Toe.", "Invalid character. Please enter either M (Mastermind) or T (Tic Tac Toe).") do |input|
-        input == 'm' || input == 'M' || input == 't' || input == 'T'
-      end
-      user_choice = user_choice.upcase
-      if user_choice == "M"
-        :mastermind
-      elsif user_choice == "T"
-        :tictactoe
-      end
+    def initial_instructions
+      raise 'Called abstract method: initial_instructions'
     end
 
     def get_player_1_name
-      user_choice = get_user_input("Player 1, please enter your name", "Please re-enter your name, using only letters") do |input|
+      user_choice = get_user_input("Player 1, please enter your name:", "Please re-enter your name, using only letters") do |input|
         input =~ /^[a-zA-Z]+$/
       end
       user_choice.capitalize
     end
 
-    def get_user_input(prompt, reprompt, &block_validation)
-      io.present_with_new_line(prompt)
-      user_choice = nil
-      while true
-        user_choice = io.receive
-        if user_choice.to_s.upcase == "EXIT"
-          #http://blog.honeybadger.io/how-to-exit-a-ruby-program/
-          exit(0)
-        end
-        #breaks out of input loop if input is valid (the block validation makes sure some rule is true)
-        break if block_validation.call(user_choice)
-        puts reprompt
-      end
-      user_choice
-    end
-
     def computer_choosing_graphic
       io.present("Computer choosing.")
       3.times do
@@ -62,6 +40,40 @@ module Shared
       io.present("\n")
     end
 
+    def winning_prompt(current_player_name)
+      if current_player_name == "Computer"
+        io.present_with_new_line(Paint["#{current_player_name} wins!", :red, :bold])
+      else
+        io.present_with_new_line(Paint["#{current_player_name} wins!", :green, :bold])
+      end
+    end
+
+    def no_winner_prompt
+      raise 'Called abstract method: no_winner_prompt'
+    end
+
+    def custom_final_message(game)
+      #hook
+    end
+
+    private
+
+    def get_user_input(prompt, reprompt, &block_validation)
+      io.present_with_new_line(prompt)
+      user_choice = nil
+      while true
+        user_choice = io.receive
+        if user_choice.to_s.upcase == "EXIT"
+          #http://blog.honeybadger.io/how-to-exit-a-ruby-program/
+          exit(0)
+        end
+        #breaks out of input loop if input is valid (the block validation makes sure some rule is true)
+        break if block_validation.call(user_choice)
+        puts reprompt
+      end
+      user_choice
+    end
+
     def marching_dots
       sleep(0.2)
       io.present(".")
@@ -70,9 +82,5 @@ module Shared
       sleep(0.1)
       io.present(".")
     end
-
-    def custom_final_message(game)
-
-    end
   end
 end

data/lib/games/shared/player.rb

@@ -1,11 +1,9 @@
 module Shared
   class Player
-    attr_accessor :value, :name, :type, :difficulty_level
+    attr_accessor :name
 
     def initialize(args = {})
       @name = args.fetch(:name, "Player 1")
-      @type = args.fetch(:type, :human)
-      @difficulty_level = args.fetch(:difficulty_level, nil)
       post_initialize(args)
     end
 

data/lib/games/shared/player_factory.rb

@@ -0,0 +1,9 @@
+module Shared
+  class PlayerFactory
+    attr_accessor :io_helpers
+
+    def initialize(io_helpers)
+      @io_helpers = io_helpers
+    end
+  end
+end

data/lib/games/shared/players_factory.rb

@@ -0,0 +1,9 @@
+module Shared
+  class PlayersFactory
+    attr_accessor :io_helpers
+
+    def initialize(io_helpers)
+      @io_helpers = io_helpers
+    end
+  end
+end

data/lib/games/tictactoe/board.rb

@@ -1,9 +1,8 @@
 module TTT
   class Board
-    attr_accessor :rows_and_cols, :squares
+    attr_accessor :squares
 
     def initialize(args = {})
-      @rows_and_cols = args[:rows_and_cols]
       @squares = args[:squares]
     end
 
@@ -28,8 +27,8 @@ module TTT
       return squares.available_choices
     end
 
-    def number_of_rows
-      rows_and_cols
+    def number_of_rows_cols
+      squares.number_of_rows_cols
     end
 
     private

data/lib/games/tictactoe/board_builder.rb

@@ -1,10 +1,10 @@
+require_relative 'board'
 require_relative 'squares_factory'
 
 module TTT
   class BoardBuilder
-    def generate_empty_board(config)
-      number_of_rows_cols = config.number_of_rows_cols
-      Board.new(rows_and_cols: number_of_rows_cols, squares: SquaresFactory.build_empty_squares(number_of_rows_cols) )
+    def generate_empty_board(number_of_rows_cols)
+      Board.new(squares: SquaresFactory.build_empty_squares(number_of_rows_cols) )
     end
   end
 end

data/lib/games/tictactoe/board_presenter_terminal.rb

@@ -13,7 +13,7 @@ module TTT
         end
         print "\n"
         #row_number starts at 0
-        puts "_"*(row.size * 5) unless row_number.equal? (number_of_rows - 1)
+        puts "_"*(row.size * 5) unless row_number.equal? (number_of_rows_cols - 1)
       end
     end
 
@@ -21,8 +21,8 @@ module TTT
       board.display_values
     end
 
-    def number_of_rows
-      board.number_of_rows
+    def number_of_rows_cols
+      board.number_of_rows_cols
     end
   end
 end

data/lib/games/tictactoe/computer_player_expert.rb

@@ -0,0 +1,12 @@
+require_relative '../tictactoe/player'
+
+module TTT
+  class ComputerPlayerExpert < TTT::Player
+    def make_move(game)
+      game.computer_choosing_graphic
+      minimax = TTT::Minimax.new(game.board, game.number_of_turns_taken, game.player_1_value, game.player_2_value)
+      minimax.run_minimax
+      minimax.choice
+    end
+  end
+end

data/lib/games/tictactoe/computer_player_novice.rb

@@ -0,0 +1,10 @@
+require_relative '../tictactoe/player'
+
+module TTT
+  class ComputerPlayerNovice < TTT::Player
+    def make_move(game)
+      game.computer_choosing_graphic
+      game.available_choices.sample
+    end
+  end
+end

data/lib/games/tictactoe/game.rb

@@ -2,18 +2,37 @@ require_relative '../shared/game'
 
 module TTT
   class Game < Shared::Game
-    attr_accessor :won_flag
+    def one_time_setup
+      self.players = players_factory.generate_players
+      number_of_rows_cols = get_board_rows
+      self.board = board_builder.generate_empty_board(number_of_rows_cols)
+    end
 
-    def local_setup
+    def every_time_setup
       self.won_flag = false
     end
 
+    def get_board_rows
+      #need this if else logic because if computer is difficult, it runs minimax, which is too slow to allow for more than 3 rows/cols
+      if second_player_expert_computer?
+        io_helpers.get_number_of_rows_cols_max_3
+      else
+        io_helpers.get_number_of_rows_cols_max_9
+      end
+    end
+
+    def change_game_state(move)
+      change_square(move, current_player_value)
+      if !won?
+        move_forward_one_turn
+      end
+    end
 
     def over?
-      won_flag || over_with_no_winner?
+      won_flag || no_more_turns?
     end
 
-    def over_with_no_winner?
+    def no_more_turns?
       board.full?
     end
 
@@ -29,6 +48,24 @@ module TTT
       end
     end
 
+    def reset_game
+      reset_board
+      self.number_of_turns_taken = 0
+      self.won_flag = false
+    end
+
+    def reset_board
+      self.board = generate_empty_board(number_of_rows_cols)
+    end
+
+    def number_of_rows_cols
+      board.number_of_rows_cols
+    end
+
+    def generate_empty_board(number_of_rows_cols)
+      board_builder.generate_empty_board(number_of_rows_cols)
+    end
+
     def available_choices
       board.available_choices
     end
@@ -45,16 +82,12 @@ module TTT
       current_player.value
     end
 
-    def current_player_difficult_computer?
-      current_player_computer? && current_player.difficulty_level == :difficult
-    end
-
-    def current_player_easy_computer?
-      current_player_computer? && current_player.difficulty_level == :easy
-    end
-
     def change_square(display_value, current_player_value)
       board.change_square(display_value, current_player_value)
     end
+
+    def get_player_choice(current_player_name, available_choices)
+      io_helpers.get_player_choice(current_player_name, available_choices)
+    end
   end
 end

data/lib/games/tictactoe/human_player.rb

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

data/lib/games/tictactoe/io_helpers.rb

@@ -0,0 +1,81 @@
+require_relative '../shared/io_helpers'
+require 'paint'
+
+module TTT
+  class IOHelpers < Shared::IOHelpers
+    def initial_instructions
+      io.present_with_new_line(Paint["-" * 60 + "TIC TAC TOE" + "-" * 60, :blue, :bold, :bright, :underline])
+      io.present_with_new_line(Paint["INSTRUCTIONS: ", :green] + "Try to fill a row, a column, or a diagonal with only your token value.")
+      io.present_with_new_line("-" * 131)
+      io.present_with_new_line(Paint["Type ",:red] + Paint["\"Exit\" ", :red, :bold] + Paint["to quit the game.", :red])
+      io.present_with_new_line("_" * 131)
+    end
+
+    def no_winner_prompt(game)
+      io.present_with_new_line(Paint["Draw! Please try again.", :red, :bold])
+    end
+
+    def get_number_of_rows_cols_max_3
+      get_user_input("Please choose how many squares you would like in each row.", "Please choose number between 2 and 3.") do |input|
+        input.to_i >=2 && input.to_i <=3
+      end
+    end
+
+    def get_number_of_rows_cols_max_9
+      get_user_input("Please choose how many squares you would like in each row.", "Please choose number between 2 and 3.") do |input|
+        input.to_i >=2 && input.to_i <=9
+      end
+    end
+
+    def get_player_2_name
+      user_choice = get_user_input("Player 2, please enter your name:", "Please re-enter your name, using only letters") do |input|
+        input =~ /^[a-zA-Z]+$/
+      end
+      user_choice.capitalize
+    end
+
+    def get_player_value(player_name = "Player 1", taken_value = "")
+      user_choice = get_user_input("#{player_name}, please enter your preferred token value, consisting of one letter only. For example, " + Paint["\"X\" ", :blue, :bold] + "and " + Paint["\"O\" ", :blue, :bold] + " are the most common token values in Tic Tac Toe.", "Invalid entry. Must be one letter. Please re-enter.") do |input|
+        (input =~ /^[a-zA-Z]$/  && input.upcase != taken_value.upcase)
+      end
+      user_choice.upcase
+    end
+
+    # def get_player_2_name
+    #   user_choice = get_user_input("Player 2, please enter your name", "Please re-enter your name, using only letters") do |input|
+    #     input =~ /^[a-zA-Z]+$/
+    #   end
+    #   user_choice.capitalize
+    # end
+
+    def get_player_2_type
+      user_choice = get_user_input("Please enter " + Paint["\"C\" ", :blue, :bold] +  "if you would like to play the Computer. Enter " + Paint["\"H\" ", :blue, :bold] + "if you would like to play the human sitting next to you:", "Invalid character. Please enter either C(Computer) or H(Human).") do |input|
+        input == 'c' || input == 'C' || input == 'h' || input == 'H'
+      end
+      user_choice = user_choice.upcase
+      if user_choice == "C"
+        :computer
+      elsif user_choice == "H"
+        :human
+      end
+    end
+
+    def get_computer_knowledge_level
+      user_choice = get_user_input("Please enter " + Paint["\"E\" ", :blue, :bold] + "if you would like to play an easy Computer. Enter " + Paint["\"D\" ", :blue, :bold] +"if you would like to play an extremely difficult computer.", "Invalid character. Please enter either E (Easy) or D (Difficult).") do |input|
+        input == 'd' || input == 'D' || input == 'e' || input == 'E'
+      end
+      user_choice = user_choice.upcase
+      if user_choice == "D"
+        :expert
+      elsif user_choice == "E"
+        :novice
+      end
+    end
+
+    def get_player_choice(current_player_name, available_choices)
+      get_user_input("#{current_player_name}, please enter the number of the square that you would like to change.", "Invalid entry. Please try again.") do |input|
+        available_choices.include?(input)
+      end
+    end
+  end
+end

data/lib/games/tictactoe/player.rb

@@ -7,5 +7,9 @@ module TTT
     def post_initialize(args = {})
       @value = args.fetch(:value, "X")
     end
+
+    def make_move
+      raise 'Called abstract method: make_move'
+    end
   end
 end