ruby_ttt 0.3.1 → 0.3.2

data/lib/ai.rb

@@ -1,70 +1,72 @@
-POS_INF = 999
-NEG_INF = -999
-WIN = 1
-LOSE = -1
-TIE = 0
+module RubyTictactoe
 
-class AI
-  attr_reader :current_player
-  def initialize(player)
-    @current_player = player
-  end
+  class AI
+    POS_INF = 999
+    NEG_INF = -999
+    WIN = 1
+    LOSE = -1
+    TIE = 0
+    attr_reader :current_player
+    def initialize(player)
+      @current_player = player
+    end
 
-  def computer_move(board, player)
-    test_board = board.dup
-    test_board.all_cells = board.all_cells.dup
-    get_best_move(test_board, player)
-  end
+    def computer_move(board, player)
+      test_board = board.dup
+      test_board.all_cells = board.all_cells.dup
+      get_best_move(test_board, player)
+    end
 
-  def get_best_move(board, player)
-    ranked_moves = rank_possible_moves(board, player)
-    move = ranked_moves.max_by {|cell, score| score}
-    move.first
-  end
+    def get_best_move(board, player)
+      ranked_moves = rank_possible_moves(board, player)
+      move = ranked_moves.max_by {|cell, score| score}
+      move.first
+    end
 
-  private
+    private
 
-  def rank_possible_moves(board, player)
-    possible_moves = board.open_cells
-    possible_moves.each_key do |cell|
-      possible_moves[cell] = get_move_score(board, player, cell)
+    def rank_possible_moves(board, player)
+      possible_moves = board.open_cells
+      possible_moves.each_key do |cell|
+        possible_moves[cell] = get_move_score(board, player, cell)
+      end
     end
-  end
 
-  def get_move_score(board, player, cell)
-    player.add_marker(board, cell)
-    best_score = apply_minimax(board, player, cell, depth=0, NEG_INF, POS_INF)
-    board.remove_marker(cell)
-    best_score
-  end
+    def get_move_score(board, player, cell)
+      player.add_marker(board, cell)
+      best_score = apply_minimax(board, player, cell, depth=0, NEG_INF, POS_INF)
+      board.remove_marker(cell)
+      best_score
+    end
 
-  def get_score(board, player)
-    return WIN if board.winner?(player.marker) && (player == current_player)
-    return LOSE if board.winner?(player.marker)
-    TIE
-  end
+    def get_score(board, player)
+      return WIN if board.winner?(player.marker) && (player == current_player)
+      return LOSE if board.winner?(player.marker)
+      TIE
+    end
 
-  def apply_minimax(board, player, cell, depth, alpha, beta)
-    return get_score(board, player) if board.game_over?
-    if (player == current_player)
-      maximizing_player = MaximizingPlayer.new(player)
-      alphabeta(board, maximizing_player, depth, alpha, beta)
-    else
-      minimizing_player = MinimizingPlayer.new(player)
-      alphabeta(board, minimizing_player, depth, alpha, beta)
+    def apply_minimax(board, player, cell, depth, alpha, beta)
+      return get_score(board, player) if board.game_over?
+      if (player == current_player)
+        maximizing_player = MaximizingPlayer.new(player)
+        alphabeta(board, maximizing_player, depth, alpha, beta)
+      else
+        minimizing_player = MinimizingPlayer.new(player)
+        alphabeta(board, minimizing_player, depth, alpha, beta)
+      end
     end
-  end
 
-  def alphabeta(board, player, depth, alpha, beta)
-    board.open_cells.each_key do |cell|
-      player.opponent.add_marker(board, cell)
-      score = (apply_minimax(board, player.opponent, cell, depth += 1, alpha, beta) / depth.to_f)
-      alpha = player.get_alpha(alpha, score)
-      beta = player.get_beta(beta, score)
-      board.remove_marker(cell)
-      break if alpha >= beta
+    def alphabeta(board, player, depth, alpha, beta)
+      board.open_cells.each_key do |cell|
+        player.opponent.add_marker(board, cell)
+        score = (apply_minimax(board, player.opponent, cell, depth += 1, alpha, beta) / depth.to_f)
+        alpha = player.get_alpha(alpha, score)
+        beta = player.get_beta(beta, score)
+        board.remove_marker(cell)
+        break if alpha >= beta
+      end
+      player.return_best_score(alpha, beta)
     end
