erics_tic_tac_toe 0.1.0

data/.gitignore

@@ -0,0 +1 @@
+pkg/

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2012 Eric Koslow
+
+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.markdown

@@ -0,0 +1,15 @@
+Tic Tac Toe
+====
+
+How to play
+----
+
+    irb -Ilib
+    require 'game'
+    Game.new.run
+
+Whats coming
+----
+
+Gem and Bin executable for playing games easily
+Play games on boards bigger than 3x3

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake'
+require 'bundler'
+require 'rake/testtask'
+
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+
+task :default => :test

data/bin/tic_tac_toe

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+libdir = File.expand_path('../../lib', __FILE__).sub(/^#{Dir.pwd}\//, '')
+begin 
+  require 'tic_tac_toe'
+rescue LoadError
+  case $!.to_s
+  when /tic_tac_toe/
+  if !$:.include?(libdir)
+      warn "warn: #$!. trying again with #{libdir} on load path"
+      $:.unshift(libdir)
+      retry
+    end
+  end
+  raise
+end
+
+TicTacToe::Game.new.run

data/lib/tic-tac-toe/board.rb

@@ -0,0 +1,148 @@
+module TicTacToe
+  class Board
+
+    SIZE = 3.freeze
+
+    def initialize(grid=nil)
+      #[[ nil, nil, nil],
+      # [ nil, nil, nil],
+      # [ nil, nil, nil]]
+      @grid = grid || [ [nil] * SIZE ] * SIZE
+    end
+
+    def get_cell(x, y)
+      @grid[y][x]
+    end
+
+    # Returns the closest middle cell
+    def center_cell
+      mid = @grid.size/2
+      get_cell(mid, mid)
+    end
+
+    # Sets the closet middle cell if its not already set
+    def center_cell=(letter)
+      mid = @grid.size/2
+      play_at(mid, mid, letter)
+    end
+
+    # Returns the corners of the grid
+    def corners
+      [@grid[0][0], 
+       @grid[0][SIZE-1], 
+       @grid[SIZE-1][SIZE-1], 
+       @grid[SIZE-1][0]]
+    end
+
+    # Returns the corners of the empty cells
+    def any_empty_position(&block)
+      SIZE.times do |y|
+        SIZE.times do |x|
+          next if get_cell(x, y)
+          yield(x, y)
+        end
+      end
+    end
+
+    # Plays a letter at a position, unless that position has already been taken
+    def play_at(x, y, letter)
+      # Weird bug I found in ruby 1.9.3-p0
+      # Given a @grid of [ [nil,nil,nil], [nil,nil,nil], [nil,nil,nil] ]
+      # If you call @grid[0][0] = 'x'
+      # I aspect @grid to be [ ['x',nil,nil], [nil,nil,nil], [nil,nil,nil] ]
+      # What happens is that @grid is [ ['x',nil,nil], ['x',nil,nil], ['x',nil,nil] ]
+      # This is a workaround for that
+      inner = @grid[y].clone
+      inner[x] ||= letter
+      @grid[y] = inner
+    end
+
+    # Returns true if the grid is empty
+    def empty?
+      each_cell do |cell|
+        return false if cell
+      end
+      true
+    end
+
+    # Returns true if the grid only has one element
+    def only_one?
+      counter = 0
+      each_cell do |cell|
+        counter += 1 if cell
+        return false if counter >= 2
+      end
+      counter == 1
+    end
+
+    # Returns true if every cell is set to a value
+    def full?
+      each_cell do |cell|
+        return false unless cell
+      end
+      true
+    end
+
+    # Returns true if the board has a wining pattern
+    def solved?
+      return true if won_across?
+      return true if won_up_and_down?
+      return true if won_diagonally?
+      false
+    end
+
+    def to_s
+      output = ["-----------\n"]
+      @grid.each_with_index do |row, i|
+        row.each_with_index do |cell, j|
+          output << "#{cell || ((i*3)+j+1)} | #{"\n" if j==2}"
+        end
+      end
+      output << ["-----------\n\n"]
+      output.join
+    end
+
+    # Preform a deep clone of the board
+    # FIXME: This only works for SIZE=3
+    def clone
+      Board.new([[@grid[0][0], @grid[0][1], @grid[0][2] ],
+                 [@grid[1][0], @grid[1][1], @grid[1][2] ],
+                 [@grid[2][0], @grid[2][1], @grid[2][2] ]])
+    end
+
+    private 
+
+    def each_cell(&block)
+      @grid.each do |row|
+        row.each do |cell|
+          yield(cell)
+        end
+      end
+    end
+
+    def won_across?(grid = @grid)
+      grid.any? do |row|
+        winning_group?(row)
+      end
+    end
+
+    def won_up_and_down?
+      won_across?(@grid.transpose)
+    end
+
+    def won_diagonally?
+      base = (0..@grid.size-1)
+      left_to_right = base.collect { |i| @grid[i][i]}
+      right_to_left = base.collect { |i| @grid[i][@grid.size-1-i]}
+      return true if winning_group?(left_to_right)
+      return true if winning_group?(right_to_left)
+      false
+    end
+
+    def winning_group?(group)
+      # Won when none of the cells are nil and they are all the same value
+      !group.any? { |cell| cell.nil? } && group.uniq.size == 1
+    end
+
+  end
+end

data/lib/tic-tac-toe/game.rb

@@ -0,0 +1,62 @@
+#This is a computer that will play a perfect game of tic-tac-toe
+#Author: Eric Koslow
+
+require_relative 'game_types/terminal_game'
+
+module TicTacToe
+  class Game
+    def initialize(type=TerminalGame)
+      @board = Board.new
+      @game_type = type.new(@board)
+    end
+
+    def run
+      if @game_type.computer_goes_first?
+        @computer_letter = O
+        get_move_from_computer!
+      else
+        @computer_letter = X
+      end
+
+      @game_type.update_board
+
+      loop do
+        @game_type.get_move_from_user!
+        @game_type.update_board
+        break if game_over?
+
+        get_move_from_computer!
+        @game_type.update_board
+        break if game_over?
+      end
+
+      if @game_type.play_again?
+        new_game
+      end
+    end
+
+    private
+
+    def new_game
+      Game.new.run
+    end
+    
+    def game_over?
+      if @board.solved?
+        @game_type.display_text("You lost!")
+        true
+      elsif @board.full?
+        @game_type.display_text("Cats game!")
+        true
+      else
+        false
+      end
+    end
+
+    def get_move_from_computer!
+      Solver.new(@board, @computer_letter).next_move!
+      @game_type.display_text("Computer's move (#{@computer_letter}):")
+    end
+
+  end
+end

data/lib/tic-tac-toe/game_types/terminal_game.rb

@@ -0,0 +1,63 @@
+module TicTacToe
+  class TerminalGame
+    class IllegalMove < RuntimeError
+    end
+
+    def initialize(board)
+      @board = board
+    end
+
+    def computer_goes_first?
+      print "Would you like to play first or second? (f/s) "
+      input = gets.chomp
+      unless input =~ /^(f|first)$/i
+        @human_letter = X
+        true
+      else
+        @human_letter = O
+        false
+      end
+    end
+
+    def get_move_from_user!
+      print "Your move (#{@human_letter}) (1-9): "
+      input = gets.chomp
+
+      if input =~ /^\d$/ 
+        cords = cord_from_num(input.to_i)
+        if !@board.get_cell(*cords)
+          @board.play_at(*(cords+[@human_letter]))
+        else
+          raise IllegalMove.new("That cell is already taken")
+        end
+      else
+        raise IllegalMove.new("Must be a single number")
+      end
+    rescue IllegalMove => e
+      display_text "Illegal Move: #{e.message}. Please try again"
+      get_move_from_user!
+    end
+
+    def play_again?
+      print "Play again? (y/n) "
+      input = gets.chomp
+      input =~ /^(y|yes)$/i
+    end
+
+    def update_board
+      puts @board
+    end
+
+    def display_text(text)
+      puts text
+    end
+
+    private
+
+    def cord_from_num(num)
+      num -= 1
+      [num % Board::SIZE, num/Board::SIZE]
+    end
+  end
+
+end

data/lib/tic-tac-toe/solver.rb

@@ -0,0 +1,16 @@
+require_relative 'strategies/threebythree_stategy'
+
+module TicTacToe
+  class Solver
+
+    def initialize(board, letter, strategy=ThreebythreeStrategy)
+      @strategy = strategy.new(board, letter)
+    end
+
+    # Performs the next perfect move and updates the board as a side effect
+    def next_move!
+      @strategy.solve!
+    end
+
+  end
+end

data/lib/tic-tac-toe/strategies/threebythree_implementations/brute_force_implementation.rb

@@ -0,0 +1,197 @@
+# Brute Force Implementation for the Three by Three Strategy
+# This implementation uses loops to try a change all of the board values and
+# checking the result
+#
+# For example, win! is implemented by trying every cell, and checking if
+# it was a winning solution
+module TicTacToe
+  class BruteForceImplementation
+
+    def initialize(board, letter)
+      @board, @letter = board, letter
+    end
+
+    # Try placing letter at every available position
+    # If the board is solved, do that
+    def win!
+      each_position do |x, y|
+        temp_board = @board.clone
+        temp_board.play_at(x, y, @letter)
+        if temp_board.solved?
+          @board.play_at(x, y, @letter)
+          return true
+        end
+      end
+      false
+    end
+
+    # Try placing the opponent's letter at every available position
+    # If the board is solved, block them at that position
+    def block!(board = @board, letter = @letter)
+      each_position do |x, y|
+        temp_board = board.clone
+        temp_board.play_at(x, y, other_player(letter))
+        if temp_board.solved?
+          board.play_at(x, y, letter)
+          return true
+        end
+      end
+      false
+    end
+
+    # Try placing the letter at every position.
+    # If there are now two winning solutions for next turn, go there
+    def fork!
+      each_forking_position do |x, y|
+        @board.play_at(x, y, @letter)
+        return true
+      end
+      false
+    end
+
+    # Try placing the opponent's letter at every position.
+    # If there are now two winning solutions for next turn, block them there
+    def block_fork!(board = @board)
+      each_forking_position(other_player) do |x, y|
+        temp_board = board.clone
+        temp_board.play_at(x,y,@letter)
+        # Search for the elusive double fork
+        each_forking_position(other_player, temp_board) do |x, y|
+          return force_a_block        
+        end
+        board.play_at(x, y, @letter)
+        return true
+      end
+      false
+    end
+
+    def center!
+      return false if @board.center_cell
+
+      @board.center_cell = @letter
+      true
+    end
+
+    # Cycle through all of the corners looking for the opponent's letter
+    # If one is found, place letter at the opposite corner
+    def oposite_corner!
+      @board.corners.each_with_index do |corner, index|
+        if corner == other_player
+          case index
+          when 0 # Top Left
+            next if @board.get_cell(Board::SIZE-1, Board::SIZE-1)
+            @board.play_at(Board::SIZE-1, Board::SIZE-1, @letter)
+            return true
+          when 1 # Top Right
+            next if @board.get_cell(0, Board::SIZE-1)
+            @board.play_at(0, Board::SIZE-1, @letter)
+            return true
+          when 2 # Bottom Right
+            next if @board.get_cell(0, 0)
+            @board.play_at(0, 0, @letter)
+            return true
+          when 3 # Bottom Left
+            next if @board.get_cell(Board::SIZE-1, 0)
+            @board.play_at(Board::SIZE-1, 0, @letter)
+            return true
+          else
+            raise Exception.new("Board#corners returned more than 4")
+          end
+        end
+      end
+      false
+    end
+
+    # Cycle though all of the corners, until one is found that is empty
+    def empty_corner!
+      @board.corners.each_with_index do |corner, index|
+        unless corner
+          case index
+          when 0 # Top Left
+            @board.play_at(0, 0, @letter)
+            return true
+          when 1 # Top Right
+            @board.play_at(Board::SIZE-1, 0, @letter)
+            return true
+          when 2 # Bottom Right
+            @board.play_at(Board::SIZE-1, Board::SIZE-1, @letter)
+            return true
+          when 3 # Bottom Left
+            @board.play_at(0, Board::SIZE-1, @letter)
+            return true
+          else
+            raise Exception.new("Board#corners returned more than 4")
+          end
+        end
+      end
+      false
+    end
+
+    # Place letter at a random empty cell, at this point it should only be sides left
+    def empty_side!
+      @board.any_empty_position do |x, y|
+        @board.play_at(x, y, @letter)
+        return true 
+      end
+      false
+    end
+
+    private
+
+    def other_player(letter = @letter)
+      letter == X ? O : X
+    end
+
+    def fork_exsits?(x, y, letter = @letter, board = @board)
+      (count = can_win_next_turn?(x, y, letter, board)) && count >= 2
+    end
+
+    def each_position(&block)
+      Board::SIZE.times do |y|
+        Board::SIZE.times do |x|
+          yield(x, y)
+        end
+      end
+    end
+
+    def each_forking_position(letter = @letter, board = @board, &block)
+      each_position do |x, y|
+        if fork_exsits?(x, y, letter, board)
+          yield(x, y)
+        end
+      end
+    end
+
+    def can_win_next_turn?(x, y, letter = @letter, board = @board)
+      count = 0
+      temp_board = board.clone
+      temp_board.play_at(x,y,letter)
+      each_position do |x, y|
+        inner_loop_board = temp_board.clone
+        inner_loop_board.play_at(x, y, letter)
+        count += 1 if inner_loop_board.solved?
+      end
+      return count == 0 ? false : count
+    end
+
+    def force_a_block
+      # Force them to block without creating another fork
+      each_position do |x, y|
+        if can_win_next_turn?(x, y)
+          temp_board = @board.clone
+          temp_board.play_at(x, y, @letter)
+          raise Exception.new("Couldn't force a block") unless block!(temp_board, other_player)
+          # Did I just create another fork with that block?
+          if fork_exsits?(x, y, other_player, temp_board)
+            next
+          else
+            @board.play_at(x, y, @letter)
+            return true
+          end
+        end
+      end
+      raise Exception.new("No position found to block the fork")
+    end
+
+  end
+end

data/lib/tic-tac-toe/strategies/threebythree_stategy.rb

@@ -0,0 +1,30 @@
+require_relative 'threebythree_implementations/brute_force_implementation'
+
+module TicTacToe
+  class ThreebythreeStrategy
+    def initialize(board, letter, implementation=BruteForceImplementation)
+      @implementation = implementation.new(board, letter)
+    end
+
+    # The strategy is from the Wikipedia article on Tic-Tac-Toe
+    # 1) Try to win
+    # 2) Try to block if they're about to win
+    # 3) Try to fork so you'll win next turn
+    # 4) Try to block their fork so they will not win next turn
+    # 5) Take the center if its not already taken
+    # 6) Play the opposite corner of your opponent
+    # 7) Play in an empty corner
+    # 8) Play in an empty side
+    def solve!
+      return if @implementation.win!
+      return if @implementation.block!
+      return if @implementation.fork!
+      return if @implementation.block_fork!
+      return if @implementation.center!
+      return if @implementation.oposite_corner!
+      return if @implementation.empty_corner!
+      return if @implementation.empty_side!
+      raise Exception.new("No possible moves to play!")
+    end
+  end
+end

data/lib/tic-tac-toe/version.rb

@@ -0,0 +1,3 @@
+module TicTacToe
+  VERSION = '0.1.0'
+end

data/lib/tic_tac_toe.rb

@@ -0,0 +1,13 @@
+# Third Party Requies
+
+# Module wide methods / constants
+module TicTacToe
+  X = 'x'.freeze
+  O = 'o'.freeze
+end
+
+# Internal Project Requires
+require 'tic-tac-toe/board'
+require 'tic-tac-toe/solver'
+require 'tic-tac-toe/game'
+

data/test/board_test.rb

@@ -0,0 +1,141 @@
+require 'test_helper'
+
+class BoardTest < MiniTest::Unit::TestCase
+  def setup
+    TicTacToe::Board.instance_eval { attr_accessor :grid } # For testing purposes
+    @board = TicTacToe::Board.new
+  end
+
+  def test_empty
+    # Board empty when created
+    assert @board.empty?
+
+    # Board not longer empty after letter placed
+    @board.play_at(0,0,'o')
+    refute @board.empty?
+  end
+
+  def test_full
+    # Board not full when empty
+    refute @board.full?
+
+    # Board full when no cells are nil
+    @board.grid = [ %w(x o x), %w(o x o), %w(x o x)]
+    assert @board.full?
+  end
+
+  def test_only_one
+    # False when empty
+    refute @board.only_one?
+
+    # True when one
+    @board.grid = [ ['x',nil,nil], [nil,nil,nil], [nil,nil,nil] ]
+    assert @board.only_one?
+
+    # False when more than one
+    @board.grid = [ ['x','x',nil], [nil,nil,nil], [nil,nil,nil] ]
+    refute @board.only_one?
+  end
+
+  def test_get_cell
+    # Returns nil when nothing in cell
+    assert_nil @board.get_cell(0, 0)
+
+    # Returns the right letter after they've been played
+    @board.play_at(0,0,"o")
+    assert_equal "o", @board.get_cell(0, 0)
+
+    @board.play_at(1,2,"o")
+    assert_equal "o", @board.get_cell(1, 2)
+  end
+
+  def test_center_cell
+    # Center cell is nil in empty grid
+    assert_nil @board.center_cell
+
+    # Returns the correct letter after its been placed
+    @board.play_at(1,1,'o')
+    assert_equal "o", @board.center_cell
+
+    # Does not override values after they've been placed
+    @board.center_cell = 'x'
+    assert_equal "o", @board.center_cell
+
+    # Can use helper when the center cell is nil
+    @board = TicTacToe::Board.new
+    @board.center_cell = 'x'
+    assert_equal "x", @board.center_cell
+  end
+
+  def test_corners
+    # All of the corners are nil in an empty grid
+    @board.corners.each { |corner| assert_nil corner }
+
+    # Will return the corners in the proper order (clockwise)
+    # 0 => Top Left
+    # 1 => Top Right
+    # 2 => Bottom Right
+    # 3 => Bottom Left
+    @board.play_at(0,0,'a')
+    @board.play_at(2,0,'b')
+    @board.play_at(2,2,'c')
+    @board.play_at(0,2,'d')
+    answers = %w( a b c d )
+    @board.corners.each_with_index { |corner, i| assert_equal answers[i], corner }
+  end
+
+  def test_play_at
+    # Cells are proper set and override nil values
+    assert_nil @board.get_cell(1,1)
+    @board.play_at(1, 1, 'x')
+    assert_equal 'x', @board.get_cell(1,1)
+  end
+
+  def test_can_not_overide_values
+    assert_nil @board.get_cell(1,1)
+    @board.play_at(1, 1, 'x')
+    assert_equal 'x', @board.get_cell(1,1)
+    @board.play_at(1, 1, 'o')
+    assert_equal 'x', @board.get_cell(1,1)
+  end
+
+  def test_solved_acoss
+    refute @board.solved?
+
+    @board.grid = [ %w(x x x), [nil, nil, nil], [nil, nil, nil]]
+    assert @board.solved?
+
+    @board.grid = [ [nil,nil,'x'], [nil,'o',nil], ['x','x','x'] ]
+    assert @board.solved?
+
+    @board.grid = [ %w(x o x), [nil, nil, nil], [nil, nil, nil]]
+    refute @board.solved?
+  end
+
+  def test_solved_up_and_down
+    refute @board.solved?
+
+    @board.grid = [ %w(x o o), ['x', nil, nil], ['x', nil, nil]]
+    assert @board.solved?
+
+    @board.grid = [ [nil, nil, 'x'], [nil, nil, 'x'], [nil, nil, 'x']]
+    assert @board.solved?
+
+    @board.grid = [ %w(x o o), ['x', nil, nil], ['o', nil, nil]]
+    refute @board.solved?
+  end
+
+  def test_won_diagonally
+    refute @board.solved?
+
+    @board.grid = [ ['x', 'o', 'x'], ['x', 'x', nil], ['o', nil, 'x']]
+    assert @board.solved?
+
+    @board.grid = [ [nil, nil, 'x'], [nil, 'x', nil], ['x', nil, nil]]
+    assert @board.solved?
+
+    @board.grid = [ [nil, nil, 'x'], [nil, 'x', nil], ['o', nil, nil]]
+    refute @board.solved?
+  end
+
+end

data/test/brute_force_implementation_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class BruteForceImplementationTest < MiniTest::Unit::TestCase
+  def setup
+    TicTacToe::BruteForceImplementation.instance_eval { attr_accessor :board }
+    @implementation = TicTacToe::BruteForceImplementation.new(TicTacToe::Board.new, 'x')
+  end
+
+  def test_can_win_next_turn
+    # Test private method that it returns the correct amount of winning moves
+
+    set_grid([[ 'x', nil, nil], [nil, nil, nil], [nil, nil, nil] ])
+    assert_equal 1, @implementation.send(:can_win_next_turn?, 0, 1)
+
+    # 1 | 2 | x
+    # 4 | o | 6
+    # 7 | x | 9
+    set_grid([[ nil, nil, 'x'], [nil, 'o', nil], [nil, 'x', nil] ])
+    assert_equal 2, @implementation.send(:can_win_next_turn?, 2, 2)
+  end
+
+  def set_grid(grid)
+    @implementation.board.instance_variable_set("@grid", grid)
+  end
+end

data/test/solver_test.rb

@@ -0,0 +1,149 @@
+require 'test_helper'
+
+class SolverTest < MiniTest::Unit::TestCase
+  def setup
+    TicTacToe::Solver.instance_eval { attr_accessor :strategy } # For testing
+    @solver = TicTacToe::Solver.new(TicTacToe::Board.new, 'x')
+    @solver.strategy.class.instance_eval { attr_accessor :implementation } # For testing
+    @solver.strategy.implementation.class.instance_eval { attr_accessor :board } # For testing
+  end
+
+  def test_win_next_move
+    refute board.solved?
+
+    # Will win, when there is a winning move
+    set_grid([[ 'x', 'x', nil], [nil, nil, nil], [nil, nil, nil] ])
+    refute board.solved? # Is not solved yet
+    @solver.next_move!
+    assert board.solved? # Solved it
+    assert_equal 'x', board.get_cell(2, 0) # Placed the right letter
+
+    set_grid([[ 'x', nil, nil], [nil, 'x', nil], [nil, nil, nil] ])
+    refute board.solved?
+    @solver.next_move!
+    assert board.solved?
+    assert_equal 'x', board.get_cell(2, 2)
+    
+    set_grid([[ 'x', nil, nil], [nil, nil, nil], ['x', nil, nil] ])
+    refute board.solved?
+    @solver.next_move!
+    assert board.solved?
+    assert_equal 'x', board.get_cell(0, 1)
+
+    # Can not win when there is no winning move
+    set_grid([[ 'o', nil, nil], [nil, nil, nil], ['o', nil, nil] ])
+    refute board.solved?
+    @solver.next_move!
+    refute board.solved?
+  end
+
+  def test_block_next_move
+    refute board.solved?
+
+    # Will block when the opponent is about to win
+    set_grid([ ['o', 'o', nil], [nil, nil,nil], [nil,nil,nil]])
+    refute board.solved?
+    @solver.next_move!
+    refute board.solved?
+    # Placed the right letter at the right place
+    assert_equal 'x', board.get_cell(2, 0) 
+  end
+
+
+  def test_fork_next_move
+    refute board.solved?
+
+    # Place letter in place where next turn is an automatic win
+    set_grid([ ['x', nil, nil], [nil, 'o',nil], [nil,nil,'x']])
+    refute board.solved?
+    @solver.next_move!
+    refute board.solved?
+    assert_equal 'x', board.get_cell(2, 0)
+
+    # 1 | 2 | x
+    # 4 | o | 6
+    # 7 | x | 9 <--
+    set_grid([ [nil, nil, 'x'], [nil, 'o',nil], [nil,'x',nil]])
+    refute board.solved?
+    @solver.next_move!
+    refute board.solved?
+    assert_equal 'x', board.get_cell(2, 2)
+  end
+
+  def test_block_fork_next_move
+    # Will block an opponent if they will have a change to fork next turn
+
+    # 1 | 2 | o
+    # 4 | x | 6
+    # 7 | o | 9 <--
+    set_grid([ [nil, nil, 'o'], [nil, 'x',nil], [nil,'o',nil]])
+    refute board.solved?
+    @solver.next_move!
+    refute board.solved?
+    assert_equal 'x', board.get_cell(2, 2)
+
+    # 1 | 2 | o
+    # 4 | x | 6
+    # o | 8 | 9
+    set_grid([[nil,nil,'o'],[nil,'x',nil],['o',nil,nil]])
+    @solver.next_move!
+    assert_nil board.get_cell(2,2)
+    assert_nil board.get_cell(0,0)
+
+    # x | 2 | 3
+    # 4 | o | 6
+    # 7 | 8 | o
+    set_grid([ ['x',nil,nil], [nil,'o',nil], [nil,nil,'o'] ])
+    @solver.next_move!
+    assert_nil board.get_cell(1, 0)
+    assert_nil board.get_cell(0, 1)
+    assert_nil board.get_cell(2, 1)
+    assert_nil board.get_cell(1, 2)
+  end
+
+  def test_center
+    # Will play in the center if its an empty board
+    assert board.empty?
+    @solver.next_move!
+    assert_equal 'x', board.center_cell
+    assert board.only_one?
+  end
+  
+  def test_oposite_corner
+    # 1 | 2 | o
+    # 4 | x | 6
+    # 7 | 8 | 9
+    set_grid([[nil,nil,'o'],[nil,'x',nil],[nil,nil,nil]])
+    @solver.next_move!
+    assert_equal 'x', board.get_cell(0, 2)
+
+    set_grid([['o',nil,nil],[nil,'x',nil],[nil,nil,nil]])
+    @solver.next_move!
+    assert_equal 'x', board.get_cell(2, 2)
+  end
+
+  def test_empty_corner
+    set_grid([[nil,nil,nil],[nil,'o',nil],[nil,nil,nil]])
+    @solver.next_move!
+    assert_equal 'x', board.get_cell(0,0)
+  end
+  
+  def test_any_empty_position
+    # o | x | o
+    # o | x | 6
+    # x | o | x
+    set_grid([['o', 'x', 'o'],['o','x',nil],['x','o','x']])
+    @solver.next_move!
+    assert_equal 'x', board.get_cell(2, 1)
+  end
+
+  private
+
+  def set_grid(grid)
+    board.instance_variable_set("@grid", grid)
+  end
+
+  def board
+    @solver.strategy.implementation.board
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'tic_tac_toe'
+require 'minitest/unit'
+require 'minitest/autorun'

data/tic-tac-toe.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "tic-tac-toe/version"
+
+Gem::Specification.new do |s|
+  s.name        = "erics_tic_tac_toe"
+  s.version     = TicTacToe::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Eric Koslow"]
+  s.email       = ["ekoslow@gmail.com"]
+  s.homepage    = "https://github.com/ekosz/Erics-Tic-Tac-Toe"
+  s.summary     = %q{A game of Tic Tac Toe}
+  s.description = %q{Plays the perfect game of Tic Tac Toe everytime. This computer can not lose.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency "rake"
+end
+

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: erics_tic_tac_toe
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Eric Koslow
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-09 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Plays the perfect game of Tic Tac Toe everytime. This computer can not lose.
+email: 
+- ekoslow@gmail.com
+executables: 
+- tic_tac_toe
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- LICENSE
+- README.markdown
+- Rakefile
+- bin/tic_tac_toe
+- lib/tic-tac-toe/board.rb
+- lib/tic-tac-toe/game.rb
+- lib/tic-tac-toe/game_types/terminal_game.rb
+- lib/tic-tac-toe/solver.rb
+- lib/tic-tac-toe/strategies/threebythree_implementations/brute_force_implementation.rb
+- lib/tic-tac-toe/strategies/threebythree_stategy.rb
+- lib/tic-tac-toe/version.rb
+- lib/tic_tac_toe.rb
+- test/board_test.rb
+- test/brute_force_implementation_test.rb
+- test/solver_test.rb
+- test/test_helper.rb
+- tic-tac-toe.gemspec
+has_rdoc: true
+homepage: https://github.com/ekosz/Erics-Tic-Tac-Toe
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A game of Tic Tac Toe
+test_files: 
+- test/board_test.rb
+- test/brute_force_implementation_test.rb
+- test/solver_test.rb
+- test/test_helper.rb