tic_tac_toes 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 919ce75f7f8ad28d261cef9d2a9c7dc1cb0fdad7
-  data.tar.gz: 676c42fa2f8acb3c7dc03d989ab40febdd9958ee
+  metadata.gz: 5b7b828672ca3ca2908fc62b6f7cf25622a16322
+  data.tar.gz: 704c24b5374e84549277e659401621ee7044ee75
 SHA512:
-  metadata.gz: 8e94d802c318a795d6272a5341a2183248cf355109abf6022ce3fd725c2080987028bc1037fb3134fc1e31f321468b93c21e66e4ea3d663c98cd45a69164efef
-  data.tar.gz: 7bd562a193cde805efb2d9ee5c12f4dc10b4e9fa78b6f1ccc622d1e4cc1c7b1438f5bf3adf523ee41ddab88362fdee97301c2f6c114ac40096fbbad4b7600342
+  metadata.gz: a9a5b96876e221e2b43c7e5996be97ea4e14af904017d6f7e5f64e3ae978ab08b71ef3f194ad25ffe690a785ca8a8168943c290b396c6c414a957dd042be566d
+  data.tar.gz: 14ff8a5d98dd83cadd2821a3321a758a716eb81783d617539777093c4eae479a5b7057fb5bb364a169169d089b58bd902a03352feb6f96c8bd5ef62e7133009f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    tic_tac_toes (0.0.9)
+    tic_tac_toes (0.1.0)
       pg
 
 GEM

data/bin/tic_tac_toes

@@ -5,13 +5,11 @@ $LOAD_PATH << File.expand_path(File.dirname(__FILE__) + '/../lib')
 require 'tic_tac_toes/command_line/prompt'
 require 'tic_tac_toes/core/io'
 
-require 'tic_tac_toes/core/board_factory'
 require 'tic_tac_toes/core/player_factory'
 require 'tic_tac_toes/command_line/menu'
 
 require 'tic_tac_toes/database/pg_wrapper'
 require 'tic_tac_toes/core/history'
-require 'tic_tac_toes/core/game_state_factory'
 
 require 'tic_tac_toes/command_line/runner'
 
@@ -20,12 +18,10 @@ database = "tic_tac_toes"
 prompt = TicTacToes::CommandLine::Prompt
 io = TicTacToes::Core::IO.new(prompt)
 
-board_factory = TicTacToes::Core::BoardFactory.new
 player_factory = TicTacToes::Core::PlayerFactory.new(io)
-menu = TicTacToes::CommandLine::Menu.new(io, board_factory, player_factory)
+menu = TicTacToes::CommandLine::Menu.new(io, player_factory)
 
 database_wrapper = TicTacToes::Database::PGWrapper.new(database)
 history = TicTacToes::Core::History.new(database_wrapper)
-game_state_factory = TicTacToes::Core::GameStateFactory.new(history)
 
-TicTacToes::CommandLine::Runner.new(io, menu, game_state_factory).run
+TicTacToes::CommandLine::Runner.new(io, menu, history).run

data/lib/tic_tac_toes/command_line/menu.rb

@@ -1,16 +1,16 @@
+require 'tic_tac_toes/core/board'
 require 'tic_tac_toes/core/rules'
 
 module TicTacToes
   module CommandLine
     class Menu
-      def initialize(io, board_factory, player_factory)
+      def initialize(io, player_factory)
         @io = io
-        @board_factory = board_factory
         @player_factory = player_factory
       end
 
       def get_board
-        @board_factory.generate_board(get_row_size)
+        TicTacToes::Core::Board.new(row_size: get_row_size)
       end
 
       def get_players

data/lib/tic_tac_toes/command_line/runner.rb

@@ -1,15 +1,17 @@
+require 'tic_tac_toes/core/game_state'
+
 module TicTacToes
   module CommandLine
     class Runner
-      def initialize(io, menu, game_state_factory)
+      def initialize(io, menu, history)
         @io = io
         @menu = menu
-        @game_state_factory = game_state_factory
+        @history = history
       end
 
       def run
         board, players = @menu.get_board, @menu.get_players
-        game_state = @game_state_factory.generate_game_state(board, players)
+        game_state = TicTacToes::Core::GameState.new(board, players, @history)
 
         take_turn(game_state) until game_state.game_over?
         end_game(game_state)
@@ -21,7 +23,7 @@ module TicTacToes
         @io.draw_board(game_state.board)
         @io.thinking_notification if game_state.current_player.needs_to_think
 
-        move = game_state.current_player.place_and_return_move(game_state.board, game_state.players)
+        move = game_state.current_player.place_and_return_move(game_state)
         game_state.turn_over(move)
       end
 

data/lib/tic_tac_toes/core/game_state.rb

@@ -14,10 +14,18 @@ module TicTacToes
         @history.record_board_size(@board.size)
       end
 
