pszals_ttt 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e94776de494fef81265f1603ad67dbb72ac6d9fd
+  data.tar.gz: 6567cdf5a42a5f46dd674bc40e3179985b152dba
+SHA512:
+  metadata.gz: 2c97013a4575ddd44fe2ca9a3dbece254d3f8babf6862d3740f5950afb5b424a19ff2a0bf0ed2c8234f28728333125960b874206526f6c7467553eb81b14ac46
+  data.tar.gz: 26419f52c36fc0e988730b29322c7ddbe2fcb605c87abc6beeebf30ac862bb1ff44e0ff0a102ff6b41761b8f5e8a5411290aa46ec3df8cb71cc5ccfcfa5b6997

data/lib/board.rb

@@ -0,0 +1,135 @@
+class Board
+
+  attr_accessor :width, :current_board, :player_1, :player_2
+	
+  def initialize(player_1, player_2)
+    @width = 3
+    @current_board = squares_with_integers
+    @player_1 = player_1
+    @player_2 = player_2
+  end
+  
+  def whose_turn
+    number_of_empty_squares%2 == 0 ? @player_2.marker : @player_1.marker
+  end
+  
+  def get_opponent
+    number_of_empty_squares%2 != 0 ? @player_2.marker : @player_1.marker
+  end
+  
+  def integer_board
+    (1..@width**2).to_a
+  end
+	
+  def squares_with_integers
+    string_board = integer_board.map {|square| square.to_s}
+  end
+	
+  def display_board
+    if @width == 3
+      @current_board.each_slice(@width).
+                     map { |a,b,c| " #{a} | #{b} | #{c} \n" }.
+                     join("---|---|---\n")
+    else
+      @current_board.each_slice(@width).
+                     map { |a,b,c,d| " #{a} | #{b} | #{c} | #{d} \n" }.
+                     join("---|---|---|---\n")      
+    end
+  end
+		
+  def reset_board
+    @current_board = squares_with_integers
+  end
+		
+  def set_square(square, marker)
+    @current_board[square.to_i - 1] = marker
+  end
+  
+  def undo_set_square(square)
+    set_square(square, square.to_s)
+  end
+	
+  def square_empty?(square)
+    @current_board[square.to_i - 1] == square.to_s ? true : false
+  end
+  
+  def list_of_open_squares
+    @current_board.select {|square| square_empty?(square.to_i)}
+  end
+  
+  def number_of_empty_squares
+    list_of_open_squares.length
+  end
+
+  def board_open?
+    number_of_empty_squares >= 1? true : false
+  end	
+
+  def number_of_filled_squares
+    @current_board.length - list_of_open_squares.length
+  end
+
+  def winner_on_board?
+    winning_marker = false
+    gather_winning_combinations.each do |combo|
+      marker = @current_board[combo[0]]
+      winner = []
+      positions = (0...@width).to_a
+      positions.each {|position| winner << @current_board[combo[position]]}
+      if winner.all? { |square| square == marker }
+        winning_marker = marker
+      end
+    end
+    return winning_marker
+  end
+  
+  def game_over?
+    (!board_open? or winner_on_board?) ? true : false
+  end
+  
+  def game_won?(marker)
+    winner_on_board? == marker ? true : false
+  end
+  
+  def board_indices
+    (0...@width**2).to_a
+  end
+  
+  def winning_rows
+    board_indices.each_slice(@width).reduce([]) {|rows, slice| rows << slice}
+  end
+  
+  def generate_column(starting_index)
+    (0...@width).reduce([]) {|column, index| 
+      column << (index*@width+starting_index)
+    }
+  end
+  
+  def winning_columns
+    (0...@width).reduce([]) {|set_of_columns, index| 
+      set_of_columns << generate_column(index)
+    }
+  end
+  
+  def diagonal_down
+    (0...@width).reduce([]) {|diagonal, index| 
+      diagonal << index*(@width + 1)
+    }
+  end
+  
+  def diagonal_up
+    (0...@width).reduce([]) {|diagonal, index| 
+      diagonal << (index + 1)*(@width - 1)
+    }
+  end
+  
+  def gather_winning_combinations
+    combos = []
+    winning_rows.each {|row| combos << row } and
+    combos << diagonal_down and
+    combos << diagonal_up and
+    winning_columns.each {|column| combos << column}
+    combos
+  end
+
+end

data/lib/configuration.rb

@@ -0,0 +1,68 @@
+require 'console_ui'
+require 'board'
+require 'game'
+require 'unbeatable_ai'
+require 'player'
+
+class Configuration
+
+  attr_accessor :ai, :ui, :board_width
+  
+  def initialize(user_interface)
+    @ui = user_interface
+    @ai = Unbeatable_AI.new
+    @board_width = false
+  end
+  
+  def configure_opponent
+    @ui.ask_for_opponent
+    opponent_type = @ui.get_opponent
+    if opponent_type == 1  
+      @ai.opponent = true
+      @ai
+    else
+      @ai.opponent = false 
+      @ai
+    end 
+  end
+    
+  def get_marker
+    @ui.ask_for_marker_type  
+    marker = @ui.get_marker_type
+    return marker
+  end
+  
+  def configure_player_1(marker)
+    if marker.length == 1 and marker =~ /[A-Za-z]/
+      player_1 = Player.new(marker)
+    else
+      @ui.marker_error
+      configure_player_1(get_marker) 
+    end
+  end
+  
+  def configure_player_2(marker)
+    if marker.length == 1 and marker =~ /[A-Za-z]/
+      player_2 = Player.new(marker)
+    else
+      @ui.marker_error
+      configure_player_2(get_marker) 
+    end  
+  end
+
+  def configure_board(player_1, player_2)
+    board = Board.new(player_1, player_2)
+    @ui.ask_for_width_of_board
+    board_width = @ui.get_width_of_board
+    if board_width == 3
+      board.width = 3
+      board
+    elsif board_width == 4
+      board.width = 4
+      board.current_board = board.squares_with_integers
+      board
+    else
+      configure_board(player_1, player_2)
+    end      
+  end
+end

data/lib/console_ui.rb

@@ -0,0 +1,75 @@
+class Console_UI
+  
+  def ask_for_width_of_board
+    put_to_console("Enter 3 for a 3x3 board or 4 for a 4x4 board.")
+  end
+
+  def get_width_of_board
+    get_input
+  end
+  
+  def ask_for_first_player
+    put_to_console("Enter 'X' or 'O.'")
+  end
+  
+  def ask_for_marker_type
+    put_to_console("Enter a character A-Z to serve as your marker type")
+  end
+  
+  def get_marker_type
+    gets.chomp
+  end
+  
+  def get_first_player
+    get_input
+  end
+  
+  def ask_for_opponent
+    put_to_console("Enter 1 for computer opponent or any key for human opponent")
+  end
+  
+  def get_opponent
+    get_input
+  end
+
+  def puts_turn(marker) 
+    put_to_console("It is #{marker}'s turn.")
+  end
+
+  def ask_for_square_to_mark
+    put_to_console('Pick an empty square to mark: ')
+  end
+    
+  def marker_error
+    put_to_console("Input error.")
+  end
+  
+  def get_square_to_mark
+    get_input
+  end
+
+  def puts_winner(winning_marker)
+    put_to_console("Player #{winning_marker} wins!")
+  end
+
+  def puts_tie
+    put_to_console("Tie Game!")
+  end
+
+  def ask_to_restart
+    put_to_console("Enter 1 to restart or any key to exit.")
+  end
+  
+  def print_board(board)
+    put_to_console(board)
+  end
+
+  def put_to_console(output)
+    puts output
+  end  
+
+  def get_input
+    gets.chomp.to_i
+  end
+
+end

data/lib/game.rb

