tictactoe-core 0.1.1

data/lib/tictactoe/players/computer.rb

@@ -0,0 +1,21 @@
+module Tictactoe
+  module Players
+    class Computer
+      attr_reader :mark
+
+      def initialize(mark, intelligence, chooser)
+        @intelligence = intelligence
+        @chooser = chooser
+        @mark = mark
+      end
+
+      def get_move(state)
+        moves = intelligence.desired_moves(state, mark)
+        chooser.choose_one(moves)
+      end
+
+      private
+      attr_reader :intelligence, :chooser
+    end
+  end
+end

data/lib/tictactoe/players/factory.rb

@@ -0,0 +1,21 @@
+module Tictactoe
+  module Players
+    class Factory
+      def initialize()
+        @factories = {}
+      end
+
+      def create(type, mark)
+        raise "No factory has been defined for type: #{type}" unless factories.has_key?(type)
+        factories[type].call(mark)
+      end
+
+      def register(type, factory)
+        factories[type] = factory
+      end
+
+      private
+      attr_accessor :factories
+    end
+  end
+end

data/lib/tictactoe/sequence.rb

@@ -0,0 +1,24 @@
+module Tictactoe
+  class Sequence
+    class Node
+      attr_reader :value
+      attr_accessor :next
+
+      def initialize(value)
+        @value = value 
+      end
+    end
+
+    attr_reader :first
+
+    def initialize(values)
+      nodes = values.map{|value| Node.new(value)}
+      nodes.each_with_index do |node, index|
+        next_index = (index +1) % nodes.length
+        node.next = nodes[next_index]
+      end
+
+      @first = nodes.first
+    end
+  end
+end

data/lib/tictactoe/state.rb

@@ -0,0 +1,64 @@
+module Tictactoe
+  class State
+    attr_reader :board, :marks
+
+    def initialize(board, marks=[nil] * board.locations.length)
+      @board = board
+      @marks = marks
+    end
+
+    def available_moves
+      @available ||= board.locations.select{|location| marks[location].nil?}
+    end
+
+    def played_moves
+      @played_moves ||= board.locations.length - available_moves.length
+    end
+
+    def make_move(location, mark)
+      new_marks = marks.clone
+      new_marks[location] = mark
+      self.class.new(board, new_marks)
+    end
+
+    def when_finished(&block)
+      yield winner if is_finished?
+    end
+
+    def is_finished?
+      is_full? || has_winner?
+    end
+
+    def winner
+      @winner ||= find_winner
+    end
+
+    private
+    def is_full?
+      available_moves.empty?
+    end
+
+    def has_winner?
+      winner != nil
+    end
+
+    def find_winner
+      for line in board.lines
+        first_mark_in_line = nil
+        is_winner = true
+
+        for location in line
+          mark = marks[location]
+          first_mark_in_line ||= mark
+
+          is_winner = mark && mark == first_mark_in_line
+          break if !is_winner
+        end
+
+        return first_mark_in_line if is_winner
+      end
+
+      nil
+    end
+  end
+end

data/runtests.sh

@@ -0,0 +1 @@
+rake spec:develop

data/spec/performance_spec.rb

@@ -0,0 +1,16 @@
+require 'timeout'
+require 'test_run'
+
+RSpec.describe 'Performance', :integration => true do
+  it 'runs a full 3x3 game in less than 1 second' do
+    Timeout::timeout(1) {
+      TestRun.new(3).game_winner
+    }
+  end
+
+  it 'runs a full 4x4 game in less than 10 seconds' do
+    Timeout::timeout(10) {
+      TestRun.new(4).game_winner
+    }
+  end
+end

data/spec/properties_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'reproducible_random'
+require 'test_run'
+
+RSpec.describe "Properties", :properties => true do
+  10.times do |n|
+    it 'two perfect players in a 4x4 board ends up in a draw' do
+      random = ReproducibleRandom.new
+
+      random.print
+      puts n
+
+      expect(TestRun.new(4, random).game_winner).to eq(nil)
+    end
+  end
+
+  10.times do |n|
+    it 'two perfect players in a 3x3 board ends up in a draw' do
+      random = ReproducibleRandom.new
+
+      random.print
+      puts n
+
+      expect(TestRun.new(3, random).game_winner).to eq(nil)
+    end
+  end
+end

data/spec/rake_rspec.rb

@@ -0,0 +1,42 @@
+require 'rspec/core/rake_task'
+  
+class RSpecTask
+  def initialize(task)
+    @task = task
+  end
+
+  def add_opts(opts)
+    @task.rspec_opts ||= ""
+    @task.rspec_opts += " #{opts}"
+  end
+
+  def include_tag(tag)
+    add_opts "--tag #{tag.to_s}"
+  end
+
+  def exclude_tag(tag)
+    add_opts "--tag ~#{tag.to_s}"
+  end
+
+  def include_tags(*tags)
+    tags.flatten.each {|t| include_tag t}
+  end
+
+  def exclude_tags(*tags)
+    tags.flatten.each {|t| exclude_tag t}
+  end
+
+  def eval(&block)
+    instance_eval &block
+  end
+
+  def method_missing(sym, *args, &block)
+    @task.send sym, *args, &block
+  end
+end
+
+def rspec_task(task_name, &block)
+  RSpec::Core::RakeTask.new(task_name) do |task|
+    RSpecTask.new(task).eval(&block)
+  end
+end

data/spec/regression_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'reproducible_random'
+require 'test_run'
+
+RSpec.describe "Regression", :regression => true do
+  def game_winner(board_size, random)
+    TestRun.new(board_size, random).game_winner
+  end
+
+  it '4x4 failure with depth 4' do
+    sequence = [0.6626694797262954, 0.30448981659546004, 0.26798910592351544, 0.2830459900271195, 0.8895551951203527, 0.9046657862565063, 0.7899802463007816, 0.9098809266633705, 0.5677509599820714, 0.18716424973282353, 0.6105498878101738, 0.2681744677257635, 0.30826022341252124, 0.053929729073694754, 0.7765776002726397, 0.21077253937369878, 0.8753238832455099, 0.9254492923943836, 0.29696052495963243, 0.10534603754755134]
+    expect(game_winner 4, ReproducibleRandom.new(sequence)).to eq(nil)
+  end
+
+  it '4x4 failure with depth 4' do
+    sequence = [0.1752952614642579, 0.8821241018038767, 0.6794926188368996, 0.8518302762222564, 0.4458811493973551, 0.9306345357423046, 0.3123799482994526, 0.5924524099570939, 0.6450816940352238, 0.8825832762954303, 0.23750013882693732, 0.12379845558667857, 0.7600372531198462, 0.9208682981404592, 0.4524751171155964, 0.31049852102768605, 0.7718096983015857, 0.6281565115385799, 0.9986801091827466, 0.18577634176797098]
+    expect(game_winner 4, ReproducibleRandom.new(sequence)).to eq(nil)
+  end
+
+  it '4x4 failure with depth 6' do
+    sequence = [0.6137695984061624, 0.2695201125662491, 0.0008415175788497598, 0.832189486355373, 0.6430165225443919, 0.8156207919820028, 0.09507654190749693, 0.8769632565382544, 0.05710300982358729, 0.2448707731542331, 0.8227686892057651, 0.1670967918329198, 0.14015244123427695, 0.5902007740200433, 0.1892333599454875, 0.16358163954350124, 0.8366990526943789, 0.3834904620942655, 0.6036916112731134, 0.35463854154420804]
+    expect(game_winner 4, ReproducibleRandom.new(sequence)).to eq(nil)
+  end
+
+  it '3x3 failure with depth 4' do
+    sequence = [0.26761252406241565, 0.3290653539136804, 0.2922656712698549, 0.6264650506684584, 0.8348217536107002, 0.6663705177073628, 0.4028423873660856, 0.8250949303519487, 0.2619108550896686, 0.9881311048809777, 0.17014068693848805, 0.9661804312253627, 0.8518758632715853, 0.4047533345563624, 0.8064386913142052, 0.8619449038153968, 0.7895923865428888, 0.19974944649456394, 0.3203368624001046, 0.08129744891781843]
+    expect(game_winner 3, ReproducibleRandom.new(sequence)).to eq(nil)
+  end
+end

data/spec/reproducible_random.rb

