ultimate_tic_tac_toe 0.0.21

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b2f259908af12ca6c27a5057faae16a431ce2313
+  data.tar.gz: c6eda1e857bc58679e0d53b50820e3e1c581058c
+SHA512:
+  metadata.gz: c983dace240e29d196ef3f89d066f2700134b5271c337377d9d785c91386c469498051aded5d4b5fe8678bd9fad2ebc6e8bbd5ed717eb18fb7381b57dabf27ee
+  data.tar.gz: e1b7e9f2f1c0dd57cf0cce8aa2ab069e3d0b8a22fc21c16c18421f85373bc34eb1d0458d0b80cf7fe72454c3ff08f4637d32f050eb577a1f7081023a5703e2a0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ultimate_tic_tac_toe.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 TODO: Write your name
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# UltimateTicTacToe
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ultimate_tic_tac_toe'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ultimate_tic_tac_toe
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/ultimate_tic_tac_toe/board.rb

@@ -0,0 +1,92 @@
+class Board
+
+HUMAN = "X"
+COMPUTER = "O"
+
+	attr_accessor :grid, :size, :possible_boards, :player
+
+	def initialize(grid_size)
+		@grid = Array.new(grid_size)
+		@size = @grid.length
+		@possible_boards = []
+	end
+
+	def winning_possibilities
+		if grid.length == 9
+			[[0,1,2], [3,4,5], [6,7,8], [0,3,6], [1,4,7], [2,5,8], [0,4,8], [2,4,6]]
+		elsif grid.length == 16
+			[[0,1,2,3], [4,5,6,7], [8,9,10,11],[12,13,14,15], [0,5,10,15], [3,6,9, 12], [0,4,8,12], [1,5,9,13], [2,6,10,14], [3,7,11,15]]
+		elsif grid.length == 25
+			[[0,1,2,3,4], [5,6,7,8,9],[10,11,12,13,14],[15,16,17,18,19], [20,21,22,23,24,25], [0,5,10,15,20], [1,6,11,16,21], [2,7,12,17,22], [3,8,13,18,23],[4,9,14,19,24], [0,6,12,18,24],[4,8,12,16,20]]
+		end
+	end
+
+	def winner?(player)
+		if grid.length == 9
+			winning_possibilities.each do |win|
+				if grid[win[0]] == player && grid[win[1]] == player && grid[win[2]] == player
+					return true
+				end
+			end
+		elsif grid.length == 16
+			winning_possibilities.each do |win|
+				if grid[win[0]] == player && grid[win[1]] == player && grid[win[2]] == player && grid[win[3]] == player
+					return true
+				end
+			end
+		elsif grid.length == 25
+			winning_possibilities.each do |win|
+				if grid[win[0]] == player && grid[win[1]] == player && grid[win[2]] == player && grid[win[3]] == player && grid[win[4]] == player
+					return true
+				end
+			end
+		end
+		false
+	end
+
+	def tie?
+		if (player_moves + computer_moves) == grid.length && !winner?("X") && !winner?("O")
+			true
+		else
+			false
+		end
+	end
+
+	def occupied?(grid, location)
+		grid[location].nil? ? false : grid[location]
+	end
+
+	def get_move_list(grid)
+		grid.each_index.select{|index| grid[index].nil?}
+	end
+
+	def unoccupied(position)
+		@grid[position].nil?
+	end
+
+	def take_turn(player)
+		player == HUMAN ? COMPUTER : HUMAN
+	end
+
+	def store_position(position, participant)
+		@grid[position] = participant
+	end
+
+	def simulate_move(board, position, player)
+		board.grid[position] = player
+		board
+	end
+
+	def current_player
+		@grid.count(HUMAN) > @grid.count(COMPUTER) ? COMPUTER : HUMAN
+	end
+
+	def player_moves
+		@grid.count(HUMAN)
+	end
+
+	def computer_moves
+		@grid.count(COMPUTER)
+	end
+
+end

data/lib/ultimate_tic_tac_toe/computer.rb