@@ -0,0 +1,79 @@
+require 'runner'
+
+class Game
+  
+  attr_accessor :player_1, :player_2
+  attr_reader :ui, :board, :ai, :unbeatable_ai, :runner 
+
+  def initialize(board, ui, ai, player_1, player_2)
+    @player_1 = player_1
+    @player_2 = player_2
+    @board = board
+    @ui = ui
+    @ai = ai
+    @unbeatable_ai = ai
+    @runner = Runner.new(ui)
+  end
+                
+  def declare_turn(marker)
+    @ui.puts_turn(marker)
+    @ui.print_board(@board.display_board)
+    @ui.ask_for_square_to_mark    
+  end
+  
+  def select_square
+    square = nil
+    marker = @board.whose_turn
+    declare_turn(marker)
+   
+    if marker == player_2.marker and @ai.opponent == true
+      square = @unbeatable_ai.make_move(@board, marker)
+    else
+      square = @ui.get_square_to_mark
+    end
+   
+    place_marker(square, marker)
+  end
+
+  def place_marker(square, marker)
+   
+    if @board.square_empty?(square) == false 
+      @ui.marker_error
+      select_square
+    end
+   
+    @board.set_square(square, marker)
+    find_winner
+  end
+
+  def find_winner
+    winner = @board.winner_on_board?
+    open_board = @board.board_open?
+   
+    if winner == false and open_board
+      select_square
+    elsif winner != false
+      game_over(@ui.puts_winner(winner))
+    else
+      game_over(@ui.puts_tie)
+    end
+  
+  end
+  
+  def game_over(final_game_message)
+    @ui.print_board(@board.display_board)
+    final_game_message
+    @ui.ask_to_restart
+    choice = @ui.get_input
+    restart?(choice)  
+  end
+  
+  def restart?(input)
+    input == 1 ? @runner.call : exit  
+  end
+      
+  def play_game
+    select_square
+  end  
+
+end

data/lib/player.rb

@@ -0,0 +1,9 @@
+class Player
+  
+  attr_reader :marker
+  
+  def initialize(selection)
+    @marker = selection
+  end
+
+end

data/lib/runner.rb

@@ -0,0 +1,29 @@
+require 'board'
+require 'game'
+require 'configuration'
+
+class Runner
+
+  def initialize(ui)
+    @ui = ui
+  end
+  
+  def call
+    configure_game
+    play_game
+  end
+
+  def configure_game
+    configuration = Configuration.new(@ui)
+    ai = configuration.configure_opponent
+    player_1 = configuration.configure_player_1(configuration.get_marker)
+    player_2 = configuration.configure_player_2(configuration.get_marker)
+    board = configuration.configure_board(player_1, player_2)
+    @game = Game.new(board, @ui, ai, player_1, player_2)
+  end
+    
+  def play_game
+    @game.play_game
+  end
+  
+end

data/lib/unbeatable_ai.rb

@@ -0,0 +1,54 @@
+require 'board'
+
+class Unbeatable_AI
+  
+  attr_accessor :opponent
+
+  def initialize
+    @opponent = false
+  end
+
+  def score_board(board, marker)
+    if !board.board_open? and !board.winner_on_board?
+      return 0 
+    elsif board.game_won?(marker)
+      1.0
+    else
+      -1.0
+    end
+  end
+
+   def minimax(board, marker, depth, alpha, beta)
+    opponent = board.get_opponent
+    score = 0
+    best_score = -1.0/0
+    if board.game_over?
+      return score_board(board, marker) / depth
+    else
+      new_alpha = alpha
+      board.list_of_open_squares.each do |square|
+        board.set_square(square, marker)
+        score = -minimax(board, opponent, depth + 1, -new_alpha, -beta)
+        board.undo_set_square(square)
+        best_score = score if score > best_score
+      end
+      return best_score 
+    end
+  end
+  
+  def make_move(board, marker)
+    best_square = nil
+    best_score = -1.0/0
+    opponent = board.get_opponent
+    board.list_of_open_squares.each do |square|
+      board.set_square(square, marker)
+      score = -minimax(board, opponent, 1, -1.0/0, 1.0/0)
+      board.undo_set_square(square)
+      if score > best_score
+        best_score = score
+        best_square = square
+      end 
+    end
+    return best_square
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: pszals_ttt
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Philip Szalwinski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-25 00:00:00.000000000 Z
+dependencies: []
+description: my tic tac toe game engine
+email: pszalwinski@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/board.rb
+- lib/configuration.rb
+- lib/console_ui.rb
+- lib/game.rb
+- lib/player.rb
+- lib/runner.rb
+- lib/unbeatable_ai.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.4
+signing_key: 
+specification_version: 4
+summary: a simple tic tac toe game
+test_files: []