-    player.return_best_score(alpha, beta)
   end
 
 end

data/lib/alpha_beta_player.rb

@@ -0,0 +1,39 @@
+module RubyTictactoe
+
+  class AlphaBetaPlayer
+    attr_accessor :marker, :opponent
+    def initialize(player)
+      @marker = player.marker
+      @opponent = player.opponent
+    end
+
+    def get_alpha(alpha, score)
+      alpha
+    end
+
+    def get_beta(beta, score)
+      beta
+    end
+  end
+
+  class MinimizingPlayer < AlphaBetaPlayer
+    def get_alpha(alpha, score)
+      score > alpha ? score : alpha
+    end
+
+    def return_best_score(alpha, beta)
+      alpha
+    end
+  end
+
+  class MaximizingPlayer < AlphaBetaPlayer
+    def get_beta(beta, score)
+      score < beta ? score : beta
+    end
+
+    def return_best_score(alpha, beta)
+      beta
+    end
+  end
+
+end

data/lib/board.rb

@@ -1,220 +1,150 @@
-MARKER_X = 'X'
-MARKER_O = 'O'
-
-class Board
-  attr_accessor :all_cells, :num_of_rows, :winning_lines
-  def initialize(num_of_rows)
-    @num_of_rows = num_of_rows
-    @all_cells = create_board_hash
-    @winning_lines = get_winning_lines
-  end
+require 'tictactoe_constants'
+
+module RubyTictactoe
 
-  def create_board_hash
-    new_board = Hash.new
-    alpha = 'A'
-    numeric = 1
-    num_of_rows.times do
+  class Board
+    include TictactoeConstants
+    attr_accessor :all_cells, :num_of_rows, :winning_lines
+    def initialize(num_of_rows)
+      @num_of_rows = num_of_rows
+      @all_cells = create_board_hash
+      @winning_lines = get_winning_lines
+    end
+
+    def create_board_hash
+      new_board = Hash.new
+      alpha = 'A'
+      numeric = 1
       num_of_rows.times do
-        cellID = numeric.to_s + alpha
-        numeric += 1
-        new_board[cellID] = nil
+        num_of_rows.times do
+          cellID = numeric.to_s + alpha
+          numeric += 1
+          new_board[cellID] = nil
+        end
+        alpha = alpha.next
+        numeric = 1
       end
-      alpha = alpha.next
-      numeric = 1
+      new_board
     end
-    new_board
-  end
 
-  def get_winning_lines
-    lines = []
-    all_rows.each { |row| lines << row }
-    all_cols.each { |col| lines << col }
-    diagonals.each { |diagonal| lines << diagonal }
-    lines
-  end
-
-  def all_rows
-    rows = []
-    cellIDs = all_cells.keys
-    beg = 0
-    ending  = num_of_rows - 1
-    until rows.length == num_of_rows
-      rows << cellIDs[beg..ending]
-      beg += num_of_rows
-      ending += num_of_rows
-    end
-    rows
-  end
-
-  def add_test_marker(marker, cell)
-    all_cells[cell] = marker
-  end
-
-  def available_cell?(cell)
-    valid_cell?(cell) && all_cells[cell].nil?
-  end
-
-  def valid_cell?(cell)
-    all_cells.has_key?(cell)
-  end
-
-  def remove_marker(cell)
-    all_cells[cell] = nil
-  end
-
-  def moves_remaining?
-    all_cells.has_value?(nil)
-  end
-
-  def winner?(marker)
-    board_markers = all_cells.select { |cell, value| value == marker }.keys
-    winning_lines.each do |line|
-      return true if (line & board_markers).length == num_of_rows
+    def get_winning_lines
+      lines = []
+      all_rows.each { |row| lines << row }
+      all_cols.each { |col| lines << col }
+      diagonals.each { |diagonal| lines << diagonal }
+      lines
     end
-    false
-  end
-
-  def game_over?
-    !moves_remaining? || winner?(MARKER_X) || winner?(MARKER_O)
-  end
 
-  def open_cells
-    all_cells.select { |k,v| v.nil? }
-  end
-
-  def empty?
-    open_cells.length == (num_of_rows * num_of_rows)
-  end
-
-  def random_cell
-    cells = open_cells.keys
-    cells_count = cells.length - 1
-    cells[rand(cells_count)]
-  end
-
-  private
-  def all_cols
-    cols = []
-    index = 0
-    num_of_rows.times do
-      cols << get_column(index)
-      index += 1
+    def all_rows
+      rows = []
+      cellIDs = all_cells.keys
+      beg = 0
+      ending  = num_of_rows - 1
+      until rows.length == num_of_rows
+        rows << cellIDs[beg..ending]
+        beg += num_of_rows
+        ending += num_of_rows
+      end
+      rows
     end
-    cols
-  end
 
-  def get_column(index)
-    column = []
-    cellIDs = all_cells.keys
-    num_of_rows.times do
-      column << cellIDs[index]
-      index += num_of_rows
+    def add_test_marker(marker, cell)
+      all_cells[cell] = marker
     end
-    column
-  end
-
-  def diagonals
-    diagonals = []
-    diagonals << diagonal_one
-    diagonals << diagonal_two
-  end
 
-  def diagonal_one
-    diagonal = []
-    alpha = 'A'
-    numeric = 1
-    num_of_rows.times do
-      diagonal << numeric.to_s + alpha
-      alpha = alpha.next
-      numeric += 1
+    def available_cell?(cell)
+      valid_cell?(cell) && all_cells[cell].nil?
     end
-    diagonal
-  end
 
-  def diagonal_two
-    diagonal = []
-    alpha = 'A'
-    numeric = num_of_rows
-    num_of_rows.times do
-      diagonal << numeric.to_s + alpha
-      alpha = alpha.next
-      numeric -= 1
+    def valid_cell?(cell)
+      all_cells.has_key?(cell)
     end
-    diagonal
-  end
 
-end
+    def remove_marker(cell)
+      all_cells[cell] = nil
+    end
 
-class CLIBoard < Board
-  attr_accessor :all_cells, :num_of_rows, :winning_lines, :io
-  def initialize(num_of_rows)
-    super
-    @io = Kernel
-  end
+    def moves_remaining?
+      all_cells.has_value?(nil)
+    end
 
-  def print_board_numbers
-    num = 1
-    io.print "    "
-    num_of_rows.times do
-      io.print "--#{num}-- "
-      num += 1
+    def winner?(marker)
+      board_markers = all_cells.select { |cell, value| value == marker }.keys
+      winning_lines.each do |line|
+        return true if (line & board_markers).length == num_of_rows
+      end
+      false
     end
-    io.print "\n"
-  end
 
-  def print_divider
-    io.print "   "
-    num_of_rows.times { io.print "------" }
-    io.print "\n"
-  end
+    def game_over?
+      !moves_remaining? || winner?(RubyTictactoe::TictactoeConstants::MARKER_X) || winner?(RubyTictactoe::TictactoeConstants::MARKER_O)
+    end
 
-  def print_board_rows
-    alpha = 'A'
-    all_rows.each do |row|
-      show_row(alpha, row)
-      alpha = alpha.next
+    def open_cells
+      all_cells.select { |k,v| v.nil? }
     end
-  end
 
-  def show_row(letter, cells)
-    io.print "#{letter}"
-    cells.each { |cell| io.print "  |  " + show_marker(cell) }
-    io.print "  | #{letter}\n"
-    print_divider
-  end
+    def empty?
+      open_cells.length == (num_of_rows * num_of_rows)
+    end
 
-  def show_marker(cell)
-    all_cells[cell].nil? ? ' ' : all_cells[cell]
-  end
+    def random_cell
+      cells = open_cells.keys
+      cells_count = cells.length - 1
+      cells[rand(cells_count)]
+    end
 
-  def display_board
-    print_board_numbers
-    print_board_rows
-    print_board_numbers
-  end
+    private
+    def all_cols
+      cols = []
+      index = 0
+      num_of_rows.times do
+        cols << get_column(index)
+        index += 1
+      end
+      cols
+    end
 
-end
+    def get_column(index)
+      column = []
+      cellIDs = all_cells.keys
+      num_of_rows.times do
+        column << cellIDs[index]
+        index += num_of_rows
+      end
+      column
+    end
 
-class WebBoard < Board
+    def diagonals
+      diagonals = []
+      diagonals << diagonal_one
+      diagonals << diagonal_two
+    end
 
-  def print_active_board
-    board_string = ''
-    all_rows.each do |row|
-      board_string += "<div class='row'>"
-      row.each { |cell| board_string += "<button name='move' value='#{cell}'> #{all_cells[cell]} <span class='cell'>.</span></button>" }
-      board_string += "</div>"
+    def diagonal_one
+      diagonal = []
+      alpha = 'A'
+      numeric = 1
+      num_of_rows.times do
+        diagonal << numeric.to_s + alpha
+        alpha = alpha.next
+        numeric += 1
+      end
+      diagonal
     end
-    board_string
-  end
 
-  def print_inactive_board
-    board_string = ''
-    all_rows.each do |row|
-      board_string += "<div class='row'>"
-      row.each { |cell| board_string += "<button> #{all_cells[cell]} <span class='cell'>.</span></button>" }
-      board_string += "</div>"
+    def diagonal_two
+      diagonal = []
+      alpha = 'A'
+      numeric = num_of_rows
+      num_of_rows.times do
+        diagonal << numeric.to_s + alpha
+        alpha = alpha.next
+        numeric -= 1
+      end
+      diagonal
     end
-    board_string
+
   end
 
 end

data/lib/game.rb

@@ -0,0 +1,49 @@
+module RubyTictactoe
+
+  class Game
+    include TictactoeConstants
+    attr_accessor :board, :player_one, :player_two, :ui, :player_first_move
+    def initialize(settings)
+      @board = settings[:board]
+      @player_one = settings[:player_one]
+      @player_two = settings[:player_two]
+      @player_first_move = settings[:player_first_move]
+      @ui = UI.new
+    end
+
+    def advance_game
+      game_status_check(current_player.opponent.marker)
+      ui.next_move_message(current_player.marker) unless board.game_over?
+    end
+
+    def game_status_check(marker)
+      if board.winner?(marker)
+        ui.winning_game_message(marker)
+      elsif !board.moves_remaining?
+        ui.tie_game_message
+      end
+    end
+
+    def verify_move(cell)
+      return false if !board.available_cell?(cell)
+      current_player.add_marker(board, cell)
+      true
+    end
+
+    def current_player
+      if total_markers(MARKER_X) > total_markers(MARKER_O)
+        player_two
+      elsif total_markers(MARKER_O) > total_markers(MARKER_X)
+        player_one
+      else
+        player_first_move
+      end
+    end
+
+    def total_markers(marker)
+      board.all_cells.select { |cell, value| value == marker }.count
+    end
+
+  end
+
+end

data/lib/game_setup.rb

@@ -1,116 +1,17 @@
-COMPUTER_PLAYER = 'computer'
-HUMAN_PLAYER = 'human'
-AI_PLAYER = 'hard computer'
-HARD_LEVEL = 'hard'
-EASY_LEVEL = 'easy'
+require 'tictactoe_constants'
 
-class GameSetup
-  attr_accessor :ui
-  def initialize
-    @ui = UI.new
-  end
-
-  def get_settings
-    {}
-  end
-end
-
-class CLIGameSetup < GameSetup
-  attr_accessor :ui
-  def initialize
-    @ui = CLIUI.new
-  end
+module RubyTictactoe
 
-  def get_settings
-    settings = super
-    begin
-      players = set_up_players
-      settings[:board] = get_board
-      settings[:player_one] = players.player_one
-      settings[:player_two] = players.player_two
-      settings[:player_first_move] = players.player_goes_first
-      settings
-    rescue Interrupt
-      ui.early_exit_message
-      exit
+  class GameSetup
+    include TictactoeConstants
+    attr_accessor :ui
+    def initialize
+      @ui = UI.new
     end
-  end
-
-  def set_up_players
-    player_one_type = get_player_type(MARKER_X)
-    player_two_type = get_player_type(MARKER_O)
-    PlayerFactory.new(player_one_type, player_two_type)
-  end
-
-  def get_player_type(marker)
-    type = ui.request_player_type(marker)
-    validated_type = valid_type?(type) ? get_difficulty_level(type) : invalid_type(type, marker)
-    ui.type_assigned_message(validated_type, marker)
-    validated_type
-  end
-
-  def get_difficulty_level(type)
-    return type if type == HUMAN_PLAYER
-    level = ui.request_difficulty_level
-    valid_level?(level) ? ui.level_assigned_message(level) : invalid_level(level)
-    player_type_by_level(level)
-  end
-
-  def valid_type?(type)
-    (type == HUMAN_PLAYER) || (type == COMPUTER_PLAYER)
-  end
-
-  def invalid_type(type, marker)
-    ui.invalid_input_message(type)
-    get_player_type(marker)
-  end
-
-  def valid_level?(level)
-    (level == HARD_LEVEL) || (level == EASY_LEVEL)
-  end
 
-  def invalid_level(level)
-    ui.invalid_input_message(level)
-    get_difficulty_level(COMPUTER_PLAYER)
-  end
-
-  def player_type_by_level(level)
-    level == HARD_LEVEL ? AI_PLAYER : COMPUTER_PLAYER
-  end
-
-  def get_board
-    rows = ui.request_board_size
-    valid_board_size?(rows) ? ui.board_assigned_message(rows) : invalid_board_size(rows)
-    CLIBoard.new(rows.to_i)
-  end
-
-  def valid_board_size?(input)
-    rows = input.to_i
-    rows.is_a?(Integer) && (rows > 2 && rows < 6)
-  end
-
-  def invalid_board_size(rows)
-    ui.invalid_input_message(rows)
-    get_board
-  end
-
-end
-
-class WebGameSetup < GameSetup
-
-  def set_up_players(player_one_type, player_two_type)
-    PlayerFactory.new(player_one_type, player_two_type)
-  end
-
-  def get_first_move_player(player_one_type, player_two_type)
-    players = PlayerFactory.new(player_one_type, player_two_type)
-    players.player_goes_first
-  end
-
-  def get_board(board_size, current_board)
-    board = WebBoard.new(board_size)
-    board.all_cells = current_board
-    board
+    def get_settings
+      {}
+    end
   end
 
 end

data/lib/player.rb

@@ -1,73 +1,36 @@
-class Player
-  attr_accessor :marker, :opponent
-  def initialize(marker)
-    @marker = marker
-    @opponent = nil
-  end
-
-  def add_marker(board, cell)
-    board.all_cells[cell] = self.marker
-  end
-
-  def get_alpha(alpha, score)
-    alpha
-  end
-
-  def get_beta(beta, score)
-    beta
-  end
-end
-
-class AIPlayer < Player
-
-  def make_move(board)
-    ai = AI.new(self)
-    cell = ai.computer_move(board, self)
-    add_marker(board, cell)
-  end
-
-end
+module RubyTictactoe
 
-class ComputerPlayer < Player
+  class Player
+    attr_accessor :marker, :opponent
+    def initialize(marker)
+      @marker = marker
+      @opponent = nil
+    end
 
-  def make_move(board)
-    cell = board.random_cell
-    add_marker(board, cell)
+    def add_marker(board, cell)
+      board.all_cells[cell] = self.marker
+    end
   end
 
-end
+  class AIPlayer < Player
 
-class HumanPlayer < Player; end
+    def make_move(board)
+      ai = AI.new(self)
+      cell = ai.computer_move(board, self)
+      add_marker(board, cell)
+    end
 
-class MinimizingPlayer < Player
-  attr_accessor :marker, :opponent
-  def initialize(player)
-    @marker = player.marker
-    @opponent = player.opponent
   end
 
-  def get_alpha(alpha, score)
-    score > alpha ? score : alpha
-  end
+  class ComputerPlayer < Player
 
-  def return_best_score(alpha, beta)
-    alpha
-  end
-end
+    def make_move(board)
+      cell = board.random_cell
+      add_marker(board, cell)
+    end
 
-class MaximizingPlayer < Player
-  attr_accessor :marker, :opponent
-  def initialize(player)
-    @marker = player.marker
-    @opponent = player.opponent
   end
 
-  def get_beta(beta, score)
-    score < beta ? score : beta
-  end
+  class HumanPlayer < Player; end
 
-  def return_best_score(alpha, beta)
-    beta
-  end
 end
-

data/lib/player_factory.rb

@@ -1,31 +1,37 @@
-class PlayerFactory
-  attr_accessor :player_one, :player_two
-  def initialize(type_one, type_two)
-    @player_one = create_player(type_one, MARKER_X)
-    @player_two = create_player(type_two, MARKER_O)
-    set_opponents
-  end
+require 'tictactoe_constants'
+
+module RubyTictactoe
 
-  def create_player(type, marker)
-    case type
-    when COMPUTER_PLAYER
-      ComputerPlayer.new(marker)
-    when HUMAN_PLAYER
-      HumanPlayer.new(marker)
-    when AI_PLAYER
-      AIPlayer.new(marker)
-    else
-      raise "Invalid player type"
+  class PlayerFactory
+    include TictactoeConstants
+    attr_accessor :player_one, :player_two
+    def initialize(type_one, type_two)
+      @player_one = create_player(type_one, MARKER_X)
+      @player_two = create_player(type_two, MARKER_O)
+      set_opponents
     end
-  end
 
-  def player_goes_first
-    rand(0..1) == 1 ? player_one : player_two
-  end
+    def create_player(type, marker)
+      case type
+      when COMPUTER_PLAYER
+        ComputerPlayer.new(marker)
+      when HUMAN_PLAYER
+        HumanPlayer.new(marker)
+      when AI_PLAYER
+        AIPlayer.new(marker)
+      else
+        raise "Invalid player type"
+      end
+    end
+
+    def player_goes_first
+      rand(0..1) == 1 ? player_one : player_two
+    end
 
-  def set_opponents
-    player_one.opponent = player_two
-    player_two.opponent = player_one
+    def set_opponents
+      player_one.opponent = player_two
+      player_two.opponent = player_one
+    end
   end
 
 end

data/lib/tictactoe_constants.rb

@@ -0,0 +1,11 @@
+module RubyTictactoe
+  module TictactoeConstants
+    MARKER_X = 'X'
+    MARKER_O = 'O'
+    COMPUTER_PLAYER = 'computer'
+    HUMAN_PLAYER = 'human'
+    AI_PLAYER = 'hard computer'
+    HARD_LEVEL = 'hard'
+    EASY_LEVEL = 'easy'
+  end
+end

data/lib/ui.rb

@@ -1,112 +1,27 @@
-class UI
-  attr_accessor :io
-  def initialize
-    @io = Kernel
-  end
-
-  def first_move_message(marker)
-    "Player '#{marker}' goes first."
-  end
-
-  def next_move_message(marker)
-    "Player '#{marker}': Make your move."
-  end
-
-  def winning_game_message(marker)
-    "GAME OVER! Player '#{marker}' wins!"
-  end
-
-  def tie_game_message
-    "GAME OVER! It's a tie!"
-  end
-
-end
-
-class CLIUI < UI
-
-  def request_player_type(marker)
-    player_type_message(marker)
-    io.gets.chomp.downcase
-  end
-
-  def request_difficulty_level
-    difficulty_level_message
-    io.gets.chomp.downcase
-  end
-
-  def request_board_size
-    board_size_message
-    io.gets.chomp.downcase
-  end
-
-  def request_human_move
-    standardize(io.gets.chomp)
-  end
-
-  def standardize(input)
-    input.split('').sort.join('').upcase
-  end
+module RubyTictactoe
 
-  def difficulty_level_message
-    io.print "Select computer difficulty level: Enter 'easy' or 'hard.'\n"
-  end
-
-  def board_size_message
-    io.print "Enter the number of rows you want your board to have (3-5).\n"
-  end
+  class UI
+    attr_accessor :io
+    def initialize
+      @io = Kernel
+    end
 
-  def level_assigned_message(level)
-    io.print "You selected difficulty level #{level.upcase}.\n"
-  end
+    def first_move_message(marker)
+      "Player '#{marker}' goes first."
+    end
 
-  def board_assigned_message(rows)
-    io.print "You selected a board with #{rows} rows.\n"
-  end
+    def next_move_message(marker)
+      "Player '#{marker}': Make your move."
+    end
 
-  def invalid_input_message(input)
-    io.print "#{input} is not a valid option.\n"
-  end
+    def winning_game_message(marker)
+      "GAME OVER! Player '#{marker}' wins!"
+    end
 
-  def player_type_message(marker)
-    io.print "For player " + "'#{marker}'," + " enter 'human' or 'computer.'\n"
-  end
-
-  def type_assigned_message(type, marker)
-    io.print "Player " + "'#{marker}' " + "is #{type}.\n"
-  end
-
-  def first_move_message(marker)
-    output = super
-    io.print "\n\n************ New Game ************\n"
-    io.print output + "\n"
-  end
-
-  def next_move_message(marker)
-    io.print "Player '#{marker}': Enter open cell ID.\n"
-  end
-
-  def winning_game_message(marker)
-    output = super
-    io.print output + "\n"
-  end
-
-  def tie_game_message
-    output = super
-    io.print output + "\n"
-  end
-
-  def taken_cell_message(cell)
-    io.print "#{cell} has already been taken!\n"
-  end
-
-  def bad_cell_message(cell)
-    io.print "#{cell} is not a valid cell ID!\n"
-  end
+    def tie_game_message
+      "GAME OVER! It's a tie!"
+    end
 
-  def early_exit_message
-    io.print "\nExiting Tic-Tac-Toe..."
-    io.print "...\n"
-    io.print "Goodbye!\n\n"
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_ttt
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-26 00:00:00.000000000 Z
+date: 2013-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -36,11 +36,13 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/ai.rb
+- lib/alpha_beta_player.rb
 - lib/board.rb
+- lib/game.rb
 - lib/game_setup.rb
 - lib/player.rb
 - lib/player_factory.rb
-- lib/ruby_ttt.rb
+- lib/tictactoe_constants.rb
 - lib/ui.rb
 homepage: http://rubygems.org/gems/ruby_ttt
 licenses: []

data/lib/ruby_ttt.rb

@@ -1,125 +0,0 @@
-require 'ai'
-require 'board'
-require 'player_factory'
-require 'game_setup'
-require 'player'
-require 'ui'
-
-class Game
-  attr_accessor :board, :player_one, :player_two, :ui, :player_first_move
-  def initialize(settings)
-    @board = settings[:board]
-    @player_one = settings[:player_one]
-    @player_two = settings[:player_two]
-    @player_first_move = settings[:player_first_move]
-    @ui = UI.new
-  end
-
-  def advance_game
-    game_status_check(current_player.opponent.marker)
-    ui.next_move_message(current_player.marker) unless board.game_over?
-  end
-
-  def game_status_check(marker)
-    if board.winner?(marker)
-      ui.winning_game_message(marker)
-    elsif !board.moves_remaining?
-      ui.tie_game_message
-    end
-  end
-
-  def verify_move(cell)
-    return false if !board.available_cell?(cell)
-    current_player.add_marker(board, cell)
-    true
-  end
-
-  def current_player
-    if total_markers(MARKER_X) > total_markers(MARKER_O)
-      player_two
-    elsif total_markers(MARKER_O) > total_markers(MARKER_X)
-      player_one
-    else
-      player_first_move
-    end
-  end
-
-  def total_markers(marker)
-    board.all_cells.select { |cell, value| value == marker }.count
-  end
-
-end
-
-class CLIGame < Game
-  attr_accessor :board, :player_one, :player_two, :ui, :player_first_move
-  def initialize(settings)
-    super
-    @ui = CLIUI.new
-  end
-
-  def start_game!
-    begin
-      play!
-    rescue Interrupt
-      ui.early_exit_message
-      exit
-    end
-  end
-
-  def play!
-    ui.first_move_message(current_player.marker)
-    until board.game_over?
-      board.display_board
-      get_next_move
-    end
-    exit_game
-  end
-
-  def get_next_move
-    if current_player.is_a?(HumanPlayer)
-      move = ui.request_human_move
-      verify_move(move) ? advance_game : invalid_move(move)
-    else
-      current_player.make_move(board)
-      advance_game
-    end
-  end
-
-  def invalid_move(cell)
-    board.valid_cell?(cell) ? ui.taken_cell_message(cell) : ui.bad_cell_message(cell)
-  end
-
-  def exit_game
-    board.display_board
-    ui.io.exit
-  end
-
-end
-
-class WebGame < Game
-  attr_accessor :board, :player_one, :player_two, :ui, :player_first_move
-  def initialize(settings)
-    super
-    @ui = UI.new
-  end
-
-  def get_message(player)
-    return ui.first_move_message(player.marker) if board.empty?
-    if board.winner?(current_player.opponent.marker)
-      ui.winning_game_message(current_player.opponent.marker)
-    elsif !board.moves_remaining?
-      ui.tie_game_message
-    else
-      ui.next_move_message(current_player.marker)
-    end
-  end
-
-  def get_first_move_player(type_one, type_two)
-    PlayerFactory.new(type_one, type_two).player_goes_first
-  end
-
-  def computer_player?(type_one, type_two)
-    ((type_one.downcase) == COMPUTER_PLAYER) || ((type_two.downcase) == COMPUTER_PLAYER)
-  end
-
-end