@@ -0,0 +1,89 @@
+class Computer
+
+HUMAN = "X"
+COMPUTER = "O"
+MAX_DEPTH = 5  #to control length of calc time
+
+	attr_accessor :best_move, :sub_alpha, :active_player
+
+	def initialize
+		@sub_alpha = []
+		@best_move = 0
+		@best_moves =[]
+	end
+
+	def computer_move(board)
+		if board.player_moves > board.computer_moves
+			@active_player = COMPUTER
+			computers_move(board)
+		end
+	end
+
+	def computers_move(board)
+		if board.computer_moves < 0
+			if board.unoccupied(6)
+				board.store_position(6, COMPUTER)
+			else
+				board.store_position(8, COMPUTER)
+			end
+		else
+			minimax(board, @active_player)
+			board.store_position(@best_move, @active_player)
+		end
+	end
+
+	def minimax(board, current_player)
+		minimax_recurse(board, current_player, 0)
+	end
+
+	def check_winner(board, depth)
+		winner = 'None'
+		winner = COMPUTER if board.winner?(COMPUTER)
+		winner = HUMAN if board.winner?(HUMAN)
+		winner = 'tie' if board.tie?
+		winner = 'tie' if (depth >= MAX_DEPTH && board.grid.size > 10)
+		winner
+	end
+
+
+	def minimax_recurse(board, player, depth)
+		winner = check_winner(board, depth)
+		unless winner == 'None'
+			if winner == 'tie'
+				return 0
+			elsif winner ==	@active_player
+				return 1
+			else
+				return -1
+			end
+		end
+
+		next_player = (player == COMPUTER ? HUMAN : COMPUTER )
+
+		if player == @active_player
+			alpha = -1
+		else
+			alpha = 1
+		end
+
+		possible_moves = board.get_move_list(board.grid)
+
+		possible_moves.each do |move|
+			new_board = board.dup
+			new_board.grid = board.grid.dup
+			next_board = new_board.simulate_move(new_board, move, player)
+			@sub_alpha = minimax_recurse(next_board, next_player, depth + 1)
+
+			if player == @active_player
+				if ((depth == 0 ) && (alpha <= @sub_alpha ))
+					@best_move = move
+				end
+				alpha = [alpha, @sub_alpha].max
+			else
+				alpha = [alpha, @sub_alpha].min
+			end
+		end
+		alpha
+	end
+
+end

data/lib/ultimate_tic_tac_toe/game.rb

@@ -0,0 +1,83 @@
+class Game
+
+HUMAN = "X"
+COMPUTER = "O"
+
+	attr_accessor :position
+
+	def initialize(interface, computer)
+		@interface = interface
+		@computer = computer
+	end
+
+	def check_within_range(position, grid_length)
+		if position == "0"
+			true
+		elsif position.to_i < grid_length && position.to_i > 0
+			true
+		else
+			false
+		end
+	end
+
+	def check_space_unoccupied(position)
+		@board.unoccupied(position)
+	end
+
+	def validate_input(inputted_position, grid)
+		end_of_grid = grid.length
+
+		until check_within_range(inputted_position, end_of_grid)
+			@interface.reject(inputted_position)
+			@interface.prompt
+			inputted_position = @interface.user_input
+		end
+
+		until check_space_unoccupied(inputted_position.to_i)
+			@interface.denied
+			@interface.prompt
+			inputted_position = @interface.user_input
+		end
+
+		inputted_position.to_i
+	end
+
+	def game_over
+		(@board.tie? || @board.winner?(COMPUTER) || @board.winner?(HUMAN))
+	end
+
+	def check_board_after_computer_move
+		if @board.winner?("O") == true
+			@interface.computer_wins
+			@interface.pretty_print_board(@board.grid)
+
+		elsif @board.tie?
+			@interface.cats_game
+		end
+	end
+
+	def play
+		@board = @board ||= Board.new(@interface.grid_size)
+
+		until game_over
+
+			@interface.pretty_print_board(@board.grid)
+			@interface.prompt
+			position = validate_input(@interface.user_input, @board.grid)
+
+			@board.store_position(position, HUMAN)
+
+			if @board.winner?("X") == true
+				@interface.player_wins
+				@interface.pretty_print_board(@board.grid)
+			else
+				@computer.computer_move(@board)
+				check_board_after_computer_move
+			end
+
+		end
+	end
+
+end
+
+

data/lib/ultimate_tic_tac_toe/interface.rb

@@ -0,0 +1,75 @@
+class Interface
+
+	def opening_prompt
+		puts "What size board do you want to play (9, 16, 25)"
+		size = user_input
+		size
+	end
+
+	def grid_size
+		size = opening_prompt
+
+		if size == "9" || size == "16" || size == '25'
+			return size.to_i
+		else
+			puts "Please enter 9, 16 or 25"
+			grid_size
+		end
+
+	end
+
+	def axis_length(size)
+		Math.sqrt(size).to_i
+	end
+
+	def insert_spaces(position, size, output, grid)
+	   if position % axis_length(size) == (axis_length(size) - 1)
+      	output << "\n" unless position == (size - 1)
+      	else
+      		if position < 10 || !grid[position].nil?
+      			output << "   "
+      		else
+      			output << "  "
+      	end
+      end
+
+	end
+
+	def pretty_print_board(grid)
+		output = ""
+		size = grid.length
+	    size.times do |position|
+	      	output << (grid[position].nil? ? position.to_s : "#{grid[position]}")
+	   		insert_spaces(position, size, output, grid)
+	    end
+	    puts "\n Your Board \n\n\n" + output
+	  end
+
+	def prompt
+		puts "Where do you want to place your X?"
+	end
+
+	def user_input
+		gets.chomp
+	end
+
+	def denied
+		puts "Already occupied, try again"
+	end
+
+	def cats_game
+		puts "CATS GAME!"
+	end
+
+	def computer_wins
+		puts "Computer wins!  Again"
+	end
+
+	def player_wins
+		puts "Human wins!  Impossible!"
+	end
+
+	def reject(position)
+		puts "#{position} isnt no good"
+	end
+end

data/lib/ultimate_tic_tac_toe/version.rb

@@ -0,0 +1,3 @@
+module UltimateTicTacToe
+  VERSION = "0.0.21"
+end

data/lib/ultimate_tic_tac_toe.rb

@@ -0,0 +1,11 @@
+$: << File.expand_path(File.dirname(__FILE__) + "/ultimate_tic_tac_toe/")
+
+require 'game'
+require 'board'
+require 'interface'
+require 'computer'
+require "version"
+
+module UltimateTicTacToe
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$: << File.dirname(__FILE__) + '/../lib/ultimate_tic_tac_toe'
+
+require 'board'
+require 'game.rb'

data/spec/ultimate_tic_tac_toe/board_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Board do
+	let(:new_board) {Board.new(9)}
+	let(:new_board_16){Board.new(16)}
+	let(:new_interface) {Interface.new}
+	HUMAN = "X"
+	COMPUTER = "O"
+
+	it "checks for player victories(3x3)" do
+		new_board.grid = ["X", 1, 2, "X", 4, 5, "X", 7, 8]
+		new_board.winner?("X").should eq true
+	end
+
+	it "checks for player victories(4x4)" do
+		new_board.grid = ["X", 1, 2, 3, 4, "X", 6, 7, 8,9,"X",11,12,13,14,"X"]
+		new_board.winner?("X").should eq true
+	end
+
+	it 'checks for a tie' do
+		new_board.grid = ["X","O","X","X","O","O","O","X","X"]
+		new_board.tie?.should == true
+	end
+
+	it 'checks for a tie(4x4)' do
+		new_board_16.grid = ["X","O","X","O","O","O","X","O","X", "X","O","O","X","O","X","X"]
+		new_board_16.tie?.should == true
+	end
+
+	it 'checks for a tie(4x4)' do
+		new_board_16.grid = ["X","O","X","O","O","O","X","O","X", "O","O","O","X","X","X","X"]
+		new_board_16.tie?.should == false
+	end
+
+	it "stores player positions" do
+		new_board.store_position(1, HUMAN)
+		new_board.grid.should == [nil, "X",nil,nil,nil,nil,nil,nil,nil]
+	end
+
+	it "checks to see if a spot is occupied" do
+		grid = [nil,nil,nil,nil,nil,nil,nil,nil,nil]
+		new_board.occupied?(grid, 3).should eq false
+	end
+
+	it "lets players alternate" do
+		new_board.take_turn(HUMAN).should == COMPUTER
+	end
+
+	it 'stores simulated moves' do
+		new_board.grid = [nil, "X",nil,nil,nil,nil,nil,nil,nil]
+		board_copy = new_board.dup
+		board_copy.simulate_move(board_copy, 3, "O").grid.should == [nil, "X",nil,"O",nil,nil,nil,nil,nil]
+	end
+
+
+	it 'makes a list of possible moves' do
+		grid = [nil, "X",nil,nil,nil,nil,nil,nil,nil]
+		new_board.get_move_list(grid).should == [0,2,3,4,5,6,7,8]
+	end
+
+	it "checks for unoccupied spaces" do
+		new_board.grid = [nil, "X",nil,nil,nil,nil,nil,nil,nil]
+		new_board.unoccupied(1).should == false
+	end
+
+	it "tests possible combinations for computer's victory(3x3)" do
+		new_board.grid = ["O", 1, 2, "O", 4, 5, "O", 7, 8]
+		new_board.winner?("O").should eq true
+	end
+
+end

data/spec/ultimate_tic_tac_toe/computer_spec.rb

@@ -0,0 +1,30 @@
+require 'computer'
+require 'board'
+
+describe Computer do
+	let!(:new_interface) {Interface.new}
+	let!(:new_board) {Board.new(9)}
+	let(:new_computer) {Computer.new}
+	let(:fun_game) {Game.new(new_interface, new_computer)}
+
+	it 'knows the current player' do
+		new_board.grid = [0,1,2,"X",4,5,6,7,8]
+		new_board.current_player.should == COMPUTER
+	end
+
+	it "checks for computer wins during recursion" do
+		new_board.grid = [0, "O", 2, "X", "O", 5, "X", "O", 8]
+		new_computer.minimax_recurse(new_board,"O", 1).should == -1
+	end
+
+	it "checks for ties during recursion" do
+		new_board.grid = ["X","O","X","X","O","O","O","X","X"]
+		new_computer.minimax_recurse(new_board, "O", 8).should == 0
+	end
+
+	it 'returns sub-alpha values for a given board' do
+		new_board.grid = [0, 1, 2 , 3, 4, 5, 6, 7, 8]
+		new_computer.minimax_recurse(new_board, HUMAN, 0).should == 1
+	end
+
+end

data/spec/ultimate_tic_tac_toe/game_spec.rb

@@ -0,0 +1,29 @@
+require 'game'
+require 'interface'
+require 'board'
+# puts $:
+describe Game do
+	let!(:new_interface) {Interface.new}
+	let!(:new_board) {Board.new(9)}
+	let(:new_computer) {Computer.new}
+	let(:fun_game) {Game.new(new_interface, new_computer)}
+
+	it "can check that human's move is within the board" do
+		fun_game.check_within_range("7", new_board.grid.length).should eq true
+	end
+
+	it 'determines when the game is over' do
+		fun_game.stub(:new).and_return(new_board)
+		new_board.stub(:tie?).and_return(true)
+		fun_game.game_over.should be(true)
+	end
+
+	it "informs the player of bad input" do
+		# new_interface.stub(:gets){"g\n"}
+		# fun_game.validate_input("\z", new_board.grid)
+		# fun_game.should_receive(:validate_input).with("d", new_board.grid)
+		fun_game.should_receive(:puts).with("f isnt no good")
+		fun_game.validate_input("f", new_board.grid)
+	# 	new_interface.prompt
+	end
+end

data/spec/ultimate_tic_tac_toe/interface_spec.rb

@@ -0,0 +1,38 @@
+require 'game'
+require 'interface'
+require 'board'
+
+
+describe Interface do
+
+	let!(:new_interface) {Interface.new}
+	let!(:new_board) {Board.new(9)}
+	let(:new_computer) {Computer.new}
+	let(:fun_game) {Game.new(new_interface, new_computer)}
+
+	# it "informs the player of bad input" do
+	# 		Interface.stub(:new).and_return(new_interface)
+	# 		new_interface.stub(:gets){"g\n"}
+	# 		fun_game.should_receive(:puts).with("f isnt no good").at_least(1).times
+	# 		new_interface.prompt
+	# 	end
+
+	# it 'prints a board that corresponds to the grid size' do
+
+	# end
+	it 'gets the initial input from human' do
+		new_interface.stub(:gets){"9\n"}
+		new_interface.opening_prompt.should == "9"
+	end
+
+	it 'determines the grid length of the board' do
+		new_interface.stub(:gets){"9\n"}
+		new_interface.grid_size.should == 9
+	end
+
+	it 'prints out a pretty board' do
+		new_interface.should_receive(:puts).with("\n Your Board \n\n\n0   1   2\n3   4   5\n6   7   8")
+		new_interface.pretty_print_board(new_board.grid)
+	end
+
+end

data/ultimate_tic_tac_toe.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ultimate_tic_tac_toe/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ultimate_tic_tac_toe"
+  spec.version       = UltimateTicTacToe::VERSION
+  spec.authors       = ["Rod Levy"]
+  spec.email         = ["rodlevy1@gmail.com"]
+  spec.description   = %q{Unbeatable Tic Tac Toe Game}
+  spec.summary       = %q{Implements a game of tic-tac-toe where the computer always wins}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: ultimate_tic_tac_toe
+version: !ruby/object:Gem::Version
+  version: 0.0.21
+platform: ruby
+authors:
+- Rod Levy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Unbeatable Tic Tac Toe Game
+email:
+- rodlevy1@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/ultimate_tic_tac_toe.rb
+- lib/ultimate_tic_tac_toe/board.rb
+- lib/ultimate_tic_tac_toe/computer.rb
+- lib/ultimate_tic_tac_toe/game.rb
+- lib/ultimate_tic_tac_toe/interface.rb
+- lib/ultimate_tic_tac_toe/version.rb
+- spec/spec_helper.rb
+- spec/ultimate_tic_tac_toe/board_spec.rb
+- spec/ultimate_tic_tac_toe/computer_spec.rb
+- spec/ultimate_tic_tac_toe/game_spec.rb
+- spec/ultimate_tic_tac_toe/interface_spec.rb
+- ultimate_tic_tac_toe.gemspec
+homepage: ''
+licenses:
+- MIT
+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.6
+signing_key: 
+specification_version: 4
+summary: Implements a game of tic-tac-toe where the computer always wins
+test_files:
+- spec/spec_helper.rb
+- spec/ultimate_tic_tac_toe/board_spec.rb
+- spec/ultimate_tic_tac_toe/computer_spec.rb
+- spec/ultimate_tic_tac_toe/game_spec.rb
+- spec/ultimate_tic_tac_toe/interface_spec.rb