tactical_tic_tac_toe 0.1.1

data/spec/computer_player_spec.rb

@@ -0,0 +1,222 @@
+require "spec_helper"
+require "computer_player"
+
+require "board"
+
+module TicTacToe
+  describe ComputerPlayer do
+    include_context "default_values"
+    include_context "helper_methods"
+
+    let(:_) { Board.blank_mark }
+    let(:x) { @default_first_player }
+    let(:o) { @default_second_player }
+
+    def new_computer_player(parameters)
+      ComputerPlayer.new(parameters)
+    end
+
+    def x_player(board)
+      parameters = {
+        board: board,
+        player_mark: x,
+        opponent_mark: o
+      }
+      new_computer_player(parameters)
+    end
+
+    def o_player(board)
+      parameters = {
+        board: board,
+        player_mark: o,
+        opponent_mark: x
+      }
+      new_computer_player(parameters)
+    end
+
+    describe "#move" do
+      it "returns the coordinates of a valid move" do
+        board_config = [
+          x, o, x,
+          x, x, o,
+          o, _, _
+        ]
+        board = build_board(board_config)
+        board.mark_cell(o, *[2, 1])
+        computer_player = x_player(board)
+        coordinates = computer_player.move
+
+        expect(board.out_of_bounds?(coordinates)).to be false
+        expect(board.blank?(coordinates)).to be true
+      end
+
+      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
+          computer_player = x_player(blank_board(board_size))
+
+          expect(computer_player.move).to eq [board_size / 2, board_size / 2]
+        end
+      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

data/spec/game_spec.rb

@@ -0,0 +1,279 @@
+require "spec_helper"
+require "game"
+
+module TicTacToe
+  describe Game do
+    include_context "default_values"
+
+    def new_game(parameters)
+      Game.new(parameters)
+    end
+
+    let(:game) { new_game({}) }
+
+    describe "#initialize" do
+      it "initializes a board and stores it in an instance variable" do
+        expect(game.board).to be_a Board
+      end
+
+      context "when given parameters" do
+        it "uses the given board" do
+          board = Board.new(size: 4)
+          custom_game = new_game(board: board)
+
+          expect(custom_game.board).to eq board
+        end
+
+        it "uses player marks of the given type" do
+          custom_game = new_game(player_marks: [:F, :B])
+
+          expect(custom_game.player_marks).to eq [:F, :B]
+        end
+
+        it "uses the given interface" do
+          interface = double("CommandLineInterface")
+          custom_game = new_game(interface: interface)
+
+          expect(custom_game.interface).to eq interface
+        end
+      end
+
+      context "when a given parameter is not provided" do
+        it "creates a board with the default size" do
+          expect(game.board.size).to eq @default_board_size
+        end
+
+        it "uses a default set of player marks" do
+          game.player_marks.each do |default_mark|
+            expect(@default_player_marks).to include default_mark
+          end
+        end
+
+        it "creates and uses a command line interface by default" do
+          expect(game.interface).to be_a CommandLineInterface
+        end
+      end
+    end
+
+    describe "#run" do
+      it "sets up the game" do
+        allow(game).to receive(:handle_turns)
+        allow(game).to receive(:handle_game_over)
+
+        expect(game).to receive(:set_up)
+        game.run
+      end
+
+      it "handles each turn" do
+        allow(game).to receive(:handle_game_over)
+        allow(game).to receive(:set_up)
+
+        expect(game).to receive(:handle_turns)
+        game.run
+      end
+
+      it "handles the end of the game" do
+        allow(game).to receive(:set_up)
+        allow(game).to receive(:handle_turns)
+
+        expect(game).to receive(:handle_game_over)
+        game.run
+      end
+    end
+
+    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])
+        game.set_up
+
+        game.players.each_with_index do |player, index|
+          expect(player).to respond_to :move
+          expect(player).to be_a index == 0 ? HumanPlayer : ComputerPlayer
+        end
+      end
+    end
+
+    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])
+        game.set_up
+        allow(game).to receive(:over?).and_return(false, false, false, false, true)
+        allow(game).to receive(:handle_one_turn)
+
+        expect(game).to receive(:handle_one_turn).exactly(5).times
+        game.handle_turns
+      end
+    end
+
+    describe "#handle_one_turn" do
+      let(:player_stub) { Object.new }
+
+      before do
+        allow(player_stub).to receive(:player_mark).and_return(@default_first_player)
+        allow(player_stub).to receive(:move).and_return([0, 0])
+      end
+
+      it "displays the game board via the interface" do
+        allow(game.interface).to receive(:report_move)
+
+        expect(game.interface).to receive(:show_game_board)
+        game.handle_one_turn(player_stub)
+      end
+
+      it "gets valid move coordinates from given player" do
+        allow(game.interface).to receive(:show_game_board)
+        allow(game.interface).to receive(:report_move)
+
+        expect(game).to receive(:get_valid_move).and_return([0, 0])
+        game.handle_one_turn(player_stub)
+      end
+
+      it "marks the game board with player's mark at the coordinates given by player" do
+        allow(game.interface).to receive(:show_game_board)
+        allow(game.interface).to receive(:report_move)
+        game.handle_one_turn(player_stub)
+
+        expect(game.board.read_cell(0, 0)).to eq @default_first_player
+      end
+
+      it "reports the move that was just made through the interface" do
+        allow(game.interface).to receive(:show_game_board)
+
+        expect(game.interface).to receive(:report_move).with(@default_first_player, [0, 0])
+        game.handle_one_turn(player_stub)
+      end
+    end
+
+    describe "#get_valid_move" do
+      let(:player_stub) { Object.new }
+
+      before do
+        allow(player_stub).to receive(:player_mark)
+      end
+
+      context "when it receives valid move coordinates from given player" do
+        it "returns those coordinates" do
+          allow(player_stub).to receive(:move).and_return([0, 0])
+
+          expect(game.get_valid_move(player_stub)).to eq [0, 0]
+        end
+      end
+
+      context "when it receives invalid move coordinates from given player" do
+        let(:occupied_coordinates) { [0, 0] }
+        let(:out_of_bounds_coordinates) { [0, game.board.size] }
+        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,
+            valid_coordinates)
+        end
+
+        it "complains through the interface" do
+          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
+          allow(game.interface).to receive(:report_invalid_move)
+
+          expect(game.get_valid_move(player_stub)).to eq valid_coordinates
+        end
+      end
+    end
+
+    describe "#handle_game_over" do
+      it "shows the final state of the game board via the interface" do
+        allow(game.interface).to receive(:report_game_over)
+
+        expect(game.interface).to receive(:show_game_board)
+        game.handle_game_over
+      end
+
+      context "when game has been won" do
+        it "reports that the given last player to move has won via the interface" do
+          allow(game.interface).to receive(:show_game_board)
+          allow(game.board).to receive(:has_winning_line?).and_return(true)
+          allow(game.board).to receive(:last_mark_made).and_return(@default_first_player)
+
+          expect(game.interface).to receive(:report_game_over).with(@default_first_player)
+          game.handle_game_over
+        end
+      end
+
+      context "when game has no winner" do
+        it "reports that game ended in a draw via the interface" do
+          allow(game.interface).to receive(:show_game_board)
+          allow(game.board).to receive(:last_mark_made).and_return(@default_first_player)
+
+          expect(game.interface).to receive(:report_game_over).with(:none)
+          game.handle_game_over
+        end
+      end
+    end
+
+    describe "#over?" do
+      it "returns true when the board has a winning line" do
+        allow(game.board).to receive(:has_winning_line?).and_return(true)
+
+        expect(game.over?).to be true
+      end
+
+      it "returns true if the board is filled" do
+        allow(game.board).to receive(:all_marked?).and_return(true)
+
+        expect(game.over?).to be true
+      end
+
+      it "returns false when the game is not over" do
+        expect(game.over?).to be false
+      end
+    end
+
+    describe "integration tests" do
+      let(:game) { new_game({}) }
+
+      before do
+          allow(game.interface).to receive(:show_game_board)
+          allow(game.interface).to receive(:solicit_move)
+          allow(game.interface).to receive(:report_move)
+          allow(game.interface).to receive(:report_invalid_move)
+          allow(game.interface).to receive(:report_game_over)
+      end
+
+      context "in a game with two computer players" do
+        before do
+          allow(game.interface).to receive(:game_setup_interaction).and_return([:computer, :computer])
+        end
+
+        it "should end the game in a draw" do
+          game.run
+
+          expect(game.board.has_winning_line?).to be false
+          expect(game.board.all_marked?).to be true
+        end
+      end
+
+      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])
+        end
+
+        it "should end in a win for the computer player against an unskilled human player" do
+          allow(game.interface).to receive(:solicit_move) do
+            game.board.blank_cell_coordinates.first
+          end
+          computer_player_mark = :o
+          game.run
+
+          expect(game.board.has_winning_line?).to be true
+          expect(game.board.last_mark_made).to be computer_player_mark
+        end
+      end
+    end
+  end
+end

data/spec/human_player_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+require "human_player"
+
+module TicTacToe
+  describe HumanPlayer do
+    include_context "default_values"
+
+    let(:interface) { double("CommandLineInterface") }
+    let(:human_player) do
+      HumanPlayer.new(
+        interface: interface,
+        player_mark: @default_first_player)
+    end
+
+    describe "#move" do
+      it "returns the coordinates of the move selected by the player" do
+        allow(interface).to receive(:solicit_move).and_return([0, 0])
+
+        expect(human_player.move).to eq [0, 0]
+      end
+    end
+  end
+end

data/spec/negamax_spec.rb

@@ -0,0 +1,90 @@
+require "spec_helper"
+require "negamax"
+
+module TicTacToe
+  describe Negamax do
+    def new_negamax(parameters)
+      Negamax.new(parameters)
+    end
+
+    describe "#apply" do
+      context "when given node meets the end-node criterion" do
+        it "returns the given node" do
+          parameters = {
+            child_node_generator: nil,
+            terminal_node_criterion: ->(_) { true },
+            evaluation_heuristic: nil
+          }
+          negamax = new_negamax(parameters)
+
+          expect(negamax.apply(:terminal_node)).to eq :terminal_node
+        end
+      end
+
+      context "when given node does not meet the given end-node criterion" do
+        it "returns the highest scoring child node" do
+          child_nodes = [{id: 1, score: 1}, {id: 2, score: 0}, {id: 3, score: -1}]
+          parameters = {
+            child_node_generator: ->(_) { child_nodes },
+            terminal_node_criterion: ->(node) { node[:id] > 0 },
+            evaluation_heuristic: ->(node) { node[:score] }
+          }
+          negamax = new_negamax(parameters)
+
+          expect(negamax.apply({id: 0})).to eq child_nodes.max_by { |n| n[:score] }
+        end
+
+        it "applies the child node generator to obtain child nodes to score" do
+          parameters = {
+            child_node_generator: ->(_) { [:child_node] },
+            terminal_node_criterion: ->(node) { node == :child_node },
+            evaluation_heuristic: ->(_) { 0 }
+          }
+          negamax = new_negamax(parameters)
+
+          expect(parameters[:child_node_generator]).to receive(:call).and_call_original
+          negamax.apply(:initial_node)
+        end
+
+        it "applies the evaluation scheme to obtain a score for child nodes" do
+          parameters = {
+            child_node_generator: ->(_) { [:child_node] },
+            terminal_node_criterion: ->(node) { node == :child_node },
+            evaluation_heuristic: ->(_) { 0 }
+          }
+          negamax = new_negamax(parameters)
+
+          heuristic = parameters[:evaluation_heuristic]
+          expect(heuristic).to receive(:call).with(:child_node).and_call_original
+          negamax.apply(:initial_node)
+        end
+
+        context "when given a root node with a depth of 3" do
+          let(:root_node) do
+            {id: 0, score: nil, children: [
+              {id: 1, score: nil, children: [
+                {id: 3, score: 1, children: nil},
+                {id: 4, score: -1, children: nil}
+              ]},
+              {id: 2, score: nil, children: [
+                {id: 5, score: 0, children: nil},
+                {id: 6, score: 0, children: nil}
+              ]}
+            ]}
+          end
+
+          it "returns the node whose children have the highest minimum score" do
+            parameters = {
+              child_node_generator: ->(node) { node[:children] },
+              terminal_node_criterion: ->(node) { node[:children].nil? },
+              evaluation_heuristic: ->(node) { node[:score] }
+            }
+            negamax = new_negamax(parameters)
+
+            expect(negamax.apply(root_node)[:id]).to eq 2
+          end
+        end
+      end
+    end
+  end
+end