erics_tic_tac_toe 0.1.0 → 0.5.0

data/lib/tic_tac_toe/players/human_player.rb

@@ -0,0 +1,28 @@
+module TicTacToe
+
+  class HumanPlayer 
+    attr_reader :letter
+    attr_writer :move
+
+    def initialize(params)
+      @letter, @move = (params['letter'] || params[:letter]), 
+                       (params['move'] || params[:move])
+    end
+
+    def get_move(_board)
+      move = @move
+      @move = nil
+      move
+    end
+
+    def has_next_move?
+      !!@move
+    end
+
+    def type
+      Player::HUMAN
+    end
+
+  end
+
+end

data/lib/tic_tac_toe/presentors/game_presenter.rb

@@ -0,0 +1,16 @@
+module TicTacToe
+  class GamePresentor
+
+    def initialize(game)
+      @game = game
+    end
+
+    def grid
+      @game.grid.each_with_index.map do |row, i|
+        row.each_with_index.map do |cell, j|
+          cell || ((i*3)+(j+1)).to_s
+        end
+      end
+    end
+  end
+end

data/lib/tic_tac_toe/presentors/player_presenter.rb

@@ -0,0 +1,13 @@
+require 'json'
+
+module TicTacToe
+  class PlayerPresenter
+    def initialize(player)
+      @player = player
+    end
+
+    def move_json(move=nil)
+      {letter: @player.letter, type: @player.type, move: move}.to_json
+    end
+  end
+end

data/lib/tic_tac_toe/strategies/minimax_strategy.rb

@@ -0,0 +1,91 @@
+module TicTacToe
+  # This implements the Minimax algorithum with AlphaBeta Prunning
+  # http://en.wikipedia.org/wiki/Minimax
+  # http://en.wikipedia.org/wiki/Alpha-beta_pruning
+  class MinimaxStrategy
+
+    attr_reader :board # Avoid getters, setters and properties
+
+    def initialize(board, letter)
+      @board, @letter = board, letter
+    end
+
+    def solve
+      raise "Can not solve a full board" if @board.full?
+      Minimax.new(@board, @letter).best_move
+    end
+  end
+
+  # The game tree needs a evaluator for generating rankings,
+  # an initial game state,
+  # and a player
+  #
+  # This class uses 5 instance variables: @evaluator, @state, 
+  # @depth, @alpha, @beta. Should be < 3
+  #
+  # This class has 63 lines. Should be <= 50
+  class Minimax
+
+    MAXDEPTH = 6
+    PositiveInfinity = +1.0/0.0 
+    NegativeInfinity = -1.0/0.0 
+
+    def initialize(board, player)
+      @start_board = board
+      @player = player
+    end
+
+    def best_move
+      @start_board.empty_positions.max_by do |column, row| 
+        score(@start_board.clone.play_at(column, row, @player), next_turn(@player))
+      end
+    end
+
+    private 
+
+    def score(board, whos_turn, depth=1, 
+              alpha=NegativeInfinity, beta=PositiveInfinity)
+
+      if board.full? || board.solved?
+        return  1.0 / depth if board.winner == @player
+        return -1.0         if board.solved?
+        return  0
+      end
+
+      if whos_turn == @player
+        board.empty_positions.each do |column, row|
+          alpha = [
+            alpha, 
+            next_score(board, column, row, whos_turn, depth, alpha, beta)
+          ].max
+          break if beta <= alpha || depth >= MAXDEPTH
+        end
+        return alpha
+      end
+
+      board.empty_positions.each do |column, row|
+        beta = [
+          beta, 
+          next_score(board, column, row, whos_turn, depth, alpha, beta)
+        ].min
+        break if alpha >= beta || depth >= MAXDEPTH
+      end
+      beta
+    end
+
+    def next_score(board, column, row, whos_turn, depth, alpha, beta)
+      score( board.clone.play_at(column, row, whos_turn),
+             next_turn(whos_turn),
+             depth+1, alpha, beta
+           )
+    end
+
+    def next_turn(player)
+      case player
+      when X then O
+      when O then X
+      end
+    end
+  end
+end
+

data/lib/tic_tac_toe/strategies/three_by_three_strategy.rb

@@ -0,0 +1,260 @@
+module TicTacToe
+  # Strategy used when playing on a 3x3 board
+  class ThreeByThreeStrategy
+    def initialize(board, letter)
+      @heuristic = ThreeByThree::Heuristic.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
+      [:win, :block, :fork, :block_fork, 
+        :center, :opposite_corner, :empty_corner, :empty_side].each do |step|
+        move = @heuristic.send(step)
+        return move if move
+        end
+
+      raise "No possible moves to play!"
+    end
+  end
+
+  module ThreeByThree
+    # 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
+    class Heuristic
+
+      attr_reader :board
+
+      def initialize(board, letter)
+        @board, @letter, @state = board, letter, PotentialState.new(board, letter)
+        @other_player = other_player
+      end
+
+      # Try placing letter at every available position
+      # If the board is solved, do that
+      def win
+        each_position do |row, column|
+          if @state.at(row, column).solved?
+            return [row, column]
+          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)
+        state = PotentialState.new(board, other_player(letter))
+        each_position do |row, column|
+          if state.at(row, column).solved?
+            return [row, column]
+          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
+        @state.each_forking_position do |row, column|
+          return [row, column]
+        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
+        PotentialState.new(@board, @other_player).each_forking_position do |row, column|
+
+          # Simulate blocking the fork
+          temp_board = @board.clone
+          temp_board.play_at(row, column, @letter)
+
+          # Search for the elusive double fork
+          if PotentialState.new(temp_board, @other_player).forking_positions.any?
+            return force_a_block 
+          end
+
+          return [row, column]
+        end
+        false
+      end
+
+      def center
+        return false if @board.get_cell(@board.size/2, @board.size/2)
+        [1,1]
+      end
+
+      # Cycle through all of the corners looking for the opponent's letter
+      # If one is found, place letter at the opposite corner
+      def opposite_corner
+        first = 0
+        last = @board.size - 1
+        corners.each_with_index do |corner, index|
+          if corner == @other_player
+            next if @board.get_cell(*opposite_corner_from_index(index).compact)
+            return opposite_corner_from_index(index)
+          end
+        end
+        false
+      end
+
+      # Cycle though all of the corners, until one is found that is empty
+      def empty_corner
+        corners.each_with_index do |corner, index|
+          next if corner
+          return corner_from_index(index)
+        end
+        false
+      end
+
+      # Place letter at a random empty cell, at this point it should only be sides left
+      def empty_side
+        @board.empty_positions do |row, column|
+          return [row, column] 
+        end
+        false
+      end
+
+      private
+
+      def corners
+        [@board.get_cell(0, 0), # Top Left
+         @board.get_cell(@board.size-1, 0), # Top Right
+         @board.get_cell(@board.size-1, @board.size-1), # Bottom Right
+         @board.get_cell(0, @board.size-1)] # Bottom Left
+      end
+
+      def corner_from_index(index)
+        first = 0
+        last = @board.size - 1
+        case index
+        when 0 # Top Left
+          [first, first]
+        when 1 # Top Right
+          [last, first]
+        when 2 # Bottom Right
+          [last, last]
+        when 3 # Bottom Left
+          [first, last]
+        end 
+      end
+
+      def opposite_corner_from_index(index)
+        first = 0
+        last = @board.size - 1
+        case index
+        when 0 # Top Left
+          [last, last]
+        when 1 # Top Right
+          [first, last]
+        when 2 # Bottom Right
+          [first, first]
+        when 3 # Bottom Left
+          [last, first]
+        end
+      end
+
+      def other_player(letter = @letter)
+        letter == X ? O : X
+      end
+
+      def each_position(&block)
+        @board.size.times do |column|
+          @board.size.times do |row|
+            yield(row, column)
+          end
+        end
+      end
+
+      def force_a_block
+        # Force them to block without creating another fork
+        each_position do |row, column|
+          if @state.at(row, column).can_win_next_turn?
+
+            # Simulate forcing them to block
+            temp_board = @board.clone
+            temp_board.play_at(row, column, @letter)
+            temp_board.play_at(*block(temp_board, @other_player), @other_player)
+
+            # Did I just create another fork with that block?
+            next if PotentialState.new(temp_board, @other_player).fork_exists?
+
+            return [row, column]
+
+          end
+        end
+      end
+    end
+    # Represents a state of players move
+    # This is comprised of a board and letter (player)
+    class PotentialState
+      def initialize(board, letter)
+        @board, @letter = board, letter
+      end
+
+      def at(row, column)
+        new_board = @board.clone
+        new_board.play_at(row, column, @letter)
+        PotentialState.new(new_board, @letter)
+      end
+
+      def solved?
+        @board.solved?
+      end
+
+      def each_forking_position(&block)
+        forking_positions.each { |position| yield(*position) }
+      end
+
+      def fork_exists?
+        winning_positions_count >= 2
+      end
+
+      def can_win_next_turn?
+        each_position do |row, column|
+          return true if at(row, column).solved?
+        end
+        false
+      end
+
+      def forking_positions
+        positions = [] 
+        each_position do |row, column|
+          positions << [row, column] if at(row, column).fork_exists?
+        end
+        positions
+      end
+
+      private
+
+      def winning_positions_count
+        count = 0
+        each_position do |row, column|
+          count += 1 if at(row, column).solved?
+        end
+        count
+      end
+
+      def each_position(&block)
+        @board.size.times do |column|
+          @board.size.times do |row|
+            yield(row, column)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/{tic-tac-toe → tic_tac_toe}/version.rb

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

data/test/board_test.rb

@@ -2,45 +2,64 @@ 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
+  def test_grid_can_be_set
+    @board.grid = 'Foo'
+    assert_equal 'Foo', @board.grid
+  end
+
+  def test_a_new_board_is_empty
     # Board empty when created
     assert @board.empty?
-
+  end
+  
+  def test_a_board_after_played_is_no_longer_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
+  def test_a_new_board_is_not_empty
     refute @board.full?
+  end
 
+  def test_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
+  def test_a_empty_board_is_not_only_one
     # False when empty
     refute @board.only_one?
-
+  end
+  
+  def test_a_board_knows_when_only_one_peice
     # True when one
     @board.grid = [ ['x',nil,nil], [nil,nil,nil], [nil,nil,nil] ]
     assert @board.only_one?
+  end
 
+  def test_a_board_with_more_than_one_place_is_not_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
+  def test_get_cell_returns_nil_when_nothing_there
     # Returns nil when nothing in cell
     assert_nil @board.get_cell(0, 0)
+  end
 
+  def test_play_at
+    # Cells are proper set and override nil values
+    @board.play_at(1, 1, 'x')
+    assert_equal 'x', @board.get_cell(1,1)
+  end
+
+  def test_get_cell
     # Returns the right letter after they've been played
     @board.play_at(0,0,"o")
     assert_equal "o", @board.get_cell(0, 0)
@@ -49,49 +68,7 @@ class BoardTest < MiniTest::Unit::TestCase
     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
+  def test_can_not_override_values
     assert_nil @board.get_cell(1,1)
     @board.play_at(1, 1, 'x')
     assert_equal 'x', @board.get_cell(1,1)
@@ -99,7 +76,7 @@ class BoardTest < MiniTest::Unit::TestCase
     assert_equal 'x', @board.get_cell(1,1)
   end
 
-  def test_solved_acoss
+  def test_solved_across
     refute @board.solved?
 
     @board.grid = [ %w(x x x), [nil, nil, nil], [nil, nil, nil]]
@@ -138,4 +115,15 @@ class BoardTest < MiniTest::Unit::TestCase
     refute @board.solved?
   end
 
+  def test_displays_correctly
+    assert_equal (<<-HEREDOC), @board.to_s
+-----------
+1 | 2 | 3 | 
+4 | 5 | 6 | 
+7 | 8 | 9 | 
+-----------
+
+HEREDOC
+  end
+
 end