ruby_ttt 0.0.7 → 0.0.8

data/lib/ai.rb

@@ -0,0 +1,66 @@
+POS_INF = 999
+NEG_INF = -999
+WIN = 1
+LOSE = -1
+TIE = 0
+
+class AI
+
+  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
+
+  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)
+    end
+  end
+
+  def get_move_score(board, player, cell)
+    board.add_marker(player.marker, 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 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)
+      alphabeta(board, maximizing_player, depth, alpha, beta)
+    else
+      minimizing_player = Minimizing.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)
+      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)
+  end
+
+end

data/lib/board.rb

@@ -0,0 +1,145 @@
+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
+
+  def create_board_hash
+    new_board = Hash.new
+    alpha = 'A'
+    numeric = 1
+    num_of_rows.times do
+      num_of_rows.times do
+        cellID = numeric.to_s + alpha
+        numeric += 1
+        new_board[cellID] = nil
+      end
+      alpha = alpha.next
+      numeric = 1
+    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_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
+
+  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 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
+    end
+    cols
+  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
+
+  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
+    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
+    end
+    diagonal
+  end
+
+end

data/lib/game.rb

@@ -0,0 +1,59 @@
+require 'ai'
+require 'board'
+require 'player'
+require 'ui'
+require 'game_setup'
+class Game
+  attr_accessor :board, :ui, :player_one, :player_two, :ai, :difficulty_level
+  def initialize(board, player_one, player_two, difficulty_level)
+    @board      = board
+    @ui         = UI.new(@board)
+    @player_one = player_one
+    @player_two = player_two
+    @ai         = AI.new
+    @difficulty_level = difficulty_level
+  end
+
+  def play!
+    until board.game_over?
+      ui.display_board
+      move = get_next_move
+      board.available_cell?(move) ? advance_game(move, current_player) : invalid_move(move)
+    end
+    exit_game
+  end
+
+  def get_next_move
+    return ui.request_human_move if current_player.player_type == HUMAN_PLAYER
+    difficulty_level == HARD_LEVEL ? ai.computer_move(board, current_player) : board.random_cell
+  end
+
+  def advance_game(cell, player)
+    board.add_marker(player.marker, cell)
+    game_status_check
+    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 invalid_move(cell)
+    board.valid_cell?(cell) ? ui.taken_cell_message(cell) : ui.bad_cell_message(cell)
+  end
+
+  def current_player
+    player_one.current_player? ? player_one : player_two
+  end
+
+  def exit_game
+    ui.display_board
+    ui.io.exit
+  end
+
+end

data/lib/game_setup.rb

@@ -0,0 +1,76 @@
+EASY_LEVEL = 'easy'
+HARD_LEVEL = 'hard'
+COMPUTER_PLAYER = 'computer'
+HUMAN_PLAYER = 'human'
+class GameSetup
+  attr_accessor :ui, :board, :player_one, :player_two
+  def initialize(board, player_one, player_two)
+    @board = board
+    @ui = UI.new(@board)
+    @player_one = player_one
+    @player_two = player_two
+  end
+
+  def start!
+    begin
+      set_opponents
+      get_player_type(player_one)
+      get_player_type(player_two)
+      level = get_difficulty_level
+      who_goes_first
+      Game.new(board, player_one, player_two, level).play!
+    rescue Interrupt
+      ui.early_exit_message
+      exit
+    end
+  end
+
+  def set_opponents
+    player_one.opponent = player_two
+    player_two.opponent = player_one
+  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 player_one.player_type == COMPUTER_PLAYER || player_two.player_type == COMPUTER_PLAYER
+    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 who_goes_first
+    rand(0..1) == 1 ? set_first_turn(player_one) : set_first_turn(player_two)
+  end
+
+  def set_first_turn(player)
+    player.turn = 1
+    ui.first_move_message(player)
+  end
+
+end

data/lib/player.rb

@@ -0,0 +1,63 @@
+class Player
+  attr_accessor :marker, :turn, :player_type, :opponent
+  def initialize(marker)
+    @marker      = marker
+    @player_type = 'human'
+    @turn        = 0
+    @opponent    = nil
+  end
+
+  def next_player_turn
+    self.turn = 0
+    self.opponent.turn = 1
+  end
+
+  def current_player?
+    self.turn == 1
+  end
+
+  def get_alpha(alpha, score)
+    alpha
+  end
+
+  def get_beta(beta, score)
+    beta
+  end
+end
+
+class Minimizing < Player
+  attr_accessor :marker, :turn, :opponent
+  def initialize(player)
+    @marker      = player.marker
+    @turn        = player.turn
+    @opponent    = player.opponent
+  end
+
+  def get_alpha(alpha, score)
+    score > alpha ? score : alpha
+  end
+
+  def return_value(alpha, beta)
+    alpha
+  end
+
+end
+
+class Maximizing < Player
+  attr_accessor :marker, :turn, :opponent
+  def initialize(player)
+    @marker      = player.marker
+    @turn        = player.turn
+    @opponent    = player.opponent
+  end
+
+  def get_beta(beta, score)
+    score < beta ? score : beta
+  end
+
+  def return_value(alpha, beta)
+    beta
+  end
+
+end
+

data/lib/ui.rb

@@ -0,0 +1,118 @@
+class UI
+  attr_accessor :board, :io
+  def initialize(board)
+    @board = board
+    @io = Kernel
+  end
+
+  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_human_move
+    standardize(io.gets.chomp)
+  end
+
+  def standardize(input)
+    input.split('').sort.join('').upcase
+  end
+
+  def difficulty_level_message
+    io.print "Select computer difficulty level: Enter 'easy' or 'hard.'\n"
+  end
+
+  def level_assigned_message(level)
+    io.print "You selected difficulty level #{level.upcase}.\n"
+  end
+
+  def invalid_input_message(input)
+    io.print " #{input} is not a valid option.\n"
+  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 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)
+    io.print "\n\n************ New Game ************\n"
+    io.print "Player '#{player.marker}' goes first.\n"
+  end
+
+  def next_move_message(player)
+    io.print "Player '#{player.marker}': Enter open cell ID.\n"
+  end
+
+  def winning_game_message(player)
+    io.print "GAME OVER! Player '#{player.marker}' wins!\n"
+  end
+
+  def tie_game_message
+    io.print "GAME OVER! It's a tie!\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 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.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -34,13 +34,19 @@ email: tsauer@8thlight.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/ai.rb
+- lib/board.rb
+- lib/game.rb
+- lib/game_setup.rb
+- lib/player.rb
+- lib/ui.rb
 homepage: http://rubygems.org/gems/ruby_ttt
 licenses: []
 post_install_message: 
 rdoc_options: []
 require_paths:
-- .
+- lib
 required_ruby_version: !ruby/object:Gem::Requirement
   none: false
   requirements: