erics_tic_tac_toe 0.5.0 → 0.5.1

data/bin/tic_tac_toe

@@ -20,8 +20,8 @@ def setup
   terminal = TicTacToe::TerminalGame.new(game.board)
 
   if terminal.computer_goes_first?
-    @player_1 = TicTacToe::ComputerPlayer.new(letter: 'o')
-    @player_2 = TicTacToe::HumanPlayer.new(letter: 'x')
+    @player_1 = TicTacToe::HumanPlayer.new(letter: 'x')
+    @player_2 = TicTacToe::ComputerPlayer.new(letter: 'o')
   else
     @player_1 = TicTacToe::HumanPlayer.new(letter: 'o')
     @player_2 = TicTacToe::HumanPlayer.new(letter: 'x')
@@ -35,6 +35,7 @@ end
 game, terminal = setup
 
 loop do
+
   game.start
   terminal = TicTacToe::TerminalGame.new(game.board)
 
@@ -42,6 +43,7 @@ loop do
     terminal.update_board
     break unless terminal.play_again?
     game, terminal = setup
+    next
   end
 
   terminal.update_board

data/lib/tic_tac_toe.rb

@@ -4,11 +4,18 @@
 module TicTacToe
   X = 'x'.freeze
   O = 'o'.freeze
+
+  def self.number_to_cords(num, size)
+    num = num.to_i
+    num -= 1
+    [num % size, num/size]
+  end
+
 end
 
 # Internal Project Requires
 require 'tic_tac_toe/board'
 require 'tic_tac_toe/game'
 require 'tic_tac_toe/player'
-require 'tic_tac_toe/presentors/game_presenter'
-require 'tic_tac_toe/presentors/player_presenter'
+require 'tic_tac_toe/presenters/game_presenter'
+require 'tic_tac_toe/presenters/player_presenter'

data/lib/tic_tac_toe/game.rb

@@ -25,7 +25,7 @@ module TicTacToe
 
     def start
       while @current_player && (move = @current_player.get_move(@board))
-        move = number_to_cords(move) unless move.is_a?(Array)
+        move = TicTacToe::number_to_cords(move, @board.size) unless move.is_a?(Array)
 
         @board.play_at(*move, @current_player.letter)
         break if over?
@@ -56,12 +56,6 @@ module TicTacToe
       solved? || cats?
     end
 
-    def number_to_cords(num)
-      num = num.to_i
-      num -= 1
-      [num % @board.size, num/@board.size]
-    end
-
     def switch_player
       @current_player = @current_player == @player_1 ? @player_2 : @player_1
     end

data/lib/tic_tac_toe/game_types/terminal_game.rb

@@ -1,86 +1,68 @@
 module TicTacToe
-  # Terminal GameType
-  # Interacts with the user through the terminal
-  # Uses puts for output, and gets for input
-  class TerminalGame
-    # Internal Error used when a user tries pulling an illegal move
-    class IllegalMove < RuntimeError
-    end
-
-    def initialize(board, io=Kernel)
-      @board = board
-      @io = io
-    end
-
-    def computer_goes_first?
-      input = get_input("Would you like to play first or second? (f/s)")
-
-      return true unless input =~ /^(f|first)$/i
-      false
-    end
-
-    def get_move_from_user
-      cords = get_cords_from_user
+  module GameType
+    # Terminal GameType
+    # Interacts with the user through the terminal
+    # Uses puts for output, and gets for input
+    class Terminal
+      # Internal Error used when a user tries pulling an illegal move
+      class IllegalMove < RuntimeError
+      end
 
-      raise IllegalMove.new("That cell is already taken") unless empty_cell?(cords)
+      def initialize(board, io=Kernel)
+        @board = board
+        @io = io
+      end
 
-      cords
-    rescue IllegalMove => error
-      display_text "Illegal Move: #{error.message}. Please try again"
-      retry
-    end
+      def computer_goes_first?
+        input = get_input("Would you like to play first or second? (f/s)")
 
-    def play_again?
-      input = get_input "Play again? (y/n)"
-      input =~ /^(y|yes)$/i
-    end
+        return true unless input =~ /^(f|first)$/i
+        false
+      end
 
-    def select(choices)
-      loop do
-        output = "Select the solver:\n"
-        choices.each_with_index { |choice, i| output += "#{i+1}: #{choice}\n" }
+      def get_move_from_user
+        cords = get_cords_from_user
 
-        input = get_input(output)
+        raise IllegalMove.new("That cell is already taken") unless empty_cell?(cords)
 
-        if input =~ /^\d+$/ and input.to_i <= choices.size
-          return choices[input.to_i-1]
-        end
+        cords
+      rescue IllegalMove => error
+        display_text "Illegal Move: #{error.message}. Please try again"
+        retry
+      end
 
-        display_text("Not a valid choice") 
+      def play_again?
+        input = get_input "Play again? (y/n)"
+        input =~ /^(y|yes)$/i
       end
-    end
 
-    def update_board
-      @io.puts @board
-    end
+      def update_board
+        @io.puts @board
+      end
 
-    def display_text(text)
-      @io.puts text
-    end
+      def display_text(text)
+        @io.puts text
+      end
 
-    private
+      private
 
-    def get_input(text)
-      @io.print text + ' '
-      @io.gets.chomp
-    end
+      def get_input(text)
+        @io.print text + ' '
+        @io.gets.chomp
+      end
 
-    def empty_cell?(cords)
-      !@board.get_cell(*cords)
-    end
+      def empty_cell?(cords)
+        !@board.get_cell(*cords)
+      end
 
-    def get_cords_from_user
-      input = get_input("Your move (1-#{@board.size**2}):")
+      def get_cords_from_user
+        input = get_input("Your move (1-#{@board.size**2}):")
 
-      raise IllegalMove.new("That is not a real location") unless input =~ /^\d+$/
+        raise IllegalMove.new("That is not a real location") unless input =~ /^\d+$/
 
-      cord_from_num(input.to_i)
-    end
+        TicTacToe::number_to_cords(input, @board.size)
+      end
 
-    def cord_from_num(num)
-      num -= 1
-      [num % @board.size, num/@board.size]
     end
   end
-
 end

data/lib/tic_tac_toe/player.rb

@@ -1,12 +1,12 @@
 module TicTacToe
-  class Player
+  module Player
     HUMAN = 'human'
     COMPUTER = 'computer'
 
     def self.build(params)
-      return HumanPlayer.new(params) if params['type'] == HUMAN
+      return Player::Human.new(params) if params['type'] == HUMAN
 
-      ComputerPlayer.new(params)
+      Player::Computer.new(params)
     end
 
   end

data/lib/tic_tac_toe/players/computer_player.rb

@@ -1,23 +1,27 @@
 module TicTacToe
 
-  class ComputerPlayer
-    attr_reader :letter
+  module Player
 
-    def initialize(params, solver=MinimaxStrategy)
-      @letter = params['letter'] || params[:letter]
-      @solver = solver
-    end
+    class Computer
+      attr_reader :letter
 
-    def get_move(board)
-      @solver.new(board, @letter).solve
-    end
+      def initialize(params, solver=Strategy::MinimaxStrategy)
+        @letter = params['letter'] || params[:letter]
+        @solver = solver
+      end
+
+      def get_move(board)
+        @solver.new(board, @letter).solve
+      end
+
+      def has_next_move?
+        true
+      end
+
+      def type
+        Player::COMPUTER
+      end
 
-    def has_next_move?
-      true
-    end
-    
-    def type
-      Player::COMPUTER
     end
 
   end

data/lib/tic_tac_toe/players/human_player.rb

@@ -1,26 +1,29 @@
 module TicTacToe
 
-  class HumanPlayer 
-    attr_reader :letter
-    attr_writer :move
+  module Player
+    class Human
+      attr_reader :letter
+      attr_writer :move
 
-    def initialize(params)
-      @letter, @move = (params['letter'] || params[:letter]), 
-                       (params['move'] || params[:move])
-    end
+      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 get_move(_board)
+        move = @move
+        @move = nil
+        move
+      end
 
-    def has_next_move?
-      !!@move
-    end
+      def has_next_move?
+        !!@move
+      end
+
+      def type
+        Player::HUMAN
+      end
 
-    def type
-      Player::HUMAN
     end
 
   end

data/lib/tic_tac_toe/presenters/game_presenter.rb

@@ -0,0 +1,21 @@
+module TicTacToe
+
+  module Presenter
+
+    class Game
+      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
+
+end

data/lib/tic_tac_toe/presenters/player_presenter.rb

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

data/lib/tic_tac_toe/strategies/minimax_strategy.rb

