tic_tac_toes 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5b7b828672ca3ca2908fc62b6f7cf25622a16322
-  data.tar.gz: 704c24b5374e84549277e659401621ee7044ee75
+  metadata.gz: 1e7b4f6653858ee05ee85a0ad10f519879bed750
+  data.tar.gz: e5aaea09afc5342b96fb823881ba26ef691f00af
 SHA512:
-  metadata.gz: a9a5b96876e221e2b43c7e5996be97ea4e14af904017d6f7e5f64e3ae978ab08b71ef3f194ad25ffe690a785ca8a8168943c290b396c6c414a957dd042be566d
-  data.tar.gz: 14ff8a5d98dd83cadd2821a3321a758a716eb81783d617539777093c4eae479a5b7057fb5bb364a169169d089b58bd902a03352feb6f96c8bd5ef62e7133009f
+  metadata.gz: 49287beb325485b2b1affb085f082f03804f8c0a9a21bd761ca8bddca64e681fb98be844dac1c6ec0d1f3df58ee96e7e23518b18351c06b021838c5cbf05cb19
+  data.tar.gz: 0874989c2aaf4f7dd1712266303fbad25c4f911507c158b65d0e1ae72b94605e842366b708485f21f51420cb99823e7bd403f8ada58b58cb947783e377cc310b

data/Gemfile.lock

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

data/lib/tic_tac_toes/command_line/menu.rb

@@ -1,5 +1,6 @@
 require 'tic_tac_toes/core/board'
 require 'tic_tac_toes/core/rules'
+require 'tic_tac_toes/core/player_factory'
 
 module TicTacToes
   module CommandLine
@@ -20,8 +21,8 @@ module TicTacToes
         computer_token = get_token(:computer, taken_tokens)
         difficulty = get_difficulty
 
-        human_player = @player_factory.generate_human_player(human_token)
-        computer_player = @player_factory.generate_computer_player(computer_token, difficulty)
+        human_player = @player_factory.generate_player(human_token, Core::PlayerFactory::HUMAN)
+        computer_player = @player_factory.generate_player(computer_token, difficulty)
         [human_player, computer_player]
       end
 

data/lib/tic_tac_toes/core/player_factory.rb

@@ -7,23 +7,29 @@ require 'tic_tac_toes/core/player'
 module TicTacToes
   module Core
     class PlayerFactory
-      def initialize(io)
-        @io = io
-      end
+
+      HUMAN = :human
+      EASY_AI = :easy
+      MEDIUM_AI = :medium
+      HARD_AI = :hard
 
       AIS = {
-        easy:    ::TicTacToes::Core::MoveStrategies::EasyAI,
-        medium:  ::TicTacToes::Core::MoveStrategies::MediumAI,
-        hard:    ::TicTacToes::Core::MoveStrategies::HardAI }
+        EASY_AI => MoveStrategies::EasyAI,
+        MEDIUM_AI => MoveStrategies::MediumAI,
+        HARD_AI => MoveStrategies::HardAI
+      }
 
-      def generate_human_player(token)
-        needs_to_think = false
-        Player.new(TicTacToes::Core::MoveStrategies::Human.new(@io), token, needs_to_think, @io)
+      def initialize(io)
+        @io = io
       end
 
-      def generate_computer_player(token, difficulty)
-        needs_to_think = true
-        Player.new(AIS[difficulty], token, needs_to_think, @io)
+      def generate_player(token, type)
+        case type
+        when HUMAN
+          Player.new(MoveStrategies::Human.new(@io), token, false, @io)
+        else
+          Player.new(AIS.fetch(type), token, true, @io)
+        end
       end
     end
   end

data/lib/tic_tac_toes/ui/adapter.rb

@@ -1,6 +1,15 @@
 module TicTacToes
   module UI
     module Adapter
+      def self.start_game(order, game_state, listener)
+        case order
+        when 'first'
+          listener.moves_were_made(game_state)
+        when 'second'
+          make_move(game_state, nil, listener)
+        end
+      end
+
       def self.make_move(game_state, move, listener)
         unless move.nil?
           move = move.to_i

data/lib/tic_tac_toes/ui/serializer.rb

@@ -13,10 +13,10 @@ module TicTacToes
         board.spaces
       end
 
-      def self.game_state_from_board_structure(board_structure)
+      def self.game_state_from_board_structure(board_structure, computer_type)
         player_factory = Core::PlayerFactory.new('unused_io')