+      def place_move(space)
+        @board.place(current_player, space)
+      end
+
       def current_player
         @players.first
       end
 
+      def next_player
+        @players[1]
+      end
+
       def turn_over(move)
         @history.record_move(move)
         @players.rotate!

data/lib/tic_tac_toes/core/history.rb

@@ -18,6 +18,7 @@ module TicTacToes
 
       def record_winner(winner)
         winner = "Draw" if winner.nil?
+        winner = winner.token unless winner.is_a? String
         @winner = winner
       end
 

data/lib/tic_tac_toes/core/move_strategies/easy_ai.rb

@@ -1,11 +1,9 @@
-require 'tic_tac_toes/core/board'
-
 module TicTacToes
   module Core
     module MoveStrategies
       module EasyAI
-        def self.move(board, players)
-          board.open_spaces.sample
+        def self.move(game_state)
+          game_state.board.open_spaces.sample
         end
       end
     end

data/lib/tic_tac_toes/core/move_strategies/hard_ai.rb

@@ -4,14 +4,18 @@ module TicTacToes
   module Core
     module MoveStrategies
       module HardAI
-        def self.move(board, players)
+        ALPHA, BETA = -1, 1
+
+        def self.move(game_state)
+          board = game_state.board
+
           return 0 if nine_board_first_move?(board)
           return second_move(board) if nine_board_second_move?(board)
 
           open_spaces = Hash[board.open_spaces.map { |space| [space, nil] }]
 
           open_spaces.each do |space, score|
-            score = minimax(generate_board(players.first, space, board), :min, players)
+            score = minimax(generate_game_state(space, game_state), :min, ALPHA, BETA)
             open_spaces[space] = score
           end
 
@@ -21,43 +25,39 @@ module TicTacToes
 
         private
 
-        def self.minimax(board, current_player, players)
-          return score(board, players) if Rules.game_over?(board, players)
+        def self.minimax(game_state, current_player, alpha, beta)
+          return score(game_state) if game_state.game_over?
 
           if current_player == :max
-            best_score = -1
-            board.open_spaces.each do |space|
-              score = minimax(generate_board(players.first, space, board), :min, players)
-              best_score = [best_score, score].max
+            game_state.board.open_spaces.each do |space|
+              alpha = [alpha, minimax(generate_game_state(space, game_state), :min, alpha, beta)].max
+              break if beta <= alpha
             end
-            best_score
-
+            alpha
           elsif current_player == :min
-            best_score = 1
-            board.open_spaces.each do |space|
-              score = minimax(generate_board(players.last, space, board), :max, players)
-              best_score = [best_score, score].min
+            game_state.board.open_spaces.each do |space|
+              beta = [beta, minimax(generate_game_state(space, game_state), :max, alpha, beta)].min
+              break if beta <= alpha
             end
-            best_score
+            beta
           end
         end
 
-        def self.generate_board(player, space, board)
-          new_board = Marshal.load(Marshal.dump(board))
-          new_board.place(player, space)
-          new_board
+        def self.generate_game_state(space, game_state)
+          new_game_state = Marshal.load(Marshal.dump(game_state))
+          new_game_state.place_move(space)
+          new_game_state.turn_over([])
+          new_game_state
         end
 
-        def self.score(board, players)
-          own_token, opponent_token = players.first.token, players.last.token
-
-          case Rules.determine_winner(board, players)
-          when own_token
+        def self.score(game_state)
+          winner = game_state.determine_winner
+          if winner.nil?
+            0
+          elsif winner.move_strategy == self
             1
-          when opponent_token
-            -1
           else
-            0
+            -1
           end
         end
 

data/lib/tic_tac_toes/core/move_strategies/human.rb

@@ -6,13 +6,13 @@ module TicTacToes
           @io = io
         end
 
-        def move(board, players)
+        def move(game_state)
           @io.move_solicitation
 
           Integer(@io.solicit_input)
           rescue ArgumentError
             @io.not_an_integer_error
-            move(board, players)
+            move(game_state)
         end
       end
     end

data/lib/tic_tac_toes/core/move_strategies/medium_ai.rb

@@ -5,9 +5,9 @@ module TicTacToes
   module Core
     module MoveStrategies
       module MediumAI
-        def self.move(board, players)
+        def self.move(game_state)
           move_strategy = [EasyAI, HardAI, HardAI].sample
-          move_strategy.move(board, players)
+          move_strategy.move(game_state)
         end
       end
     end

data/lib/tic_tac_toes/core/player.rb

@@ -10,10 +10,10 @@ module TicTacToes
         @io = io
       end
 
-      def place_and_return_move(board, players)
+      def place_and_return_move(game_state)
         loop do
-          space = @move_strategy.move(board, players)
-          break [@token, space] if board.place(self, space)
+          space = @move_strategy.move(game_state)
+          break [@token, space] if game_state.place_move(space)
           @io.invalid_move_error
         end
       end

data/lib/tic_tac_toes/core/rules.rb

@@ -32,7 +32,7 @@ module TicTacToes
 
         players.each do |player|
           player_has_won = win?(board, player)
-          winner = player.token if player_has_won
+          winner = player if player_has_won
         end
 
         winner

data/lib/tic_tac_toes/ui/adapter.rb

@@ -4,7 +4,7 @@ module TicTacToes
       def self.make_move(game_state, move, listener)
         unless move.nil?
           move = move.to_i
-          game_state.board.place(game_state.current_player, move)
+          game_state.place_move(move)
         end
 
         if game_state.game_over?
@@ -13,7 +13,7 @@ module TicTacToes
         end
 
         game_state.turn_over(move)
-        game_state.current_player.place_and_return_move(game_state.board, game_state.players)
+        game_state.current_player.place_and_return_move(game_state)
 
         if game_state.game_over?
           tell_listener_game_is_over(game_state, listener)
@@ -26,13 +26,13 @@ module TicTacToes
       private
 
       def self.tell_listener_game_is_over(game_state, listener)
-        winning_token = game_state.determine_winner
+        winning_player = game_state.determine_winner
 
-        case winning_token
+        case winning_player
         when nil
           listener.game_ended_in_draw(game_state)
         else 
-          listener.game_ended_in_winner(game_state, winning_token)
+          listener.game_ended_in_winner(game_state, winning_player.token)
         end
       end
     end

data/lib/tic_tac_toes/version.rb

@@ -1,3 +1,3 @@
 module TicTacToes
-  VERSION = "0.0.9"
+  VERSION = "0.1.0"
 end

data/spec/tic_tac_toes/command_line/menu_spec.rb

@@ -1,5 +1,4 @@
 require 'tic_tac_toes/command_line/menu'
-require 'tic_tac_toes/core/board_factory'
 require 'tic_tac_toes/core/player_factory'
 require 'tic_tac_toes/core/io'
 require 'tic_tac_toes/core/move_strategies/human'
@@ -7,9 +6,8 @@ require 'tic_tac_toes/core/move_strategies/medium_ai'
 
 describe TicTacToes::CommandLine::Menu do
   let(:io) { double }
-  let(:board_factory) { TicTacToes::Core::BoardFactory.new }
   let(:player_factory) { TicTacToes::Core::PlayerFactory.new(io) }
-  let(:menu) { TicTacToes::CommandLine::Menu.new(io, board_factory, player_factory) }
+  let(:menu) { TicTacToes::CommandLine::Menu.new(io, player_factory) }
 
   describe '#get_board' do
     let(:invalid_row_size) { 11 }

data/spec/tic_tac_toes/command_line/runner_spec.rb

@@ -1,38 +1,4 @@
 require 'tic_tac_toes/command_line/runner'
 
 describe TicTacToes::CommandLine::Runner do
-  describe '#run' do
-    let(:game_state) { double(board: 'board', players: 'players', game_over: true) }
-
-    let(:io)                  { double(draw_board: true,
-                                       thinking_notification: true,
-                                       game_over_notification: true) }
-    let(:menu)                { double(get_board: true,
-                                       get_players: true) }
-    let(:game_state)          { double(board: 'board',
-                                       players: 'players',
-                                       game_over: true,
-                                       game_over?: true,
-                                       determine_winner: true) }
-    let(:game_state_factory)  { double(generate_game_state: game_state) }
-
-    let(:runner) { TicTacToes::CommandLine::Runner.new(io, menu, game_state_factory) }
-
-    it 'gets an initial game state' do
-      expect(game_state_factory).to receive(:generate_game_state)
-      runner.run
-    end
-
-    it 'takes turns until the game is over' do
-      allow(game_state).to receive(:game_over?).and_return(false, true)
-
-      expect(runner).to receive(:take_turn).once
-      runner.run
-    end
-
-    it 'ends the game when the game is over' do
-      expect(runner).to receive(:end_game)
-      runner.run
-    end
-  end
 end

data/spec/tic_tac_toes/core/game_state_spec.rb

@@ -13,6 +13,41 @@ describe TicTacToes::Core::GameState do
     end
   end
 