@@ -1,89 +1,87 @@
 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
+  module Strategy
+    # This implements the Minimax algorithum with AlphaBeta Prunning
+    # http://en.wikipedia.org/wiki/Minimax
+    # http://en.wikipedia.org/wiki/Alpha-beta_pruning
+    class MinimaxStrategy
 
-    def initialize(board, letter)
-      @board, @letter = board, letter
-    end
+      attr_reader :board
 
-    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 initialize(board, letter)
+        @board, @letter = board, letter
+      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))
+      def solve
+        raise "Can not solve a full board" if @board.full?
+        Minimax.new(@board, @letter).best_move
       end
     end
 
-    private 
+    # The game tree needs a evaluator for generating rankings,
+    # an initial game state,
+    # and a player
+    class Minimax
 
-    def score(board, whos_turn, depth=1, 
-              alpha=NegativeInfinity, beta=PositiveInfinity)
+      MAXDEPTH = 6
+      PositiveInfinity = +1.0/0.0 
+      NegativeInfinity = -1.0/0.0 
 
-      if board.full? || board.solved?
-        return  1.0 / depth if board.winner == @player
-        return -1.0         if board.solved?
-        return  0
+      def initialize(board, player)
+        @start_board = board
+        @player = player
       end
 
-      if whos_turn == @player
+      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|
-          alpha = [
-            alpha, 
+          beta = [
+            beta, 
             next_score(board, column, row, whos_turn, depth, alpha, beta)
-          ].max
-          break if beta <= alpha || depth >= MAXDEPTH
+          ].min
+          break if alpha >= beta || depth >= MAXDEPTH
         end
-        return alpha
+        beta
       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
+      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
-      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
+      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

@@ -1,257 +1,259 @@
 module TicTacToe
-  # Strategy used when playing on a 3x3 board
-  class ThreeByThreeStrategy
-    def initialize(board, letter)
-      @heuristic = ThreeByThree::Heuristic.new(board, letter)
-    end
+  module Strategy
+    # 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
+      # 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!"
+        raise "No possible moves to play!"
+      end
     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
+    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
+        attr_reader :board
 
-      def initialize(board, letter)
-        @board, @letter, @state = board, letter, PotentialState.new(board, letter)
-        @other_player = other_player
-      end
+        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]
+        # 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
-        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]
+        # 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
-        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]
+        # 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
-        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|
+        # 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)
 
-          # 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
 
-          # Search for the elusive double fork
-          if PotentialState.new(temp_board, @other_player).forking_positions.any?
-            return force_a_block 
+            return [row, column]
           end
-
-          return [row, column]
+          false
         end
-        false
-      end
 
-      def center
-        return false if @board.get_cell(@board.size/2, @board.size/2)
-        [1,1]
-      end
+        def center
+          return false if @board.get_cell(@board.size/2, @board.size/2)
+          [@board.size/2, @board.size/2]
+        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)
+        # 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
-        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)
+        # 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
-        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] 
+        # 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
-        false
-      end
 
-      private
+        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 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 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]
+        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
-      end
 
-      def other_player(letter = @letter)
-        letter == X ? O : X
-      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)
+        def each_position(&block)
+          @board.size.times do |column|
+            @board.size.times do |row|
+              yield(row, column)
+            end
           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?
+        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)
+              # 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?
+              # Did I just create another fork with that block?
+              next if PotentialState.new(temp_board, @other_player).fork_exists?
 
-            return [row, column]
+              return [row, column]
 
+            end
           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
+      # 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 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 solved?
+          @board.solved?
+        end
 
-      def each_forking_position(&block)
-        forking_positions.each { |position| yield(*position) }
-      end
+        def each_forking_position(&block)
+          forking_positions.each { |position| yield(*position) }
+        end
 
-      def fork_exists?
-        winning_positions_count >= 2
-      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?
+        def can_win_next_turn?
+          each_position do |row, column|
+            return true if at(row, column).solved?
+          end
+          false
         end
-        false
-      end
 
-      def forking_positions
-        positions = [] 
-        each_position do |row, column|
-          positions << [row, column] if at(row, column).fork_exists?
+        def forking_positions
+          positions = [] 
+          each_position do |row, column|
+            positions << [row, column] if at(row, column).fork_exists?
+          end
+          positions
         end
-        positions
-      end
 
-      private
+        private
 
-      def winning_positions_count
-        count = 0
-        each_position do |row, column|
-          count += 1 if at(row, column).solved?
+        def winning_positions_count
+          count = 0
+          each_position do |row, column|
+            count += 1 if at(row, column).solved?
+          end
+          count
         end
-        count
-      end
 
-      def each_position(&block)
-        @board.size.times do |column|
-          @board.size.times do |row|
-            yield(row, column)
+        def each_position(&block)
+          @board.size.times do |column|
+            @board.size.times do |row|
+              yield(row, column)
+            end
           end
         end
       end

data/lib/tic_tac_toe/version.rb

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

data/test/game_presentor_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 class GamePresentorTest < MiniTest::Unit::TestCase
   def setup
     @game = TicTacToe::Game.new
-    @presentor = TicTacToe::GamePresentor.new(@game)
+    @presentor = TicTacToe::Presenter::Game.new(@game)
   end
 
   def test_grid
@@ -12,7 +12,7 @@ class GamePresentorTest < MiniTest::Unit::TestCase
 
   def test_grid_with_moves
     @game = TicTacToe::Game.new([['x', nil, nil], [nil, nil, nil], [nil, nil, nil]])
-    @presentor = TicTacToe::GamePresentor.new(@game)
+    @presentor = TicTacToe::Presenter::Game.new(@game)
 
     assert_equal [%w(x 2 3), %w(4 5 6), %w(7 8 9)], @presentor.grid
   end

data/test/player_presenter_test.rb

@@ -7,6 +7,6 @@ class PlayerPresenterTest < MiniTest::Unit::TestCase
 
   def test_move_json
     assert_equal({letter: 'x', type: 'mock', move: '1'}.to_json,
-                 TicTacToe::PlayerPresenter.new(@player_mock).move_json('1'))
+                 TicTacToe::Presenter::Player.new(@player_mock).move_json('1'))
   end
 end

data/test/player_test.rb

@@ -5,12 +5,12 @@ class BoardMock; end
 class PlayerTest < MiniTest::Unit::TestCase
 
   def test_build_human_player
-    assert_equal TicTacToe::HumanPlayer,
+    assert_equal TicTacToe::Player::Human,
                  TicTacToe::Player.build('type' => 'human').class
   end
 
   def test_build_computer_player
-    assert_equal TicTacToe::ComputerPlayer,
+    assert_equal TicTacToe::Player::Computer,
                  TicTacToe::Player.build('type' => 'computer').class
   end
 end
@@ -36,7 +36,7 @@ end
 
 class HumanPlayerTest < MiniTest::Unit::TestCase
   def setup
-    @player = TicTacToe::HumanPlayer.new('letter' => "x", 'move' => [0,0])
+    @player = TicTacToe::Player::Human.new('letter' => "x", 'move' => [0,0])
   end
 
   include SharedPlayerTests
@@ -50,7 +50,7 @@ class ComputerPlayerTest < MiniTest::Unit::TestCase
     end
   end
   def setup
-    @player = TicTacToe::ComputerPlayer.new({'letter' => "x"}, SolverMock)
+    @player = TicTacToe::Player::Computer.new({'letter' => "x"}, SolverMock)
   end
 
   include SharedPlayerTests

data/test/potential_state_test.rb

@@ -48,6 +48,6 @@ private
   def set_grid(grid)
     board = TicTacToe::Board.new
     board.grid = grid
-    @state = TicTacToe::ThreeByThree::PotentialState.new(board, 'x')
+    @state = TicTacToe::Strategy::ThreeByThree::PotentialState.new(board, 'x')
   end
 end

data/test/solver_test.rb

@@ -165,7 +165,7 @@ end
 class MinimaxSolverTest < MiniTest::Unit::TestCase
   def setup
     @board = TicTacToe::Board.new
-    @solver = TicTacToe::MinimaxStrategy.new(@board, 'x')
+    @solver = TicTacToe::Strategy::MinimaxStrategy.new(@board, 'x')
   end
   
   include SharedSolverTests
@@ -174,7 +174,7 @@ end
 class ThreeByThreeSolverTest < MiniTest::Unit::TestCase
   def setup
     @board = TicTacToe::Board.new
-    @solver = TicTacToe::ThreeByThreeStrategy.new(@board, 'x')
+    @solver = TicTacToe::Strategy::ThreeByThreeStrategy.new(@board, 'x')
   end
   
   include SharedSolverTests

