tic_tac_toe_nhu 0.0.5 → 0.0.11

data/spec/tic_tac_toe/strategy/minimax_spec.rb

@@ -1,157 +1,156 @@
 require 'tic_tac_toe/spec_helper'
 require 'tic_tac_toe/board'
 require 'tic_tac_toe/strategy/minimax'
-require 'tic_tac_toe/values'
 
 describe TicTacToe::Strategy::Minimax, :slow_test => true do
 
   before(:each) do
     @board = TicTacToe::Board.new(3)
-    @computer_value = TicTacToe::VALUES[1]
-    @opponent_value = TicTacToe::Values.opponent(@computer_value)
-    @strategy = TicTacToe::Strategy::Minimax.new(@computer_value)
+    @opponent = "X"
+    @computer = "O"
+    @strategy = TicTacToe::Strategy::Minimax.new(@board, @computer, @opponent)
   end
 
   context "move" do
     context "when there is only one position left" do
       it "returns move when it's a winning move" do
-        mark((1...@board.size**2), @computer_value)
-        @strategy.move(@board).should == 0
+        mark((1...@board.size**2), @computer)
+        @strategy.move.should == 0
       end
 
       it "returns the move when it's a tied" do
-        mark([0, 2, 5, 6], @computer_value)
-        mark([1, 3, 4, 8], @opponent_value)
-        @strategy.move(@board).should == 7
+        mark([0, 2, 5, 6], @computer)
+        mark([1, 3, 4, 8], @opponent)
+        @strategy.move.should == 7
       end
 
       it "returns the move when opponent wins" do
-        mark((0...@board.size**2 - 1).to_a, @opponent_value)
-        @strategy.move(@board).should == 8
+        mark((0...@board.size**2 - 1).to_a, @opponent)
+        @strategy.move.should == 8
       end
     end
 
     context "when there are two positions left" do
       it "returns losing scores when the two moves are losing moves" do
-        mark((2...@board.size**2).to_a, @opponent_value)
-        @strategy.move(@board).should == 0
+        mark((2...@board.size**2).to_a, @opponent)
+        @strategy.move.should == 0
       end
 
       it "returns the first win move when the two moves are winning moves" do
-        mark((2...@board.size**2).to_a, @computer_value)
-        @strategy.move(@board).should == 0
+        mark((2...@board.size**2).to_a, @computer)
+        @strategy.move.should == 0
       end
 
       it "returns the first tie move when the two moves are tie moves" do
-        mark([0, 2, 7], @computer_value)
-        mark([1, 4, 6, 8], @opponent_value)
-        @strategy.move(@board).should == 3
+        mark([0, 2, 7], @computer)
+        mark([1, 4, 6, 8], @opponent)
+        @strategy.move.should == 3
       end
 
       it "returns win move when there are winning and losing moves" do
-        mark([0, 1, 3, 7], @computer_value)
-        mark([2, 4, 5], @opponent_value)
-        @strategy.move(@board).should == 6
+        mark([0, 1, 3, 7], @computer)
+        mark([2, 4, 5], @opponent)
+        @strategy.move.should == 6
       end
 
       it "returns winning move when there are winning and tie moves" do
-        mark([0, 2, 3, 4], @computer_value)
-        mark([1, 5, 8], @opponent_value)
-        @strategy.move(@board).should == 6
+        mark([0, 2, 3, 4], @computer)
+        mark([1, 5, 8], @opponent)
+        @strategy.move.should == 6
       end
 
       it "returns tied move when there are losing and tie moves" do
-        mark([2, 3, 4], @computer_value)
-        mark([0, 5, 6, 7], @opponent_value)
-        @strategy.move(@board).should == 8
+        mark([2, 3, 4], @computer)
+        mark([0, 5, 6, 7], @opponent)
+        @strategy.move.should == 8
       end
 
       context "winning move appear later in the board" do
         it "returns win move when winning move is later than losing move" do