-        human_player = player_factory.generate_human_player(X)
-        computer_player = player_factory.generate_computer_player(O, :hard)
+        human_player = player_factory.generate_player(X, Core::PlayerFactory::HUMAN)
+        computer_player = player_factory.generate_player(O, Core::PlayerFactory.const_get(computer_type))
         players = [human_player, computer_player]
 
         board_structure_with_players = replace_tokens_with_players(board_structure, human_player, computer_player)
@@ -25,12 +25,28 @@ module TicTacToes
         Core::GameState.new(board, players, NullHistory.new)
       end
 
-      def self.game_state_to_board_structure(game_state)
+      def self.board_structure_from_game_state(game_state)
         structure_with_players = game_state.board.spaces
 
         replace_players_with_tokens(structure_with_players)
       end
 
+      def self.computer_type_from_game_state(game_state)
+        type = nil
+
+        game_state.players.each do |player|
+          if player.move_strategy == Core::PlayerFactory::AIS.fetch(Core::PlayerFactory::EASY_AI)
+            type = 'EASY_AI'
+          elsif player.move_strategy == Core::PlayerFactory::AIS.fetch(Core::PlayerFactory::MEDIUM_AI)
+            type = 'MEDIUM_AI'
+          elsif player.move_strategy == Core::PlayerFactory::AIS.fetch(Core::PlayerFactory::HARD_AI)
+            type = 'HARD_AI'
+          end
+        end
+
+        type
+      end
+
       private
 
       def self.replace_tokens_with_players(board_structure, human_player, computer_player)

data/lib/tic_tac_toes/version.rb

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

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

@@ -7,8 +7,8 @@ describe TicTacToes::Core::MoveStrategies::EasyAI do
   describe '#move' do
     it "returns a randomly-selected valid move" do
       player_factory = TicTacToes::Core::PlayerFactory.new('unused_io')
-      x = player_factory.generate_human_player('x')
-      o = player_factory.generate_computer_player('o', :hard)
+      x = player_factory.generate_player('x', TicTacToes::Core::PlayerFactory::HUMAN)
+      o = player_factory.generate_player('o', TicTacToes::Core::PlayerFactory::EASY_AI)
       players = [x, o]
 
       board = TicTacToes::TestBoardGenerator.generate([  o, nil, nil,

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

@@ -7,8 +7,8 @@ describe TicTacToes::Core::MoveStrategies::MediumAI do
   describe '#move' do
     it "returns a valid move (based on either EasyAI or HardAI)" do
       player_factory = TicTacToes::Core::PlayerFactory.new('unused_io')
-      x = player_factory.generate_human_player('x')
-      o = player_factory.generate_computer_player('o', :hard)
+      x = player_factory.generate_player('x', TicTacToes::Core::PlayerFactory::HUMAN)
+      o = player_factory.generate_player('o', TicTacToes::Core::PlayerFactory::MEDIUM_AI)
       players = [x, o]
 
       board = TicTacToes::TestBoardGenerator.generate([  o,  o,   x,

data/spec/tic_tac_toes/core/player_factory_spec.rb

@@ -3,29 +3,25 @@ require 'tic_tac_toes/core/move_strategies/medium_ai'
 require 'tic_tac_toes/core/player_factory'
 
 describe TicTacToes::Core::PlayerFactory do
-  let(:player_factory) { TicTacToes::Core::PlayerFactory.new("io") }
+  describe '#generate_player' do
+    before { @player_factory = TicTacToes::Core::PlayerFactory.new('io') }
 
-  describe '#generate_human_player' do
-    it "returns a player with the correct token and move strategy" do
-      strategy = TicTacToes::Core::MoveStrategies::Human
-      token = 'X'
+    context 'when passed HUMAN' do
+      it "returns a player with the correct token and a Human move strategy" do
+        human_player = @player_factory.generate_player('X', TicTacToes::Core::PlayerFactory::HUMAN)
 
-      human_player = player_factory.generate_human_player(token)
-      expect(human_player.move_strategy).to be_a strategy
-      expect(human_player.token).to eq(token)
+        expect(human_player.token).to eq('X')
+        expect(human_player.move_strategy).to be_a TicTacToes::Core::MoveStrategies::Human
+      end
     end
-  end
 
-  describe '#generate_computer_player' do
-    it 'returns a player with the correct token and move strategy' do
-      token = 'O'
-      difficulty = :medium
-      strategy = TicTacToes::Core::MoveStrategies::MediumAI
+    context 'when passed EASY_AI, MEDIUM_AI, or HARD_AI' do
+      it 'returns a player with the correct token and correct AI move strategy' do
+        computer_player = @player_factory.generate_player('O', TicTacToes::Core::PlayerFactory::MEDIUM_AI)
 
-      computer_player = player_factory.generate_computer_player(token,
-                                                                difficulty)
-      expect(computer_player.move_strategy).to eq(strategy)
-      expect(computer_player.token).to eq(token)
+        expect(computer_player.move_strategy).to eq(TicTacToes::Core::MoveStrategies::MediumAI)
+        expect(computer_player.token).to eq('O')
+      end
     end
   end
 end

data/spec/tic_tac_toes/ui/adapter_spec.rb

@@ -4,12 +4,37 @@ require 'tic_tac_toes/test_board_generator'
 require 'tic_tac_toes/ui/adapter'
 
 describe TicTacToes::UI::Adapter do
+  describe '#start_game' do
+    context 'when passed an order of “first”' do
+      it 'sends its listener #moves_were_made with the game state' do
+        order = 'first'
+        game_state = double
+        listener = double
+
+        expect(listener).to receive(:moves_were_made).with(game_state)
+        TicTacToes::UI::Adapter.start_game(order, game_state, listener)
+      end
+    end
+
+    context 'when passed an order of “second”' do
+      it 'sends its listener #moves_were_made with the game state' do
+        order = 'second'
+        computer_player = double(place_and_return_move: 0)
+        game_state = double(game_over?: false, turn_over: true, current_player: computer_player)
+        listener = double
+
+        expect(listener).to receive(:moves_were_made).with(game_state)
+        TicTacToes::UI::Adapter.start_game(order, game_state, listener)
+      end
+    end
+  end
+
   describe '#make_move' do
     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(:x)          { player_factory.generate_player('x', TicTacToes::Core::PlayerFactory::HUMAN) }
+    let(:o)          { player_factory.generate_player('o', TicTacToes::Core::PlayerFactory::HARD_AI) }
     let(:players)    { [x, o] }
 
     context 'when the game is still in progress' do

data/spec/tic_tac_toes/ui/serializer_spec.rb

@@ -12,10 +12,12 @@ describe TicTacToes::UI::Serializer do
   end
 
   describe '#game_state_from_board_structure' do
-    it 'returns a game state object based on a board structure' do
+    it 'returns a game state object based on a board structure and computer type' do
       board_structure = [nil, nil, nil, nil, 'X', nil, nil, nil, nil]
+      computer_type = 'EASY_AI'
+      ai = TicTacToes::Core::PlayerFactory::AIS.fetch(TicTacToes::Core::PlayerFactory::EASY_AI)
 
-      game_state = TicTacToes::UI::Serializer.game_state_from_board_structure(board_structure)
+      game_state = TicTacToes::UI::Serializer.game_state_from_board_structure(board_structure, computer_type)
       middle_space = game_state.board.space(4)
       first_player = game_state.players.first
       second_player = game_state.players.last
@@ -23,21 +25,32 @@ describe TicTacToes::UI::Serializer do
       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)
+      expect(second_player.move_strategy).to eq(ai)
     end
   end
 
-  describe '#game_state_to_board_structure' do
+  describe '#board_structure_from_game_state' 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)
+      first_player = player_factory.generate_player(TicTacToes::UI::Serializer::X, TicTacToes::Core::PlayerFactory::HUMAN)
+      second_player = player_factory.generate_player(TicTacToes::UI::Serializer::O, TicTacToes::Core::PlayerFactory::HARD_AI)
       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)
+      expect(TicTacToes::UI::Serializer.board_structure_from_game_state(game_state)).to eq(board_structure)
+    end
+  end
+
+  describe '#computer_type_from_game_state' do
+    it 'returns the type of a game state’s computer player' do
+      move_strategy = TicTacToes::Core::PlayerFactory::AIS.fetch(TicTacToes::Core::PlayerFactory::EASY_AI)
+      computer_player = double(move_strategy: move_strategy)
+      players = [computer_player]
+      game_state = double(players: players)
+      expect(TicTacToes::UI::Serializer.computer_type_from_game_state(game_state)).to eq('EASY_AI')
     end
   end
 end

metadata

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