+  describe '#place_move' do
+    let(:x) { double("human player", token: "x") }
+    let(:o) { double("computer player", token: "o") }
+    let(:players) { [x, o] }
+
+    let(:history) { double(record_board_size: true) }
+
+    it 'returns nil if the board’s space is not nil' do
+      board = TicTacToes::TestBoardGenerator.generate([  x, nil, nil,
+                                                       nil, nil, nil,
+                                                       nil, nil, nil])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
+
+      expect(game_state.place_move(0)).to eq(nil)
+    end
+
+    it 'returns nil if it isn’t in its board’s spaces range' do
+      board = TicTacToes::TestBoardGenerator.generate([nil, nil, nil,
+                                                       nil, nil, nil,
+                                                       nil, nil, nil])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
+      expect(game_state.place_move(9)).to eq(nil)
+    end
+
+    it 'places the current player at the space if the space is nil and in the board’s spaces range' do
+      board = TicTacToes::TestBoardGenerator.generate([nil, nil, nil,
+                                                       nil, nil, nil,
+                                                       nil, nil, nil])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
+
+      game_state.place_move(0)
+      expect(game_state.board.space(0)).to eq(game_state.current_player)
+    end
+  end
+
   describe '#current_player' do
     it 'returns the first item of its players array' do
       history = double(record_board_size: true)
@@ -24,6 +59,17 @@ describe TicTacToes::Core::GameState do
     end
   end
 
+  describe '#next_player' do
+    it 'returns the second item of its players array' do
+      history = double(record_board_size: true)
+      players = ['first_player', 'second_player']
+      game_state = TicTacToes::Core::GameState.new('board', players, history)
+
+      next_player = game_state.next_player
+      expect(next_player).to eq('second_player')
+    end
+  end
+
   describe '#turn_over' do
     it 'records the last move' do
       move = double
@@ -47,21 +93,21 @@ describe TicTacToes::Core::GameState do
 
   describe '#game_over' do
     it 'records the winner' do
-      winner = double
+      winning_player = double
       history = double(record_board_size: true, persist: true)
       game_state = TicTacToes::Core::GameState.new('board', 'players', history)
 
-      expect(history).to receive(:record_winner).with(winner)
-      game_state.game_over(winner)
+      expect(history).to receive(:record_winner).with(winning_player)
+      game_state.game_over(winning_player)
     end
 
     it 'persists its history' do
-      winner = double
+      winning_player = double(token: 'x')
       history = double(record_board_size: true, record_winner: true)
       game_state = TicTacToes::Core::GameState.new('board', 'players', history)
 
       expect(history).to receive(:persist)
-      game_state.game_over(winner)
+      game_state.game_over(winning_player)
     end
   end
 
@@ -76,6 +122,7 @@ describe TicTacToes::Core::GameState do
       board = TicTacToes::TestBoardGenerator.generate([x, x,   o,
                                                        o, o, nil,
                                                        x, o,   x])
+
       game_state = TicTacToes::Core::GameState.new(board, players, history)
       expect(game_state.game_over?).to be false
     end
@@ -113,7 +160,8 @@ describe TicTacToes::Core::GameState do
       winning_token = "o"
       game_state = TicTacToes::Core::GameState.new(board, players, history)
 
-      expect(game_state.determine_winner).to eql(winning_token)
+      winning_player = game_state.determine_winner
+      expect(winning_player.token).to eq(winning_token)
     end
 
     it "returns nil if there is not a winner" do
@@ -125,5 +173,4 @@ describe TicTacToes::Core::GameState do
       expect(game_state.determine_winner).to be_nil
     end
   end
-
 end

data/spec/tic_tac_toes/core/history_spec.rb

@@ -23,11 +23,11 @@ describe TicTacToes::Core::History do
   end
 
   describe '#record_winner' do
-    it "records the passed winner" do
-      token = "O"
+    it "records the token of the passed winner" do
+      winner = double(token: 'O')
 
-      history.record_winner(token)
-      expect(history.winner).to eq(token)
+      history.record_winner(winner)
+      expect(history.winner).to eq(winner.token)
     end
   end
 

data/spec/tic_tac_toes/core/move_strategies/easy_ai_spec.rb

@@ -1,18 +1,25 @@
 require 'tic_tac_toes/test_board_generator'
+require 'tic_tac_toes/core/game_state'
 require 'tic_tac_toes/core/move_strategies/easy_ai'
+require 'tic_tac_toes/core/player_factory'
 
 describe TicTacToes::Core::MoveStrategies::EasyAI do
   describe '#move' do
-    let(:players) { double("players") }
-    let(:easy_ai) { TicTacToes::Core::MoveStrategies::EasyAI }
-
     it "returns a randomly-selected valid move" do
-      board = TicTacToes::TestBoardGenerator.generate([ :O, nil, nil,
-                                                       nil,  :X, nil,
-                                                       nil,  :X, nil])
+      player_factory = TicTacToes::Core::PlayerFactory.new('unused_io')
+      x = player_factory.generate_human_player('x')
+      o = player_factory.generate_computer_player('o', :hard)
+      players = [x, o]
+
+      board = TicTacToes::TestBoardGenerator.generate([  o, nil, nil,
+                                                       nil,   x, nil,
+                                                       nil,   x, nil])
+
+      history = double(record_board_size: true)
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
       valid_moves = [1, 2, 3, 5, 6, 8]
 
