tic_tac_toes 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e7b4f6653858ee05ee85a0ad10f519879bed750
-  data.tar.gz: e5aaea09afc5342b96fb823881ba26ef691f00af
+  metadata.gz: 0e7dac5d68711dc5bafd138607af1f05cb9753c5
+  data.tar.gz: 20480d443fcc914f9f844aa40db5a90b4a52300f
 SHA512:
-  metadata.gz: 49287beb325485b2b1affb085f082f03804f8c0a9a21bd761ca8bddca64e681fb98be844dac1c6ec0d1f3df58ee96e7e23518b18351c06b021838c5cbf05cb19
-  data.tar.gz: 0874989c2aaf4f7dd1712266303fbad25c4f911507c158b65d0e1ae72b94605e842366b708485f21f51420cb99823e7bd403f8ada58b58cb947783e377cc310b
+  metadata.gz: 6d6b6478a8b3c54643825073c4106336c210f715c119570dbbac80caf89f6cd8a8dbe1b1ad0758557326603e115b4e987aa0792fbe318ebb8680ce30035bc1b7
+  data.tar.gz: b3bbd7b5bc6dc32e8fb175bc2d66160e4f8177be37ab301ac9ef1d492b58a5c095e325ef47f66b4f1d10b1fafd7cb7a7451b2ad9eacddb4c4f52a25f0e23afda

data/Gemfile.lock

@@ -14,14 +14,14 @@ GEM
       rspec-core (~> 3.0.0)
       rspec-expectations (~> 3.0.0)
       rspec-mocks (~> 3.0.0)
-    rspec-core (3.0.3)
+    rspec-core (3.0.4)
       rspec-support (~> 3.0.0)
-    rspec-expectations (3.0.3)
+    rspec-expectations (3.0.4)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.0.0)
-    rspec-mocks (3.0.3)
+    rspec-mocks (3.0.4)
       rspec-support (~> 3.0.0)
-    rspec-support (3.0.3)
+    rspec-support (3.0.4)
 
 PLATFORMS
   ruby

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

@@ -4,7 +4,7 @@ module TicTacToes
   module Core
     module MoveStrategies
       module HardAI
-        ALPHA, BETA = -1, 1
+        ALPHA, BETA, DEPTH = -100, 100, 0
 
         def self.move(game_state)
           board = game_state.board
@@ -15,7 +15,7 @@ module TicTacToes
           open_spaces = Hash[board.open_spaces.map { |space| [space, nil] }]
 
           open_spaces.each do |space, score|
-            score = minimax(generate_game_state(space, game_state), :min, ALPHA, BETA)
+            score = minimax(generate_game_state(space, game_state), :min, ALPHA, BETA, DEPTH)
             open_spaces[space] = score
           end
 
@@ -25,18 +25,18 @@ module TicTacToes
 
         private
 
-        def self.minimax(game_state, current_player, alpha, beta)
-          return score(game_state) if game_state.game_over?
+        def self.minimax(game_state, current_player, alpha, beta, depth)
+          return score(game_state, depth) if game_state.game_over?
 
           if current_player == :max
             game_state.board.open_spaces.each do |space|
-              alpha = [alpha, minimax(generate_game_state(space, game_state), :min, alpha, beta)].max
+              alpha = [alpha, minimax(generate_game_state(space, game_state), :min, alpha, beta, depth + 1)].max
               break if beta <= alpha
             end
             alpha
           elsif current_player == :min
             game_state.board.open_spaces.each do |space|
-              beta = [beta, minimax(generate_game_state(space, game_state), :max, alpha, beta)].min
+              beta = [beta, minimax(generate_game_state(space, game_state), :max, alpha, beta, depth + 1)].min
               break if beta <= alpha
             end
             beta
@@ -50,14 +50,14 @@ module TicTacToes
           new_game_state
         end
 
-        def self.score(game_state)
+        def self.score(game_state, depth)
           winner = game_state.determine_winner
           if winner.nil?
             0
-          elsif winner.move_strategy == self
-            1
+          elsif winner.move_strategy.is_a? Human
+            -100
           else