@@ -0,0 +1,16 @@
+class ReproducibleRandom
+  attr_accessor :sequence, :progress
+
+  def initialize(sequence = 20.times.map{Random.new.rand})
+    @sequence = sequence
+    @progress = sequence.cycle
+  end
+
+  def rand
+    progress.next
+  end
+
+  def print
+    puts "ReproducibleRandom sequence: #{sequence.to_s}"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+RSpec.configure  do |config|
+  config.order = :random
+end

data/spec/test_run.rb

@@ -0,0 +1,19 @@
+dirname = File.expand_path(File.dirname(File.dirname(__FILE__))) + "/lib"
+$LOAD_PATH.unshift(dirname) unless $LOAD_PATH.include?(dirname)
+
+require 'tictactoe/game'
+
+class TestRun
+  attr_reader :board_size, :random
+  def initialize(board_size, random = Random.new)
+    @board_size = board_size
+    @random = random
+  end
+
+  def game_winner
+    game = Tictactoe::Game.new(board_size, :computer, :computer, random)
+    game.register_human_factory(nil)
+    game.tick() until game.is_finished?()
+    game.winner
+  end
+end

data/spec/tictactoe/ai/ab_minimax_spec.rb

@@ -0,0 +1,511 @@
+require 'spec_helper'
+require 'tictactoe/ai/ab_minimax'
+
+RSpec.describe Tictactoe::Ai::ABMinimax do
+  def strategy(tree)
+    minimax = described_class.new(-1, -1, 10)
+    strategy = minimax.best_nodes(tree)
+    strategy
+  end
+
+  def leaf(score)
+    spy "leaf scored: #{score}", :is_final? => true, :score => score
+  end
+
+  describe 'given a leaf node' do
+    describe 'there is no strategy possible' do
+      it do
+        expect(strategy leaf 1)
+        .to eq([])
+      end
+
+      it do
+        expect(strategy leaf(-1))
+        .to eq([])
+      end
+
+      it do
+        expect(strategy leaf 0)
+        .to eq([])                    
+      end
+    end
+  end
+
+  def tree(children)
+    spy "tree, children: #{children.to_s}", :is_final? => false, :children => children
+  end
+  
+  describe 'given a one-leaf one-level tree' do
+    it 'does not ask the root for the score' do
+      root = tree [leaf(1)]
+      strategy root
+      expect(root).not_to have_received(:score)
+    end
+
+    describe 'has that leaf as the only strategy' do
+      it do
+        leaf = leaf(1)
+        expect(strategy tree [leaf])
+        .to eq([leaf])
+      end
+
+      it do
+        leaf = leaf(-1)
+        expect(strategy tree [leaf])
+        .to eq([leaf])
+      end
+
+      it do
+        leaf = leaf(0)
+        expect(strategy tree [leaf])
+        .to eq([leaf])
+      end
+    end
+  end
+
+  describe 'given a multiple-leaves one-level tree' do
+    describe 'chooses the best leaves' do
+      it do
+        best_leaf = leaf(1)
+        expect(strategy tree [best_leaf, leaf(0)])
+        .to eq([best_leaf])
+      end
+
+      it do
+        best_leaf = leaf(0)
+        expect(strategy tree [best_leaf, leaf(-1)])
+        .to eq([best_leaf])
+      end
+
+      it do
+        best_leaf = leaf(1)
+        expect(strategy tree [leaf(0), best_leaf])
+        .to eq([best_leaf])
+      end
+
+      it do
+        best_leaf = leaf(0)
+        expect(strategy tree [leaf(-1), best_leaf])
+        .to eq([best_leaf])
+      end
+
+      it do
+        leaf1 = leaf(1)
+        leaf2 = leaf(1)
+        expect(strategy tree [leaf1, leaf2])
+        .to eq([leaf1, leaf2])
+      end
+
+      it do
+        leaf2 = leaf(1)
+        leaf3 = leaf(1)
+        expect(strategy tree [leaf(0), leaf2, leaf3])
+        .to eq([leaf2, leaf3])
+      end
+
+      it do
+        leaf1 = leaf(1)
+        leaf3 = leaf(1)
+        expect(strategy tree [leaf1, leaf(0), leaf3])
+        .to eq([leaf1, leaf3])
+      end
+    end
+  end
+
+  describe 'given a two-level one-leaf tree' do
+    it 'does not ask the subtree for the score' do
+      subtree = tree [leaf(1)]
+      strategy tree [subtree]
+      expect(subtree).not_to have_received(:score)
+    end
+
+    it do
+      subtree = tree [leaf(1)]
+      expect(strategy tree [subtree])
+      .to eq([subtree])
+    end
+  end
+
+  describe 'given complex tree' do
+    describe 'chooses the best option even if it is immediate' do
+      it do
+        best_option = leaf(1)
+        root = tree([
+          #my choice
+          best_option,
+          tree([
+            #other's choice
+            leaf(0)
+          ]),
+        ])
+
+        expect(strategy root)
+        .to eq([best_option])
+      end
+
+      it do
+        best_option = leaf(1)
+        root = tree([
+          #my choice
+          tree([
+            #other's choice
+            leaf(0)
+          ]),
+          best_option,
+        ])
+
+        expect(strategy root)
+        .to eq([best_option])
+      end
+    end
+
+    describe 'chooses the best option even if it is one-level deep' do
+      it do
+        best_option = tree([
+          #other's choice
+          leaf(1)
+        ])
+        root = tree([
+          #my choice
+          leaf(0),
+          best_option,
+        ])
+
+        expect(strategy root)
+        .to eq([best_option])
+      end
+
+      it do
+        best_option = tree([
+          #other's choice
+          leaf(1)
+        ])
+        root = tree([
+          #my choice
+          best_option,
+          leaf(0),
+        ])
+
+        expect(strategy root)
+        .to eq([best_option])
+      end
+    end
+
+    describe 'chooses equivalent options even if they are at different levels' do
+      it do
+        option1 = tree([
+          #other's choice
+          leaf(1)
+        ])
+        option2 = leaf(1)
+        root = tree([
+          #my choice
+          option1,
+          option2,
+        ])
+
+        expect(strategy root)
+        .to eq([option1, option2])
+      end
+
+      it do
+        option1 = tree([
+          #other's choice
+          leaf(0)
+        ])
+        option2 = leaf(0)
+        root = tree([
+          #my choice
+          option1,
+          option2,
+        ])
+
+        expect(strategy root)
+        .to eq([option1, option2])
+      end
+    end
+
+    describe 'assumes the opponent chooses the worst option' do
+      it do
+        best_option = leaf(0)
+        root = tree([
+          #my choice
+          best_option,
+          tree([
+            #other's choice
+            leaf(1),
+            leaf(-1),
+          ]),
+        ])
+
+        expect(strategy root)
+        .to eq([best_option])
+      end
+
+      it do
+        best_option = tree([
+          #other's choice
+          leaf(0),
+          leaf(1),
+        ])
+        root = tree([
+          #my choice
+          leaf(-1),
+          best_option,
+        ])
+
+        expect(strategy root)
+        .to eq([best_option])
+      end
+
+      it do
+        best_option = leaf(0)
+        root = tree([
+          #my choice
+          best_option,
+          tree([
+            #other's choice
+            leaf(1),
+            leaf(1),
+            leaf(-1),
+          ]),
+        ])
+
+        expect(strategy root)
+        .to eq([best_option])
+      end
+    end
+
+    describe 'stops evaluating when the branch is going to be discarded by my decision' do
+      it do
+        not_evaluated_node = leaf(-1)
+        root = tree([
+          #my choice
+          leaf(1),
+          tree([
+            #other's choice
+            leaf(0),
+            not_evaluated_node,
+          ]),
+        ])
+
+        strategy root
+        expect(not_evaluated_node).not_to have_received(:score)
+      end
+
+      it do
+        not_evaluated_node = leaf(1)
+        root = tree([
+          #my choice
+          leaf(0),
+          tree([
+            #other's choice
+            leaf(-1),
+            not_evaluated_node,
+          ]),
+        ])
+
+        strategy root
+        expect(not_evaluated_node).not_to have_received(:score)
+      end
+
+      it do
+        evaluated_node = leaf(-1)
+        root = tree([
+          #my choice
+          leaf(1),
+          tree([
+            #other's choice
+            leaf(1),
+            evaluated_node,
+          ]),
+        ])
+
+        strategy root
+        expect(evaluated_node).to have_received(:score)
+      end
+    end
+
+    describe 'stops evaluating when the branch is going to be discarded by the opponents decision' do
+      it do
+        not_evaluated_node = leaf(-1)
+        root = tree([
+          #my choice
+          tree([
+            #other's choice
+            leaf(-1),
+            tree([
+              #my choice
+              leaf(0),
+              not_evaluated_node,
+            ]),
+          ]),
+        ])
+
+        strategy root
+        expect(not_evaluated_node).not_to have_received(:score)
+      end
+    end
+
+    describe 'stops evaluating when the opponent has the possibility to choose the minimum score' do
+      it do
+        not_evaluated_node = leaf(0)
+        root = tree([
+          #my choice
+          leaf(-1),
+          tree([
+            #other's choice
+            leaf(-1),
+            not_evaluated_node,
+          ]),
+        ])
+
+        strategy root
+        expect(not_evaluated_node).not_to have_received(:score)
+      end
+    end
+
+    describe 'given tree-level deep tree with only maximizing choices' do
+      it 'goes in depth until the leaves' do
+        last_leaf = leaf(-1)
+        root = tree([
+          # my choice
+          leaf(0),
+          tree([
+            #other's choice
+            tree([
+              #my choice
+              leaf(1),
+              last_leaf,
+            ])
+          ]),
+        ])
+
+        strategy root
+        expect(last_leaf).to have_received(:score)
+      end
+
+      it 'and a better option at the last level, chooses it' do
+        best_option = tree([
+          #other's choice
+          tree([
+            #my choice
+            leaf(1)
+          ])
+        ])
+
+        root = tree([
+          #my choice
+          leaf(-1),
+          best_option,
+        ])
+
+        expect(strategy root).to eq([best_option])
+      end
+
+      it 'assumes the opponent is going to minimize my winnings' do
+        best_option = leaf(0)
+
+        root = tree([
+          #my choice
+          tree([
+            #other's choice
+            tree([
+              #my choice
+              leaf(-1),
+            ]),
+            tree([
+              #my choice
+              leaf(1),
+            ])
+          ]),
+          best_option,
+        ])
+
+        expect(strategy root).to eq([best_option])
+      end
+    end
+
+    describe 'given a depth limit' do
+      describe 'supposes that the deeper trees have the minimum score possible' do
+        it do
+          evaluated_leaf = leaf(-1)
+          not_evaluated_leaf = leaf(1)
+          options_perceived_as_equivalent = [
+            #depth 0
+            evaluated_leaf,
+            tree([
+              #depth 1
+              not_evaluated_leaf
+            ])
+          ]
+
+          root = tree(options_perceived_as_equivalent)
+
+          minimax = described_class.new(-1, -1, 0)
+          expect(minimax.best_nodes root).to eq(options_perceived_as_equivalent)
+          expect(evaluated_leaf).to have_received(:score)
+          expect(not_evaluated_leaf).not_to have_received(:score)
+        end
+
+        it do
+          evaluated_leaf = leaf(0)
+          not_evaluated_leaf = leaf(1)
+          option_perceived_as_best = tree([
+            #depth 1
+            evaluated_leaf,
+          ])
+
+          root = tree([
+            #depth 0
+            option_perceived_as_best,
+            tree([
+              #depth 1
+              tree([
+                #depth 2
+                not_evaluated_leaf
+              ])
+            ])
+          ])
+
+          minimax = described_class.new(-1, -1, 1)
+          expect(minimax.best_nodes root).to eq([option_perceived_as_best])
+          expect(evaluated_leaf).to have_received(:score)
+          expect(not_evaluated_leaf).not_to have_received(:score)
+        end
+
+        it do
+          evaluated_leaf = leaf(0)
+          not_evaluated_leaf = leaf(1)
+          option_perceived_as_best = tree([
+            #depth 1
+            tree([
+              #depth 2
+              evaluated_leaf,
+            ]),
+          ])
+
+          root = tree([
+            #depth 0
+            option_perceived_as_best,
+            tree([
+              #depth 1
+              tree([
+                #depth 2
+                tree([
+                  #depth 3
+                  not_evaluated_leaf
+                ])
+              ])
+            ])
+          ])
+
+          minimax = described_class.new(-1, -1, 2)
+          expect(minimax.best_nodes root).to eq([option_perceived_as_best])
+          expect(evaluated_leaf).to have_received(:score)
+          expect(not_evaluated_leaf).not_to have_received(:score)
+        end
+      end
+    end
+  end
+end