tic_tac_toe_nhu 0.0.2

data/lib/tic_tac_toe/board.rb

@@ -0,0 +1,99 @@
+module TicTacToe
+  class MoveNotAvailableError < StandardError
+  end
+
+  class Board
+    attr_reader :squares, :size, :unique_marked_values
+
+    def initialize(size = 3)
+      @size = size
+      reset
+    end
+
+    def reset
+      @squares = Array.new(size**2)
+      @unique_marked_values = []
+      @moves_history = []
+    end
+
+    def mark(move, value)
+      if move_available?(move)
+        squares[move] = value
+        @unique_marked_values << value if !@unique_marked_values.include?(value)
+      else
+        raise MoveNotAvailableError
+      end
+    end
+
+    def clear(move)
+      squares[move] = nil
+    end
+
+    def filled?
+      available_moves.empty?
+    end
+
+    def number_of_moves
+      squares.size - available_moves.size
+    end
+
+    def rows
+      (0...size).inject([]) do |result, row|
+        result << squares[row*size, size]
+      end
+    end
+
+    def columns
+      result = []
+      (0...size).each do |col|
+        result << squares.values_at(* squares.each_index.select do |i|
+          (col - i) % 3 == 0
+        end)
+      end
+      result
+    end
+
+    def diagonals
+      left_diagonal = diagonal_from_top_left
+      right_diagonal = diagonal_from_top_right
+      [left_diagonal, right_diagonal]
+    end
+
+    def available_moves
+      result = []
+      (0...squares.size).each do |move|
+        result << move if move_available?(move)
+      end
+      result
+    end
+
+    private
+    def move_available?(move)
+      return false if out_of_range?(move)
+      return false if marked?(move)
+
+      true
+    end
+
+    def out_of_range?(move)
+      return true if move < 0
+      return true if move >= squares.size
+      return false
+    end
+
+    def marked?(move)
+      squares[move]
+    end
+
+    def diagonal_from_top_right
+      result = squares.values_at(*squares.each_index.select do |i|
+        i % (size - 1) == 0
+      end)
+      result[1, size]
+    end
+
+    def diagonal_from_top_left
+      squares.values_at(*squares.each_index.select {|i| i % (size + 1) == 0})
+    end
+  end
+end

data/lib/tic_tac_toe/game.rb

@@ -0,0 +1,41 @@
+require 'tic_tac_toe/rules'
+
+module TicTacToe
+  class Game
+    attr_reader :current_player, :board
+
+    def initialize(board, player1, player2)
+      @board = board
+      @current_player = @player1 = player1
+      @player2 = player2
+      @rules = TicTacToe::Rules.new(@board)
+    end
+
+    def make_move
+      player_move = @current_player.move
+      if player_move
+        @board.mark(player_move, @current_player.value)
+        change_player
+      end
+    end
+
+    def over?
+      @rules.game_over?
+    end
+
+    def winner
+      player(@rules.winner)
+    end
+
+    private
+    def change_player
+      @current_player = (@current_player == @player1) ? @player2 : @player1
+    end
+
+    def player(mark)
+      return @player1 if mark == @player1.value
+      return @player2 if mark == @player2.value
+    end
+
+  end
+end

data/lib/tic_tac_toe/game_factory.rb

@@ -0,0 +1,55 @@
+require 'tic_tac_toe/game'
+require 'tic_tac_toe/board'
+require 'tic_tac_toe/player_factory'
+
+module TicTacToe
+  class GameFactory
+    def initialize(player_factory = TicTacToe::PlayerFactory.new)
+      @player_factory = player_factory
+    end
+
+    def types
+      ["You vs Computer", "Computer vs You", "You vs Friend", "Computer vs Computer"]
+    end
+
+    def create(type_index, board)
+      case type_index
+      when 1
+        human_computer_game(board)
+      when 2
+        computer_human_game(board)
+      when 3
+        human_human_game(board)
+      when 4
+        computer_computer_game(board)
+      else
+        raise ArgumentError, "Type does not exist. Please select a number corresponding to the game type."
+      end
+    end
+
+    private
+    def computer_human_game(board)
+      computer = @player_factory.computer(board)
+      human = @player_factory.human
+      TicTacToe::Game.new(board, computer, human)
+    end
+
+    def human_computer_game(board)
+      computer = @player_factory.computer(board)
+      human = @player_factory.human
+      TicTacToe::Game.new(board, human, computer)
+    end
+
+    def human_human_game(board)
+      human1 = @player_factory.human
+      human2 = @player_factory.human("Friend", "O")
+      TicTacToe::Game.new(board, human1, human2)
+    end
+
+    def computer_computer_game(board)
+      computer1 = @player_factory.computer(board, "X", "O")
+      computer2 = @player_factory.computer(board, "O", "X")
+      TicTacToe::Game.new(board, computer1, computer2)
+    end
+  end
+end

data/lib/tic_tac_toe/main.rb

@@ -0,0 +1,47 @@
+require 'tic_tac_toe/ui/console'
+require 'tic_tac_toe/game_factory'
+require 'tic_tac_toe/board'
+
+module TicTacToe
+  class Main
+    attr_writer :rules
+
+    def initialize(ui = TicTacToe::Console.new, game_factory = TicTacToe::GameFactory.new)
+      @ui = ui
+      @board = TicTacToe::Board.new
+      @game_factory = game_factory
+    end
+
+    def start
+      @ui.display_welcome_message
+      game_type = @ui.game_type
+      @game = @game_factory.create(game_type, @board)
+
+      play until @game.over?
+      @ui.display_board(@board)
+      display_result
+    end
+
+    private
+    def play
+      @ui.display_board(@board)
+      player = @game.current_player
+      @ui.display_player_turn(player)
+      begin
+        @game.make_move
+      rescue MoveNotAvailableError
+        @ui.display_square_not_available
+      end
+    end
+
+    def display_result
+      winner = @game.winner
+      if winner
+        @ui.display_winner(winner)
+      else
+        @ui.display_tied_game
+      end
+    end
+
+  end
+end

data/lib/tic_tac_toe/player.rb

@@ -0,0 +1,15 @@
+module TicTacToe
+  class Player
+    attr_reader :name, :value, :strategy
+
+    def initialize(name, value, strategy)
+      @name = name
+      @value = value
+      @strategy = strategy
+    end
+
+    def move
+      @strategy.move
+    end
+  end
+end

data/lib/tic_tac_toe/player_factory.rb

@@ -0,0 +1,17 @@
+require 'tic_tac_toe/strategy/minimax'
+require 'tic_tac_toe/strategy/console_user'
+require 'tic_tac_toe/player'
+
+module TicTacToe
+  class PlayerFactory
+
+    def human(name = "User", value = "X")
+      TicTacToe::Player.new(name, value, TicTacToe::Strategy::ConsoleUser.new)
+    end
+
+    def computer(board, value = "O", opponent_value = "X")
+      ai = TicTacToe::Strategy::Minimax.new(board, value, opponent_value)
+      TicTacToe::Player.new("Computer", value, ai)
+    end
+  end
+end

data/lib/tic_tac_toe/rules.rb

@@ -0,0 +1,32 @@
+module TicTacToe
+  class Rules
+    def initialize(board)
+      @board = board
+    end
+
+    def game_over?
+      return true if winner
+      return true if @board.filled?
+      false
+    end
+
+    def tied?
+      !winner && @board.filled?
+    end
+
+    def winner
+      @board.unique_marked_values.detect {|p| win?(p)}
+    end
+
+    private
+    def win?(player)
+      square_sets.any? do |squares|
+        squares.all? {|square| square == player}
+      end
+    end
+
+    def square_sets
+      @board.rows + @board.columns + @board.diagonals
+    end
+  end
+end

data/lib/tic_tac_toe/strategy/console_user.rb

@@ -0,0 +1,26 @@
+module TicTacToe
+  module Strategy
+    class ConsoleUser
+
+      def initialize(input = STDIN, output = STDOUT)
+        @input = input
+        @output = output
+      end
+
+      def move
+        move = nil
+
+        until move =~ NUMBER
+          @output.puts("Please enter a square number that is not marked: ")
+          move = @input.gets
+        end
+
+        move.to_i
+      end
+
+      private
+      NUMBER = /\d/
+
+    end
+  end
+end

data/lib/tic_tac_toe/strategy/minimax.rb

@@ -0,0 +1,83 @@
+require 'tic_tac_toe/rules'
+
+module TicTacToe
+  module Strategy
+    class Minimax
+      def initialize(board, player, opponent)
+        @board = board
+        @player = player
+        @opponent = opponent
+        @rules = TicTacToe::Rules.new(@board)
+      end
+
+      def move
+        if first_move?
+          first_move
+        else
+          move = minimax(@player)
+          move.move
+        end
+      end
+
+      private
+      WINNING_SCORE = 1
+      LOSING_SCORE = -1
+      TIE = 0
+      MIDDLE_SQUARE = 4
+
+      def first_move?
+        moves_count = @board.number_of_moves
+        moves_count == 0 || moves_count == 1
+      end
+
+      def first_move
+        return MIDDLE_SQUARE if @board.available_moves.include?(MIDDLE_SQUARE)
+        0
+      end
+
+      def minimax(player)
+        moves = []
+        @board.available_moves.each do |move|
+          @board.mark(move, player)
+          moves << player_move(player, move)
+          @board.clear(move)
+          found_best_move?(moves[-1])
+        end
+        best_move(moves)
+      end
+
+      def player_move(player, move)
+        if @rules.game_over?
+          PlayerMove.new(move, score(player), 0)
+        else
+          child_move = minimax(opponent(player))
+          PlayerMove.new(move, -child_move.score, child_move.depth += 1)
+        end
+      end
+
+      def found_best_move?(move)
+        move.score == WINNING_SCORE and move.depth == 0
+      end
+
+      def score(player)
+        winner = @rules.winner
+        return WINNING_SCORE if winner == player
+        return LOSING_SCORE if winner == opponent(player)
+        return TIE if @rules.tied?
+
+        nil
+      end
+
+      def opponent(player)
+        (player == @player) ? @opponent : @player
+      end
+
+      def best_move(moves)
+        sorted_moves = moves.sort{ |a, b| [a.score, a.depth] <=> [b.score, b.depth]}
+        sorted_moves.max_by {|m| m.score}
+      end
+    end
+
+    PlayerMove = Struct.new(:move, :score, :depth)
+  end
+end

data/lib/tic_tac_toe/ui/console.rb

@@ -0,0 +1,60 @@
+require 'tic_tac_toe/game_factory'
+
+module TicTacToe
+  class Console
+
+    def initialize(input = STDIN, output=STDOUT)
+      @input = input
+      @output = output
+    end
+
+    def display_welcome_message
+      @output.puts("Welcome to Tic Tac Toe!")
+    end
+
+    def display_board(board)
+      @output.puts(build_board(board))
+    end
+
+    def game_type
+      @output.puts("Please select a game type.")
+      @output.puts(game_type_list)
+      type = @input.gets
+      type.to_i
+    end
+
+    def display_winner(winner)
+      @output.puts("#{winner.name}(#{winner.value}) win!")
+    end
+
+    def display_tied_game
+      @output.puts("It's a tied!")
+    end
+
+    def display_square_not_available
+      @output.puts("Square is not available. Please enter a different square.")
+    end
+
+    def display_player_turn(player)
+      @output.puts("It's #{player.name}(#{player.value}) turn.")
+    end
+
+    private
+    def build_board(board)
+      result = ""
+      board.squares.each_with_index do |value, index|
+         result << "| #{value || index} "
+         result << "|\n" if (index + 1) % board.size == 0
+      end
+      result
+    end
+
+    def game_type_list
+      result = ""
+      TicTacToe::GameFactory.new.types.each_with_index do |value, index|
+        result << "#{index + 1} - #{value}\n"
+      end
+      result
+    end
+  end
+end

data/spec/integration/tictactoe/tic_tac_toe.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+require 'tic_tac_toe'
+require 'tic_tac_toe/mock/player'
+
+player = MockPlayer.new([8, 6, 3])
+game = TicTacToe::GameFactory.computer_user_game
+game.start

data/spec/mocks/game.rb

@@ -0,0 +1,11 @@
+require 'surrogate/rspec'
+
+class MockGame
+  Surrogate.endow(self)
+  define_reader :board
+  define_reader :current_player
+
+  define :make_move
+  define :winner
+  define(:over?){true}
+end

data/spec/mocks/game_factory.rb

@@ -0,0 +1,8 @@
+require 'surrogate/rspec'
+
+class MockGameFactory
+  Surrogate.endow(self)
+  define(:initialize) {|player_factory|}
+  define :types
+  define(:create) {|type, board|}
+end

data/spec/mocks/player_factory.rb

@@ -0,0 +1,8 @@
+require 'surrogate/rspec'
+
+class MockPlayerFactory
+  Surrogate.endow(self)
+
+  define(:human) {|name = "Sue", value = "X"|}
+  define(:computer) {|board, value = "X", opponent="O"|}
+end

data/spec/mocks/rules.rb

@@ -0,0 +1,9 @@
+require 'surrogate/rspec'
+
+class MockRules
+  Surrogate.endow(self)
+  define(:initialize) {|board|}
+  define(:game_over?) {true}
+  define(:tied?)
+  define(:winner)
+end

data/spec/mocks/strategy/dynamic.rb

@@ -0,0 +1,19 @@
+class MockDynamicStrategy
+  attr_accessor :moves
+
+  def initialize(moves = [])
+    @moves = moves
+  end
+
+  def add_move(move)
+    @moves << move
+  end
+
+  def move
+    @moves.shift
+  end
+
+  def needs_input?
+    true
+  end
+end

data/spec/mocks/ui/console.rb

@@ -0,0 +1,15 @@
+require 'surrogate/rspec'
+
+class MockConsole
+
+  Surrogate.endow(self)
+
+  define :display_welcome_message
+  define(:display_board) {|board|}
+  define(:display) {|message|}
+  define :game_type
+  define(:display_winner){|winner|}
+  define :display_tied_game
+  define :display_square_not_available
+  define(:display_player_turn) {|player|}
+end