-            -1
+            100 - depth
           end
         end
 

data/lib/tic_tac_toes/ui/adapter.rb

@@ -1,3 +1,6 @@
+require 'tic_tac_toes/core/player_factory'
+require 'tic_tac_toes/core/move_strategies/hard_ai'
+
 module TicTacToes
   module UI
     module Adapter
@@ -32,6 +35,23 @@ module TicTacToes
         listener.moves_were_made(game_state)
       end
 
+      def self.predictions(game_state)
+        predictions = []
+        (0..8).each do |space|
+          next predictions << nil unless game_state.board.space(space).nil?
+
+          potential_game_state = generate_game_state(game_state, space)
+          next predictions << predicted_result(potential_game_state) if potential_game_state.game_over?
+
+          potential_game_state.turn_over([])
+          potential_game_state.place_move(Core::MoveStrategies::HardAI.move(potential_game_state))
+          next predictions << predicted_result(potential_game_state) if potential_game_state.game_over?
+
+          predictions << nil
+        end
+        predictions
+      end
+
       private
 
       def self.tell_listener_game_is_over(game_state, listener)
@@ -44,6 +64,25 @@ module TicTacToes
           listener.game_ended_in_winner(game_state, winning_player.token)
         end
       end
+
+      def self.generate_game_state(game_state, space)
+        new_game_state = Marshal.load(Marshal.dump(game_state))
+        new_game_state.turn_over([])
+        new_game_state.place_move(space)
+        new_game_state
+      end
+
+      def self.predicted_result(game_state)
+        winner = game_state.determine_winner
+
+        if winner.nil?
+          "tie"
+        elsif winner.move_strategy.is_a? Core::MoveStrategies::Human
+          "win"
+        else
+          "loss"
+        end
+      end
     end
   end
 end

data/lib/tic_tac_toes/version.rb

@@ -1,3 +1,3 @@
 module TicTacToes
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

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

@@ -1,13 +1,16 @@
 require 'tic_tac_toes/test_board_generator'
 require 'tic_tac_toes/core/move_strategies/hard_ai'
+require 'tic_tac_toes/core/move_strategies/human'
 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(:depth) { TicTacToes::Core::MoveStrategies::HardAI::DEPTH }
   let(:hard_ai) { TicTacToes::Core::MoveStrategies::HardAI }
-  let(:x) { TicTacToes::Core::Player.new("human", "x", false, "io") }
+  let(:human) { TicTacToes::Core::MoveStrategies::Human.new('unused_io') }
+  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 }
@@ -69,9 +72,9 @@ describe TicTacToes::Core::MoveStrategies::HardAI do
                                                        o,   o, nil,
                                                        x, nil,   x])
       game_state = TicTacToes::Core::GameState.new(board, players, history)
-      win_score = 1
+      win_score = 99
 
-      expect(hard_ai.minimax(game_state, :max, alpha, beta)).to eql(win_score)
+      expect(hard_ai.minimax(game_state, :max, alpha, beta, depth)).to eql(win_score)
     end
 
     it 'returns the correct score for a pre-loss board' do
@@ -79,9 +82,9 @@ describe TicTacToes::Core::MoveStrategies::HardAI do
                                                        nil, nil, nil,
                                                          x, nil,   x])
       game_state = TicTacToes::Core::GameState.new(board, players, history)
-      loss_score = -1
+      loss_score = -100
 
-      expect(hard_ai.minimax(game_state, :max, alpha, beta)).to eql(loss_score)
+      expect(hard_ai.minimax(game_state, :max, alpha, beta, depth)).to eql(loss_score)
     end
 
     it 'returns the correct score for a pre-draw board' do
@@ -91,7 +94,7 @@ describe TicTacToes::Core::MoveStrategies::HardAI do
       game_state = TicTacToes::Core::GameState.new(board, players, history)
       draw_score = 0
 
-      expect(hard_ai.minimax(game_state, :max, alpha, beta)).to eql(draw_score)
+      expect(hard_ai.minimax(game_state, :max, alpha, beta, depth)).to eql(draw_score)
     end
   end
 
@@ -116,9 +119,9 @@ describe TicTacToes::Core::MoveStrategies::HardAI do
                                                        nil,   o, nil,
                                                        nil, nil,   o])
       game_state = TicTacToes::Core::GameState.new(board, players, history)
-      win_score = 1
+      win_score = 100
 
-      expect(hard_ai.score(game_state)).to eq(win_score)
+      expect(hard_ai.score(game_state, depth)).to eq(win_score)
     end
 
     it 'returns the correct score when no one has won' do
@@ -128,7 +131,7 @@ describe TicTacToes::Core::MoveStrategies::HardAI do
       game_state = TicTacToes::Core::GameState.new(board, players, history)
       draw_score = 0
 
-      expect(hard_ai.score(game_state)).to eql(draw_score)
+      expect(hard_ai.score(game_state, depth)).to eql(draw_score)
     end
 
     it 'returns the correct score when the opponent has won' do
@@ -136,9 +139,9 @@ describe TicTacToes::Core::MoveStrategies::HardAI do
                                                        nil,   x, nil,
                                                        nil, nil,   x])
       game_state = TicTacToes::Core::GameState.new(board, players, history)
-      loss_score = -1
+      loss_score = -100
 
-      expect(hard_ai.score(game_state)).to eql(loss_score)
+      expect(hard_ai.score(game_state, depth)).to eql(loss_score)
     end
   end
 end

data/spec/tic_tac_toes/ui/adapter_spec.rb

@@ -91,4 +91,57 @@ describe TicTacToes::UI::Adapter do
       end
     end
   end
+
+  describe '#predictions' do
+    let(:history)    { TicTacToes::UI::NullHistory.new }
+
+    player_factory = TicTacToes::Core::PlayerFactory.new('unused_io')
+    let(:x)          { player_factory.generate_player('x', TicTacToes::Core::PlayerFactory::HUMAN) }
+    let(:o)          { player_factory.generate_player('o', TicTacToes::Core::PlayerFactory::HARD_AI) }
+    let(:players)    { [o, x] }   
+
+    it 'returns an array indicating which moves will result in a win' do
+      board = TicTacToes::TestBoardGenerator.generate([   x,   x, nil,
+                                                        nil, nil, nil,
+                                                        nil,   x,   x])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
+
+      expect(TicTacToes::UI::Adapter.predictions(game_state)).to eq([  nil,   nil, "win",
+                                                                       nil, "win",   nil,
+                                                                     "win",   nil,   nil])
+    end
+
+    it 'returns an array indicating which moves will result in an immediate tie' do
+      board = TicTacToes::TestBoardGenerator.generate([x, x,   o,
+                                                       o, o,   x,
+                                                       x, o, nil])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
+
+      expect(TicTacToes::UI::Adapter.predictions(game_state)).to eq([nil, nil,   nil,
+                                                                     nil, nil,   nil,
+                                                                     nil, nil, "tie"])
+    end
+
+    it 'returns an array indicating which moves will result in a tie after the subsequent move' do
+      board = TicTacToes::TestBoardGenerator.generate([o,   o,   x,
+                                                       x,   x,   o,
+                                                       o, nil, nil])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
+
+      expect(TicTacToes::UI::Adapter.predictions(game_state)).to eq([nil,   nil,   nil,
+                                                                     nil,   nil,   nil,
+                                                                     nil, "tie", "tie"])
+    end
+
+    it 'returns an array indicating which moves will result in a loss after the subsequent move' do
+      board = TicTacToes::TestBoardGenerator.generate([  o,   x,    o,
+                                                         x,   o,  nil,
+                                                       nil, nil,    x])
+      game_state = TicTacToes::Core::GameState.new(board, players, history)
+
+      expect(TicTacToes::UI::Adapter.predictions(game_state)).to eq([   nil,    nil,    nil,
+                                                                        nil,    nil, "loss",
+                                                                        nil, "loss",    nil])
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tic_tac_toes
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Ben Spatafora
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-11 00:00:00.000000000 Z
+date: 2014-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler