tactical_tic_tac_toe 0.1.1

data/spec/old_computer_player_spec.rb

@@ -0,0 +1,230 @@
+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

data/spec/player_factory_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+require "player_factory"
+
+require "game"
+
+module TicTacToe
+  describe PlayerFactory do
+    include_context "default_values"
+
+    describe ".build" do
+      let(:player_types) { [AvailablePlayerTypes::HUMAN, AvailablePlayerTypes::COMPUTER] }
+      let(:player_classes) { [HumanPlayer, ComputerPlayer] }
+      let(:player_config) do
+        {
+          game: Game.new({}),
+          player_mark: @default_player_marks.first
+        }
+      end
+
+      def build_player(config)
+        PlayerFactory.build(config)
+      end
+
+      it "creates a player of the given type" do
+        player_types.zip(player_classes).each do |type, player_class|
+          player_config[:type] = type
+
+          expect(build_player(player_config)).to be_a player_class
+        end
+      end
+
+      it "creates players that respond to #move" do
+        player_types.each do |type|
+          player_config[:type] = type
+
+          expect(build_player(player_config)).to respond_to :move
+        end
+      end
+
+      it "creates players that use the given mark" do
+        player_types.each do |type|
+          player_config[:type] = type
+
+          expect(build_player(player_config).player_mark).to eq player_config[:player_mark]
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,107 @@
+require "rspec"
+require "rspec/collection_matchers"
+
+RSpec.shared_context "default_values" do
+  before :all do
+    @default_board_size = 3
+    @default_first_player = :x
+    @default_second_player = :o
+    @default_player_marks = [:x, :o]
+    @default_player_types = [:human, :computer]
+  end
+end
+
+RSpec.shared_context "helper_methods" do
+  def blank_board_configuration(board_size)
+    (0...board_size**2).map { TicTacToe::Board.blank_mark }
+  end
+
+  def at_least_one_repeated_line?(string)
+    lines = string.split("\n")
+    lines.uniq.length < lines.length
+  end
+
+  def random_coordinates(board_size)
+    [rand(board_size), rand(board_size)]
+  end
+
+  def new_board(parameters)
+    TicTacToe::Board.new(parameters)
+  end
+
+  def build_board(config)
+    size = Math.sqrt(config.size).to_i
+    new_board(size: size, config: config)
+  end
+
+  def blank_board(board_size)
+    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|
+        if row == 0
+          mark = col.odd? ? first_mark : second_mark
+          board.mark_cell(mark, row, col)
+        else
+          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

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: tactical_tic_tac_toe
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Batman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-01 00:00:00.000000000 Z
+dependencies: []
+description: Command line tic tac toe! Run with command 'ttt'
+email: no@no.no
+executables:
+- ttt
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/ttt
+- lib/available_player_types.rb
+- lib/board.rb
+- lib/command_line_interface.rb
+- lib/computer_player.rb
+- 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
+- spec/command_line_interface_spec.rb
+- spec/computer_player_spec.rb
+- 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
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Command line tic tac toe.
+test_files: []