tictactoe-core 0.1.1

data/spec/tictactoe/ai/ab_negamax_spec.rb

@@ -0,0 +1,199 @@
+require 'spec_helper'
+require 'tictactoe/ai/ab_negamax'
+
+RSpec.describe Tictactoe::Ai::ABNegamax do
+  def preferred_nodes(tree, depth = 10, depth_reached_score = -10)
+    negamax = described_class.new(depth, depth_reached_score)
+    strategy = negamax.best_nodes(tree)
+    strategy
+  end
+
+  def score(tree, depth = 10, depth_reached_score = -10)
+    negamax = described_class.new(depth, depth_reached_score)
+    negamax.score(tree)
+  end
+
+  def leaf(score)
+    spy "leaf scored: #{score}", :is_final? => true, :score => score
+  end
+
+  def tree(children)
+    spy "tree, children: #{children.to_s}", :is_final? => false, :children => children
+  end
+
+  it 'with one player choice of score 0, the resulting score is 0' do
+    root = tree([
+      #player choice
+      leaf(0)
+    ])
+
+    expect(score(root)).to eq(0)
+  end
+
+  it 'with one player choice of score -1 for player, the resulting score is -1' do
+    root = tree([
+      #player choice
+      leaf(-1)
+    ])
+
+    expect(score(root)).to eq(-1)
+  end
+
+  it 'with two player choices of score 0 and 1 for player, the resulting score is 1 (the best for player)' do
+    root = tree([
+      #player choice
+      leaf(1),
+      leaf(0),
+    ])
+
+    expect(score(root)).to eq(1)
+  end
+
+  it 'with one opponnent choice of score 1 for player, the resulting score is 1' do
+    root = tree([
+      #player choice
+      tree([
+        #opponent choice
+        leaf(1),
+      ])
+    ])
+
+    expect(score(root)).to eq(1)
+  end
+
+  it 'with two opponnent choices of score 0 and 1 for player, it will chose 0 (the worst for player)' do
+    root = tree([
+      #player choice
+      tree([
+        #opponent choice
+        leaf(1),
+        leaf(0),
+      ])
+    ])
+
+    expect(score(root)).to eq(0)
+  end
+
+  it 'with a depth limit of 0 and a score of -10 for the deeper nodes, when provided a single node at depth 1 returns -10' do
+    depth = 0
+    depth_reached_score = -10
+
+    all_children = [
+      #player choice
+      leaf(1),
+    ]
+    root = tree(all_children)
+
+    expect(score(root, depth, depth_reached_score)).to eq(-10)
+    expect(preferred_nodes(root, depth, depth_reached_score)).to eq(all_children)
+  end
+
+  it 'with a depth limit of 1 and a score of -10 for the deeper nodes, when provided a single node at depth 2 returns -10' do
+    depth_limit = 1
+    depth_reached_score = -10
+
+    root = tree([
+      #player choice
+      tree([
+        #opponent choice
+        leaf(1),
+      ])
+    ])
+
+    expect(score(root, depth_limit, depth_reached_score)).to eq(-10)
+  end
+
+  it 'with a depth limit of 2 and a score of -10 for the deeper nodes, when provided a single node of score 1 at depth 2 returns 1' do
+    depth_limit = 2
+    depth_reached_score = -10
+
+    root = tree([
+      #player choice
+      tree([
+        #opponent choice
+        leaf(1),
+      ])
+    ])
+
+    expect(score(root, depth_limit, depth_reached_score)).to eq(1)
+  end
+
+  it 'with a branch that is going to be worse than a previous choice, stops evaluating once it knows' do
+    not_evaluated_node = leaf(100)
+    root = tree([
+      #player choice
+      leaf(1),
+      tree([
+        #opponent choice
+        leaf(0),
+        not_evaluated_node,
+      ])
+    ])
+
+    root_score = score(root)
+
+    expect(root_score).to eq(1)
+    expect(not_evaluated_node).not_to have_received(:score)
+    expect(not_evaluated_node).not_to have_received(:is_leaf?)
+  end
+
+  it 'with a branch that is going to be discarded by the opponents choice, stops evaluating once it knows' do
+    not_evaluated_node = leaf(-1)
+    root = tree([
+      #player choice
+      tree([
+        #opponent choice
+        leaf(-1),
+        tree([
+          #player choice
+          leaf(0),
+          not_evaluated_node,
+        ]),
+      ]),
+    ])
+
+    score(root)
+    expect(not_evaluated_node).not_to have_received(:score)
+  end
+
+  it 'with one player choice of score 0, that is the only preferred node' do
+    only_option = leaf(0)
+    root = tree([
+      #player choice
+      only_option
+    ])
+
+    expect(preferred_nodes(root)).to eq([only_option])
+  end
+
+  it 'with two player choices of score 0, those two are the prefered nodes' do
+    option1 = leaf(0)
+    option2 = leaf(0)
+    root = tree([
+      #player choice
+      option1,
+      option2
+    ])
+
+    expect(preferred_nodes(root)).to eq([option1, option2])
+  end
+
+  it 'with equivalent branches, those are the preferred nodes' do
+    option1 = tree([
+      #opponent choice
+      leaf(0)
+    ])
+    option2 = tree([
+      #opponent choice
+      leaf(0)
+    ])
+
+    root = tree([
+      #player choice
+      option1,
+      option2
+    ])
+
+    expect(preferred_nodes(root)).to eq([option1, option2])
+  end
+end

