tic_tac_toes 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 085e4d7d1fd5316dd0a28ca154203ae9411e3c2f
-  data.tar.gz: ef98016568277620377b83e02aa0ea58827a379b
+  metadata.gz: 919ce75f7f8ad28d261cef9d2a9c7dc1cb0fdad7
+  data.tar.gz: 676c42fa2f8acb3c7dc03d989ab40febdd9958ee
 SHA512:
-  metadata.gz: 688112f80e57889cbd0cf27e190f3f2a7a8e41dc6823ef9ee1d47bf622cd5f554c52b8684c4332c97d838ea923c5b32cb2f0687f92f9a2d3ff9169c5730ba308
-  data.tar.gz: ccf022fc972444762499b6ac6a9450dc91ae27be064d24692c11cbdfe232814ff6ad18425e98f56c052c6649aa8de7a0a3c56b1f664fea422ec3aee2db4af24a
+  metadata.gz: 8e94d802c318a795d6272a5341a2183248cf355109abf6022ce3fd725c2080987028bc1037fb3134fc1e31f321468b93c21e66e4ea3d663c98cd45a69164efef
+  data.tar.gz: 7bd562a193cde805efb2d9ee5c12f4dc10b4e9fa78b6f1ccc622d1e4cc1c7b1438f5bf3adf523ee41ddab88362fdee97301c2f6c114ac40096fbbad4b7600342

data/Gemfile.lock

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

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

@@ -5,6 +5,7 @@ module TicTacToes
     module MoveStrategies
       module HardAI
         def self.move(board, players)
+          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] }]
@@ -60,6 +61,10 @@ module TicTacToes
           end
         end
 
+        def self.nine_board_first_move?(board)
+          board.size == 9 && board.open_spaces.count == 9
+        end
+
         def self.nine_board_second_move?(board)
           board.size == 9 && board.open_spaces.count == 8
         end

data/lib/tic_tac_toes/ui/adapter.rb

@@ -1,95 +1,39 @@
-require 'tic_tac_toes/core/board'
-require 'tic_tac_toes/core/game_state'
-require 'tic_tac_toes/core/player_factory'
-require 'tic_tac_toes/core/rules'
-
 module TicTacToes
   module UI
     module Adapter
-      def self.new_board_structure
-        board = Core::Board.new
-        board.spaces
-      end
-
-      def self.make_move(board_structure, move, listener)
-        move = move.to_i
-        game_state = game_state_from_board_structure(board_structure)
-
-        human_player = game_state.players.first
-        game_state.board.place(human_player, move)
+      def self.make_move(game_state, move, listener)
+        unless move.nil?
+          move = move.to_i
+          game_state.board.place(game_state.current_player, move)
+        end
 
-        if Core::Rules.game_over?(game_state.board, game_state.players)
-          return listener.game_is_over(game_state_to_board_structure(game_state), "Game over")
+        if game_state.game_over?
+          tell_listener_game_is_over(game_state, listener)
+          return
         end
 
         game_state.turn_over(move)
+        game_state.current_player.place_and_return_move(game_state.board, game_state.players)
 
-        computer_player = game_state.players.first
-        computer_player.place_and_return_move(game_state.board, game_state.players)
-
-        if Core::Rules.game_over?(game_state.board, game_state.players)
-          return listener.game_is_over(game_state_to_board_structure(game_state), "Game over")
+        if game_state.game_over?
+          tell_listener_game_is_over(game_state, listener)
+          return
         end
 
-        listener.move_was_valid(game_state_to_board_structure(game_state))
-      end
-
-      def self.game_state_from_board_structure(board_structure)
-        player_factory = Core::PlayerFactory.new('unused_io')
-        human_player = player_factory.generate_human_player('X')
-        computer_player = player_factory.generate_computer_player('O', :hard)
-        players = [human_player, computer_player]
-
-        board_structure_with_players = replace_tokens_with_players(board_structure, human_player, computer_player)
-        board = board_from_structure(board_structure_with_players)
-
-        Core::GameState.new(board, players, NullHistory.new)
-      end
-
-      def self.game_state_to_board_structure(game_state)
-        structure_with_players = game_state.board.spaces
-
-        replace_players_with_tokens(structure_with_players)
+        listener.moves_were_made(game_state)
       end
 
       private
 
-      def self.replace_tokens_with_players(board_structure, human_player, computer_player)
-        board_structure.map do |space|
-          case space
-          when 'X'
-            human_player
-          when 'O'
-            computer_player
-          else
-            nil
-          end
-        end
-      end
-
-      def self.replace_players_with_tokens(board_structure)
-        board_structure.map { |space| space.token unless space.nil? }
-      end
-
-      def self.board_from_structure(board_structure)
-        row_size = Math.sqrt(board_structure.count).to_i
-        board = Core::Board.new(row_size: row_size)
+      def self.tell_listener_game_is_over(game_state, listener)
+        winning_token = game_state.determine_winner
 
-        board_structure.each_with_index do |player, index|
-          board.place(player, index)
+        case winning_token
+        when nil
+          listener.game_ended_in_draw(game_state)
+        else 
+          listener.game_ended_in_winner(game_state, winning_token)
         end
-
-        board
-      end
-    end
-
-    class NullHistory
-      def record_board_size(size)
-        nil
-      end
-
-      def record_move(move)
-        nil
       end
     end
   end

data/lib/tic_tac_toes/ui/serializer.rb

@@ -0,0 +1,75 @@
+require 'tic_tac_toes/core/board'
+require 'tic_tac_toes/core/game_state'
+require 'tic_tac_toes/core/player_factory'
+
+module TicTacToes
+  module UI
+    module Serializer
+      X = 'X'
+      O = 'O'
+
+      def self.new_board_structure
+        board = Core::Board.new
+        board.spaces
+      end
+
+      def self.game_state_from_board_structure(board_structure)
+        player_factory = Core::PlayerFactory.new('unused_io')
+        human_player = player_factory.generate_human_player(X)
+        computer_player = player_factory.generate_computer_player(O, :hard)
+        players = [human_player, computer_player]
+
+        board_structure_with_players = replace_tokens_with_players(board_structure, human_player, computer_player)
+        board = board_from_structure(board_structure_with_players)
+
+        Core::GameState.new(board, players, NullHistory.new)
+      end
+
+      def self.game_state_to_board_structure(game_state)
+        structure_with_players = game_state.board.spaces
+
+        replace_players_with_tokens(structure_with_players)
+      end
+
+      private
+
+      def self.replace_tokens_with_players(board_structure, human_player, computer_player)
+        board_structure.map do |space|
+          case space
+          when X
+            human_player
+          when O
+            computer_player
+          else
+            nil
+          end
+        end
+      end
+
+      def self.replace_players_with_tokens(board_structure)
+        board_structure.map { |space| space.token unless space.nil? }
+      end
+
+      def self.board_from_structure(board_structure)
+        row_size = Math.sqrt(board_structure.count).to_i
+        board = Core::Board.new(row_size: row_size)
+
+        board_structure.each_with_index do |player, index|
+          board.place(player, index)
+        end
+
+        board
+      end
+    end
+
+    class NullHistory
+      def record_board_size(size)
+        nil
+      end
+
+      def record_move(move)
+        nil
+      end
+    end
+  end
+end

data/lib/tic_tac_toes/version.rb

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

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

@@ -20,6 +20,14 @@ describe TicTacToes::Core::MoveStrategies::HardAI do
     end
 
     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])
+        
+        expect(hard_ai.move(board, players)).to eq(0)
+      end
+
       it "returns 4 when the opponent’s first move was a corner" do
         board = TicTacToes::TestBoardGenerator.generate([nil, nil, nil,
                                                          nil, nil, nil,

data/spec/tic_tac_toes/ui/adapter_spec.rb

@@ -1,72 +1,69 @@
-require 'tic_tac_toes/core/board'
 require 'tic_tac_toes/core/game_state'
 require 'tic_tac_toes/core/player_factory'
+require 'tic_tac_toes/test_board_generator'
 require 'tic_tac_toes/ui/adapter'
 
 describe TicTacToes::UI::Adapter do
-  describe '#new_board_structure' do
-    it 'returns a new board structure' do
-      new_board_structure = [nil, nil, nil, nil, nil, nil, nil, nil, nil]
-      expect(TicTacToes::UI::Adapter.new_board_structure).to eq(new_board_structure)
-    end
-  end
-
   describe '#make_move' do
+    let(:history) { double(record_board_size: true,
+                           record_move: true) }
+    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] }
+
     context 'when the game is still in progress' do
-      it 'sends its listener a `valid` message with an updated board structure' do
-        board_structure = ["X", nil, nil, nil, "O", nil, nil, nil, nil]
-        move = "2"
+      it 'sends its listener #moves_were_made with the updated game state' do
+        board = TicTacToes::TestBoardGenerator.generate([  x, nil, nil,
+                                                         nil,   o, nil,
+                                                         nil, nil, nil])
+        game_state = TicTacToes::Core::GameState.new(board, players, history)
+        move = '2'
         listener = double
 
-        updated_board_structure = ["X", "O", "X", nil, "O", nil, nil, nil, nil]
+        allow(listener).to receive(:moves_were_made)
+        TicTacToes::UI::Adapter.make_move(game_state, move, listener)
 
-        expect(listener).to receive(:move_was_valid).with(updated_board_structure)
-        TicTacToes::UI::Adapter.make_move(board_structure, move, listener)
+        first_move, second_move = 2, 1
+        game_state.board.place(x, first_move)
+        game_state.board.place(o, second_move)
+        expect(listener).to have_received(:moves_were_made).with(game_state)
       end
     end
 
-    context 'when the game has ended' do
-      it 'sends its listener a `game_over` message with an updated board structure and a game over message' do
-        board_structure = ["X", "X", nil, nil, nil, nil, nil, nil, nil]
-        move = "2"
+    context 'when the game has ended with a winner' do
+      it 'sends its listener #game_ended_in_winner with the updated game state and the winning token' do
+        board = TicTacToes::TestBoardGenerator.generate([  x,   x, nil,
+                                                         nil, nil, nil,
+                                                         nil, nil, nil])
+        game_state = TicTacToes::Core::GameState.new(board, players, history)
+        move = '2'
         listener = double
+        winning_token = 'x'
 
-        updated_board_structure = ["X", "X", "X", nil, nil, nil, nil, nil, nil]
-        game_over_message = "Game over"
+        allow(listener).to receive(:game_ended_in_winner)
+        TicTacToes::UI::Adapter.make_move(game_state, move, listener)
 
-        expect(listener).to receive(:game_is_over).with(updated_board_structure, game_over_message)
-        TicTacToes::UI::Adapter.make_move(board_structure, move, listener)
+        game_state.board.place(x, 2)
+        expect(listener).to have_received(:game_ended_in_winner).with(game_state, winning_token)
       end
     end
-  end
-
-  describe '#game_state_from_board_structure' do
-    it 'returns a game state object based on a board structure' do
-      board_structure = [nil, nil, nil, nil, "X", nil, nil, nil, nil]
 
-      game_state = TicTacToes::UI::Adapter.game_state_from_board_structure(board_structure)
-      middle_space = game_state.board.space(4)
-      first_player = game_state.players.first
-      second_player = game_state.players.last
-
-      expect(middle_space.token).to eq('X')
-      expect(first_player.token).to eq('X')
-      expect(second_player.token).to eq('O')
-    end
-  end
+    context 'when the game has ended in a draw' do
+      it 'sends its listener #game_ended_in_draw with the updated game state' do
+        board = TicTacToes::TestBoardGenerator.generate([x, x,   o,
+                                                         o, o,   x,
+                                                         x, o, nil])
+        game_state = TicTacToes::Core::GameState.new(board, players, history)
+        move = '8'
+        listener = double
 
-  describe '#game_state_to_board_structure' do
-    it 'returns a board structure based on a game state object' do
-      player_factory = TicTacToes::Core::PlayerFactory.new('unused_io')
-      first_player = player_factory.generate_human_player('X')
-      second_player = player_factory.generate_computer_player('O', :hard)
-      players = [first_player, second_player]
-      board = TicTacToes::Core::Board.new
-      board.place(first_player, 4)
+        allow(listener).to receive(:game_ended_in_draw)
+        TicTacToes::UI::Adapter.make_move(game_state, move, listener)
 
-      game_state = TicTacToes::Core::GameState.new(board, players, TicTacToes::UI::NullHistory.new)
-      board_structure = [nil, nil, nil, nil, "X", nil, nil, nil, nil]
-      expect(TicTacToes::UI::Adapter.game_state_to_board_structure(game_state)).to eq(board_structure)
+        game_state.board.place(x, 8)
+        expect(listener).to have_received(:game_ended_in_draw).with(game_state)
+      end
     end
   end
 end

data/spec/tic_tac_toes/ui/serializer_spec.rb

@@ -0,0 +1,43 @@
+require 'tic_tac_toes/core/board'
+require 'tic_tac_toes/core/game_state'
+require 'tic_tac_toes/core/player_factory'
+require 'tic_tac_toes/ui/serializer'
+
+describe TicTacToes::UI::Serializer do
+  describe '#new_board_structure' do
+    it 'returns a new board structure' do
+      new_board_structure = [nil, nil, nil, nil, nil, nil, nil, nil, nil]
+      expect(TicTacToes::UI::Serializer.new_board_structure).to eq(new_board_structure)
+    end
+  end
+
+  describe '#game_state_from_board_structure' do
+    it 'returns a game state object based on a board structure' do
+      board_structure = [nil, nil, nil, nil, 'X', nil, nil, nil, nil]
+
+      game_state = TicTacToes::UI::Serializer.game_state_from_board_structure(board_structure)
+      middle_space = game_state.board.space(4)
+      first_player = game_state.players.first
+      second_player = game_state.players.last
+
+      expect(middle_space.token).to eq(TicTacToes::UI::Serializer::X)
+      expect(first_player.token).to eq(TicTacToes::UI::Serializer::X)
+      expect(second_player.token).to eq(TicTacToes::UI::Serializer::O)
+    end
+  end
+
+  describe '#game_state_to_board_structure' do
+    it 'returns a board structure based on a game state object' do
+      player_factory = TicTacToes::Core::PlayerFactory.new('unused_io')
+      first_player = player_factory.generate_human_player(TicTacToes::UI::Serializer::X)
+      second_player = player_factory.generate_computer_player(TicTacToes::UI::Serializer::O, :hard)
+      players = [first_player, second_player]
+      board = TicTacToes::Core::Board.new
+      board.place(first_player, 4)
+
+      game_state = TicTacToes::Core::GameState.new(board, players, TicTacToes::UI::NullHistory.new)
+      board_structure = [nil, nil, nil, nil, 'X', nil, nil, nil, nil]
+      expect(TicTacToes::UI::Serializer.game_state_to_board_structure(game_state)).to eq(board_structure)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tic_tac_toes
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Ben Spatafora
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-28 00:00:00.000000000 Z
+date: 2014-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler