tictactoe-core 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0c6951ba1348109e58534d413b08206c18b0fa94
+  data.tar.gz: 8c33ce5f64a2e0215f41f6c682d8773509002e19
+SHA512:
+  metadata.gz: 31b53621e6afa8e9aaf7f2bcd57d667ac10056f7c1d5944a6359e646a9e7a9404b0af2b11dbb23db04040a4caf17d9c3080eb252cd4c1552259f2098d0b864f5
+  data.tar.gz: a275b3c67c86b11195fe1e86baf70c4fdbf944c036a67e61b6976e32c0a9ae5e3bf2e6adbb14274718c83490e8a6e1c1f1830964af669c6ff9a9242f11285f7c

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - "2.2.0"
+  - "2.1.0"
+  - "2.0.0-p598"
+script: "rake spec:ci"
+addons:
+  code_climate:
+      repo_token: f7b977ac9c2d1d7678f076881c00b89610e14a86dee04df3066081ff6fd6b8dc

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+gem "rspec" , "~> 3.1.0", :group => :test
+gem "codeclimate-test-reporter", :group => :test, :require => nil

data/README.md

@@ -0,0 +1,2 @@
+# tictactoe-core.rb
+![](https://travis-ci.org/demonh3x/tictactoe-core.rb.svg?branch=master) [![Code Climate](https://codeclimate.com/github/demonh3x/tictactoe.rb/badges/gpa.svg)](https://codeclimate.com/github/demonh3x/tictactoe.rb) [![Test Coverage](https://codeclimate.com/github/demonh3x/tictactoe.rb/badges/coverage.svg)](https://codeclimate.com/github/demonh3x/tictactoe.rb)

data/Rakefile

@@ -0,0 +1,34 @@
+task :default => ["spec:develop"]
+
+namespace :spec do
+  require './spec/rake_rspec'
+
+  rspec_task(:unit) do
+    exclude_tags :integration, :regression, :properties
+  end
+
+  rspec_task(:develop) do
+    exclude_tags :regression, :properties
+  end
+
+  rspec_task(:ci) do
+    add_opts "--color -fd"
+    exclude_tags :properties
+  end
+
+  rspec_task(:properties) do
+    include_tags :properties
+  end
+end
+
+task :profile do
+  require 'ruby-prof'
+  require './spec/test_run'
+
+  RubyProf.start
+
+  TestRun.new(4).game_winner 
+
+  result = RubyProf.stop
+  RubyProf::GraphHtmlPrinter.new(result).print(STDOUT)
+end

data/lib/tictactoe.rb

@@ -0,0 +1 @@
+require 'tictactoe/game'

data/lib/tictactoe/ai/ab_minimax.rb

@@ -0,0 +1,78 @@
+module Tictactoe
+  module Ai
+    class ABMinimax
+      def initialize(min_score, heuristic_score, depth_limit)
+        @min_score_possible = min_score
+        @heuristic_score = heuristic_score
+        @depth_limit = depth_limit
+      end
+
+      def best_nodes(tree)
+        most_beneficial_strategy(tree, nil, depth_limit)[:nodes]
+      end
+
+      private
+      attr_reader :min_score_possible, :heuristic_score, :depth_limit
+
+      def most_beneficial_strategy(tree, previous_most_damaging_score, depth)
+        my_best_score = min_score_possible
+        best_nodes = []
+
+        tree.children.each do |child|
+          if child.is_final?
+            score = child.score
+          elsif depth == 0
+            score = heuristic_score
+          else
+            score = most_damaging_score(child, my_best_score, depth-1)
+          end
+
+          my_best_score ||= score
+
+          if score == my_best_score
+            best_nodes << child
+          end
+
+          if score > my_best_score
+            my_best_score = score
+            best_nodes = [child]
+          end
+
+          break if previous_most_damaging_score && previous_most_damaging_score <= score
+        end
+
+        return {
+          :score => my_best_score,
+          :nodes => best_nodes
+        }
+      end
+
+      def most_damaging_score(child, my_best_score, depth)
+        most_damaging_score = nil
+
+        child.children.each do |grandchild|
+          if grandchild.is_final?
+            minimizing_score = grandchild.score
+          elsif depth == 0
+            minimizing_score = heuristic_score
+          else
+            res = most_beneficial_strategy(grandchild, most_damaging_score, depth-1)
+            minimizing_score = res[:score]
+          end
+
+          most_damaging_score ||= minimizing_score
+
+          if minimizing_score < most_damaging_score
+            most_damaging_score = minimizing_score
+          end
+
+          it_cannot_be_worse = min_score_possible && most_damaging_score == min_score_possible
+          there_is_a_better_option = my_best_score && most_damaging_score < my_best_score
+          break if it_cannot_be_worse || there_is_a_better_option
+        end
+
+        most_damaging_score
+      end
+    end
+  end
+end

data/lib/tictactoe/ai/ab_negamax.rb

@@ -0,0 +1,45 @@
+module Tictactoe
+  module Ai
+    class ABNegamax
+      COLOR_SELF = 1
+      COLOR_OPPONENT = -1
+
+      def initialize(depth_limit, depth_reached_score)
+        @depth_limit = depth_limit
+        @depth_reached_score = depth_reached_score
+      end
+
+      attr_reader :depth_reached_score, :depth_limit
+
+      def score(tree)
+        negamax(tree)[:score]
+      end
+
+      def best_nodes(tree)
+        negamax(tree)[:nodes]
+      end
+      
+      private
+      def negamax(node, depth = depth_limit, a = -1000, b = 1000, color = COLOR_SELF)
+        return {:score => color * node.score, :nodes => []} if node.is_final?
+        return {:score => color * depth_reached_score, :nodes => node.children} if depth == 0
+
+        best_score = -1000
+        best_nodes = []
+        node.children.each do |child|
+          score = -negamax(child, depth-1, -b, -a, -color)[:score]
+          if score > best_score
+            best_score = score
+            best_nodes = [child]
+          elsif score == best_score
+            best_nodes << child
+          end
+          a = [a, score].max
+          break if a > b
+        end
+
+        {:score => best_score, :nodes => best_nodes}
+      end
+    end
+  end
+end

data/lib/tictactoe/ai/perfect_intelligence.rb

@@ -0,0 +1,35 @@
+require 'tictactoe/ai/ab_minimax'
+require 'tictactoe/ai/tree'
+
+module Tictactoe
+  module Ai
+    class PerfectIntelligence
+      SCORE_FOR_UNKNOWN_FUTURE = -1
+
+      def desired_moves(state, player)
+        find_best_moves(state, player)
+      end
+
+      private
+      def find_best_moves(state, player)
+        depth = dynamic_depth_for(state)
+        root = Tree.new(state, player)
+        ai = ABMinimax.new(-1000, SCORE_FOR_UNKNOWN_FUTURE, depth)
+        ai.best_nodes(root).map(&:move)
+      end
+
+      def dynamic_depth_for(state)
+        is_4_by_4 = state.board.locations.length == 16
+        if is_4_by_4
+          initial_depth_to_stay_out_of_trouble = 0
+          minimum_depth_to_avoid_lethal_moves = 7
+        else
+          initial_depth_to_stay_out_of_trouble = 4
+          minimum_depth_to_avoid_lethal_moves = 5
+        end
+
+        [minimum_depth_to_avoid_lethal_moves, state.played_moves + initial_depth_to_stay_out_of_trouble].min
+      end
+    end
+  end
+end

data/lib/tictactoe/ai/random_chooser.rb

@@ -0,0 +1,21 @@
+module Tictactoe
+  module Ai
+    class RandomChooser
+      def initialize(random)
+        @random = random
+      end
+
+      def choose_one(list)
+        index = bounded_random list.size
+        list[index]
+      end
+
+      private
+      attr_accessor :random
+
+      def bounded_random(outer_bound)
+        (random.rand * outer_bound).to_i
+      end
+    end
+  end
+end

data/lib/tictactoe/ai/tree.rb

@@ -0,0 +1,44 @@
+module Tictactoe
+  module Ai
+    class Tree
+      MAXIMUM_SCORE = 2
+      MINIMUM_SCORE = -2
+      NEUTRAL_SCORE = 0
+
+      def initialize(state, mark, current_mark = mark, move_to_arrive_here=nil)
+        @state = state
+        @mark = mark
+        @current_mark = current_mark
+        @move = move_to_arrive_here
+      end
+      attr_reader :state, :mark, :current_mark, :move
+
+      def is_final?
+        state.is_finished?
+      end
+
+      def children
+        state.available_moves.map do |move|
+          next_state = state.make_move(move, current_mark.value)
+          Tree.new(next_state, mark, current_mark.next, move)
+        end
+      end
+
+      def score 
+        height = state.available_moves.length + 1
+        base_score * height
+      end
+
+      def base_score
+        case state.winner
+        when mark.value
+          MAXIMUM_SCORE
+        when nil
+          NEUTRAL_SCORE
+        else
+          MINIMUM_SCORE
+        end
+      end
+    end
+  end
+end

data/lib/tictactoe/boards/board_type_factory.rb

@@ -0,0 +1,15 @@
+require 'tictactoe/boards/three_by_three_board'
+require 'tictactoe/boards/four_by_four_board'
+
+module Tictactoe
+  module Boards
+    class BoardTypeFactory
+      def create(side_size)
+        case side_size
+        when 3 then ThreeByThreeBoard.new
+        when 4 then FourByFourBoard.new
+        end
+      end
+    end
+  end
+end

data/lib/tictactoe/boards/four_by_four_board.rb

@@ -0,0 +1,28 @@
+module Tictactoe
+  module Boards
+    class FourByFourBoard
+      LOCATIONS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+
+      HORIZONTAL_LINES = [
+        [0, 1, 2, 3],
+        [4, 5, 6, 7],
+        [8, 9, 10, 11],
+        [12, 13, 14, 15],
+      ]
+      VERTICAL_LINES = HORIZONTAL_LINES.transpose
+      DIAGONALS = [
+        [0, 5, 10, 15],
+        [3, 6, 9, 12],
+      ]
+      LINES = HORIZONTAL_LINES + VERTICAL_LINES + DIAGONALS
+
+      def locations
+        LOCATIONS
+      end
+
+      def lines
+        LINES
+      end
+    end
+  end
+end

data/lib/tictactoe/boards/three_by_three_board.rb

@@ -0,0 +1,27 @@
+module Tictactoe
+  module Boards
+    class ThreeByThreeBoard
+      LOCATIONS = [0, 1, 2, 3, 4, 5, 6, 7, 8]
+
+      HORIZONTAL_LINES = [
+        [0, 1, 2],
+        [3, 4, 5],
+        [6, 7, 8],
+      ]
+      VERTICAL_LINES = HORIZONTAL_LINES.transpose
+      DIAGONALS = [
+        [0, 4, 8],
+        [2, 4, 6],
+      ]
+      LINES = HORIZONTAL_LINES + VERTICAL_LINES + DIAGONALS
+
+      def locations
+        LOCATIONS
+      end
+
+      def lines
+        LINES
+      end
+    end
+  end
+end

data/lib/tictactoe/game.rb

@@ -0,0 +1,102 @@
+require 'tictactoe/state'
+require 'tictactoe/sequence'
+require 'tictactoe/boards/board_type_factory'
+require 'tictactoe/ai/perfect_intelligence'
+require 'tictactoe/ai/random_chooser'
+
+require 'tictactoe/players/factory'
+require 'tictactoe/players/computer'
+
+module Tictactoe
+  class Game
+    attr_accessor :board_size, :x_type, :o_type, :random
+    attr_accessor :current_player, :state
+
+    def initialize(board_size, x_type, o_type, random=Random.new)
+      @board_size = board_size
+      @x_type = x_type
+      @o_type = o_type
+      @random = random
+    end
+
+    def register_human_factory(factory)
+      players_factory.register(:human, factory)
+      reset
+    end
+
+    def tick
+      move = get_move
+      if is_valid?(move) && !is_finished?
+        update_state(move)
+        advance_player
+      end
+    end
+
+    def is_finished?
+      state.is_finished?
+    end
+
+    def winner
+      state.winner
+    end
+
+    def marks
+      state.marks
+    end
+
+    def available
+      state.available_moves
+    end
+
+    private
+    def is_valid?(move)
+      move && state.available_moves.include?(move)
+    end
+
+    def update_state(move)
+      self.state = state.make_move(move, current_player.value.mark.value)
+    end
+
+    def advance_player
+      self.current_player = current_player.next
+    end
+
+    def get_move
+      current_player.value.get_move(state)
+    end
+
+    def reset
+      reset_players
+      reset_state
+    end
+
+    def reset_players
+      first_mark = Sequence.new([:x, :o]).first
+
+      x_player = players_factory.create(x_type, first_mark)
+      o_player = players_factory.create(o_type, first_mark.next)
+
+      self.current_player = Sequence.new([x_player, o_player]).first
+    end
+
+    def players_factory
+      @players_factory ||= create_players_factory
+    end
+
+    def create_players_factory
+      factory = Players::Factory.new()
+      factory.register(:computer, computer_factory)
+      factory
+    end
+
+    def computer_factory
+      intelligence = Ai::PerfectIntelligence.new
+      chooser = Ai::RandomChooser.new(random)
+      lambda {|mark| Players::Computer.new(mark, intelligence, chooser)}
+    end
+
+    def reset_state
+      self.state = State.new(Boards::BoardTypeFactory.new.create(board_size))
+    end
+  end
+end