bashrw-ttt 0.1.1

data/bin/play.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path("../../lib/ttt/interfaces/cli/lib", __FILE__)
+require 'ttt/setup'
+require 'ttt/context'
+require 'cli/cli_game'
+
+context       = TTT::Context.instance
+context.setup = TTT::Setup
+CLI::CLIGame.new(context, $stdin, $stdout).play

data/lib/bashrw-ttt.rb

@@ -0,0 +1,3 @@
+Dir.glob(File.expand_path "../ttt/*.rb", __FILE__) do |file|
+  require file
+end

data/lib/ttt/ai.rb

@@ -0,0 +1,33 @@
+require 'ttt/player'
+require 'ttt/minimax'
+
+module TTT
+  class AI < Player
+    include Minimax
+    attr_accessor :board, :max_ply
+
+    def move(options)
+      self.board = (options[:board].dup)
+    end
+
+    def opposite_side(side)
+      side == "x" ? "o" : "x"
+    end
+
+    def available_moves
+      board[].each.with_index.map { |element, index| index if element == " " }.compact
+    end
+
+    def undo_move(index)
+      board[][index] = " "
+    end
+
+    def no_gui?
+      true
+    end
+
+    def prompt
+      "Computer thinking."
+    end
+  end
+end

data/lib/ttt/ai_easy.rb

@@ -0,0 +1,17 @@
+require 'ttt/ai'
+module TTT
+  class AIEasy < AI
+    def move(options)
+      super
+      random_move
+    end
+
+    def random_move
+      move = nil
+      available_moves.each do |square|
+        move ||= square if Time.new.usec % 3 == 0
+      end
+      return(move ? move : available_moves.last)
+    end
+  end
+end

data/lib/ttt/ai_hard.rb

@@ -0,0 +1,21 @@
+require 'ttt/ai'
+module TTT
+  class AIHard < AI
+
+    def move(options)
+      super
+      self.max_ply = max_ply_for(available_moves.length)
+      minimax
+    end
+
+    def max_ply_for(moves)
+      if moves > 16
+        return 7
+      elsif moves > 10
+        return 9
+      else
+        return 11
+      end
+    end
+  end
+end

data/lib/ttt/ai_medium.rb

@@ -0,0 +1,21 @@
+require 'ttt/ai'
+module TTT
+  class AIMedium < AI
+
+    def move(options)
+      super
+      self.max_ply = set_max_ply(available_moves.length)
+      minimax
+    end
+
+    def set_max_ply(moves)
+      if moves > 15
+       return 3
+      elsif moves > 5
+       return 5
+      else
+       return 7
+      end
+    end
+  end
+end

data/lib/ttt/ai_medium_back.rb

@@ -0,0 +1,58 @@
+require 'ttt/ai'
+module TTT
+  class AIMedium < AI
+    attr_accessor :max_ply, :best
+
+    def move(options)
+      board(options[:board].dup)
+      self.max_ply = set_max_ply(available_moves.length)
+      self.best    = {}
+      self.best[:index] = nil
+      self.best[:score] = 0
+      minimax
+    end
+
+    def minimax(max_player = true, ply = 0, min_score = 1000, max_score = -1000)
+      if board.winner?
+        return(max_player ? (-1000 + ply) : (1000 - ply))
+      elsif board.draw_game?
+        return 0
+      end
+
+      if ply >= max_ply
+        return(max_player ? (max_score) : (min_score))
+      end
+
+      best_move = 0
+      score = (max_player ? max_score : min_score )
+      available_moves.each do |index|
+        board[][index] = ( max_player ? side : opposite_side(side) )
+        score          = minimax(!max_player, ply + 1, min_score, max_score)
+        undo_move(index)
+        if max_player && score > max_score
+          max_score  = score
+          best_move  = index
+        elsif !max_player && score < min_score
+          min_score  = score
+        end
+        break if max_min_swapped?(max_score, min_score)
+      end
+
+      return( ply == 0 ? best_move : ( max_player ? max_score : min_score ) )
+    end
+
+    def set_max_ply(moves)
+      if moves > 15
+       return 3
+      elsif moves > 5
+       return 5
+      else
+       return 7
+      end
+    end
+
+    def max_min_swapped?(max, min)
+      max >= min
+    end
+  end
+end

data/lib/ttt/board.rb

@@ -0,0 +1,37 @@
+module TTT
+  class Board
+    attr_accessor :board
+
+    def []
+      board
+    end
+
+    def []=(array)
+      self.board = array
+    end
+
+    def update cell, side
+      self.board[cell.to_i] = side
+    end
+
+    def empty?
+      !(board.include?("x") || board.include?("o"))
+    end
+
+    def full?
+      !board.include?(" ")
+    end
+
+    def free?(cell)
+      board[cell] == " "
+    end
+
+    def finished?
+      draw_game? || winner?
+    end
+
+    def draw_game?
+      (!board.include? " ") && !winner?
+    end
+  end
+end

data/lib/ttt/config_helper.rb

@@ -0,0 +1,53 @@
+require 'ttt/config_options'
+
+module TTT
+  class ConfigHelper
+    def self.player_types
+      ConfigOptions::HUMAN_READABLE_PLAYERS
+    end
+
+    def self.board_types
+      ConfigOptions::HUMAN_READABLE_BOARDS
+    end
+
+    def self.bucket
+      ConfigOptions::BUCKET
+    end
+
+    def self.port
+      ConfigOptions::PORT
+    end
+
+    def self.http_backend
+      ConfigOptions::HTTP_BACKEND
+    end
+
+    def self.get_player_const(player_type)
+      ConfigOptions::PLAYERS[get_player_index(player_type)]
+    end
+
+    def self.get_board_const(board_type)
+      ConfigOptions::BOARDS[get_board_index(board_type)]
+    end
+
+    def self.get_player_index(player_type)
+      ConfigOptions::HUMAN_READABLE_PLAYERS.index(player_type)
+    end
+
+    def self.get_board_index(board_type)
+      ConfigOptions::HUMAN_READABLE_BOARDS.index(board_type)
+    end
+
+    def self.get_db_const
+      ConfigOptions::DB
+    end
+
+    def self.get_history_const
+      ConfigOptions::HISTORY
+    end
+
+    def self.get_game_interactor_const
+      ConfigOptions::INTERACTOR
+    end
+  end
+end

data/lib/ttt/config_options.rb

@@ -0,0 +1,27 @@
+require 'ttt/ai'
+require 'ttt/ai_easy'
+require 'ttt/ai_medium'
+require 'ttt/ai_hard'
+require 'ttt/human'
+require 'ttt/board'
+require 'ttt/three_by_three'
+require 'ttt/four_by_four'
+require 'ttt/three_by_three_by_three'
+require 'ttt/game_history'
+require 'ttt/riak_db'
+require 'ttt/game_interactor'
+
+module TTT
+  class ConfigOptions
+    BOARDS                 = [TTT::ThreeByThree, TTT::FourByFour, TTT::ThreeByThreeByThree]
+    HUMAN_READABLE_BOARDS  = %w(3x3 4x4 3x3x3)
+    PLAYERS                = [TTT::Human, TTT::AIEasy, TTT::AIMedium, TTT::AIHard]
+    HUMAN_READABLE_PLAYERS = ["Human", "AI Easy", "AI Medium", "AI Hard"]
+    DB                     = TTT::RiakDB
+    PORT                   = 8091 # 8098 is default
+    HTTP_BACKEND           = :Excon
+    BUCKET                 = "ttt_games"
+    HISTORY                = TTT::GameHistory
+    INTERACTOR             = TTT::GameInteractor
+  end
+end

data/lib/ttt/context.rb