data/test/terminal_game_test.rb

@@ -19,34 +19,34 @@ class TerminalGameTest < MiniTest::Unit::TestCase
   end
 
   def test_computer_goes_first
-    assert TicTacToe::TerminalGame.new(nil, IoMock.new("s")).computer_goes_first?
-    refute TicTacToe::TerminalGame.new(nil, IoMock.new("f")).computer_goes_first?
+    assert TicTacToe::GameType::Terminal.new(nil, IoMock.new("s")).computer_goes_first?
+    refute TicTacToe::GameType::Terminal.new(nil, IoMock.new("f")).computer_goes_first?
   end
 
   def test_get_move_from_user
-    game = TicTacToe::TerminalGame.new(TicTacToe::Board.new, IoMock.new("1"))
+    game = TicTacToe::GameType::Terminal.new(TicTacToe::Board.new, IoMock.new("1"))
     assert_equal [0, 0], game.get_move_from_user
 
-    game = TicTacToe::TerminalGame.new(TicTacToe::Board.new, IoMock.new("9"))
+    game = TicTacToe::GameType::Terminal.new(TicTacToe::Board.new, IoMock.new("9"))
     assert_equal [2, 2], game.get_move_from_user
   end
 
   def test_handle_bad_input
-    game = TicTacToe::TerminalGame.new(TicTacToe::Board.new, IoMock.new(["1", "a"]))
+    game = TicTacToe::GameType::Terminal.new(TicTacToe::Board.new, IoMock.new(["1", "a"]))
     assert_equal [0, 0], game.get_move_from_user
   end
 
   def test_play_again
-    game = TicTacToe::TerminalGame.new(nil, IoMock.new("y"))
+    game = TicTacToe::GameType::Terminal.new(nil, IoMock.new("y"))
     assert game.play_again?
 
-    game = TicTacToe::TerminalGame.new(nil, IoMock.new("n"))
+    game = TicTacToe::GameType::Terminal.new(nil, IoMock.new("n"))
     refute game.play_again?
   end
 
   def test_update_board
     mock = IoMock.new
-    game = TicTacToe::TerminalGame.new("FooBar", mock)
+    game = TicTacToe::GameType::Terminal.new("FooBar", mock)
     game.update_board
 
     assert_equal "FooBar", mock.output
@@ -54,25 +54,10 @@ class TerminalGameTest < MiniTest::Unit::TestCase
 
   def test_display_text
     mock = IoMock.new
-    game = TicTacToe::TerminalGame.new(nil, mock)
+    game = TicTacToe::GameType::Terminal.new(nil, mock)
     game.display_text("FooBar")
 
     assert_equal "FooBar", mock.output
   end
 
-  def test_select_solver
-    mock = IoMock.new("1")
-    game = TicTacToe::TerminalGame.new(nil, mock)
-    assert_equal "FooBar", game.select(["FooBar", "BarFoo"])
-
-    mock = IoMock.new("2")
-    game = TicTacToe::TerminalGame.new(nil, mock)
-    assert_equal "BarFoo", game.select(["FooBar", "BarFoo"])
-  end
-
-  def test_select_bad_choice
-    mock = IoMock.new(["1", 'x'])
-    game = TicTacToe::TerminalGame.new(nil, mock)
-    assert_equal "FooBar", game.select(["FooBar", "BarFoo"])
-  end
 end

metadata

@@ -2,7 +2,7 @@
 name: erics_tic_tac_toe
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors: 
 - Eric Koslow
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-15 00:00:00 -05:00
+date: 2012-08-27 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -57,8 +57,8 @@ files:
 - lib/tic_tac_toe/player.rb
 - lib/tic_tac_toe/players/computer_player.rb
 - lib/tic_tac_toe/players/human_player.rb
-- lib/tic_tac_toe/presentors/game_presenter.rb
-- lib/tic_tac_toe/presentors/player_presenter.rb
+- lib/tic_tac_toe/presenters/game_presenter.rb
+- lib/tic_tac_toe/presenters/player_presenter.rb
 - lib/tic_tac_toe/strategies/minimax_strategy.rb
 - lib/tic_tac_toe/strategies/three_by_three_strategy.rb
 - lib/tic_tac_toe/version.rb

data/lib/tic_tac_toe/presentors/game_presenter.rb

@@ -1,16 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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