data/spec/tictactoe/ai/perfect_intelligence_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+require 'tictactoe/ai/perfect_intelligence'
+require 'tictactoe/state'
+require 'tictactoe/sequence'
+require 'tictactoe/boards/three_by_three_board'
+require 'tictactoe/boards/four_by_four_board'
+
+RSpec.describe Tictactoe::Ai::PerfectIntelligence do
+  def board(*marks)
+    state = Tictactoe::State.new(Tictactoe::Boards::ThreeByThreeBoard.new)
+    marks.each_with_index do |mark, location|
+      state = state.make_move(location, mark)
+    end
+    state
+  end
+
+  def play(state)
+    player = Tictactoe::Sequence.new([:x, :o]).first
+    described_class.new().desired_moves(state, player)
+  end
+
+  it 'given only one possible play, should do it' do
+    state = board(
+      :x, :o, nil,
+      :o, :x, :x,
+      :x, :o, :o
+    )
+    expect(play(state)).to eq [2]
+  end
+
+  it 'given the possibility to lose, should block' do
+    state = board(
+      :x, nil, nil,
+      :o, nil, :o,
+      :x, nil, nil
+    )
+    expect(play(state)).to eq [4]
+  end
+  
+  it 'given the possibility to lose, should block, not matter if there is a fork comming' do
+    state = board(
+      :x, nil, nil,
+      :x, nil, nil,
+      :o, nil, :o,
+    )
+    expect(play(state)).to eq [7]
+  end
+
+  it 'given the possibility to win, should prefer it' do
+    state = board(
+      :x,  :o,  :x,
+      :o,  :x,  :o,
+      nil, nil, :o 
+    )
+    expect(play(state)).to eq [6]
+  end
+
+  it 'given the possibility to win, should prefer it over blocking or forking' do
+    state = board(
+      :x,  nil, :o,
+      nil, nil, :o,
+      :x,  nil, nil
+    )
+    expect(play(state)).to eq [3]
+  end
+
+  it 'given the possibility to fork, should prefer it' do
+    state = board(
+      :x,  :o,  :x,
+      nil, nil, :o,
+      nil, nil, nil
+    )
+    expect(play(state)).to eq [4, 6]
+  end
+
+  it 'given the possibility to block, should prefer it over forking' do
+    state = board(
+      nil, nil, :x,
+      nil, :o,  nil,
+      :x,  :o,  nil
+    )
+    expect(play(state)).to eq [1]
+  end
+
+  it 'given the possibility to block a fork, should do it' do
+    #:o started the game
+    state = board(
+      :o,  :x,  :o,
+      nil, nil, nil,
+      nil, nil, nil,
+    )
+    expect(play(state)).to eq [4]
+  end
+
+  it 'given two possible forks for the opponent, should attack avoiding the creation of the fork' do
+    #:o started the game
+    state = board(
+      nil, nil, :o,
+      nil, :x,  nil,
+      :o,  nil, nil,
+    )
+    expect(play(state)).to eq [1, 3, 5, 7]
+  end
+
+  def board4(*marks)
+    state = Tictactoe::State.new(Tictactoe::Boards::FourByFourBoard.new)
+    marks.each_with_index do |mark, location|
+      state = state.make_move(location, mark)
+    end
+    state
+  end
+
+  it 'given initial state, any option is valid' do
+    state = board4(
+      nil, nil, nil, nil,
+      nil, nil, nil, nil,
+      nil, nil, nil, nil,
+      nil, nil, nil, nil,
+    )
+    expect(play(state)).to eq((0..15).to_a)
+  end
+end