-      move = easy_ai.move(board, players)
+      move = TicTacToes::Core::MoveStrategies::EasyAI.move(game_state)
       expect(valid_moves).to include(move)
     end
   end

data/spec/tic_tac_toes/core/move_strategies/hard_ai_spec.rb

@@ -1,129 +1,144 @@
 require 'tic_tac_toes/test_board_generator'
 require 'tic_tac_toes/core/move_strategies/hard_ai'
+require 'tic_tac_toes/core/game_state'
 require 'tic_tac_toes/core/player'
 
 describe TicTacToes::Core::MoveStrategies::HardAI do
+  let(:alpha) { TicTacToes::Core::MoveStrategies::HardAI::ALPHA }
+  let(:beta) { TicTacToes::Core::MoveStrategies::HardAI::BETA }
   let(:hard_ai) { TicTacToes::Core::MoveStrategies::HardAI }
   let(:x) { TicTacToes::Core::Player.new("human", "x", false, "io") }
   let(:o) { TicTacToes::Core::Player.new(hard_ai, "o", true, "io") }
   let(:players) { [o, x] }
-
+  let(:history) { TicTacToes::UI::NullHistory.new }
 
   describe '#move' do
-    it "returns the best move" do
+    it 'returns the best move' do
       board = TicTacToes::TestBoardGenerator.generate([x, nil, nil,
                                                        o,   o, nil,
                                                        x, nil,   x])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
       best_move = 5
 
-      expect(hard_ai.move(board, players)).to eql(best_move)
+      expect(hard_ai.move(game_state)).to eql(best_move)
     end
 
-    context "when playing on a 3x3 board" do
+    context 'when playing on a 3x3 board' do
       it 'returns 0 when making the first move' do
         board = TicTacToes::TestBoardGenerator.generate([nil, nil, nil,
                                                          nil, nil, nil,
                                                          nil, nil, nil])
+        game_state = TicTacToes::Core::GameState.new(board, players, history)
         
-        expect(hard_ai.move(board, players)).to eq(0)
+        expect(hard_ai.move(game_state)).to eq(0)
       end
 
-      it "returns 4 when the opponent’s first move was a corner" do
+      it 'returns 4 when the opponent’s first move was a corner' do
         board = TicTacToes::TestBoardGenerator.generate([nil, nil, nil,
                                                          nil, nil, nil,
                                                          nil, nil,   x])
+        game_state = TicTacToes::Core::GameState.new(board, players, history)
 
-        expect(hard_ai.move(board, players)).to eq(4)
+        expect(hard_ai.move(game_state)).to eq(4)
       end
       
-      it "returns 4 when the opponent’s first move was an edge" do
+      it 'returns 4 when the opponent’s first move was an edge' do
         board = TicTacToes::TestBoardGenerator.generate([nil, nil, nil,
                                                          nil, nil,   x,
                                                          nil, nil, nil])
+        game_state = TicTacToes::Core::GameState.new(board, players, history)
 
-        expect(hard_ai.move(board, players)).to eq(4)
+        expect(hard_ai.move(game_state)).to eq(4)
       end
 
-      it "returns 0 when the opponent’s first move was the center" do
+      it 'returns 0 when the opponent’s first move was the center' do
         board = TicTacToes::TestBoardGenerator.generate([nil, nil, nil,
                                                          nil,   x, nil,
                                                          nil, nil, nil])
+        game_state = TicTacToes::Core::GameState.new(board, players, history)
 
-        expect(hard_ai.move(board, players)).to eq(0)
+        expect(hard_ai.move(game_state)).to eq(0)
       end
     end
   end
 
 
   describe '#minimax' do
-    it "returns the correct score for a pre-win board" do
+    it 'returns the correct score for a pre-win board' do
       board = TicTacToes::TestBoardGenerator.generate([x, nil, nil,
                                                        o,   o, nil,
                                                        x, nil,   x])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
       win_score = 1
 
-      expect(hard_ai.minimax(board, :max, players)).to eql(win_score)
+      expect(hard_ai.minimax(game_state, :max, alpha, beta)).to eql(win_score)
     end
 
-    it "returns the correct score for a pre-loss board" do
+    it 'returns the correct score for a pre-loss board' do
       board = TicTacToes::TestBoardGenerator.generate([  o,   o,   x,
                                                        nil, nil, nil,
                                                          x, nil,   x])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
       loss_score = -1
 
-      expect(hard_ai.minimax(board, :max, players)).to eql(loss_score)
+      expect(hard_ai.minimax(game_state, :max, alpha, beta)).to eql(loss_score)
     end
 
-    it "returns the correct score for a pre-draw board" do
+    it 'returns the correct score for a pre-draw board' do
       board = TicTacToes::TestBoardGenerator.generate([x,   x, o,
                                                        o, nil, x,
                                                        x,   o, x])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
       draw_score = 0
 