-          mark([1, 2, 5, 7], @computer_value)
-          mark([0, 3, 4], @opponent_value)
-          @strategy.move(@board).should == 8
+          mark([1, 2, 5, 7], @computer)
+          mark([0, 3, 4], @opponent)
+          @strategy.move.should == 8
         end
 
         it "returns winning move when winning move is later than tie move" do
-          mark([0, 2, 4, 5], @computer_value)
-          mark([1, 3, 6], @opponent_value)
-          @strategy.move(@board).should == 8
+          mark([0, 2, 4, 5], @computer)
+          mark([1, 3, 6], @opponent)
+          @strategy.move.should == 8
         end
 
         it "returns tied move when there are losing and tie moves" do
-          mark([2, 3, 4], @computer_value)
-          mark([0, 5, 6, 7], @opponent_value)
-          @strategy.move(@board).should == 8
+          mark([2, 3, 4], @computer)
+          mark([0, 5, 6, 7], @opponent)
+          @strategy.move.should == 8
         end
       end
     end
 
     context "when there are three moves left" do
       it "chooses the winning move when there is one available" do
-        mark([1, 4], @computer_value)
-        mark([0, 3, 2, 5], @opponent_value)
-        @strategy.move(@board).should == 7
+        mark([1, 4], @computer)
+        mark([0, 3, 2, 5], @opponent)
+        @strategy.move.should == 7
       end
 
       it "chooses a tie move when there are only losing and tie moves" do
-        mark([1, 4], @computer_value)
-        mark([0, 2, 5, 7], @opponent_value)
-        @strategy.move(@board).should == 8
+        mark([1, 4], @computer)
+        mark([0, 2, 5, 7], @opponent)
+        @strategy.move.should == 8
       end
     end
 
     context "when there are 4 moves left" do
       it "chooses a winning move when one is available" do
-        mark([0, 4], @computer_value)
-        mark([1, 2, 6], @opponent_value)
-        @strategy.move(@board).should == 8
+        mark([0, 4], @computer)
+        mark([1, 2, 6], @opponent)
+        @strategy.move.should == 8
       end
 
       it "chooses a move that would create 2 winning moves" do
-        mark([0, 6], @computer_value)
-        mark([1, 3, 5], @opponent_value)
-        @strategy.move(@board).should == 4
+        mark([0, 6], @computer)
+        mark([1, 3, 5], @opponent)
+        @strategy.move.should == 4
       end
     end
   end
 
   it "chooses the winning move when available" do
-    mark([1, 4], @computer_value)
-    mark([0], @opponent_value)
-    @strategy.move(@board).should == 7
+    mark([1, 4], @computer)
+    mark([0], @opponent)
+    @strategy.move.should == 7
   end
 
   it "chooses the winning move when available" do
-    mark([0, 4], @computer_value)
-    mark([1, 2], @opponent_value)
-    @strategy.move(@board).should == 8
+    mark([0, 4], @computer)
+    mark([1, 2], @opponent)
+    @strategy.move.should == 8
   end
 
   it "chooses a blocking move when there is no winning move" do
-    mark([2], @computer_value)
-    mark([0, 4], @opponent_value)
-    @strategy.move(@board).should == 8
+    mark([2], @computer)
+    mark([0, 4], @opponent)
+    @strategy.move.should == 8
   end
 
   it "chooses a blocking move when there is no winning move" do
-    mark([2], @computer_value)
-    mark([1, 4], @opponent_value)
-    @strategy.move(@board).should == 7
+    mark([2], @computer)
+    mark([1, 4], @opponent)
+    @strategy.move.should == 7
   end
 
   it "chooses the middle square when computer is the second player" do
-    mark([0], @opponent_value)
-    @strategy.move(@board).should == 4
+    mark([0], @opponent)
+    @strategy.move.should == 4
   end
 
   it "chooses the first corner of the board when the middle square is taken as a second player" do
-    mark([4], @opponent_value)
-    @strategy.move(@board).should == 0
+    mark([4], @opponent)
+    @strategy.move.should == 0
   end
 
   it "chooses the middle square on the first move" do
-    @strategy.move(@board).should == 4
+    @strategy.move.should == 4
   end
 
   def move_node(move, score)

data/spec/tic_tac_toe/ui/console_spec.rb

@@ -79,7 +79,7 @@ describe TicTacToe::Console do
   it "displays winner" do
     player = TicTacToe::Player.new("Todd", "X", nil)
     @console.display_winner(player)
-    @output.string.should == "Todd(X) wins!\n"
+    @output.string.should == "Todd(X) win!\n"
   end
 
   it "display tied game" do

data/tic_tac_toe_nhu.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'tic_tac_toe_nhu'
-  s.version     = '0.0.5'
+  s.version     = '0.0.11'
   s.date        = '2013-06-11'
   s.summary     = "Tic Tac Toe"
   s.description = "A simple tic tac toe game with AI"
@@ -8,5 +8,4 @@ Gem::Specification.new do |s|
   s.email       = 'nhu313@gmail.com'
   s.files       = `git ls-files`.split("\n")
   s.homepage    = 'http://rubygems.org/gems/tic_tac_toe_nhu'
-  s.executables << 'tic_tac_toe'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tic_tac_toe_nhu
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.11
 platform: ruby
 authors:
 - Nhu Nguyen
@@ -12,8 +12,7 @@ date: 2013-06-11 00:00:00.000000000 Z
 dependencies: []
 description: A simple tic tac toe game with AI
 email: nhu313@gmail.com
-executables:
-- tic_tac_toe
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
@@ -32,36 +31,33 @@ files:
 - features/tictactoe_submit_move.feature
 - lib/tic_tac_toe/board.rb
 - lib/tic_tac_toe/game.rb
-- lib/tic_tac_toe/game_state.rb
-- lib/tic_tac_toe/game_state_factory.rb
+- lib/tic_tac_toe/game_factory.rb
 - lib/tic_tac_toe/player.rb
 - lib/tic_tac_toe/player_factory.rb
 - lib/tic_tac_toe/rules.rb
+- lib/tic_tac_toe/runner.rb
 - lib/tic_tac_toe/strategy/console_user.rb
 - lib/tic_tac_toe/strategy/minimax.rb
 - lib/tic_tac_toe/ui/console.rb
-- lib/tic_tac_toe/values.rb
 - spec/integration/tictactoe/unbeatable_computer_spec.rb
 - spec/mocks/game.rb
-- spec/mocks/game_state.rb
-- spec/mocks/game_state_factory.rb
-- spec/mocks/player.rb
+- spec/mocks/game_factory.rb
 - spec/mocks/player_factory.rb
 - spec/mocks/rules.rb
 - spec/mocks/strategy/dynamic.rb
 - spec/mocks/ui/console.rb
 - spec/tic_tac_toe/board_spec.rb
+- spec/tic_tac_toe/game_factory_spec.rb
 - spec/tic_tac_toe/game_spec.rb
-- spec/tic_tac_toe/game_state_factory_spec.rb
-- spec/tic_tac_toe/game_state_spec.rb
+- spec/tic_tac_toe/player_factory_mock.rb
 - spec/tic_tac_toe/player_factory_spec.rb
 - spec/tic_tac_toe/player_spec.rb
 - spec/tic_tac_toe/rules_spec.rb
+- spec/tic_tac_toe/runner_spec.rb
 - spec/tic_tac_toe/spec_helper.rb
 - spec/tic_tac_toe/strategy/console_user_spec.rb
 - spec/tic_tac_toe/strategy/minimax_spec.rb
 - spec/tic_tac_toe/ui/console_spec.rb
-- spec/tic_tac_toe/values_spec.rb
 - tic_tac_toe_nhu.gemspec
 homepage: http://rubygems.org/gems/tic_tac_toe_nhu
 licenses: []

data/lib/tic_tac_toe/game_state.rb

@@ -1,35 +0,0 @@
-require 'tic_tac_toe/board'
-require 'tic_tac_toe/rules'
-
-module TicTacToe
-  class GameState
-    attr_reader :board, :current_player
-
-    def initialize(players, board = TicTacToe::Board.new)
-      @board = board
-      @players = players
-      @current_player = players[0]
-    end
-
-    def change_player
-      @current_player = (@players[0] == @current_player)? @players[1] : @players[0]
-    end
-
-    def game_over?
-      rules.game_over?
-    end
-
-    def winner
-      player(rules.winner)
-    end
-
-    private
-    def rules
-      TicTacToe::Rules.new(board)
-    end
-
-    def player(value)
-      @players.detect {|p| p.value == value}
-    end
-  end
-end

data/lib/tic_tac_toe/game_state_factory.rb

@@ -1,56 +0,0 @@
-require 'tic_tac_toe/game_state'
-require 'tic_tac_toe/board'
-require 'tic_tac_toe/player_factory'
-require 'tic_tac_toe/values'
-
-module TicTacToe
-  class GameStateFactory
-    def initialize(player_factory = TicTacToe::PlayerFactory.new)
-      @player_factory = player_factory
-    end
-
-    def types
-      [[:human, :computer], [:computer, :human], [:human, :human], [:computer, :computer]]
-    end
-
-    def create(game_type)
-      case game_type
-      when 1
-        human_computer_game
-      when 2
-        computer_human_game
-      when 3
-        human_human_game
-      when 4
-        computer_computer_game
-      else
-        raise ArgumentError, "Type #{game_type} does not exist. Please select a number corresponding to the game type."
-      end
-    end
-
-    private
-    def computer_human_game
-      create_game(@player_factory.computer, @player_factory.human)
-    end
-
-    def human_computer_game
-      create_game(@player_factory.human, @player_factory.computer)
-    end
-
-    def human_human_game
-      player1 = @player_factory.human
-      player2 = @player_factory.human("Friend", TicTacToe::Values.opponent(player1.value))
-      create_game(player1, player2)
-    end
-
-    def computer_computer_game
-      computer1 = @player_factory.computer(TicTacToe::VALUES[0])
-      computer2 = @player_factory.computer(TicTacToe::Values.opponent(computer1.value))
-      create_game(computer1, computer2)
-    end
-
-    def create_game(player1, player2)
-      TicTacToe::GameState.new([player1, player2])
-    end
-  end
-end

data/lib/tic_tac_toe/values.rb

@@ -1,10 +0,0 @@
-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/mocks/game_state.rb

@@ -1,18 +0,0 @@
-require 'surrogate/rspec'
-require 'tic_tac_toe/game_state'
-
-class MockGameState
-  Surrogate.endow(self)
-  define_reader :board
-  define_reader :current_player
-
-  define :winner
-  define :change_player
-  define(:game_over?){true}
-end
-
-describe TicTacToe::GameState do
-  it "checks MockGameState" do
-    MockGameState.should be_substitutable_for(TicTacToe::GameState)
-  end
-end

data/spec/mocks/game_state_factory.rb

@@ -1,14 +0,0 @@
-require 'surrogate/rspec'
-
-class MockGameStateFactory
-  Surrogate.endow(self)
-  define(:initialize) {|player_factory|}
-  define :types
-  define(:create) {|type|}
-end
-
-describe TicTacToe::GameStateFactory do
-  it "checks game factory" do
-    MockGameStateFactory.should be_substitutable_for(TicTacToe::GameStateFactory)
-  end
-end

data/spec/mocks/player.rb

@@ -1,16 +0,0 @@
-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/tic_tac_toe/game_state_factory_spec.rb

@@ -1,63 +0,0 @@
-require 'tic_tac_toe/spec_helper'
-require 'tic_tac_toe/game_state_factory'
-require 'tic_tac_toe/player_factory'
-require 'mocks/player_factory'
-require 'tic_tac_toe/player'
-
-describe TicTacToe::GameStateFactory do
-  before(:each) do
-    @player_factory = MockPlayerFactory.new
-    @game_factory = TicTacToe::GameStateFactory.new(@player_factory)
-  end
-
-  it "returns 4 types of games" do
-    @game_factory.types.size.should == 4
-  end
-
-  context "creates game state" do
-    before(:each) do
-      @human = TicTacToe::Player.new("Human", TicTacToe::VALUES[0], nil)
-      @computer = TicTacToe::Player.new("Computer", opponent_value(@human.value), nil)
-
-      @player_factory.will_have_human @human
-      @player_factory.will_have_computer @computer
-    end
-
-    def test_game_state_creation(game_type, players)
-      game = @game_factory.create(game_type)
-      game.current_player.should == players[0]
-      game.change_player
-      game.current_player.should == players[1]
-    end
-
-    it "returns human vs computer game state" do
-      test_game_state_creation(1, [@human, @computer])
-    end
-
-    it "returns computer vs human game" do
-      test_game_state_creation(2, [@computer, @human])
-    end
-
-    it "returns user vs user game" do
-      @human2 = TicTacToe::Player.new("Human 2", opponent_value(@human.value), nil)
-      @player_factory.will_have_human @human, @human2
-
-      test_game_state_creation(3, [@human, @human2])
-    end
-
-    it "returns computer vs computer game" do
-      @computer2 = TicTacToe::Player.new("Computer 2", opponent_value(@computer.value), nil)
-      @player_factory.will_have_computer @computer, @computer2
-
-      test_game_state_creation(4, [@computer, @computer2])
-    end
-  end
-
-  it "raises an error when the game type doesn't exist" do
-    lambda{@game_factory.create(10)}.should raise_error(ArgumentError)
-  end
-
-  def opponent_value(value)
-    TicTacToe::Values.opponent(value)
-  end
-end

data/spec/tic_tac_toe/game_state_spec.rb

@@ -1,73 +0,0 @@
-require 'tic_tac_toe/spec_helper'
-require 'tic_tac_toe/board'
-require 'tic_tac_toe/game_state'
-require 'tic_tac_toe/player'
-require 'tic_tac_toe/values'
-
-describe TicTacToe::GameState do
-  attr_reader :game_state, :player1, :player2, :board
-
-  before(:each) do
-    @board = TicTacToe::Board.new
-    @player1 = TicTacToe::Player.new("player1", TicTacToe::VALUES[0], nil)
-    @player2 = TicTacToe::Player.new("player1", TicTacToe::VALUES[1], nil)
-    @game_state = TicTacToe::GameState.new([@player1, @player2], @board)
-  end
-
-
-  it "can read board" do
-    game_state.board.should == board
-  end
-
-  describe "current player" do
-    it "starts with player 1 as the current player" do
-      game_state.current_player.should == player1
-    end
-
-    it "changes current player to player 2" do
-      game_state.current_player.should == player1
-      game_state.change_player
-      game_state.current_player.should == player2
-    end
-
-    it "changes current player to player 1 after two calls on change player" do
-      game_state.current_player.should == player1
-      game_state.change_player
-      game_state.change_player
-      game_state.current_player.should == player1
-    end
-  end
-
-  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
-
-  def mark_winning_board(value)
-    [0, 4, 8].each do |move|
-      game_state.board.mark(move, value)
-    end
-  end
-end

data/spec/tic_tac_toe/values_spec.rb

@@ -1,17 +0,0 @@
-require 'tic_tac_toe/values'
-
-describe "Values" do
-  VALUES = ["X", "O"]
-
-  it "has X and O values" do
-    TicTacToe::VALUES.should == VALUES
-  end
-
-  it "gets opponent for X" do
-    TicTacToe::Values.opponent(VALUES[0]).should == VALUES[1]
-  end
-
-  it "gets opponent for O" do
-    TicTacToe::Values.opponent(VALUES[1]).should == VALUES[0]
-  end
-end