tactical_tic_tac_toe 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 01bb765823d823d69d962bdcf3cd43e8bf7fc48f
-  data.tar.gz: d2215f338e0b37e2fe3e6fc2d7b17fb4c731e3c1
+  metadata.gz: 91f9d2072259b9710988edde50d53c39cc3962e7
+  data.tar.gz: fb68237c3ad7abf7c4259fef3bffc81d45701629
 SHA512:
-  metadata.gz: f44cc813fba53dec3622cb8051a8551578e7ff941c12d11539e4d48b38eb118641abb19c8b2439aa8e26b6b8b09cd41c30513979363eb06417c8684d32be6772
-  data.tar.gz: bda0c00122f5e46f4234725dd4045f3541d757b30de32ec6f159c496bf1bb04fe7eb8927153bed5a42fd49204461fdc293d1ebfbd69ab486b879e45fe4a65396
+  metadata.gz: 0232937a96a30ad91f9d27fbb38cd67edfd6a7f5e327557edfb2859faa4dd60fe4fa396bc6732c10fee0fe1bcd2c8f9a823a1beacfe6bfa4758b9fd322cd8a10
+  data.tar.gz: 2303ffecb1799bfda197289f85d7e418b34edb71efa5f5a83a87d16853d86f2c77df5dfcd34dd5ebdb7fd4e0cb08c252ebdd0305d464e34fb3f3a86b845847f8

data/lib/board.rb

@@ -1,34 +1,23 @@
 module TicTacToe
   class Board
-    BoardError = Class.new(StandardError)
     BLANK_MARK = nil
 
     attr_reader :size, :last_move_made
 
-    def self.blank_mark
-      BLANK_MARK
-    end
-
     def initialize(parameters)
-      fail BoardError, "Given size is too small, must be 3 or greater" if parameters[:size] < 3
-
       @size = parameters[:size]
-      config = parameters[:config] || blank_board_configuration
-      @cells = map_configuration_to_cells(config)
+      @cells = parameters[:config] || blank_board_configuration
+      @last_move_made = parameters[:last_move_made]
     end
 
     def read_cell(row, col)
-      fail BoardError, "Cell coordinates are out of bounds" if out_of_bounds?([row, col])
-
-      @cells[row][col]
+      @cells[row * @size + col]
     end
 
     def mark_cell(mark, row, col)
-      fail BoardError, "Cell coordinates are out of bounds" if out_of_bounds?([row, col])
-      fail BoardError, "Cannot alter a marked cell" if marked?([row, col])
-
-      @last_move_made = [row, col]
-      @cells[row][col] = mark
+      config = @cells.dup
+      config[row * @size + col] = mark
+      Board.new(size: @size, config: config, last_move_made: [row, col])
     end
 
     def lines
@@ -50,10 +39,6 @@ module TicTacToe
       self.read_cell(*last_move_made)
     end
 
-    def deep_copy
-      Board.new(size: @size, config: map_cells_to_configuration(@cells))
-    end
-
     def blank?(coordinates)
       self.read_cell(*coordinates) == BLANK_MARK
     end
@@ -83,20 +68,8 @@ module TicTacToe
 
     private
 
-    def map_configuration_to_cells(config)
-      if Math.sqrt(config.size).to_i != @size
-        fail BoardError, "Given size does not reconcile with given configuration"
-      end
-
-      config.each_slice(@size).to_a
-    end
-
-    def map_cells_to_configuration(cells)
-      cells.flatten
-    end
-
     def blank_board_configuration
-      (0...@size**2).map { BLANK_MARK }
+      Array.new(@size**2) { BLANK_MARK }
     end
 
     def row_at(row)

data/lib/computer_player.rb

@@ -5,12 +5,12 @@ module TicTacToe
     attr_reader :player_mark
 
     def initialize(parameters)
-      @board = parameters[:board]
       @player_mark = parameters[:player_mark]
       @opponent_mark = parameters[:opponent_mark]
     end
 
-    def move
+    def move(game)
+      @board = game.board
       if @board.all_blank? && @board.size.odd?
         [:row, :col].map { @board.size / 2 }
       else
@@ -49,11 +49,10 @@ module TicTacToe
 
         board.blank_cell_coordinates.map do |coordinates|
           child_node = {
-            board: board.deep_copy,
+            board: board.mark_cell(current_player_mark, *coordinates),
             current_player_mark: toggle_mark(current_player_mark),
             last_move_made: coordinates
           }
-          child_node[:board].mark_cell(current_player_mark, *coordinates)
           child_node
         end
       end

data/lib/game.rb

@@ -37,13 +37,13 @@ module TicTacToe
     def handle_one_turn(current_player)
       @interface.show_game_board(@board)
       coordinates = get_valid_move(current_player)
-      @board.mark_cell(current_player.player_mark, *coordinates)
+      @board = @board.mark_cell(current_player.player_mark, *coordinates)
       @interface.report_move(current_player.player_mark, coordinates)
     end
 
     def get_valid_move(player)
       loop do
-        coordinates = player.move
+        coordinates = player.move(self)
         if @board.out_of_bounds?(coordinates) || @board.marked?(coordinates)
           @interface.report_invalid_move(coordinates)
         else

data/lib/human_player.rb

@@ -3,12 +3,11 @@ module TicTacToe
     attr_reader :player_mark
 
     def initialize(parameters)
-      @player_mark = parameters[:player_mark]
-      @interface = parameters[:interface]
+      @player_mark = parameters.fetch(:player_mark)
     end
 
-    def move
-      @interface.solicit_move(@player_mark)
+    def move(game)
+      game.interface.solicit_move(@player_mark)
     end
   end
 end

data/spec/board_spec.rb

@@ -6,28 +6,11 @@ module TicTacToe
     include_context "default_values"
     include_context "helper_methods"
 
-    let(:board_error) { Board::BoardError }
-    let(:_) { Board.blank_mark }
+    let(:_) { Board::BLANK_MARK }
     let(:x) { @default_player_marks.first }
     let(:o) { @default_player_marks.last }
 
-    describe ".blank_mark" do
-      it "returns the mark used by board to indicate a blank cell" do
-        board = blank_board(@default_board_size)
-
-        board.all_coordinates.each do |coordinates|
-          expect(board.read_cell(*coordinates)).to eq Board.blank_mark
-        end
-      end
-    end
-
     describe "#initialize" do
-      it "raises error if given size is less than 3" do
-        error_info = [board_error, "Given size is too small, must be 3 or greater"]
-
-        expect { new_board(size: 2) }.to raise_error(*error_info)
-      end
-
       context "given the configuration of a board with preexisting marks" do
         let(:config) do
           [ x, _, _,
@@ -42,16 +25,6 @@ module TicTacToe
             expect(board.read_cell(*coordinates)).to eq mark
           end
         end
-
-        it "raises error if given configuration does not reconcile with given size" do
-          error_info = [board_error, "Given size does not reconcile with given configuration"]
-          params = {
-            size: Math.sqrt(config.size).to_i + 1,
-            config: config
-          }
-
-          expect { new_board(params) }.to raise_error(*error_info)
-        end
       end
 
       context "when not given a configuration of a board with preexisting marks" do
@@ -79,14 +52,6 @@ module TicTacToe
 
         expect(board.read_cell(0, 0)).to eq mark
       end
-
-      it "raises error if cell coordinates are out of bounds" do
-        error_info = [board_error, "Cell coordinates are out of bounds"]
-        board = blank_board(@default_board_size)
-        oob_coordinates = [board.size, board.size]
-
-        expect { board.read_cell(*oob_coordinates) }.to raise_error(*error_info)
-      end
     end
 
     describe "#mark_cell" do
@@ -94,30 +59,24 @@ module TicTacToe
       let(:coordinates) { random_coordinates(board.size) }
       let(:mark) { @default_player_marks.sample }
 
-      it "sets the contents of an empty cell at the given row and column" do
-        board.mark_cell(mark, *coordinates)
+      it "returns a new board with the given coordinates played" do
+        board = blank_board(@default_board_size)
 
-        expect(board.read_cell(*coordinates)).to eq mark
+        expect(board.mark_cell(mark, *coordinates).read_cell(*coordinates)).to eq(mark)
       end
 
-      it "records the coordinates of the last mark made" do
-        board.mark_cell(mark, *coordinates)
-
-        expect(board.last_move_made).to eq coordinates
-      end
+      it "does not mutate the board" do
+        board = blank_board(@default_board_size)
 
-      it "raises error if cell coordinates are out of bounds" do
-        error_info = [board_error, "Cell coordinates are out of bounds"]
-        oob_coordinates = [board.size, board.size]
+        board.mark_cell(mark, *coordinates)
 
-        expect { board.mark_cell(mark, *oob_coordinates)}.to raise_error(*error_info)
+        expect(board).to be_all_blank
       end
 
-      it "raises error when attempting to change contents of non-empty cell" do
-        error_info = [board_error, "Cannot alter a marked cell"]
-        board.mark_cell(mark, *coordinates)
+      it "records the coordinates of the last mark made" do
+        returned_board = board.mark_cell(mark, *coordinates)
 
-        expect { board.mark_cell(mark, *coordinates) }.to raise_error(*error_info)
+        expect(returned_board.last_move_made).to eq coordinates
       end
     end
 
@@ -178,41 +137,13 @@ module TicTacToe
         it "returns the last mark made on the board" do
           board = blank_board(@default_board_size)
           mark = @default_player_marks.sample
-          board.mark_cell(mark, *random_coordinates(board.size))
+          returned_board = board.mark_cell(mark, *random_coordinates(board.size))
 
-          expect(board.last_mark_made).to eq mark
+          expect(returned_board.last_mark_made).to eq mark
         end
       end
     end
 
-    describe "#deep_copy" do
-      it "returns a new board" do
-        board = blank_board(@default_board_size)
-        board_copy = board.deep_copy
-
-        expect(board).not_to eq board_copy
-      end
-
-      it "returns a board that has the same marks as called board" do
-        config = [x, o, x, o, x, o, _, _, _].shuffle
-        board = build_board(config)
-        board_copy = board.deep_copy
-
-        board.all_coordinates.each do |coordinates|
-          expect(board.read_cell(*coordinates)).to eq board_copy.read_cell(*coordinates)
-        end
-      end
-
-      it "returns a board which references cells that are not those of called board" do
-        board = blank_board(@default_board_size)
-        board_copy = board.deep_copy
-        coordinates = random_coordinates(board.size)
-        board.mark_cell(@default_player_marks.first, *coordinates)
-
-        expect(board.read_cell(*coordinates)).not_to eq board_copy.read_cell(*coordinates)
-      end
-    end
-
     describe "#blank?" do
       it "returns true if cell at given coordinates is blank" do
         board = blank_board(@default_board_size)
@@ -223,9 +154,9 @@ module TicTacToe
       it "returns false if cell at given coordinates is not blank" do
         board = blank_board(@default_board_size)
         coordinates = random_coordinates(board.size)
-        board.mark_cell(@default_player_marks.sample, *coordinates)
+        returned_board = board.mark_cell(@default_player_marks.sample, *coordinates)
 
-        expect(board.blank?(coordinates)).to be false
+        expect(returned_board.blank?(coordinates)).to be false
       end
     end
 
@@ -233,9 +164,9 @@ module TicTacToe
       it "returns true if cell at given coordinates has any player's mark" do
         board = blank_board(@default_board_size)
         coordinates = random_coordinates(board.size)
-        board.mark_cell(@default_player_marks.sample, *coordinates)
+        returned_board = board.mark_cell(@default_player_marks.sample, *coordinates)
 
-        expect(board.marked?(coordinates)).to be true
+        expect(returned_board.marked?(coordinates)).to be true
       end
 
       it "returns false if cell at given coordinates does not have a player's mark" do

data/spec/computer_player_spec.rb

@@ -2,13 +2,14 @@ require "spec_helper"
 require "computer_player"
 
 require "board"
+require "game"
 
 module TicTacToe
   describe ComputerPlayer do
     include_context "default_values"
     include_context "helper_methods"
 
-    let(:_) { Board.blank_mark }
+    let(:_) { Board::BLANK_MARK }
     let(:x) { @default_first_player }
     let(:o) { @default_second_player }
 
@@ -41,10 +42,10 @@ module TicTacToe
           x, x, o,
           o, _, _
         ]
-        board = build_board(board_config)
-        board.mark_cell(o, *[2, 1])
+        board = build_board(board_config).mark_cell(o, *[2, 1])
+        game = Game.new(board: board)
         computer_player = x_player(board)
-        coordinates = computer_player.move
+        coordinates = computer_player.move(game)
 
         expect(board.out_of_bounds?(coordinates)).to be false
         expect(board.blank?(coordinates)).to be true
@@ -53,9 +54,11 @@ module TicTacToe
       context "when game board has a center space and it is blank" do
         it "returns the center coordinates" do
           board_size = @default_board_size.odd? ? @default_board_size : 3
+          game = Game.new(board: blank_board(board_size))
+
           computer_player = x_player(blank_board(board_size))
 
-          expect(computer_player.move).to eq [board_size / 2, board_size / 2]
+          expect(computer_player.move(game)).to eq [board_size / 2, board_size / 2]
         end
       end
 
@@ -75,9 +78,10 @@ module TicTacToe
           winning_moves = [[0, 1], [1, 2], [2, 0]]
           board_configs.zip(winning_moves).each do |board_config, winning_move|
             board = build_board(board_config)
+            game = Game.new(board: board)
             computer_player = x_player(board)
 
-            expect(computer_player.move).to eq winning_move
+            expect(computer_player.move(game)).to eq winning_move
           end
         end
       end
@@ -98,9 +102,10 @@ module TicTacToe
           winning_moves = [[1, 0], [2, 1], [0, 2]]
           board_configs.zip(winning_moves).each do |board_config, winning_move|
             board = build_board(board_config)
+            game = Game.new(board: board)
             computer_player = x_player(board)
 
-            expect(computer_player.move).to eq winning_move
+            expect(computer_player.move(game)).to eq winning_move
           end
         end
       end
@@ -119,8 +124,9 @@ module TicTacToe
           board_configs.zip(winning_moves).each do |board_config, winning_move|
             board = build_board(board_config)
             computer_player = x_player(board)
+            game = Game.new(board: board)
 
-            expect(computer_player.move).to eq winning_move
+            expect(computer_player.move(game)).to eq winning_move
           end
         end
       end
@@ -142,8 +148,9 @@ module TicTacToe
           board_configs.zip(winning_moves).each do |board_config, winning_move|
             board = build_board(board_config)
             computer_player = o_player(board)
+            game = Game.new(board: board)
 
-            expect(computer_player.move).to eq winning_move
+            expect(computer_player.move(game)).to eq winning_move
           end
         end
       end
@@ -165,8 +172,9 @@ module TicTacToe
           board_configs.zip(winning_moves).each do |board_config, winning_move|
             board = build_board(board_config)
             computer_player = o_player(board)
+            game = Game.new(board: board)
 
-            expect(computer_player.move).to eq winning_move
+            expect(computer_player.move(game)).to eq winning_move
           end
         end
       end
@@ -185,8 +193,9 @@ module TicTacToe
           board_configs.zip(winning_moves).each do |board_config, winning_move|
             board = build_board(board_config)
             computer_player = o_player(board)
+            game = Game.new(board: board)
 
-            expect(computer_player.move).to eq winning_move
+            expect(computer_player.move(game)).to eq winning_move
           end
         end
       end
@@ -212,8 +221,9 @@ module TicTacToe
           board_configs.zip(good_move_sets).each do |board_config, good_moves|
             board = build_board(board_config)
             computer_player = o_player(board)
+            game = Game.new(board: board)
 
-            expect(good_moves).to include computer_player.move
+            expect(good_moves).to include computer_player.move(game)
           end
         end
       end

data/spec/game_spec.rb

@@ -4,6 +4,7 @@ require "game"
 module TicTacToe
   describe Game do
     include_context "default_values"
+    include_context "helper_methods"
 
     def new_game(parameters)
       Game.new(parameters)
@@ -83,7 +84,9 @@ module TicTacToe
 
     describe "#set_up" do
       it "uses information from the interface to create the players" do
-        allow(game.interface).to receive(:game_setup_interaction).and_return([:human, :computer])
+        allow(game.interface).to receive(:game_setup_interaction) do
+          [AvailablePlayerTypes::HUMAN, AvailablePlayerTypes::COMPUTER]
+        end
         game.set_up
 
         game.players.each_with_index do |player, index|
@@ -95,7 +98,9 @@ module TicTacToe
 
     describe "#handle_turns" do
       it "executes turns until the game is over" do
-        allow(game.interface).to receive(:game_setup_interaction).and_return([:human, :computer])
+        allow(game.interface).to receive(:game_setup_interaction) do
+          [AvailablePlayerTypes::HUMAN, AvailablePlayerTypes::COMPUTER]
+        end
         game.set_up
         allow(game).to receive(:over?).and_return(false, false, false, false, true)
         allow(game).to receive(:handle_one_turn)
@@ -165,7 +170,6 @@ module TicTacToe
         let(:valid_coordinates) { [0, game.board.size - 1] }
 
         before do
-          game.board.mark_cell(@default_first_player, 0, 0)
           allow(player_stub).to receive(:move).and_return(
             occupied_coordinates,
             out_of_bounds_coordinates,
@@ -173,12 +177,16 @@ module TicTacToe
         end
 
         it "complains through the interface" do
+          _ = Board::BLANK_MARK
+          game = Game.new(board: build_board([0, _, _, _, _, _, _, _, _]))
           expect(game.interface).to receive(:report_invalid_move).exactly(2).times
 
           game.get_valid_move(player_stub)
         end
 
         it "gets another move from player until it receives valid coordinates" do
+          _ = Board::BLANK_MARK
+          game = Game.new(board: build_board([0, _, _, _, _, _, _, _, _]))
           allow(game.interface).to receive(:report_invalid_move)
 
           expect(game.get_valid_move(player_stub)).to eq valid_coordinates
@@ -247,7 +255,9 @@ module TicTacToe
 
       context "in a game with two computer players" do
         before do
-          allow(game.interface).to receive(:game_setup_interaction).and_return([:computer, :computer])
+          allow(game.interface).to receive(:game_setup_interaction) do
+            [AvailablePlayerTypes::COMPUTER, AvailablePlayerTypes::COMPUTER]
+          end
         end
 
         it "should end the game in a draw" do
@@ -260,7 +270,9 @@ module TicTacToe
 
       context "in a game with a human player and a computer player" do
         before do
-          allow(game.interface).to receive(:game_setup_interaction).and_return([:human, :computer])
+          allow(game.interface).to receive(:game_setup_interaction) do
+            [AvailablePlayerTypes::HUMAN, AvailablePlayerTypes::COMPUTER]
+          end
         end
 
         it "should end in a win for the computer player against an unskilled human player" do

data/spec/human_player_spec.rb

@@ -8,15 +8,16 @@ module TicTacToe
     let(:interface) { double("CommandLineInterface") }
     let(:human_player) do
       HumanPlayer.new(
-        interface: interface,
+        # interface: interface,
         player_mark: @default_first_player)
     end
 
     describe "#move" do
       it "returns the coordinates of the move selected by the player" do
+        game = Game.new(interface: interface)
         allow(interface).to receive(:solicit_move).and_return([0, 0])
 
-        expect(human_player.move).to eq [0, 0]
+        expect(human_player.move(game)).to eq [0, 0]
       end
     end
   end

data/spec/spec_helper.rb

@@ -7,13 +7,16 @@ RSpec.shared_context "default_values" do
     @default_first_player = :x
     @default_second_player = :o
     @default_player_marks = [:x, :o]
-    @default_player_types = [:human, :computer]
+    @default_player_types = [
+      TicTacToe::AvailablePlayerTypes::HUMAN,
+      TicTacToe::AvailablePlayerTypes::COMPUTER
+    ]
   end
 end
 
 RSpec.shared_context "helper_methods" do
   def blank_board_configuration(board_size)
-    (0...board_size**2).map { TicTacToe::Board.blank_mark }
+    (0...board_size**2).map { TicTacToe::Board::BLANK_MARK }
   end
 
   def at_least_one_repeated_line?(string)
@@ -38,25 +41,9 @@ RSpec.shared_context "helper_methods" do
     new_board(size: board_size)
   end
 
-  def board_with_potential_win_loss_or_draw(board_size, player_marks)
-    first_mark, second_mark = player_marks
-    board = blank_board(board_size)
-    (0...board_size - 1).each { |col| board.mark_cell(first_mark, 0, col) }
-    (0...board_size - 1).each { |col| board.mark_cell(second_mark, 1, col) }
-    (2...board_size).each do |row|
-      (0...board_size - 1).each do |col|
-        mark = col.even? ? first_mark : second_mark
-        board.mark_cell(mark, row, col)
-      end
-    end
-    board
-  end
-
   def board_with_draw(board_size, player_marks)
     first_mark, second_mark = player_marks
-    board = blank_board(board_size)
-    (0...board_size).each do |row|
-      (0...board_size).each do |col|
+    blank_board(board_size).blank_cell_coordinates.reduce(blank_board(board_size)) do |board, (row, col)|
         if row == 0
           mark = col.odd? ? first_mark : second_mark
           board.mark_cell(mark, row, col)
@@ -64,44 +51,6 @@ RSpec.shared_context "helper_methods" do
           mark = col.even? ? first_mark : second_mark
           board.mark_cell(mark, row, col)
         end
-      end
-    end
-    board
-  end
-
-  def all_wins(board_size, winning_mark)
-    winning_boards = horizontal_wins(board_size, winning_mark)
-    winning_boards.concat vertical_wins(board_size, winning_mark)
-    winning_boards.concat diagonal_wins(board_size, winning_mark)
-  end
-
-  def horizontal_wins(board_size, winning_mark)
-    (0...board_size).each_with_object([]) do |row, winning_boards|
-      board = blank_board(board_size)
-      (0...board_size).each { |col| board.mark_cell(winning_mark, row, col) }
-      winning_boards << board
     end
   end
-
-  def vertical_wins(board_size, winning_mark)
-    (0...board_size).each_with_object([]) do |col, winning_boards|
-      board = blank_board(board_size)
-      (0...board_size).each { |row| board.mark_cell(winning_mark, row, col) }
-      winning_boards << board
-    end
-  end
-
-  def diagonal_wins(board_size, winning_mark)
-    ldiag_board = blank_board(board_size)
-    (0...board_size).each do |index|
-      ldiag_board.mark_cell(winning_mark, index, index)
-    end
-
-    rdiag_board = blank_board(board_size)
-    (0...board_size).each do |index|
-      rdiag_board.mark_cell(winning_mark, index, rdiag_board.size - index - 1)
-    end
-
-    [ldiag_board, rdiag_board]
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tactical_tic_tac_toe
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Batman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-01 00:00:00.000000000 Z
+date: 2015-10-26 00:00:00.000000000 Z
 dependencies: []
 description: Command line tic tac toe! Run with command 'ttt'
 email: no@no.no
@@ -25,7 +25,6 @@ files:
 - lib/game.rb
 - lib/human_player.rb
 - lib/negamax.rb
-- lib/old_computer_player.rb
 - lib/player_factory.rb
 - lib/tactical_tic_tac_toe.rb
 - spec/board_spec.rb
@@ -34,7 +33,6 @@ files:
 - spec/game_spec.rb
 - spec/human_player_spec.rb
 - spec/negamax_spec.rb
-- spec/old_computer_player_spec.rb
 - spec/player_factory_spec.rb
 - spec/spec_helper.rb
 homepage: http://rubygems.org/gems/tactical_tic_tac_toe

data/lib/old_computer_player.rb

@@ -1,89 +0,0 @@
-module TicTacToe
-  class OldComputerPlayer
-    attr_reader :player_mark
-
-    def initialize(parameters)
-      @player_mark = parameters[:player_mark]
-      @opponent_mark = parameters[:opponent_mark]
-      @board = parameters[:board]
-    end
-
-    def move
-      center_coordinate = [@board.size / 2, @board.size / 2]
-      if !@board.marked?(center_coordinate) && @board.size.odd?
-        center_coordinate
-      else
-        select_best_move
-      end
-    end
-
-    private
-
-    def select_best_move
-      best_score_so_far = {
-        player: -Float::INFINITY, # highest score is best for player
-        opponent: Float::INFINITY # lowest score is best for opponent
-      }
-
-      successor_boards = generate_possible_successor_boards(@board, @player_mark)
-      best_board = successor_boards.max_by { |board| minimax(board, false, best_score_so_far) }
-      best_board.last_move_made
-    end
-
-    def generate_possible_successor_boards(board, mark)
-      board.blank_cell_coordinates.map do |coordinates|
-        successor_board = board.deep_copy
-        successor_board.mark_cell(mark, *coordinates)
-        successor_board
-      end
-    end
-
-    def minimax(board, my_turn, best_score_so_far)
-      if board.has_winning_line? || board.all_marked?
-        evaluate(board)
-      else
-        select_score_of_best_successor_board(board, my_turn, best_score_so_far.dup)
-      end
-    end
-
-    def evaluate(board)
-      board.lines.each do |line|
-        return Float::INFINITY if line.all? { |cell| cell == @player_mark }
-        return -Float::INFINITY if line.all? { |cell| cell == @opponent_mark }
-      end
-      0
-    end
-
-    def select_score_of_best_successor_board(board, my_turn, best_score_so_far)
-      current_player_mark = my_turn ? @player_mark : @opponent_mark
-
-      successor_boards = generate_possible_successor_boards(board, current_player_mark)
-      scores = score_successor_boards(successor_boards, my_turn, best_score_so_far)
-
-      my_turn ? scores.max : scores.min
-    end
-
-    def score_successor_boards(successor_boards, my_turn, best_score_so_far)
-      successor_boards.each_with_object([]) do |board, scores|
-        score = minimax(board, !my_turn, best_score_so_far.dup)
-        scores << score
-
-        update_best_score_so_far(my_turn, best_score_so_far, score)
-        return scores if best_score_guaranteed_elsewhere?(best_score_so_far)
-      end
-    end
-
-    def update_best_score_so_far(my_turn, best_score_so_far, score)
-      if score > best_score_so_far[:player] && my_turn
-        best_score_so_far[:player] = score
-      end
-      if score < best_score_so_far[:opponent] && !my_turn
-        best_score_so_far[:opponent] = score
-      end
-    end
-
-    def best_score_guaranteed_elsewhere?(best_score_so_far)
-      best_score_so_far[:player] >= best_score_so_far[:opponent]
-    end
-  end
-end

data/spec/old_computer_player_spec.rb

@@ -1,230 +0,0 @@
-require "spec_helper"
-require "old_computer_player"
-
-require "board"
-
-module TicTacToe
-  describe OldComputerPlayer do
-    include_context "default_values"
-    include_context "helper_methods"
-
-    let(:ai) do
-      described_class.new(
-        board: blank_board(@default_board_size),
-        player_mark: @default_first_player,
-        opponent_mark: @default_second_player)
-    end
-    let(:infinity) { Float::INFINITY }
-    let(:neg_infinity) { -Float::INFINITY }
-
-    describe "#initialize" do
-      it "takes a parameters hash with the player's mark, opponent's mark, and the game board" do
-        params = {
-          board: blank_board(@default_board_size),
-          player_mark: @default_first_player,
-          opponent_mark: @default_second_player
-        }
-
-        expect { described_class.new(params) }.not_to raise_error
-      end
-    end
-
-    describe "#move" do
-      context "when a center space is available" do
-        it "returns the move coordinate for centermost space" do
-          [3, 5, 7].each do |odd_size|
-            custom_ai = described_class.new(
-              board: blank_board(odd_size),
-              player_mark: @default_first_player,
-              opponent_mark: @default_second_player)
-
-            expect(custom_ai.move).to eq [odd_size / 2, odd_size / 2]
-          end
-        end
-      end
-
-      context "when a center space is not available" do
-        let(:_) { Board.blank_mark }
-        let(:x) { @default_first_player }
-        let(:o) { @default_second_player }
-
-        def x_player(board)
-          parameters = {
-            board: board,
-            player_mark: x,
-            opponent_mark: o
-          }
-          OldComputerPlayer.new(parameters)
-        end
-
-        def o_player(board)
-          parameters = {
-            board: board,
-            player_mark: o,
-            opponent_mark: x
-          }
-          OldComputerPlayer.new(parameters)
-        end
-
-        context "when computer player can make a horizontal winning move" do
-          it "returns the coordinates of the winning move" do
-            board_configs = [
-              [ x, _, x,
-                _, o, _,
-                o, x, o ],
-              [ o, _, _,
-                x, x, _,
-                o, o, x ],
-              [ _, o, _,
-                x, o, o,
-                _, x, x ]
-            ]
-            winning_moves = [[0, 1], [1, 2], [2, 0]]
-            board_configs.zip(winning_moves).each do |board_config, winning_move|
-              board = build_board(board_config)
-              computer_player = x_player(board)
-
-              expect(computer_player.move).to eq winning_move
-            end
-          end
-        end
-
-        context "when computer player can make a vertical winning move" do
-          it "returns the coordinates of the winning move" do
-            board_configs = [
-              [ x, _, o,
-                _, o, x,
-                x, _, o ],
-              [ o, x, o,
-                o, x, _,
-                x, _, _ ],
-              [ _, o, _,
-                _, o, x,
-                o, x, x ]
-            ]
-            winning_moves = [[1, 0], [2, 1], [0, 2]]
-            board_configs.zip(winning_moves).each do |board_config, winning_move|
-              board = build_board(board_config)
-              computer_player = x_player(board)
-
-              expect(computer_player.move).to eq winning_move
-            end
-          end
-        end
-
-        context "when computer player can make a diagonal winning move" do
-          it "returns the coordinates of the winning move" do
-            board_configs = [
-              [ x, _, o,
-                o, x, _,
-                x, o, _ ],
-              [ o, x, _,
-                o, x, _,
-                x, o, _ ]
-            ]
-            winning_moves = [[2, 2], [0, 2]]
-            board_configs.zip(winning_moves).each do |board_config, winning_move|
-              board = build_board(board_config)
-              computer_player = x_player(board)
-
-              expect(computer_player.move).to eq winning_move
-            end
-          end
-        end
-
-        context "when opponent can make a horizontal winning move next turn" do
-          it "returns the coordinates of the move that blocks the opponent from winning" do
-            board_configs = [
-              [ x, _, x,
-                _, o, _,
-                o, x, o ],
-              [ o, _, _,
-                x, x, _,
-                o, o, x ],
-              [ _, o, _,
-                x, o, o,
-                _, x, x ]
-            ]
-            winning_moves = [[0, 1], [1, 2], [2, 0]]
-            board_configs.zip(winning_moves).each do |board_config, winning_move|
-              board = build_board(board_config)
-              computer_player = o_player(board)
-
-              expect(computer_player.move).to eq winning_move
-            end
-          end
-        end
-
-        context "when opponent can make a vertical winning move next turn" do
-          it "returns the coordinates of the move that blocks the opponent from winning" do
-            board_configs = [
-              [ x, _, o,
-                _, o, x,
-                x, _, o ],
-              [ o, x, o,
-                o, x, _,
-                x, _, _ ],
-              [ _, o, _,
-                _, o, x,
-                o, x, x ]
-            ]
-            winning_moves = [[1, 0], [2, 1], [0, 2]]
-            board_configs.zip(winning_moves).each do |board_config, winning_move|
-              board = build_board(board_config)
-              computer_player = o_player(board)
-
-              expect(computer_player.move).to eq winning_move
-            end
-          end
-        end
-
-        context "when opponent can make a diagonal winning move next turn" do
-          it "returns the coordinates of the move that blocks the opponent from winning" do
-            board_configs = [
-              [ x, _, o,
-                o, x, _,
-                x, o, _ ],
-              [ o, x, _,
-                o, x, _,
-                x, o, _ ]
-            ]
-            winning_moves = [[2, 2], [0, 2]]
-            board_configs.zip(winning_moves).each do |board_config, winning_move|
-              board = build_board(board_config)
-              computer_player = o_player(board)
-
-              expect(computer_player.move).to eq winning_move
-            end
-          end
-        end
-
-        context "when opponent can make a fork next turn" do
-          it "returns the coordinates of a move that prevents that fork" do
-            board_configs = [
-              [ x, _, _,
-                _, x, _,
-                _, _, o ],
-              [ x, _, _,
-                _, o, _,
-                _, _, x ],
-              [ _, x, _,
-                _, x, _,
-                _, o, _ ]
-            ]
-            good_move_sets = [
-              [[2, 0], [0, 2]],
-              [[0, 1], [1, 0], [1, 2], [2, 1]],
-              [[0, 0], [0, 2], [2, 0], [2, 2]]
-            ]
-            board_configs.zip(good_move_sets).each do |board_config, good_moves|
-              board = build_board(board_config)
-              computer_player = o_player(board)
-
-              expect(good_moves).to include computer_player.move
-            end
-          end
-        end
-      end
-    end
-  end
-end