tttazures 0.0.4 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86905b2d2ffae64896bc07afeabeeac7943ba70f
-  data.tar.gz: 44ae05f387b0a8ed9929112c2401dd075e4da34c
+  metadata.gz: 460e19f29c18852dacd3caa80532ca13dfad0420
+  data.tar.gz: f1219fe9ebdd295aebd4368b58d29a98346c9dbc
 SHA512:
-  metadata.gz: 4e6467a7fc1a8feba19c11ba8c541337da577a8dad7635967ad9cbd318430279f6cc28e07518875cff39207a6b3d8008893f90804485662d6f1706bc0d31d44a
-  data.tar.gz: f1f293fac35e578fc95ebbc979a3e582e5967403d7515302215e183d68780be65d8575e2b471cad40b2cc5f9b15e1c8b09a2c12a56deb71bc8d2b3945c0679fe
+  metadata.gz: a5cbc1431951539ce91812d3e4464d02972b66421b67cc62c5114583c9c9b5e2e6ade8751fb5d7857e498944b46a5f2705f7b7acd214264ec200f717d35ae50f
+  data.tar.gz: a80d5113273b3f26f936b14bdfc2ae1565738015a7c64624e12fde150ca23a4e25b9ee8bc4c7fddca9584bd0252e3b1ece363e34607fe2941db8a210fe374087

data/lib/board.rb

@@ -0,0 +1,49 @@
+class Board
+
+    attr_reader :row_length
+
+    def get_print_results
+		#row length d because
+		#it is needed to show correct 2d version of @board_array array
+		[@board_array, @row_length]
+    end
+    
+    def get_open_spots
+        open_spots = []
+        @board_array.each_index {|index| open_spots << index if @board_array[index] == :open}
+        open_spots
+    end
+
+    def remove_choice choice
+        @board_array[choice] = :open if valid_choice? choice 
+    end
+
+	def record_choice choice, player
+		if valid_choice?(choice) && @board_array[choice] == :open
+            @board_array[choice] = player
+			return true
+		else return false end
+	end
+
+	def valid_choice? choice
+		choice = choice.to_i
+		if choice >= 0 && choice <= @board_array.length
+		return true else return false end
+	end
+
+
+
+    #deprecated, write tests for board_is_full?
+	def check_for_tie
+		if @board_array.include?(:open) then return :continue_game else return :tie end
+	end
+
+    def win_is_found a
+         a.size == 1 && !a.include?(:open)
+    end
+
+    def board_is_full?
+        !@board_array.include?(:open)
+    end
+
+end

data/lib/board_printer_three_dim.rb

@@ -0,0 +1,40 @@
+class BoardPrinterThreeDim
+
+	def initialize output= STDOUT
+		@output = output
+	end
+
+	def print print_results
+		board = print_results[0]
+		row_length = print_results[1].to_i
+
+		start_index = 0
+		row_length.times do
+			index = start_index
+			row_length.times do
+				row_length.times do
+					symbol = get_element_symbol board, index
+					if symbol.to_s.size == 1
+						@output.print "  #{symbol} "
+					else
+						@output.print " #{symbol} "
+					end
+					index += 1
+				end
+				@output.print "   "
+				index += 6
+			end
+			@output.puts 
+			start_index += row_length
+		end
+        @output.puts
+	end
+
+	def get_element_symbol board_array, index
+		case board_array[index]
+		when :x then symbol = "X"
+		when :o then symbol = "O"
+		else symbol = index end
+		symbol
+	end
+end

data/lib/board_printer_two_dim.rb

@@ -0,0 +1,32 @@
+class BoardPrinterTwoDim
+
+	def initialize output= STDOUT
+		@output = output
+	end
+
+    def print print_results
+		board = print_results[0]
+		row_length = print_results[1]
+
+		board.to_enum.with_index.each do |value, index|
+			symbol = get_element_symbol board, index
+
+			if symbol.to_s.size == 1
+				@output.print "  #{symbol}"
+			else
+				@output.print " #{symbol}"
+			end
+
+			@output.puts "" if (index+1) % row_length == 0 && (index+1) != (row_length * row_length)
+		end
+		@output.puts "\n \n"
+	end
+
+	def get_element_symbol board_array, index
+		case board_array[index]
+		when :x then symbol = "X"
+		when :o then symbol = "O"
+		else symbol = index end
+		symbol
+	end
+end

data/lib/computer_ai.rb

@@ -0,0 +1,78 @@
+class ComputerAI
+
+    MIN_ALPHA = -1.0/0
+    MAX_BETA = 1.0/0
+    TOP_DEPTH = 0
+
+    attr_reader :player, :threshold
+
+    def initialize player, threshold 
+        @threshold = threshold
+        @player = player
+    end
+
+    def make_move board
+        update_depth_limit(board)
+        if use_mini_max? then best_options = mini_max_top(board, @player)
+        else best_options = make_random_move(board) end
+        choice = best_options.sample
+        board.record_choice(choice, @player)
+        choice
+    end
+
+    def mini_max_top board, player
+        best_moves = []
+        best_score = -1.0/0
+        open_moves = board.get_open_spots
+        open_moves.each do |move|
+            board.record_choice(move,player)
+            score = -mini_max(board, opponent(player), TOP_DEPTH+1, MIN_ALPHA, MAX_BETA)
+            board.remove_choice(move)
+            if score > best_score
+                best_score = score
+                best_moves.clear << move
+            elsif score == best_score
+                best_moves << move
+            end
+        end
+        best_moves
+    end
+
+    def mini_max board,player, depth, alpha, beta
+        if depth >= @depth_limit || alpha >= beta then return 0 end
+
+        if board.check_board_status == :tie 
+            return 0
+        elsif board.check_board_status != :continue_game 
+            return -(@depth_limit/depth)
+        end
+
+        open_moves = board.get_open_spots
+        open_moves.each do |move|
+            board.record_choice(move,player)
+            score = -mini_max(board, opponent(player), depth+1, -beta,-alpha)
+            board.remove_choice(move)
+            alpha = score if score > alpha
+        end
+        alpha
+    end
+
+    def update_depth_limit board
+        if board.get_open_spots.size > 18 then @depth_limit = 4
+        elsif board.get_open_spots.size > 14 then @depth_limit = 5 
+        elsif board.get_open_spots.size > 8 then @depth_limit = 6
+        else @depth_limit = 7 end
+    end
+
+    def make_random_move board
+        board.get_open_spots
+    end
+
+    def use_mini_max?
+        if rand(100) < @threshold then true else false end
+    end
+
+    def opponent player
+        if player == :o then return :x else return :o end
+    end
+end

data/lib/config.rb

@@ -0,0 +1,78 @@
+require_relative './computer_ai'
+require_relative './human_player'
+require_relative './two_dimensional_board'
+require_relative './three_dimensional_board'
+
+class Configurer
+
+    def initialize console
+        @console = console
+    end
+
+    def get_board
+        choice = get_board_choice
+        case choice
+        when 0 then TwoDimensionalBoard.new 3 
+        when 1 then TwoDimensionalBoard.new 4 
+        when 2 then TwoDimensionalBoard.new 5
+        when 3 then ThreeDimensionalBoard.new 3
+        end
+    end
+
+    def get_players
+        user_input = @console.query_user_for_game_type
+        players = {} 
+        case user_input
+        when 0
+            players[:player1] = HumanPlayer.new(:x, @console)
+            players[:player2] = HumanPlayer.new(:o, @console)
+        when 1
+            players[:player1] = HumanPlayer.new(:x, @console)
+            players[:player2] = set_ai_difficulty(:o)
+        when 2
+            players[:player1] = set_ai_difficulty(:o)
+            players[:player2] = HumanPlayer.new(:x, @console)
+        when 3
+            players[:player1] = set_ai_difficulty(:x)
+            players[:player2] = set_ai_difficulty(:o)
+        end
+        players
+    end
+
+    def set_ai_difficulty symbol
+		ai_difficulty_choice = get_ai_choice_from_user(symbol)
+        case ai_difficulty_choice
+        when 0 then ComputerAI.new(symbol, 10)
+        when 1 then ComputerAI.new(symbol, 50)
+        when 2 then ComputerAI.new(symbol, 100)
+        end
+    end
+
+    def get_board_choice
+        valid_choice = false
+        while valid_choice == false
+            choice = @console.query_user_for_board_type
+            if choice >= 0 && choice < 4 then valid_choice = true
+            else @console.print_user_input_error end
+        end 
+        choice
+    end
+
+    def get_ai_choice_from_user symbol
+         valid_choice = false
+         while(!valid_choice)
+            choice = @console.query_user_for_ai_difficulty(symbol)
+            if choice < 3 && choice >= 0 then valid_choice = true end
+         end
+        choice
+    end
+
+    def get_board_printer board
+        if board.get_type == :two_dimensional_board 
+            BoardPrinterTwoDim.new
+        elsif board.get_type == :three_dimensional_board
+            BoardPrinterThreeDim.new 
+        end
+    end
+
+end

data/lib/console_ui.rb

@@ -0,0 +1,107 @@
+class ConsoleUI
+
+    def initialize output= STDOUT
+    @output = output
+    end
+
+    def query_user_for_choice user
+        @output.puts "User #{user}: Choose!"
+        receive_user_choice.to_i
+    end
+
+    def query_user_for_new_game
+        print_new_game_prompt
+        choice = receive_user_choice
+        return choice == "y" ? true : false
+    end
+
+    def receive_user_choice
+        begin
+        choice = gets.chomp.downcase
+        rescue Interrupt => e
+            @output.puts e
+        end
+        say_goodbye if choice == 'q'
+        return choice
+    end
+
+    def print_player_move move, player
+        puts "Player #{player.player} chose #{move}"
+    end
+
+    def respond_to_choice choice_accepted, choice
+        if choice_accepted then @output.puts "You Chose: #{choice}"
+        else print_user_input_error end
+    end
+
+    def query_user_for_board_type 
+        print_board_options
+        receive_user_choice.to_i
+    end
+
+    def query_user_for_ai_difficulty symbol
+        print_ai_difficulty_options(symbol)
+        receive_user_choice.to_i
+    end
+
+    def query_user_for_game_type
+        valid_choice = false
+        while valid_choice == false
+            print_game_options
+            choice = receive_user_choice.to_i
+            if choice >= 0 && choice < 4 then valid_choice = true
+            else print_user_input_error end
+        end
+        choice
+    end
+
+    def print_board_options
+        @output.puts "What type of board size would you like to use?"
+        @output.puts "   Choose 0 for 3x3 board"
+        @output.puts "   Choose 1 for 4x4 board"
+        @output.puts "   Choose 2 for 5x5 board"
+        @output.puts "   Choose 3 for 3x3x3 board"
+    end
+
+    def print_ai_difficulty_options player
+        @output.puts "How difficult will Player #{player} AI be?"
+        @output.puts "   Choose 0: AI is easy to beat"
+        @output.puts "   Choose 1: AI is medium difficulty"
+        @output.puts "   Choose 2: AI is unbeatable (except for 3x3x3)"
+    end
+
+    def print_game_options
+        @output.puts "Choose Game Type"
+        @output.puts "  Choose 0 for Human v. Human"
+        @output.puts "  Choose 1 for Human v. Computer, Human goes first"
+        @output.puts "  Choose 2 for Human v. Computer, Computer goes first"
+        @output.puts "  Choose 3 for Computer v. Computer"
+    end
+
+    def present_game_result game_result
+        if game_result == :tie then @output.puts "Game Over: Tie"
+        else @output.puts "Game Over.  Player #{game_result} Wins" end
+    end
+
+    def greet_user
+    @output.puts "---Welcome to Tic Tac Toe---"
+        @output.puts "Press 'q' at any time to exit game"
+    end
+
+    def say_goodbye
+        @output.puts "Thanks for playing!"
+        exit
+    end
+
+    def print_user_input_error
+        @output.puts "Whoops! That choice wasn't valid, try again:"
+    end
+
+    def print_new_game_prompt
+        @output.puts "Would you like to start another game? Press 'Y' if yes. Press Any Other Key to Exit"
+    end
+
+    def print printString
+        @output.puts printString;
+    end
+end

data/lib/driver.rb

@@ -0,0 +1,3 @@
+require './game_controller'
+controller = GameController.new
+controller.run

data/lib/game_controller.rb

@@ -0,0 +1,76 @@
+require_relative './console_ui'
+require_relative './computer_ai'
+require_relative './human_player'
+require_relative './two_dimensional_board'
+require_relative './three_dimensional_board'
+require_relative './board_printer_three_dim'
+require_relative './board_printer_two_dim'
+require_relative "./config"
+
+class GameController 
+
+    attr_reader :console, :ai
+
+	def initialize
+		@console = ConsoleUI.new
+        @config = Configurer.new(@console)
+	end
+
+	def run
+
+		@console.greet_user
+		new_game = true
+		while new_game
+		
+            setup_game
+			player = @player1 
+			while @board.check_board_status == :continue_game
+			    display_board
+                move = player.make_move(@board)
+                @console.print_player_move(move,player)
+		        player = opponent(player)
+			end
+
+            display_board
+			present_game_result
+			new_game = play_again?
+		end
+	end
+
+    def setup_game
+        set_players
+        @board = @config.get_board
+        @board_printer = @config.get_board_printer(@board)
+    end
+
+    def set_players
+        players = @config.get_players
+        @player1 = players[:player1]
+        @player2 = players[:player2]
+    end
+
+	def display_board
+		@board_printer.print(@board.get_print_results)
+	end
+
+	def present_game_result
+		@console.present_game_result(@board.check_board_status)
+	end
+
+	def play_again?
+        response = @console.query_user_for_new_game
+
+		if response then true
+		else
+			@console.say_goodbye
+			false
+		end
+	end
+
+	def opponent player
+		if player == @player1 then @player2 else @player1 end
+	end
+
+end
+
+

data/lib/human_player.rb

@@ -0,0 +1,17 @@
+class HumanPlayer
+
+    attr_reader :player
+
+    def initialize player, console
+        @console = console
+        @player = player
+    end
+
+    def make_move board
+        valid_choice = false
+        while !valid_choice
+            choice = @console.query_user_for_choice(@player)
+            valid_choice = board.record_choice(choice, @player)
+        end
+    end
+end

data/lib/three_dimensional_board.rb

@@ -0,0 +1,197 @@
+require_relative "./board"
+
+class ThreeDimensionalBoard < Board
+
+    def initialize size
+       @board_array = Array.new(size**3, :open)
+       @row_length = size
+       @row_length_squared = size**2
+    end
+
+	def get_print_results
+		#row length needed to show correct 2d version of @board_array array
+		[@board_array, 3]
+	end
+
+    def get_type
+        :three_dimensional_board
+    end
+
+	def check_board_status
+		result = :continue_game
+		if (column_result = check_column_win(@board_array)) != :continue_game 
+			result = column_result
+		elsif (row_result = check_rows_for_win(@board_array)) != :continue_game
+			result = row_result
+		elsif (diag_result = check_diagonal_wins(@board_array)) != :continue_game
+			result = diag_result
+		elsif (tie_result = check_for_tie) != :continue_game
+			result = tie_result
+		end
+		return result
+	end
+
+	def check_column_win board
+		start_index = 0
+		@row_length.times do
+			@row_length.times do
+				if board[start_index] != :open
+					if board[start_index] == board[start_index + 3] && board[start_index+3] == board[start_index + 6]
+						return board[start_index]
+					end
+				end
+				start_index += 1
+			end
+			start_index += 6
+		end
+		return :continue_game
+	end
+
+	def check_rows_for_win board
+		if (result = check_left_right_row_for_win(board)) != :continue_game
+			return result
+		elsif (result = check_front_to_back_row_win(board)) != :continue_game
+			return result
+		else return :continue_game end
+	end
+
+    def check_left_right_row_for_win board
+        for row_number in 0...(@row_length**2)
+            row = get_row(row_number, board).uniq
+            return row.pop if win_is_found(row)
+        end
+        :continue_game
+    end
+
+    def get_row row_number, board
+        start_index = row_number * @row_length
+        board.slice(start_index, @row_length)
+    end
+
+    def get_front_back_row start_index, board
+        board.select.with_index{|x,i| x if (i-start_index) % (@row_length**2) == 0}
+    end
+
+    def check_front_to_back_row_win board
+        for row_number in 0..(@row_length**2)
+            row = get_front_back_row(row_number,board).uniq
+            return row.pop if win_is_found(row) 
+        end
+        :continue_game
+    end
+
+	def check_diagonal_wins board
+		if (result = check_top_bottom_diagonal(board)) != :continue_game 
+			return result
+		elsif (result = check_bottom_top_diagonal(board)) != :continue_game
+			return result
+		elsif (result = horizontal_left_right_diagonal_check(board)) != :continue_game
+			return result
+		elsif (result = horizontal_right_left_diagonal_check(board)) != :continue_game
+			return result
+		elsif (result = vertical_top_bottom_diagonal_check(board)) != :continue_game
+			return result
+		elsif (result = vertical_bottom_top_diagonal_check(board)) != :continue_game
+			return result
+		elsif (result = angled_through_center_diagonals_check(board)) != :continue_game
+			return result 
+		else return :continue_game end	
+	end
+
+
+
+    def check_top_bottom_diagonal board
+        for diag_number in 0...@row_length
+            index = diag_number*@row_length_squared
+            sub_board = board.slice(index, @row_length_squared)
+            diagonal = get_top_bottom_diagonal(index, sub_board).uniq
+            return diagonal.pop if win_is_found(diagonal)
+        end
+        :continue_game
+    end
+
+    def get_top_bottom_diagonal start_index, board
+		board.select.with_index {|x,i| x if i % (@row_length+1) == 0}
+    end
+
+	def check_bottom_top_diagonal board
+		index = 6
+		@row_length.times do
+			if board[index] != :open
+				if board[index] == board[index-2] && board[index-2] == board[index-4]
+					return board[index]
+				end
+			end
+			index += 9
+		end
+		return :continue_game
+	end
+
+	def horizontal_left_right_diagonal_check board
+		index = 0
+		@row_length.times do
+			if board[index] != :open
+				if board[index] == board[index+10] && board[index+10] == board[index+20]
+					return board[index]
+				end
+			end
+			index += 3
+		end
+		return :continue_game
+	end
+
+	def horizontal_right_left_diagonal_check board
+		index = 2
+		@row_length.times do
+			if board[index] != :open
+				if board[index] == board[index+8] && board[index+8] == board[index+16]
+					return board[index]
+				end
+			end
+			index += 3
+		end
+		return :continue_game
+	end
+
+	def vertical_top_bottom_diagonal_check board
+		index = 0
+		@row_length.times do
+			if board[index] != :open
+				if board[index] == board[index+12] && board[index+12] == board[index+24]
+					return board[index]
+				end
+			end
+			index += 1
+		end
+		return :continue_game
+	end
+
+	def vertical_bottom_top_diagonal_check board
+		index = 6
+		@row_length.times do
+			if board[index] != :open
+				if board[index] == board[index+6] && board[index+6] == board[index+12]
+					return board[index]
+				end
+			end
+			index += 1
+		end
+		return :continue_game
+	end
+
+	def angled_through_center_diagonals_check board
+		#scores diagonals starting at a front corner, angling through center,
+		#ending at back, opposite corner of cube
+		if board[0] != :open && board[0] == board[13] && board[13] == board[26]
+			return board[0]
+		elsif board[2] != :open && board[2] == board[13] && board[13] == board[24]
+			return board[2]
+		elsif board[6] != :open && board[6] == board[13] && board[13] == board[20]
+			return board[6]
+		elsif board[8] != :open && board[8] == board[13] && board[13] == board[18]
+			return board[8]
+		end
+		return :continue_game
+	end
+
+end