ruby_ttt 0.0.4 → 0.0.6

data/ruby_ttt.rb

@@ -0,0 +1,7 @@
+File.join(File.expand_path(File.dirname(__FILE__)), "..", "lib")
+require 'game'
+
+# board = Board.new(3)
+# player_one = Player.new(MARKER_X)
+# player_two = Player.new(MARKER_O)
+# GameSetup.new(board, player_one, player_two).start!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_ttt
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -35,18 +35,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/ai.rb
-- lib/board.rb
-- lib/game.rb
-- lib/game_setup.rb
-- lib/player.rb
-- lib/ui.rb
+- ruby_ttt.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:

data/lib/ai.rb

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

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

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

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

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

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