games_bfox 0.2.0

data/lib/games/mastermind/pegs.rb

@@ -0,0 +1,50 @@
+module MM
+  class Pegs
+    attr_reader :collection_of_pegs
+
+    #collection_of_pegs is a multi-dimensional array
+
+    def initialize(args)
+      @collection_of_pegs = args[:collection_of_pegs]
+    end
+
+    def retrieve_peg(row, col)
+      if row >= number_of_rows || col >= number_of_cols
+        return nil
+      else
+        return collection_of_pegs[row][col]
+      end
+    end
+
+    def current_row(number_of_turns_taken)
+      collection_of_pegs[number_of_turns_taken]
+    end
+
+    def display_values
+      # reversed so that game appears to be filling itself in from top to bottom
+      collection_of_pegs.reverse.map do |row|
+        row.map do |peg|
+          peg.display_value
+        end
+      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
+      end
+
+      def number_of_cols
+        collection_of_pegs[0].length
+      end
+  end
+end
+

data/lib/games/mastermind/pegs_factory.rb

@@ -0,0 +1,26 @@
+require_relative 'pegs'
+require_relative 'peg'
+
+module MM
+  module PegsFactory
+    def self.build_empty_pegs(rows = 12, cols = 4, pegs_class = Pegs)
+      pegs = Array.new(rows) do
+        Array.new(cols)
+      end
+
+      pegs.each_with_index do |element, row|
+        element.each_index do |col|
+          pegs[row][col] = create_empty_peg(row, col)
+        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 )
+    end
+  end
+end

data/lib/games/mastermind/players_factory.rb

@@ -0,0 +1,15 @@
+require_relative '../shared/player'
+
+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)
+      else
+        player_1 = Shared::Player.new(name: config.player_1_name, type: :computer)
+      end
+      [player_1]
+    end
+  end
+end

data/lib/games/mastermind.rb

@@ -0,0 +1,13 @@
+Dir[File.join(File.expand_path(File.dirname(__FILE__)), 'shared', '*.rb')].each {|file| require file }
+Dir[File.join(File.expand_path(File.dirname(__FILE__)), 'mastermind', '*.rb')].each {|file| require file }
+
+class Mastermind
+  def self.run
+    io = Shared::IOTerminal.new
+    board_presenter = MM::BoardPresenterTerminal.new
+
+    game = MM::Game.new(game_module: MM, io: io, board_presenter: board_presenter)
+    # game.setup
+    game.play
+  end
+end

data/lib/games/shared/array_iterator.rb

@@ -0,0 +1,28 @@
+#from Design Patterns by Russ Olsen pg 128-129
+module Shared
+  class ArrayIterator
+    def initialize(array)
+      @array = array
+      @index = 0
+    end
+
+    def has_next?
+      @index < @array.length
+    end
+
+    def item
+      @array[@index]
+    end
+
+    def peek
+      @array[@index]
+    end
+
+    def next_item
+      value = @array[@index]
+      @index += 1
+      value
+    end
+  end
+end
+

data/lib/games/shared/game.rb

@@ -0,0 +1,155 @@
+Dir[File.join(File.dirname(__FILE__), '*.rb')].each {|file| require file }
+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')}
+
+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
+
+    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
+      config.every_time_setup
+      self.players = players_factory.generate_players(config)
+      self.board = board_builder.generate_empty_board(config)
+      local_setup
+    end
+
+    #to be implemented by subclasses
+    def local_setup
+    end
+
+    #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)
+    end
+
+    def play
+      one_time_setup
+      while true
+        every_time_setup
+        while !over?
+          print_board
+          move = move_generator.get_player_choice(self)
+          game_state_changer.change_game_state(move, self)
+        end
+
+        #need to print_final_iteration of board
+        print_board
+
+        if won?
+          winning_prompt
+        elsif over_with_no_winner?
+          no_winner_prompt
+        end
+
+        game_resetter.reset_game(self)
+        new_game_starting_graphic
+      end
+    end
+
+    def current_player
+      players[current_turn_player_index]
+    end
+
+    def current_player_name
+      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?
+        return nil
+      end
+      current_player
+    end
+
+    def display_values
+      board.display_values
+    end
+
+    private
+
+    def over?
+      raise 'Called abstract method: over?'
+    end
+
+    def over_with_no_winner?
+      raise 'Called abstract method: draw?'
+    end
+
+    def won?
+      raise 'Called abstract method: won?'
+    end
+
+    def print_board
+      board_presenter.present_board(board)
+    end
+
+    def number_of_players
+      players.size
+    end
+
+    def current_turn_player_index
+      (number_of_turns_taken % number_of_players)
+    end
+
+    def winning_prompt
+      input_helper.winning_prompt(current_player.name)
+    end
+
+    def no_winner_prompt
+      input_helper.no_winner_prompt
+    end
+
+    def new_game_starting_graphic
+      input_helper.new_game_starting_graphic
+    end
+  end
+end

