tic_tac_toe_nhu 0.0.11 → 0.1.0

data/lib/tic_tac_toe/strategy/console_user.rb

@@ -7,7 +7,7 @@ module TicTacToe
         @output = output
       end
 
-      def move
+      def move(*board)
         move = nil
 
         until move =~ NUMBER

data/lib/tic_tac_toe/strategy/minimax.rb

@@ -1,33 +1,35 @@
 require 'tic_tac_toe/rules'
+require 'tic_tac_toe/values'
 
 module TicTacToe
   module Strategy
     class Minimax
-      def initialize(board, player, opponent)
-        @board = board
-        @player = player
-        @opponent = opponent
+      WINNING_SCORE = 1
+      LOSING_SCORE = -1
+      TIE = 0
+      MIDDLE_SQUARE = 4
+
+      def initialize(player_value)
+        @player_value = player_value
+        @opponent_value = TicTacToe::Values.opponent(@player_value)
       end
 
-      def move
-        return first_move if first_move?
-        move = minimax(@player, @board)
+      def move(board)
+        return first_move(board) if first_move?(board)
+        move = minimax(player_value, board)
         move.move
       end
 
       private
-      WINNING_SCORE = 1
-      LOSING_SCORE = -1
-      TIE = 0
-      MIDDLE_SQUARE = 4
+      attr_reader :player_value, :opponent_value
 
-      def first_move?
-        moves_count = @board.number_of_moves
+      def first_move?(board)
+        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)
+      def first_move(board)
+        return MIDDLE_SQUARE if board.available_moves.include?(MIDDLE_SQUARE)
         0
       end
 
@@ -63,7 +65,7 @@ module TicTacToe
       end
 
       def opponent(player)
-        (player == @player) ? @opponent : @player
+        (player == player_value) ? opponent_value : player_value
       end
 
       def best_move(moves)

data/lib/tic_tac_toe/ui/console.rb

@@ -28,7 +28,7 @@ module TicTacToe
     end
 
     def display_winner(winner)
-      @output.puts("#{winner.name}(#{winner.value}) win!")
+      @output.puts("#{winner.name}(#{winner.value}) wins!")
     end
 
     def display_tied_game
@@ -55,7 +55,7 @@ module TicTacToe
 
     def game_type_list
       result = ""
-      TicTacToe::GameFactory.new.types.each_with_index do |value, index|
+      TicTacToe::GameFactory.new.types.each_with_index.map do |value, index|
         result << "#{index + 1} - #{game_type_values(value)}\n"
       end
       result

data/lib/tic_tac_toe/values.rb

@@ -0,0 +1,10 @@
+module TicTacToe
+  VALUES = ["X", "O"]
+
+  class Values
+    def self.opponent(value)
+      return VALUES[1] if value == VALUES[0]
+      VALUES[0]
+    end
+  end
+end

data/spec/{integration → acceptance}/tictactoe/unbeatable_computer_spec.rb

@@ -1,6 +1,7 @@
 require 'tic_tac_toe/board'
 require 'tic_tac_toe/rules'
 require 'tic_tac_toe/player_factory'
+require 'tic_tac_toe/values'
 
 class SimpleStrategy
   attr_accessor :next_move
@@ -11,9 +12,12 @@ class SimpleStrategy
 end
 
 describe "Unbeatable computer", :slow_test => true  do
+  attr_reader :computer
+
   before(:each) do
     @board = TicTacToe::Board.new
-    @human_value = "X"
+    @human_value = TicTacToe::VALUES[0]
+    @computer = TicTacToe::PlayerFactory.new.create(:computer, TicTacToe::VALUES[1])
   end
 
   it "wins all game when computer goes first" do
@@ -25,10 +29,8 @@ describe "Unbeatable computer", :slow_test => true  do
     play_game_for_each_available_move(@board)
   end
 
-  def make_computer_move(clone_board)
-    computer = TicTacToe::PlayerFactory.new.computer(clone_board)
-    clone_board.mark(computer.move, computer.value)
-    clone_board
+  def make_computer_move(board)
+    board.mark(computer.move(board), computer.value)
   end
 
   def rules(board)
@@ -50,7 +52,7 @@ describe "Unbeatable computer", :slow_test => true  do
 
   def make_players_move(board, move_history, move)
     move_history << move
-    board.mark(move, "X")
+    board.mark(move, @human_value)
     make_computer_move(board) if !rules(board).game_over?
     play_game_for_each_available_move(board, move_history)
   end

data/spec/mocks/game.rb

@@ -5,9 +5,9 @@ class MockGame
   define_reader :board
   define_reader :current_player
 
-  define(:make_move) {|*value| }
   define :winner
-  define(:over?){true}
+  define(:game_over?){true}
+  define(:make_player_move){|*move|}
 end
 
 describe TicTacToe::Game do

data/spec/mocks/game_factory.rb

@@ -4,7 +4,7 @@ class MockGameFactory
   Surrogate.endow(self)
   define(:initialize) {|player_factory|}
   define :types
-  define(:create) {|type, board|}
+  define(:create) {|type|}
 end
 
 describe TicTacToe::GameFactory do

data/spec/mocks/player.rb

@@ -0,0 +1,16 @@
+require 'surrogate/rspec'
+
+class MockPlayer
+  Surrogate.endow(self)
+  define(:initialize) {|name = "Player", value = "X", strategy = "no"|}
+  define_reader :name
+  define_reader :value
+  define_reader :strategy
+  define(:move) {|board|}
+end
+
+describe TicTacToe::Player do
+  it "checks if mock is substitutable" do
+    MockPlayer.should be_substitutable_for(TicTacToe::Player)
+  end
+end

data/spec/mocks/player_factory.rb

@@ -1,10 +1,11 @@
 require 'surrogate/rspec'
+require 'tic_tac_toe/values'
 
 class MockPlayerFactory
   Surrogate.endow(self)
 
-  define(:human) {|name = "Sue", value = "X"|}
-  define(:computer) {|board, value = "X", opponent="O"|}
+  define(:create){|player_type, value|}
+  define(:types){TicTacToe::PlayerFactory.new.types}
 end
 
 describe TicTacToe::PlayerFactory do

data/spec/mocks/strategy/dynamic.rb

@@ -9,7 +9,7 @@ class MockDynamicStrategy
     @moves << move
   end
 
-  def move
+  def move(*board)
     @moves.shift
   end
 

data/spec/tic_tac_toe/game_factory_spec.rb

@@ -1,78 +1,59 @@
 require 'tic_tac_toe/spec_helper'
 require 'tic_tac_toe/game_factory'
 require 'tic_tac_toe/player_factory'
+require 'tic_tac_toe/player'
 require 'mocks/player_factory'
 
 describe TicTacToe::GameFactory do
-
   before(:each) do
-    @board = "board"
     @player_factory = MockPlayerFactory.new
     @game_factory = TicTacToe::GameFactory.new(@player_factory)
   end
 
-  it "ensures MockPlayerFactory has the same interface as PlayerFactory" do
-    MockPlayerFactory.should be_substitutable_for(TicTacToe::PlayerFactory)
-  end
-
   it "returns 4 types of games" do
     @game_factory.types.size.should == 4
   end
 
-  it "sets the board in the game" do
-    game = @game_factory.create(1, @board)
-    game.board.should == @board
-  end
-
-  it "returns human vs computer game" do
-    human = "human"
-    computer = "computer"
-    @player_factory.will_have_human human
-    @player_factory.will_have_computer computer
-
-    game = @game_factory.create(1, @board)
-    game.current_player.should == human
+  context "creates game" do
+    before(:each) do
+      @human = TicTacToe::Player.new("Human", TicTacToe::VALUES[0], nil)
+      @computer = TicTacToe::Player.new("Computer", opponent_value(@human.value), nil)
+    end
 
-    @player_factory.was asked_for :computer
-    @player_factory.was asked_for :human
-  end
+    def test_game_state_creation(game_type, players)
+      @player_factory.will_create players[0], players[1]
 
-  it "returns computer vs human game" do
-    human = "human"
-    computer = "computer"
-    @player_factory.will_have_human human
-    @player_factory.will_have_computer computer
+      game = @game_factory.create(game_type)
+      game.current_player.should == players[0]
+      game.make_player_move(1)
+      game.current_player.should == players[1]
+    end
 
-    game = @game_factory.create(2, @board)
-    game.current_player.should == computer
+    it "returns user vs user game" do
+      @human2 = TicTacToe::Player.new("Human 2", opponent_value(@human.value), nil)
+      test_game_state_creation(1, [@human, @human2])
+    end
 
-    @player_factory.was asked_for :computer
-    @player_factory.was asked_for :human
-  end
+    it "returns human vs computer game" do
+      test_game_state_creation(2, [@human, @computer])
+    end
 
-  it "returns user vs user game" do
-    human1 = "mary"
-    human2 = "alice"
-    @player_factory.will_have_human human1, human2
+    it "returns computer vs human game" do
+      test_game_state_creation(3, [@computer, @human])
+    end
 
-    game = @game_factory.create(3, @board)
-    game.current_player.should == human1
+    it "returns computer vs computer game" do
+      @computer2 = TicTacToe::Player.new("Computer 2", opponent_value(@computer.value), nil)
+      test_game_state_creation(4, [@computer, @computer2])
+    end
 
-    @player_factory.was asked_for(:human).times(2)
+  it "raises an error when the game type doesn't exist" do
+    lambda{@game_factory.create(10)}.should raise_error(ArgumentError)
   end
 
-  it "returns computer vs computer game" do
-    computer1 = "computer1"
-    computer2 = "computer2"
-    @player_factory.will_have_computer computer2, computer1
-
-    game = @game_factory.create(4, @board)
-    game.current_player.should == computer2
-
-    @player_factory.was asked_for(:computer).times(2)
   end
 
-  it "raises an error when the game type doesn't exist" do
-    lambda{@game_factory.create(5, @board)}.should raise_error(ArgumentError)
+  def opponent_value(value)
+    TicTacToe::Values.opponent(value)
   end
 end

data/spec/tic_tac_toe/game_spec.rb

@@ -1,113 +1,104 @@
 require 'tic_tac_toe/spec_helper'
-require 'tic_tac_toe/game'
 require 'tic_tac_toe/board'
+require 'tic_tac_toe/game'
 require 'tic_tac_toe/player'
+require 'tic_tac_toe/values'
 require 'mocks/strategy/dynamic'
 
 describe TicTacToe::Game do
+  attr_reader :game_state, :player1, :player2, :board
+
   before(:each) do
     @board = TicTacToe::Board.new
-
     @player1_strategy = MockDynamicStrategy.new
-    @player1 = TicTacToe::Player.new("Todd", "X", @player1_strategy)
+    @player1 = TicTacToe::Player.new("player1", TicTacToe::VALUES[0], @player1_strategy)
+    @player2 = TicTacToe::Player.new("player1", TicTacToe::VALUES[1], nil)
+    @game_state = TicTacToe::Game.new([@player1, @player2], @board)
+  end
 
-    @player2_strategy = MockDynamicStrategy.new
-    @player2 = TicTacToe::Player.new("John", "O", @player2_strategy)
 
-    @game = TicTacToe::Game.new(@board, @player1, @player2)
+  it "can read board" do
+    game_state.board.should == board
   end
 
-  context "marking board" do
-    it "mark the board with user input when caller doesn't pass in a move" do
+  describe "game over" do
+    it "is false when there is no mark" do
+      game_state.should_not be_game_over
+    end
+
+    it "should be over when there is a winner" do
+      mark_winning_board(player1.value)
+      game_state.should be_game_over
+    end
+  end
+
+  describe "winner" do
+    it "has no winner when there is no mark" do
+      game_state.winner.should be_nil
+    end
+
+    it "is player 1" do
+      mark_winning_board(player1.value)
+      game_state.winner.should == player1
+    end
+
+    it "is player 2" do
+      mark_winning_board(player2.value)
+      game_state.winner.should == player2
+    end
+  end
+
+  context "make player move" do
+    it "mark the board with player move when caller doesn't pass in a move" do
       @player1_strategy.add_move(1)
-      @game.make_move
+      @game_state.make_player_move
       @board.unique_marked_values.should include(@player1.value)
     end
 
     it "does not mark the board if user doesn't return an input and caller didn't pass in a move" do
       @player1_strategy.add_move(nil)
-      @game.make_move
+      @game_state.make_player_move
       @board.unique_marked_values.should_not include(@player1.value)
     end
 
     it "marks the board with the move passed in" do
       @player1_strategy.add_move(1)
       move = 2
-      @game.make_move(move)
+      @game_state.make_player_move(move)
       @board.available_moves.should_not include(move)
     end
 
     it "marks the board with player move when move passed in is nil" do
       @player1_strategy.add_move(1)
-      @game.make_move(nil)
+      @game_state.make_player_move(nil)
       @board.available_moves.should_not include(1)
     end
 
     it "marks the board with current player value when the move passed in" do
       move = 2
-      @game.make_move(move)
+      @game_state.make_player_move(move)
       @board.unique_marked_values.should include(@player1.value)
     end
   end
 
-  describe "return winner player based on the value return from rules" do
-    it "is Todd when value is X" do
-      mark_board([0, 1, 2], @player1.value)
-      @game.winner.should == @player1
-    end
-
-    it "is John when it is O" do
-      mark_board([0, 1, 2], @player2.value)
-      @game.winner.should == @player2
-    end
-
-    it "is nil when no one wins" do
-      @game.winner.should be_nil
-    end
-  end
-
   describe "changes player" do
     it "doesn't change player if player 1 doesn't return a move" do
-      @game.current_player.should == @player1
-      @player1_strategy.add_move(nil)
-
-      @game.make_move
-      @game.current_player.should == @player1
+      @game_state.current_player.should == @player1
+      @game_state.make_player_move
+      @game_state.current_player.should == @player1
     end
 
     it "changes to player 2 after player 1 moves" do
-      @game.current_player.should == @player1
-      @player1_strategy.add_move(1)
-
-      @game.make_move
-      @game.current_player.should == @player2
+      @game_state.current_player.should == @player1
+      @game_state.make_player_move(1)
+      @game_state.current_player.should == @player2
     end
   end
 
-  describe "game over" do
-    it "is over when there is a winner" do
-      mark_board([0, 1, 2], @player2.value)
-      @game.should be_over
-    end
-
-    it "is over when there is a tied" do
-      mark_board((0...9).to_a, "i")
-      @game.should be_over
-    end
-
-    it "is not over when there is no mark on the board" do
-      @game.should_not be_over
-    end
-
-    it "is not over when there is no winner or a tied" do
-      mark_board([1, 2], @player1.value)
-      @game.should_not be_over
-    end
-  end
 
-  def mark_board(moves, value)
-    moves.each do |m|
-      @board.mark(m, value)
+  def mark_winning_board(value)
+    [0, 4, 8].each do |move|
+      game_state.board.mark(move, value)
     end
   end
 end