bashrw_ttt 0.1.0

data/lib/ttt/minimax.rb

@@ -0,0 +1,46 @@
+module TTT
+  module TTT::Minimax
+    def minimax(max_player = true, ply = 0, alpha = -1000, beta = 1000)
+      return(board.winner? ? winning_score(max_player, ply) : 0) if base_case_satisfied?
+      ab_value            = max_player ? alpha : beta
+      return ab_value if ply >= max_ply
+
+      ab_value, best_move = gen_score_game_tree(max_player, ply, alpha, beta, ab_value)
+      return(ply == 0 ? best_move : ab_value)
+    end
+
+    def gen_score_game_tree(max_player, ply, alpha, beta, ab_value)
+      best_move = 0
+      available_moves.each do |index|
+        board[][index]                   = mark_curr_player_side(max_player)
+        score                            = minimax(!max_player, ply + 1, alpha, beta)
+        alpha, beta, ab_value, best_move = eval_score(max_player, index, score, alpha, beta, ab_value, best_move)
+        undo_move(index)
+        break if alpha_beta_swapped?(alpha, beta)
+      end
+      [ab_value, best_move]
+    end
+
+    def eval_score(max_player, index, score, alpha, beta, ab_value, best_move)
+      best_move, alpha, ab_value = [index, score, score] if max_player && score > ab_value
+      beta, ab_value             = [score, score]        if !max_player && score < ab_value
+      [alpha, beta, ab_value, best_move]
+    end
+
+    def alpha_beta_swapped?(alpha, beta)
+      alpha >= beta
+    end
+
+    def base_case_satisfied?
+      board.winner? || board.draw_game?
+    end
+
+    def winning_score(max_player, ply)
+      max_player ? (-1000 + ply) : (1000 - ply)
+    end
+
+    def mark_curr_player_side(max_player)
+      max_player ? side : opposite_side(side)
+    end
+  end
+end

data/lib/ttt/move_history.rb

@@ -0,0 +1,10 @@
+module TTT
+  class MoveHistory
+    attr_reader :side, :move
+    def initialize(options)
+      @side = options.fetch(:side)
+      @move = options.fetch(:move)
+    end
+  end
+end
+

data/lib/ttt/move_traverser.rb

@@ -0,0 +1,49 @@
+require 'yaml'
+
+module TTT
+  class MoveTraverser
+    attr_accessor :game_history, :move_index, :current_index
+    def initialize(game_history)
+      self.move_index    = 0
+      self.game_history  = game_history
+      self.current_index = 0
+    end
+
+    def initialize_history
+      self.move_index = max_length
+    end
+
+    def max_length
+      game_history.history.length
+    end
+
+    def adjust_move_index(distance)
+      if move_index + distance >= 0 && move_index + distance <= max_length
+        self.move_index += distance
+      elsif move_index + distance < 0
+        self.move_index = 0
+      else
+        self.move_index = max_length
+      end
+    end
+
+    def history_board_builder(board, move_number_limit = move_index)
+      total_moves    = game_history.history.length
+      clone_board    = YAML.load(YAML.dump(board))
+      clean_board(clone_board)
+      clone_history  = YAML.load(YAML.dump(game_history.history))
+
+      total_moves.times do |n|
+        cur_move = clone_history.shift
+        if (n + 1) <= move_number_limit
+          clone_board.update(cur_move.move, cur_move.side)
+        end
+      end
+      clone_board.board
+    end
+
+    def clean_board(board)
+      board.board.each_index { |index| board.update index, " " }
+    end
+  end
+end

data/lib/ttt/player.rb

@@ -0,0 +1,15 @@
+module TTT
+  class Player
+    attr_accessor :side
+    def initialize(options)
+      self.side = options.fetch(:side)
+    end
+
+    def move; end
+
+    def ==(other_player)
+      self.class == other_player.class &&
+        side == other_player.side
+    end
+  end
+end

data/lib/ttt/riak_db.rb

@@ -0,0 +1,53 @@
+require 'riak'
+module TTT
+  class RiakDB
+    Riak.disable_list_keys_warnings = true
+    attr_accessor :client, :bucket, :cur_id
+    def initialize(options)
+      port            = options.fetch(:port, 8098)
+      http_backend    = options.fetch(:http_backend, :Excon)
+      self.bucket     = options.fetch(:bucket)
+      self.client     = Riak::Client.new(:http_port => port)
+      self.cur_id     = client[bucket].keys.length.to_s
+    end
+
+    def add_game(game)
+      self.cur_id = inc_cur_id
+      new_game              = client[bucket].get_or_new(cur_id)
+      new_game.content_type = "text/yaml"
+      new_game.data         = { :game => game, :id => cur_id }
+      new_game.store
+      cur_id
+    end
+
+    def game_list
+      client[bucket].keys.map(&:to_i).sort.map(&:to_s)
+    end
+
+    def get_game(id)
+      begin
+        game = client[bucket].get(id.to_s)
+      rescue Riak::HTTPFailedRequest
+        nil
+      else
+        game.data[:game]
+      end
+    end
+
+    def save_game(id, game)
+      riak_game      = client[bucket].get(id)
+      riak_game.data = { :game => game, :id => id }
+      riak_game.store
+    end
+
+    def delete_game(id)
+      riak_game      = client[bucket].get(id)
+      riak_game.delete
+    end
+
+    private
+    def inc_cur_id
+      (client[bucket].keys.length + 1).to_s
+    end
+  end
+end

data/lib/ttt/setup.rb

@@ -0,0 +1,59 @@
+require 'ttt/config_helper'
+require 'ttt/game'
+
+module TTT
+  class Setup
+    def players
+      ConfigHelper.player_types
+    end
+
+    def boards
+      ConfigHelper.board_types
+    end
+
+    def new_game(options)
+      Game.new(:player1 => instantiate_player(1, options.fetch(:player1)),
+               :player2 => instantiate_player(2, options.fetch(:player2)),
+               :board   => instantiate_board(options.fetch(:board)),
+               :history => instantiate_history)
+    end
+
+    def new_db
+      instantiate_db
+    end
+
+    def new_interactor
+      instantiate_interactor
+    end
+
+    def db
+      ConfigHelper.get_db_const
+    end
+
+    def interactor
+      ConfigHelper.get_game_interactor_const
+    end
+
+    private
+    def instantiate_interactor
+      ConfigHelper.get_game_interactor_const.new(instantiate_db)
+    end
+
+    def instantiate_db
+      ConfigHelper.get_db_const.new(:port => ConfigHelper.port, :http_backend => ConfigHelper.http_backend, :bucket => ConfigHelper.bucket)
+    end
+
+    def instantiate_history
+      ConfigHelper.get_history_const.new
+    end
+
+    def instantiate_player(player_num, player_type)
+      side = player_num == 1 ? "x" : "o"
+      ConfigHelper.get_player_const(player_type).new(:side => side)
+    end
+
+    def instantiate_board(board_type)
+      ConfigHelper.get_board_const(board_type).new
+    end
+  end
+end

data/lib/ttt/three_by_three.rb

@@ -0,0 +1,35 @@
+require 'ttt/board'
+
+module TTT
+  class ThreeByThree < Board
+    attr_accessor :win_arr, :win_block
+    def initialize
+      self.board   = Array.new(9, " ")
+      self.win_arr = [[0,1,2], [0,4,8], [0,3,6], [1,4,7], [2,5,8], [2,4,6], [3,4,5], [6,7,8]]
+      self.win_block = [[0,1,3,4], [1,2,4,5], [3,4,6,7], [4,5,7,8]]
+    end
+
+    def winner?
+      win_arr.each do |win_combo|
+        return true if board[win_combo[0]] == board[win_combo[1]] &&
+                       board[win_combo[1]] == board[win_combo[2]] &&
+                       board[win_combo[0]] != " "
+      end
+      block_winner?
+    end
+
+    def block_winner?
+      win_block.each do |win_combo|
+        return true if board[win_combo[0]] == board[win_combo[1]] &&
+                       board[win_combo[1]] == board[win_combo[2]] &&
+                       board[win_combo[2]] == board[win_combo[3]] &&
+                       board[win_combo[0]] != " "
+      end
+      false
+    end
+
+    def board_type
+      "three_by_three"
+    end
+  end
+end

data/lib/ttt/three_by_three_by_three.rb

@@ -0,0 +1,37 @@
+require 'ttt/board'
+module TTT
+  class ThreeByThreeByThree < Board
+    attr_accessor :win_arr
+    def initialize
+      self.board   = Array.new(27, " ")
+
+      self.win_arr = [[0,1,2], [0,4,8], [0,3,6], [1,4,7],
+                      [2,5,8], [2,4,6], [3,4,5], [6,7,8],
+                      [9,10,11], [12,13,14], [15,16,17],
+                      [9,12,15], [10,13,16], [11,14,17],
+                      [9,13,17], [11,13,15], [18,19,20],
+                      [21,22,23], [24,25,26], [18,21,24],
+                      [19,22,25], [20,23,26], [18,22,26],
+                      [20,22,24], [0,9,18], [1,10,19], [2,11,20],
+                      [3,12,21], [4,13,22], [5,14,23], [6,15,24],
+                      [7,16,25], [8,17,26], [0,13,26], [2,13,24],
+                      [2,14,26], [0,12,24], [1,13,25], [6,13,20],
+                      [8,13,18], [3,13,23], [5,13,21], [6,16,26],
+                      [7,13,19], [8,16,24], [0,10,20], [2,10,18],
+                      [6,12,18], [8,14,20]]
+    end
+
+    def winner?
+      win_arr.each do |win_combo|
+        return true if board[win_combo[0]] == board[win_combo[1]] &&
+                       board[win_combo[1]] == board[win_combo[2]] &&
+                       board[win_combo[0]] != " "
+      end
+      false
+    end
+
+    def board_type
+      "three_by_three_by_three"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+#require 'simplecov'
+#SimpleCov.start
+require 'ttt/ai'
+require 'ttt/player'
+require 'ttt/game'
+require 'ttt/board'
+require 'ttt/game_history'
+require 'ttt/ai_easy'
+require 'ttt/ai_medium'
+require 'ttt/ai_hard'
+require 'ttt/four_by_four'
+require 'ttt/three_by_three'
+require 'ttt/three_by_three_by_three'
+require 'ttt/human'
+require 'ttt/riak_db'
+require 'ttt/setup'
+require 'ttt/config_helper'
+require 'ttt/move_traverser'
+require 'ttt/game_interactor'
+require 'ttt/context'

data/spec/ttt/ai_easy_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module TTT
+  describe AIEasy do
+    let(:ai)    { AIEasy.new(side: "x") }
+    let(:board) { ThreeByThree.new }
+
+    describe "#minimax" do
+      it "returns a random available move from the game board" do
+        board[] = ["x", "o", " ", " ", " ", " ", "o", "x", "o" ]
+        [2, 3, 4, 5].include? ai.move(board: board)
+      end
+    end
+  end
+end