data/lib/games/shared/input_helper.rb

@@ -0,0 +1,74 @@
+module Shared
+  class InputHelper
+    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
+    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|
+        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
+        sleep(0.3)
+        io.present(".")
+      end
+      io.present("\n")
+    end
+
+    def new_game_starting_graphic
+      io.present("New game starting in 3")
+      i = 2
+      2.times do
+        marching_dots
+        io.present("#{i.to_s}")
+        i = i - 1
+      end
+      marching_dots
+      io.present("\n")
+    end
+
+    def marching_dots
+      sleep(0.2)
+      io.present(".")
+      sleep(0.2)
+      io.present(".")
+      sleep(0.1)
+      io.present(".")
+    end
+  end
+end

data/lib/games/shared/io_terminal.rb

@@ -0,0 +1,25 @@
+module Shared
+  class IOTerminal
+    def present(prompt)
+      print prompt
+    end
+
+    def present_with_new_line(prompt)
+      puts prompt
+    end
+
+    def receive
+      result = gets.chomp
+      if is_int?(result)
+        return result.to_i
+      else
+        return result.chomp
+      end
+    end
+
+    private
+    def is_int?(figure)
+      Integer(figure) rescue false
+    end
+  end
+end

data/lib/games/shared/player.rb

@@ -0,0 +1,15 @@
+module Shared
+  class Player
+    attr_accessor :value, :name, :type, :difficulty_level
+
+    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
+
+    def post_initialize(args)
+    end
+  end
+end

data/lib/games/shared/version.rb

@@ -0,0 +1,3 @@
+module Shared
+  VERSION = "0.3.0"
+end

data/lib/games/tictactoe/board.rb

@@ -0,0 +1,40 @@
+module TTT
+  class Board
+    attr_accessor :rows_and_cols, :squares
+
+    def initialize(args = {})
+      @rows_and_cols = args[:rows_and_cols]
+      @squares = args[:squares]
+    end
+
+    def change_square(display_value, new_value)
+      square_to_change = retrieve_square(display_value)
+      square_to_change.change_value(new_value)
+    end
+
+    def full?
+      return squares.full?
+    end
+
+    def won?
+      return squares.any_combination_won?
+    end
+
+    def display_values
+      return squares.display_values
+    end
+
+    def available_choices
+      return squares.available_choices
+    end
+
+    def number_of_rows
+      rows_and_cols
+    end
+
+    private
+    def retrieve_square(display_value)
+      return squares.retrieve_square(display_value)
+    end
+  end
+end

data/lib/games/tictactoe/board_builder.rb

@@ -0,0 +1,10 @@
+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) )
+    end
+  end
+end

data/lib/games/tictactoe/board_presenter_terminal.rb

@@ -0,0 +1,28 @@
+module TTT
+  class BoardPresenterTerminal
+    attr_accessor :board
+
+    def present_board(board)
+      @board = board
+      #board.display_values will return multidimensional array
+      display_values.each_with_index do |row, row_number|
+        row.each_with_index do |display_value, index|
+          #http://www.evc-cit.info/cit020/beginning-programming/chp_04/file_printf.html
+          printf "%2s", display_value
+          print " | " unless index == (row.size - 1)
+        end
+        print "\n"
+        #row_number starts at 0
+        puts "_"*(row.size * 5) unless row_number.equal? (number_of_rows - 1)
+      end
+    end
+
+    def display_values
+      board.display_values
+    end
+
+    def number_of_rows
+      board.number_of_rows
+    end
+  end
+end

data/lib/games/tictactoe/game.rb

@@ -0,0 +1,60 @@
+require_relative '../shared/game'
+
+module TTT
+  class Game < Shared::Game
+    attr_accessor :won_flag
+
+    def local_setup
+      self.won_flag = false
+    end
+
+
+    def over?
+      won_flag || over_with_no_winner?
+    end
+
+    def over_with_no_winner?
+      board.full?
+    end
+
+    def won?
+      if won_flag
+        return true
+      end
+
+      if board.won?
+        self.won_flag = true
+      else
+        false
+      end
+    end
+
+    def available_choices
+      board.available_choices
+    end
+
+    def player_1_value
+      players[0].value
+    end
+
+    def player_2_value
+      players[1].value
+    end
+
+    def current_player_value
+      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
+  end
+end

data/lib/games/tictactoe/game_config.rb

@@ -0,0 +1,73 @@
+module TTT
+  class GameConfig
+    attr_accessor :input_helper
+
+    attr_accessor :player_1_name
+    attr_accessor :player_1_value
+    attr_accessor :player_2_type
+    attr_accessor :player_2_name
+    attr_accessor :player_2_value
+    attr_accessor :computer_difficulty_level
+    attr_accessor :number_of_rows_cols
+
+    def initialize(input_helper)
+      @input_helper = input_helper
+    end
+
+    def one_time_setup
+      set_player_1_values
+      set_player_2_values
+      set_board_rows_cols
+    end
+
+    def every_time_setup
+
+    end
+
+    def set_player_1_values
+      self.player_1_name = input_helper.get_player_1_name
+      self.player_1_value = input_helper.get_player_1_value(player_1_name)
+    end
+
+    def set_player_2_values
+      self.player_2_type = input_helper.get_player_2_type
+      if player_2_human?
+        self.player_2_name = input_helper.get_player_2_name
+        self.player_2_value = input_helper.get_player_2_value(player_1_value)
+      elsif player_2_computer?
+        self.player_2_name = "Computer"
+        self.player_2_value = get_computer_value
+        self.computer_difficulty_level = input_helper.get_computer_difficulty_level
+      end
+    end
+
+    def set_board_rows_cols
+      #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 computer_difficult?
+        self.number_of_rows_cols = input_helper.get_number_of_rows_cols_max_3
+      else
+        self.number_of_rows_cols = input_helper.get_number_of_rows_cols_max_9
+      end
+    end
+
+    def player_2_human?
+      player_2_type == :human
+    end
+
+    def player_2_computer?
+      player_2_type == :computer
+    end
+
+    def computer_difficult?
+      computer_difficulty_level == :difficult
+    end
+
+    def get_computer_value
+      if player_1_value != "O"
+        "O"
+      else
+        "X"
+      end
+    end
+  end
+end

data/lib/games/tictactoe/game_resetter.rb

@@ -0,0 +1,16 @@
+module TTT
+  class GameResetter
+    attr_accessor :game
+
+    def reset_game(game)
+      @game = game
+      reset_board
+      game.number_of_turns_taken = 0
+      game.won_flag = false
+    end
+
+    def reset_board
+      game.board = game.generate_empty_board(game.config)
+    end
+  end
+end

data/lib/games/tictactoe/game_state_changer.rb

@@ -0,0 +1,17 @@
+module TTT
+  class GameStateChanger
+    attr_accessor :game
+
+    def change_game_state(player_choice, game)
+      @game = game
+      change_square(player_choice)
+    end
+
+    def change_square(display_value)
+      game.change_square(display_value, game.current_player_value)
+      if !game.won?
+        game.move_forward_one_turn
+      end
+    end
+  end
+end