@@ -0,0 +1,214 @@
+require 'ttt/setup'
+
+module TTT
+  class Context
+    class << self
+      def instance
+        @instance ||= new
+      end
+
+      private :new
+   end
+
+    def setup=(setup_const)
+      @setup = setup_const.new
+    end
+
+    def setup
+      @setup
+    end
+
+    def players
+      @setup.players
+    end
+
+    def boards
+      @setup.boards
+    end
+
+    def create_game(player1, player2, board)
+      game = @setup.new_game(:player1 => player1, :player2 => player2, :board => board)
+      add_game(game)
+    end
+
+    def add_game(game)
+      game_interactor.add_game(game)
+    end
+
+    def get_game(id)
+      game_interactor.get_game(id)
+    end
+
+    def save_game(id, game)
+      game_interactor.save_game(id, game)
+    end
+
+    def game_list
+      game_interactor.game_list
+    end
+
+    def delete_game(id)
+      game_interactor.delete_game(id)
+    end
+
+    def update_game(id, move, side)
+      if game = db_instance.get_game(id)
+        game_interactor.update_game(game, move, side)
+        game_interactor.save_game(id, game)
+      else
+        nil
+      end
+    end
+
+    def ai_move?(id)
+      if game = db_instance.get_game(id)
+        game_interactor.ai_move?(game)
+      else
+        nil
+      end
+    end
+
+    def ai_move(id)
+      if game = game_interactor.get_game(id)
+        game_interactor.ai_move(id, game)
+      else
+        nil
+      end
+    end
+
+    def finished?(id)
+      if game = game_interactor.get_game(id)
+        game_interactor.finished?(game)
+      else
+        nil
+      end
+    end
+
+    def winner(id)
+      if game = game_interactor.get_game(id)
+        game_interactor.winner(game)
+      else
+        nil
+      end
+    end
+
+    def winner?(id)
+      if game = game_interactor.get_game(id)
+        game_interactor.winner?(game)
+      else
+        nil
+      end
+    end
+
+    def draw?(id)
+      if game = game_interactor.get_game(id)
+        game_interactor.draw?(game)
+      else
+        nil
+      end
+    end
+
+    def which_board(id)
+      if game = game_interactor.get_game(id)
+        game_interactor.which_board(game)
+      else
+        nil
+      end
+    end
+
+    def valid_move?(id, move)
+      if game = game_interactor.get_game(id)
+        game_interactor.valid_move?(game, move)
+      else
+        nil
+      end
+    end
+
+    def adjust_move_index(id, value)
+      if game = game_interactor.get_game(id)
+        game_interactor.adjust_move_index(game, value)
+        game_interactor.save_game(id, game)
+      else
+        nil
+      end
+    end
+
+    def get_history_board(id)
+      if game = game_interactor.get_game(id)
+        game_interactor.get_history_board(game)
+      else
+        nil
+      end
+    end
+
+    def get_move_traverser(id)
+      if game = game_interactor.get_game(id)
+        game_interactor.get_move_traverser(game)
+      else
+        nil
+      end
+    end
+
+    def save_move_traverser(id, move_traverser)
+      if game = game_interactor.get_game(id)
+        game_interactor.save_move_traverser(id, game, move_traverser)
+      end
+    end
+
+    def initialize_history(id)
+      if game = game_interactor.get_game(id)
+        game_interactor.initialize_history(game)
+        save_game(id, game)
+      else
+        nil
+      end
+    end
+
+    def get_history_length(id)
+      if game = game_interactor.get_game(id)
+        game_interactor.get_history_length(game)
+      end
+    end
+
+    def get_move_index(id)
+      if game = game_interactor.get_game(id)
+        game_interactor.get_move_index(game)
+      else
+        nil
+      end
+    end
+
+    def get_history(id)
+      if game = game_interactor.get_game(id)
+        game_interactor.get_history(game)
+      else
+        nil
+      end
+    end
+
+    def which_current_player?(id)
+      if game = game_interactor.get_game(id)
+        game_interactor.which_current_player?(game)
+      else
+        nil
+      end
+    end
+
+    def board(id)
+      if game = game_interactor.get_game(id)
+        game_interactor.board(game)
+      else
+        nil
+      end
+    end
+
+    private
+    def db_instance
+      @db_instance ||= @setup.new_db
+    end
+
+    def game_interactor
+      @game_interactor ||= @setup.new_interactor
+    end
+  end
+end

data/lib/ttt/four_by_four.rb