-      expect(hard_ai.minimax(board, :max, players)).to eql(draw_score)
+      expect(hard_ai.minimax(game_state, :max, alpha, beta)).to eql(draw_score)
     end
   end
 
 
-  describe '#generate_board' do
-    it "returns a board based on a token, a space, and an existing board" do
-      token, space = o, 3
+  describe '#generate_game_state' do
+    it 'returns a game state based on a space and an existing game state' do
+      space, token = 3, 'o'
       board = TicTacToes::TestBoardGenerator.generate([  x, nil, nil,
                                                        nil,   o, nil,
                                                          x, nil, nil])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
 
-      new_board = hard_ai.generate_board(token, space, board)
-      expect(new_board.space(space)).to eql(token)
+      new_game_state = hard_ai.generate_game_state(space, game_state)
+      expect(new_game_state.board.space(space).token).to eq(token)
     end
   end
 
 
   describe '#score' do
-    it "returns the correct score when HardAI has won" do
+    it 'returns the correct score when HardAI has won' do
       board = TicTacToes::TestBoardGenerator.generate([  o, nil, nil,
                                                        nil,   o, nil,
                                                        nil, nil,   o])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
       win_score = 1
 
-      expect(hard_ai.score(board, players)).to eql(win_score)
+      expect(hard_ai.score(game_state)).to eq(win_score)
     end
 
-    it "returns the correct score when no one has won" do
+    it 'returns the correct score when no one has won' do
       board = TicTacToes::TestBoardGenerator.generate([o, o, x,
                                                        x, x, o,
                                                        o, x, o])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
       draw_score = 0
 
-      expect(hard_ai.score(board, players)).to eql(draw_score)
+      expect(hard_ai.score(game_state)).to eql(draw_score)
     end
 
-    it "returns the correct score when the opponent has won" do
+    it 'returns the correct score when the opponent has won' do
       board = TicTacToes::TestBoardGenerator.generate([  x, nil, nil,
                                                        nil,   x, nil,
                                                        nil, nil,   x])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
       loss_score = -1
 
-      expect(hard_ai.score(board, players)).to eql(loss_score)
+      expect(hard_ai.score(game_state)).to eql(loss_score)
     end
   end
 end

data/spec/tic_tac_toes/core/move_strategies/human_spec.rb

@@ -2,29 +2,29 @@ require 'tic_tac_toes/core/move_strategies/human'
 
 describe TicTacToes::Core::MoveStrategies::Human do
   describe '#move' do
-    let(:io)     { double("io", solicit_input: 0, move_solicitation: true, not_an_integer_error: true) }
+    let(:io)     { double('io', solicit_input: 0, move_solicitation: true, not_an_integer_error: true) }
     let(:human)  { TicTacToes::Core::MoveStrategies::Human.new(io) }
 
-    it "displays a move solicitation" do
+    it 'displays a move solicitation' do
       expect(io).to receive(:move_solicitation)
-      human.move("board", "players")
+      human.move('game_state')
     end
 
     context 'when given not-integer-like input' do
-      let(:not_integer_like)  { "string" }
-      let(:integer_like)      { "100" }
+      let(:not_integer_like)  { 'string' }
+      let(:integer_like)      { '100' }
 
-      it "displays a not an integer error" do
+      it 'displays a not an integer error' do
         allow(io).to receive(:solicit_input).and_return(not_integer_like, integer_like)
 
         expect(io).to receive(:not_an_integer_error).once
-        human.move("board", "players")
+        human.move('game_state')
       end
 
-      it "only returns a move (converted to integer) once it gets integer-like input" do
+      it 'only returns a move (converted to integer) once it gets integer-like input' do
         allow(io).to receive(:solicit_input).and_return(not_integer_like, integer_like)
 
-        expect(human.move("board", "players")).to eq(100)
+        expect(human.move('game_state')).to eq(100)
       end
     end
   end

data/spec/tic_tac_toes/core/move_strategies/medium_ai_spec.rb

@@ -1,20 +1,25 @@
 require 'tic_tac_toes/test_board_generator'
+require 'tic_tac_toes/core/game_state'
 require 'tic_tac_toes/core/move_strategies/medium_ai'
+require 'tic_tac_toes/core/player_factory'
 
 describe TicTacToes::Core::MoveStrategies::MediumAI do
-  let(:medium_ai) { TicTacToes::Core::MoveStrategies::MediumAI }
-  let(:x) { TicTacToes::Core::Player.new("human", "x", false, "io") }
-  let(:o) { TicTacToes::Core::Player.new(medium_ai, "o", true, "io") }
-  let(:players) { [x, o] }
-
   describe '#move' do
     it "returns a valid move (based on either EasyAI or HardAI)" do
-      board = TicTacToes::TestBoardGenerator.generate([  o, o,   x,
-                                                       nil, x, nil,
-                                                       nil, x, nil])
+      player_factory = TicTacToes::Core::PlayerFactory.new('unused_io')
+      x = player_factory.generate_human_player('x')
+      o = player_factory.generate_computer_player('o', :hard)
+      players = [x, o]
+
+      board = TicTacToes::TestBoardGenerator.generate([  o,  o,   x,
+                                                       nil,  x, nil,
+                                                       nil,  x, nil])
+
+      history = TicTacToes::UI::NullHistory.new
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
       valid_moves = [3, 5, 6, 8]
 
-      move = medium_ai.move(board, players)
+      move = TicTacToes::Core::MoveStrategies::MediumAI.move(game_state)
       expect(valid_moves).to include(move)
     end
   end

data/spec/tic_tac_toes/core/player_spec.rb

@@ -2,31 +2,34 @@ require 'tic_tac_toes/core/board'
 require 'tic_tac_toes/core/player'
 
 describe TicTacToes::Core::Player do
-  let(:board)         { TicTacToes::Core::Board.new(row_size: 3) }
-  let(:io)            { double("io", invalid_move_error: true) }
-  let(:players)       { double("players") }
+  let(:board)          { TicTacToes::Core::Board.new(row_size: 3) }
 
-  describe '#place_and_return_move' do
-    let(:move_strategy)   { double("move_strategy") }
-    let(:token)           { "X" }
-    let(:needs_to_think)  { false }
+  let(:io)             { double(invalid_move_error: true) }
+
+  let(:move_strategy)  { double }
+  let(:x)              { TicTacToes::Core::Player.new(move_strategy, 'x', false, io) }
+  let(:o)              { double }
+  let(:players)        { [x, o] }
+
+  let(:history)        { double(record_board_size: true) }
 
-    let(:player) { TicTacToes::Core::Player.new(move_strategy, token, needs_to_think, io) }
- 
-    it "only places/returns a move once it receives a valid move" do
+  let(:game_state)     { TicTacToes::Core::GameState.new(board, players, history) }
+
+  describe '#place_and_return_move' do
+    it 'only places/returns a move once it receives a valid move' do
       invalid_space, valid_space = 9, 0
       allow(move_strategy).to receive(:move).and_return(invalid_space, valid_space)
 
-      player.place_and_return_move(board, players)
-      expect(board.space(valid_space)).to eq(player)
+      x.place_and_return_move(game_state)
+      expect(board.space(valid_space)).to eq(x)
     end
 
-    it "displays an invalid move error when given an invalid move" do
+    it 'displays an invalid move error when given an invalid move' do
       invalid_space, valid_space = 9, 0
       allow(move_strategy).to receive(:move).and_return(invalid_space, valid_space)
 
       expect(io).to receive(:invalid_move_error)
-      player.place_and_return_move(board, players)
+      x.place_and_return_move(game_state)
     end
   end
 end

data/spec/tic_tac_toes/core/rules_spec.rb

@@ -86,13 +86,14 @@ describe TicTacToes::Core::Rules do
 
 
   describe '#determine_winner' do
-    it "returns the winning token when there is a winner" do
+    it "returns the winning player when there is a winner" do
       board = TicTacToes::TestBoardGenerator.generate([  o, nil, nil,
                                                        nil,   o, nil,
                                                        nil, nil,   o])
       winning_token = "o"
 
-      expect(rules.determine_winner(board, players)).to eql(winning_token)
+      winning_player = rules.determine_winner(board, players)
+      expect(winning_player.token).to eql(winning_token)
     end
 
     it "returns nil if there is not a winner" do

data/spec/tic_tac_toes/ui/adapter_spec.rb

@@ -5,12 +5,12 @@ require 'tic_tac_toes/ui/adapter'
 
 describe TicTacToes::UI::Adapter do
   describe '#make_move' do
-    let(:history) { double(record_board_size: true,
-                           record_move: true) }
+    let(:history)    { TicTacToes::UI::NullHistory.new }
+
     player_factory = TicTacToes::Core::PlayerFactory.new('unused_io')
-    let(:x) { player_factory.generate_human_player('x') }
-    let(:o) { player_factory.generate_computer_player('o', :hard) }
-    let(:players) { [x, o] }
+    let(:x)          { player_factory.generate_human_player('x') }
+    let(:o)          { player_factory.generate_computer_player('o', :hard) }
+    let(:players)    { [x, o] }
 
     context 'when the game is still in progress' do
       it 'sends its listener #moves_were_made with the updated game state' do
@@ -25,8 +25,8 @@ describe TicTacToes::UI::Adapter do
         TicTacToes::UI::Adapter.make_move(game_state, move, listener)
 
         first_move, second_move = 2, 1
-        game_state.board.place(x, first_move)
-        game_state.board.place(o, second_move)
+        board.place(x, first_move)
+        board.place(o, second_move)
         expect(listener).to have_received(:moves_were_made).with(game_state)
       end
     end
@@ -44,7 +44,7 @@ describe TicTacToes::UI::Adapter do
         allow(listener).to receive(:game_ended_in_winner)
         TicTacToes::UI::Adapter.make_move(game_state, move, listener)
 
-        game_state.board.place(x, 2)
+        board.place(x, 2)
         expect(listener).to have_received(:game_ended_in_winner).with(game_state, winning_token)
       end
     end
@@ -61,7 +61,7 @@ describe TicTacToes::UI::Adapter do
         allow(listener).to receive(:game_ended_in_draw)
         TicTacToes::UI::Adapter.make_move(game_state, move, listener)
 
-        game_state.board.place(x, 8)
+        board.place(x, 8)
         expect(listener).to have_received(:game_ended_in_draw).with(game_state)
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tic_tac_toes
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors:
 - Ben Spatafora
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-29 00:00:00.000000000 Z
+date: 2014-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -90,9 +90,7 @@ files:
 - lib/tic_tac_toes/command_line/prompt.rb
 - lib/tic_tac_toes/command_line/runner.rb
 - lib/tic_tac_toes/core/board.rb
-- lib/tic_tac_toes/core/board_factory.rb
 - lib/tic_tac_toes/core/game_state.rb
-- lib/tic_tac_toes/core/game_state_factory.rb
 - lib/tic_tac_toes/core/history.rb
 - lib/tic_tac_toes/core/io.rb
 - lib/tic_tac_toes/core/move_strategies/easy_ai.rb
@@ -111,9 +109,7 @@ files:
 - lib/tic_tac_toes/version.rb
 - spec/tic_tac_toes/command_line/menu_spec.rb
 - spec/tic_tac_toes/command_line/runner_spec.rb
-- spec/tic_tac_toes/core/board_factory_spec.rb
 - spec/tic_tac_toes/core/board_spec.rb
-- spec/tic_tac_toes/core/game_state_factory_spec.rb
 - spec/tic_tac_toes/core/game_state_spec.rb
 - spec/tic_tac_toes/core/history_spec.rb
 - spec/tic_tac_toes/core/io_spec.rb
@@ -157,9 +153,7 @@ summary: The game Tic-tac-toe, featuring an unbeatable AI
 test_files:
 - spec/tic_tac_toes/command_line/menu_spec.rb
 - spec/tic_tac_toes/command_line/runner_spec.rb
-- spec/tic_tac_toes/core/board_factory_spec.rb
 - spec/tic_tac_toes/core/board_spec.rb
-- spec/tic_tac_toes/core/game_state_factory_spec.rb
 - spec/tic_tac_toes/core/game_state_spec.rb
 - spec/tic_tac_toes/core/history_spec.rb
 - spec/tic_tac_toes/core/io_spec.rb

data/lib/tic_tac_toes/core/board_factory.rb

@@ -1,11 +0,0 @@
-require 'tic_tac_toes/core/board'
-
-module TicTacToes
-  module Core
-    class BoardFactory
-      def generate_board(row_size)
-        Board.new(row_size: row_size)
-      end
-    end
-  end
-end

data/lib/tic_tac_toes/core/game_state_factory.rb

@@ -1,15 +0,0 @@
-require 'tic_tac_toes/core/game_state'
-
-module TicTacToes
-  module Core
-    class GameStateFactory
-      def initialize(history)
-        @history = history
-      end
-
-      def generate_game_state(board, players)
-        GameState.new(board, players, @history)
-      end
-    end
-  end
-end

data/spec/tic_tac_toes/core/board_factory_spec.rb

@@ -1,13 +0,0 @@
-require 'tic_tac_toes/core/board_factory'
-
-describe TicTacToes::Core::BoardFactory do
-  describe '#generate_board' do
-    it 'returns a board object generated from a row size' do
-      board_factory = TicTacToes::Core::BoardFactory.new
-      row_size = 5
-
-      board = board_factory.generate_board(row_size)
-      expect(board.row_size).to eq(row_size)
-    end
-  end
-end

data/spec/tic_tac_toes/core/game_state_factory_spec.rb

@@ -1,15 +0,0 @@
-require 'tic_tac_toes/core/game_state_factory'
-
-describe TicTacToes::Core::GameStateFactory do
-  describe '#generate_game_state' do
-    it 'returns a game state object generated from a board object and player array' do
-      history = double(record_board_size: true)
-      game_state_factory = TicTacToes::Core::GameStateFactory.new(history)
-      board, players = double(size: 3), double
-
-      game_state = game_state_factory.generate_game_state(board, players)
-      expect(game_state.board).to eq(board)
-      expect(game_state.players).to eq(players)
-    end
-  end
-end