data/spec/ttt/ai_hard_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+module TTT
+  describe AIHard do
+    let(:ai)    { AIHard.new(side: "o") }
+    let(:board) { ThreeByThree.new }
+
+    describe "#minimax" do
+      it "takes a winning move when one is immediately avaialable" do
+        #situation: o to move
+        #    o  |  o  | win
+        #   ---------------
+        #    x  |  x  |
+        #   ---------------
+        #       |     |
+        board[] = ['o', 'o', ' ', 'x', 'x', ' ', ' ', ' ', ' ']
+        ai.move(board: board)
+        ai.minimax.should == 2
+      end
+
+      it "blocks an opponnent's winning move when one is found" do
+        #situation: o to move
+        #    x  |  x  | block
+        #   ---------------
+        #    o  |     |
+        #   ---------------
+        #    o  |     |
+        board[] = ['x', 'x', ' ', 'o', ' ', ' ', 'o', ' ', ' ']
+        ai.move(board: board)
+        ai.minimax.should == 2
+      end
+
+      it "it prevents forking" do
+        #situation: o to move
+        #    x  |  o  |
+        #   ---------------
+        #    o  |     | x
+        #   ---------------
+        #       |  x  | best
+        board[] = ['x', 'o', ' ', 'o', ' ', 'x', ' ', 'x', ' ']
+        ai.move(board: board)
+        ai.minimax.should == 8
+      end
+    end
+
+    it "finds the best opening move on small games" do
+      board[] = Array.new(9, " ")
+      ai.move(board: board)
+      ai.minimax.should == 4
+    end
+
+    describe "#alpha_beta_swapped?" do
+      it "returns true when alpha >= beta" do
+        ai.alpha_beta_swapped?(500, 500).should == true
+      end
+
+      it "returns false when alpha < beta" do
+        ai.alpha_beta_swapped?(200, 800).should == false
+      end
+    end
+
+    describe "#max_ply_for" do
+      it "returns 7 when available moves > 16" do
+        ai.max_ply_for(17).should == 7
+      end
+
+      it "returns 9 when available moves <= 16 and > 10" do
+        ai.max_ply_for(12).should == 9
+      end
+
+      it "returns 11 when available moves <= 10" do
+        ai.max_ply_for(7).should == 11
+      end
+    end
+  end
+end

data/spec/ttt/ai_medium_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module TTT
+  describe AIMedium do
+    let(:ai)    { AIMedium.new(side: "o") }
+    let(:board) { ThreeByThree.new }
+
+    describe "#minimax" do
+      it "blocks a potential fork win" do
+        #situation: x to move
+        #     o  |     |  x
+        #   -----------------
+        #        |  o  | block
+        #   -----------------
+        #        |     |  x
+        board[] = ['o', ' ', 'x', ' ', 'o', ' ', ' ', ' ', 'x']
+        ai.move(board: board)
+        ai.minimax.should == 5
+      end
+
+      it "takes a winning move when one is immediately avaialable" do
+        #situation: o to move
+        #    o  |  o  | win
+        #   ---------------
+        #    x  |  x  |
+        #   ---------------
+        #       |     |
+        board[] = ['o', 'o', ' ', 'x', 'x', ' ', ' ', ' ', ' ']
+        ai.move(board: board)
+        ai.minimax.should == 2
+      end
+
+      it "blocks an opponnent's winning move when one is found" do
+        #situation: o to move
+        #    x  |  x  | block
+        #   ---------------
+        #    o  |     |
+        #   ---------------
+        #    o  |     |
+        board[] = ['x', 'x', ' ', 'o', ' ', ' ', 'o', ' ', ' ']
+        ai.move(board: board)
+        ai.minimax.should == 2
+      end
+
+      it "returns 0 when it's a draw" do
+        board[] = ['x', 'o', 'o', 'o', 'x', 'x', 'o', 'x', 'o']
+        ai.move(board: board).should == 0
+      end
+    end
+
+    describe "#set_max_ply" do
+      it "returns 3 when number of available moves > 15" do
+        ai.set_max_ply(16).should == 3
+      end
+
+      it "returns 5 when number of available moves > 5 && < 15" do
+        ai.set_max_ply(14).should == 5
+      end
+
+      it "returns 7 when the number of available moves < 5" do
+        ai.set_max_ply(3).should == 7
+      end
+    end
+  end
+end