@@ -0,0 +1,62 @@
+require 'ttt/board'
+module TTT
+  class FourByFour < Board
+    attr_accessor :x_arr, :diag_arr, :block_arr
+    def initialize
+      self.board   = Array.new(16, " ")
+      self.x_arr   = [[0,1,2,3], [4,5,6,7], [8,9,10,11], [12,13,14,15]]
+      self.diag_arr = [[0, 5, 10, 15], [3, 6, 9, 12]]
+      self.block_arr = [[0,1,4,5], [1,2,5,6], [2,3,6,7], [4,5,8,9], [5,6,9,10], [6,7,10,11], [8,9,12,13], [9,10,13,14], [10,11,14,15]]
+    end
+
+    def winner?
+      horizontal_winner? || vertical_winner? || diag_winner? || block_winner?
+    end
+
+    def horizontal_winner?
+      x_arr.each do |x_win|
+        return true if board[x_win[0]] != " " &&
+                        board[x_win[0]] == board[x_win[1]] &&
+                        board[x_win[1]] == board[x_win[2]] &&
+                        board[x_win[2]] == board[x_win[3]]
+      end
+      false
+    end
+
+    def vertical_winner?
+      x_arr.transpose.each do |y_win|
+        return true if board[y_win[0]] != " " &&
+                        board[y_win[0]] == board[y_win[1]] &&
+                        board[y_win[1]] == board[y_win[2]] &&
+                        board[y_win[2]] == board[y_win[3]]
+      end
+      false
+    end
+
+    def diag_winner?
+      diag_arr.each do |diag_win|
+         return true if board[diag_win[0]] != " " &&
+                        board[diag_win[0]] == board[diag_win[1]] &&
+                        board[diag_win[1]] == board[diag_win[2]] &&
+                        board[diag_win[2]] == board[diag_win[3]]
+
+      end
+      false
+    end
+
+    def block_winner?
+      block_arr.each do |block_win|
+         return true if board[block_win[0]] != " " &&
+                        board[block_win[0]] == board[block_win[1]] &&
+                        board[block_win[1]] == board[block_win[2]] &&
+                        board[block_win[2]] == board[block_win[3]]
+
+      end
+      false
+    end
+
+    def board_type
+      "four_by_four"
+    end
+  end
+end

data/lib/ttt/game.rb

@@ -0,0 +1,94 @@
+module TTT
+  class Game
+    attr_accessor :board, :player1, :player2, :current_player, :history, :db
+
+    def initialize(options)
+      self.board          = options[:board]
+      self.player1        = options[:player1]
+      self.player2        = options[:player2]
+      self.current_player = self.player1
+      self.history        = options.fetch(:history)
+    end
+
+    def ai_move?
+      current_player.no_gui?
+    end
+
+    def which_board
+      board.board_type
+    end
+
+    def next_move
+      return nil unless ai_move?
+      input = current_player.move(:board => board)
+      mark_move(input)
+      record_move(input)
+      switch_player
+      input
+    end
+
+    def valid_move?(input)
+      input.class == Fixnum && 0 <= input && input <= (board[].length - 1) && board.free?(input.to_i)
+    end
+
+    def mark_move(cell, side = current_player.side)
+      board.update(cell, side)
+    end
+
+    def record_move(cell, side = current_player.side)
+      history.record_move(cell, side)
+    end
+
+    def show_history
+      history.show
+    end
+
+    def adjust_move_index(index_diff)
+      history.adjust_move_index(index_diff)
+    end
+
+    def get_history_board(move_number_limit = history.move_traverser.move_index)
+      history.get_history_board(board, move_number_limit)
+    end
+
+    def initialize_history
+      history.initialize_history
+    end
+
+    def switch_player
+      if player1.side == current_player.side
+        self.current_player = self.player2
+      else
+        self.current_player = self.player1
+      end
+    end
+
+    def which_current_player?
+      current_player.equal?(player1) ? "Player 1" : "Player 2"
+    end
+
+    def last_player
+      current_player == player1 ? "Player 2" : "Player 1"
+    end
+
+    def finished?
+      board.finished?
+    end
+
+    def not_finished?
+      !board.finished?
+    end
+
+    def winner?
+      board.winner?
+    end
+
+    def draw?
+      board.draw_game?
+    end
+
+    def board_arr
+      board[]
+    end
+  end
+end

data/lib/ttt/game_history.rb

@@ -0,0 +1,37 @@
+require 'ttt/move_history'
+require 'ttt/move_traverser'
+
+module TTT
+  class GameHistory
+    attr_accessor :history, :move_traverser
+    def initialize
+      self.history         = []
+      self.move_traverser  = MoveTraverser.new(self)
+    end
+
+    def record_move(cell, side)
+      self.history << MoveHistory.new(:move => cell, :side => side)
+      inc_move_index
+    end
+
+    def inc_move_index
+      self.move_traverser.move_index = history.length
+    end
+
+    def show
+      self.history
+    end
+
+    def adjust_move_index(index_diff)
+      move_traverser.adjust_move_index(index_diff)
+    end
+
+    def get_history_board(board, move_number_limit = move_traverser.move_index)
+      move_traverser.history_board_builder(board, move_number_limit)
+    end
+
+    def initialize_history
+      move_traverser.initialize_history
+    end
+  end
+end