ruby_ttt 0.1.5 → 0.1.9

data/lib/ai.rb

@@ -5,6 +5,10 @@ LOSE = -1
 TIE = 0
 
 class AI
+  attr_reader :current_player
+  def initialize(player)
+    @current_player = player
+  end
 
   def computer_move(board, player)
     test_board = board.dup
@@ -28,39 +32,39 @@ class AI
   end
 
   def get_move_score(board, player, cell)
-    board.add_marker(player.marker, 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 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 = Maximizing.new(player)
+    if (player == current_player)
+      maximizing_player = MaximizingPlayer.new(player)
       alphabeta(board, maximizing_player, depth, alpha, beta)
     else
-      minimizing_player = Minimizing.new(player)
+      minimizing_player = MinimizingPlayer.new(player)
       alphabeta(board, minimizing_player, depth, alpha, beta)
     end
   end
 
   def alphabeta(board, player, depth, alpha, beta)
     board.open_cells.each_key do |cell|
-      board.add_marker(player.opponent.marker, 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_value(alpha, beta)
+    player.return_best_score(alpha, beta)
   end
 
 end

data/lib/board.rb

@@ -46,22 +46,10 @@ class Board
     rows
   end
 
-  def add_marker(marker, cell)
+  def add_test_marker(marker, cell)
     all_cells[cell] = marker
   end
 
-  def winner?(marker)
-    board_markers = all_cells.select { |k,v| v == marker }.keys
-    winning_lines.each do |line|
-      return true if (line & board_markers).length == num_of_rows
-    end
-    false
-  end
-
-  def game_over?
-    !moves_remaining? || winner?(MARKER_X)|| winner?(MARKER_O)
-  end
-
   def available_cell?(cell)
     valid_cell?(cell) && all_cells[cell].nil?
   end
@@ -78,6 +66,18 @@ class Board
     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
+    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
@@ -143,4 +143,78 @@ class Board
     diagonal
   end
 
+end
+
+class CLIBoard < Board
+  attr_accessor :all_cells, :num_of_rows, :winning_lines, :io
+  def initialize(num_of_rows)
+    super
+    @io = Kernel
+  end
+
+  def print_board_numbers
+    num = 1
+    io.print "    "
+    num_of_rows.times do
+      io.print "--#{num}-- "
+      num += 1
+    end
+    io.print "\n"
+  end
+
+  def print_divider
+    io.print "   "
+    num_of_rows.times { io.print "------" }
+    io.print "\n"
+  end
+
+  def print_board_rows
+    alpha = 'A'
+    all_rows.each do |row|
+      show_row(alpha, row)
+      alpha = alpha.next
+    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 show_marker(cell)
+    all_cells[cell].nil? ? ' ' : all_cells[cell]
+  end
+
+  def display_board
+    print_board_numbers
+    print_board_rows
+    print_board_numbers
+  end
+
+end
+
+class WebBoard < Board
+
+  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>"
+    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>"
+    end
+    board_string
+  end
+
 end

data/lib/game_setup.rb

@@ -0,0 +1,111 @@
+COMPUTER_PLAYER = 'computer'
+HUMAN_PLAYER = 'human'
+AI_PLAYER = 'hard computer'
+HARD_LEVEL = 'hard'
+EASY_LEVEL = 'easy'
+
+class GameSetup; end
+
+class CLIGameSetup < GameSetup
+  attr_accessor :ui
+  def initialize
+    @ui = CLIUI.new
+  end
+
+  def get_settings
+    settings = {}
+    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
+    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_board
+  #   board = Board.new(session[:board_size])
+  #   board.all_cells = session[:current_board]
+  # end
+
+  # def get_settings
+  #   settings = {}
+  #   players = set_up_players
+  #   settings[:board] = get_board
+  #   settings[:player_one] = players.player_one
+  #   settings[:player_two] = players.player_two
+  #   settings[:player_goes_first] = players.player_goes_first
+  #   settings
+  # end
+
+end

data/lib/player.rb

@@ -1,19 +1,12 @@
 class Player
-  attr_accessor :marker, :turn, :player_type, :opponent
+  attr_accessor :marker, :opponent
   def initialize(marker)
-    @marker      = marker
-    @player_type = 'human'
-    @turn        = 0
-    @opponent    = nil
+    @marker = marker
+    @opponent = nil
   end
 
-  def next_player_turn
-    self.turn = 0
-    self.opponent.turn = 1
-  end
-
-  def current_player?
-    self.turn == 1
+  def add_marker(board, cell)
+    board.all_cells[cell] = self.marker
   end
 
   def get_alpha(alpha, score)
@@ -25,36 +18,55 @@ class Player
   end
 end
 
-class Minimizing < Player
-  attr_accessor :marker, :turn, :opponent
+class AIPlayer < Player
+
+  def make_move(board)
+    ai = AI.new(self)
+    cell = ai.computer_move(board, self)
+    add_marker(board, cell)
+  end
+
+end
+
+class ComputerPlayer < Player
+
+  def make_move(board)
+    cell = board.random_cell
+    add_marker(board, cell)
+  end
+
+end
+
+class HumanPlayer < Player; end
+
+class MinimizingPlayer < Player
+  attr_accessor :marker, :opponent
   def initialize(player)
-    @marker      = player.marker
-    @turn        = player.turn
-    @opponent    = player.opponent
+    @marker = player.marker
+    @opponent = player.opponent
   end
 
   def get_alpha(alpha, score)
     score > alpha ? score : alpha
   end
 
-  def return_value(alpha, beta)
+  def return_best_score(alpha, beta)
     alpha
   end
 end
 
-class Maximizing < Player
-  attr_accessor :marker, :turn, :opponent
+class MaximizingPlayer < Player
+  attr_accessor :marker, :opponent
   def initialize(player)
-    @marker      = player.marker
-    @turn        = player.turn
-    @opponent    = player.opponent
+    @marker = player.marker
+    @opponent = player.opponent
   end
 
   def get_beta(beta, score)
     score < beta ? score : beta
   end
 
-  def return_value(alpha, beta)
+  def return_best_score(alpha, beta)
     beta
   end
 end

data/lib/player_factory.rb

@@ -0,0 +1,31 @@
+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
+
+  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
+  end
+
+end

data/lib/ruby_ttt.rb

@@ -1,92 +1,64 @@
 require 'ai'
 require 'board'
+require 'player_factory'
+require 'game_setup'
 require 'player'
 require 'ui'
 
-EASY_LEVEL = 'easy'
-HARD_LEVEL = 'hard'
-COMPUTER_PLAYER = 'computer'
-HUMAN_PLAYER = 'human'
-
 class Game
-  attr_accessor :board, :player_one, :player_two, :ai, :difficulty_level
-  def initialize(board, player_one, player_two)
-    @board      = board
-    @player_one = player_one
-    @player_two = player_two
-    @ai         = AI.new
-    @difficulty_level = nil
-  end
-
-  def set_opponents
-    player_one.opponent = player_two
-    player_two.opponent = player_one
+  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 computer_player_selected?
-    (player_one.player_type == COMPUTER_PLAYER) || (player_two.player_type == COMPUTER_PLAYER)
+  def advance_game
+    game_status_check(current_player.opponent.marker)
+    ui.next_move_message(current_player.marker) unless board.game_over?
   end
 
-  def who_goes_first
-    rand(0..1) == 1 ? set_first_turn(player_one) : set_first_turn(player_two)
+  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 set_first_turn(player)
-    player.turn = 1
-    ui.first_move_message(player)
+  def verify_move(cell)
+    return false if !board.available_cell?(cell)
+    current_player.add_marker(board, cell)
+    true
   end
 
-  def verify_move(cell)
-    if board.available_cell?(cell)
-      board.add_marker(current_player.marker, cell)
-      true
+  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
-      invalid_move(cell)
+      player_first_move
     end
   end
 
-  def get_computer_move
-    difficulty_level == HARD_LEVEL ? ai.computer_move(board, current_player) : board.random_cell
-  end
-
-  def computer_move?
-    current_player.player_type == COMPUTER_PLAYER
+  def total_markers(marker)
+    board.all_cells.select { |cell, value| value == marker }.count
   end
 
-  def advance_game
-    game_status_check
-    current_player.next_player_turn
-    ui.next_move_message(current_player) unless board.game_over?
-  end
-
-  def game_status_check
-    if board.winner?(current_player.marker)
-      ui.winning_game_message(current_player)
-    elsif !board.moves_remaining?
-      ui.tie_game_message
-    end
-  end
-
-  def current_player
-    player_one.current_player? ? player_one : player_two
-  end
 end
 
 class CLIGame < Game
-  attr_accessor :ui
-
-  def initialize(board, player_one, player_two)
+  attr_accessor :board, :player_one, :player_two, :ui, :player_first_move
+  def initialize(settings)
     super
-    @ui = CLIUI.new(board)
+    @ui = CLIUI.new
   end
 
-  def start_cli_game!
+  def start_game!
     begin
-      set_opponents
-      get_player_type(player_one)
-      get_player_type(player_two)
-      level = get_difficulty_level
-      who_goes_first
       play!
     rescue Interrupt
       ui.early_exit_message
@@ -94,71 +66,33 @@ class CLIGame < Game
     end
   end
 
-  def get_player_type(player)
-    type = ui.request_player_type(player.marker)
-    validate_type(type, player) ? set_player_type(type, player) : invalid_type(type, player)
-  end
-
-  def get_difficulty_level
-    return nil unless computer_player_selected?
-    level = ui.request_difficulty_level
-    validate_level(level) ? ui.level_assigned_message(level) : invalid_level(level)
-  end
-
-  def validate_type(type, player)
-    (type == HUMAN_PLAYER) || (type == COMPUTER_PLAYER)
-  end
-
-  def set_player_type(type, player)
-    player.player_type = type
-    ui.type_assigned_message(type, player.marker)
-  end
-
-  def invalid_type(type, player)
-    ui.invalid_input_message(type)
-    get_player_type(player)
-  end
-
-  def validate_level(level)
-    (level == HARD_LEVEL) || (level == EASY_LEVEL)
-  end
-
-  def invalid_level(level)
-    ui.invalid_input_message(level)
-    get_difficulty_level
-  end
-
   def play!
     until board.game_over?
-      ui.display_board
-      move = computer_move? ? get_computer_move : ui.request_human_move
-      advance_game if verify_move(move)
+      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
-    ui.display_board
+    board.display_board
     ui.io.exit
   end
 
 end
 
-class WebGame < Game
-  attr_accessor :ui
-
-  def initialize(board, player_one, player_two)
-    super
-    @ui = WebUI.new(board)
-  end
-
-  def set_player_types(player_one_type, player_two_type)
-    player_one.player_type = player_one_type
-    player_two.player_type = player_two_type
-  end
-
-end
+class WebGame < Game; end

data/lib/ui.rb

@@ -1,19 +1,16 @@
 class UI
-  attr_accessor :board
-  def initialize(board)
-    @board = board
-  end
+  def initialize; end
 
-  def first_move_message(player)
-    "Player '#{player.marker}' goes first."
+  def first_move_message(marker)
+    "Player '#{marker}' goes first."
   end
 
-  def next_move_message(player)
-    "Player '#{player.marker}': Make your move."
+  def next_move_message(marker)
+    "Player '#{marker}': Make your move."
   end
 
-  def winning_game_message(player)
-    "GAME OVER! Player '#{player.marker}' wins!"
+  def winning_game_message(marker)
+    "GAME OVER! Player '#{marker}' wins!"
   end
 
   def tie_game_message
@@ -24,8 +21,7 @@ end
 
 class CLIUI < UI
   attr_accessor :io
-  def initialize(board)
-    super
+  def initialize
     @io = Kernel
   end
 
@@ -39,6 +35,11 @@ class CLIUI < UI
     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
@@ -51,12 +52,20 @@ class CLIUI < UI
     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
+
   def level_assigned_message(level)
     io.print "You selected difficulty level #{level.upcase}.\n"
   end
 
+  def board_assigned_message(rows)
+    io.print "You selected a board with #{rows} rows.\n"
+  end
+
   def invalid_input_message(input)
-    io.print " #{input} is not a valid option.\n"
+    io.print "#{input} is not a valid option.\n"
   end
 
   def player_type_message(marker)
@@ -67,58 +76,17 @@ class CLIUI < UI
     io.print "Player " + "'#{marker}' " + "is #{type}.\n"
   end
 
-  def print_board_numbers
-    num = 1
-    io.print "    "
-    board.num_of_rows.times do
-      io.print "--#{num}-- "
-      num += 1
-    end
-    io.print "\n"
-  end
-
-  def print_divider
-    io.print "   "
-    board.num_of_rows.times { io.print "------" }
-    io.print "\n"
-  end
-
-  def print_board_rows
-    alpha = 'A'
-    board.all_rows.each do |row|
-      show_row(alpha, row)
-      alpha = alpha.next
-    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 show_marker(cell)
-    board.all_cells[cell].nil? ? ' ' : board.all_cells[cell]
-  end
-
-  def display_board
-    print_board_numbers
-    print_board_rows
-    print_board_numbers
-  end
-
-  def first_move_message(player)
+  def first_move_message(marker)
     output = super
     io.print "\n\n************ New Game ************\n"
     io.print output + "\n"
   end
 
-  def next_move_message(player)
-    io.print "Player '#{player.marker}': Enter open cell ID.\n"
+  def next_move_message(marker)
+    io.print "Player '#{marker}': Enter open cell ID.\n"
   end
 
-  def winning_game_message(player)
+  def winning_game_message(marker)
     output = super
     io.print output + "\n"
   end
@@ -142,28 +110,4 @@ class CLIUI < UI
     io.print "Goodbye!\n\n"
   end
 
-end
-
-class WebUI < UI
-
-  def print_active_board
-    board_string = ''
-    board.all_rows.each do |row|
-      board_string += "<div class='row'>"
-      row.each { |cell| board_string += "<button name='move' value='#{cell}'> #{board.all_cells[cell]} <span class='cell'>.</span></button>" }
-      board_string += "</div>"
-    end
-    board_string
-  end
-
-  def print_inactive_board
-    board_string = ''
-    board.all_rows.each do |row|
-      board_string += "<div class='row'>"
-      row.each { |cell| board_string += "<button> #{board.all_cells[cell]} <span class='cell'>.</span></button>" }
-      board_string += "</div>"
-    end
-    board_string
-  end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_ttt
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-17 00:00:00.000000000 Z
+date: 2013-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -37,7 +37,9 @@ extra_rdoc_files: []
 files:
 - lib/ai.rb
 - lib/board.rb
+- lib/game_setup.rb
 - lib/player.rb
+- lib/player_factory.rb
 - lib/ruby_ttt.rb
 - lib/ui.rb
 homepage: http://rubygems.org/gems/ruby_ttt