data/spec/tictactoe/ai/random_choser_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'tictactoe/ai/random_chooser'
+
+RSpec.describe Tictactoe::Ai::RandomChooser do
+  def choose_with(random_value, list)
+    random = spy :rand => random_value
+    described_class.new(random).choose_one list
+  end
+  
+  describe 'given only one option' do
+    describe 'should choose it no matter the random value'  do
+      it 'for example: minimum random value' do
+        expect(choose_with 0.0, [1]).to eq 1
+      end
+
+      it 'for example: maximum random value' do
+        expect(choose_with 0.99, [1]).to eq 1
+      end
+    end
+  end
+
+  describe 'given two options' do
+    it 'chooses the first one when the random is less than a half' do
+        expect(choose_with 0.0, [1, 2]).to eq 1
+        expect(choose_with 0.4, [1, 2]).to eq 1
+    end
+
+    it 'chooses the second one when the random is more than a half' do
+        expect(choose_with 0.5, [1, 2]).to eq 2
+        expect(choose_with 0.99, [1, 2]).to eq 2
+    end
+  end
+    
+  describe 'given three options' do
+    it 'chooses the first one when the random is less than a third' do
+        expect(choose_with 0.0, [1, 2, 3]).to eq 1
+        expect(choose_with 0.3, [1, 2, 3]).to eq 1
+    end
+
+    it 'chooses the second one when the random is between a third and two thirds' do
+        expect(choose_with 0.4, [1, 2, 3]).to eq 2
+        expect(choose_with 0.6, [1, 2, 3]).to eq 2
+    end
+
+    it 'chooses the third one when the random is more than two thirds' do
+        expect(choose_with 0.7, [1, 2, 3]).to eq 3
+        expect(choose_with 0.9, [1, 2, 3]).to eq 3
+    end
+  end
+end

data/spec/tictactoe/boards/board_type_factory_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'tictactoe/boards/board_type_factory'
+
+RSpec.describe Tictactoe::Boards::BoardTypeFactory do
+  def create(side_size)
+    described_class.new.create(side_size)
+  end
+
+  it 'given 3 returns a ThreeByThreeBoard' do
+    expect(create(3)).to be_an_instance_of(Tictactoe::Boards::ThreeByThreeBoard)
+  end
+  
+  it 'given 4 returns a FourByFourBoard' do
+    expect(create(4)).to be_an_instance_of(Tictactoe::Boards::FourByFourBoard)
+  end
+end

data/spec/tictactoe/boards/four_by_four_board_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'tictactoe/boards/four_by_four_board'
+
+RSpec.describe Tictactoe::Boards::FourByFourBoard do
+   it 'has the possible locations' do
+     expect(described_class.new.locations).to eq([
+       0, 1, 2, 3,
+       4, 5, 6, 7,
+       8, 9, 10, 11,
+       12, 13, 14, 15
+     ])
+   end
+
+   it 'should know the lines' do
+     expect(described_class.new.lines).to eq([
+       [0, 1, 2, 3],
+       [4, 5, 6, 7],
+       [8, 9, 10, 11],
+       [12, 13, 14, 15],
+
+       [0, 4, 8, 12],
+       [1, 5, 9, 13],
+       [2, 6, 10, 14],
+       [3, 7, 11, 15],
+
+       [0, 5, 10, 15],
+       [3, 6, 9, 12]
+     ])
+   end
+end

data/spec/tictactoe/boards/three_by_three_board_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'tictactoe/boards/three_by_three_board'
+
+RSpec.describe Tictactoe::Boards::ThreeByThreeBoard do
+  before(:each) do
+    @board = described_class.new
+  end
+
+  it "should know the available locations" do
+    expect(@board.locations).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8])
+  end
+
+  it "should know the lines" do
+    expected_lines = [
+      [0, 1, 2],
+      [3, 4, 5],
+      [6, 7, 8],
+
+      [0, 3, 6],
+      [1, 4, 7],
+      [2, 5, 8],
+
+      [0, 4, 8],
+      [2, 4, 6],
+    ]
+    actual_lines = @board.lines
+
+    expect(actual_lines).to match_array(expected_lines)
+  end
+end