ttt 1.0.0

data/lib/ttt/computer_player.rb

@@ -0,0 +1,74 @@
+require 'ttt/ratings'
+
+module TTT
+  class ComputerPlayer
+        
+    attr_accessor :game
+    
+    def initialize(game)
+      self.game = game
+    end
+    
+    def player_number
+      game.turn
+    end
+    
+    def take_turn
+      game.mark best_move
+    end
+    
+    def best_move
+      return imperative_move if imperative_move?  # allow to customize certain situations
+      move, rating, game = moves_by_rating.first  # otherwise go by rating
+      move
+    end
+    
+    def moves_by_rating
+      return to_enum(:moves_by_rating) unless block_given?
+      moves = []
+      game.available_moves.each do |move|
+        new_game = game.pristine_mark move
+        moves << [ move, rate(new_game), new_game ]
+      end
+      moves = moves.sort_by { |move, rating, new_game| -rating } # highest rating first
+      moves.each     { |move, rating, new_game| yield move, rating, new_game }
+    end
+    
+    def rate(game)
+      RATINGS[game.board][player_number]
+    end
+    
+    # allows us to override ratings in cases where they make the robot look stupid
+    def imperative_move
+      # if we can win *this turn*, then take it because
+      # it rates winning next turn the same as winning in 3 turns
+      game.available_moves.each do |move|
+        new_game = game.pristine_mark move
+        return move if new_game.over? && new_game.winner == player_number
+      end
+      
+      # if we can block the opponent from winning *this turn*, then take it, because
+      # it rates losing this turn the same as losing in 3 turns
+      if moves_by_rating.all? { |move, rating, game| rating == -1 }
+        Game.winning_states do |position1, position2, position3|
+          a, b, c = board[position1-1, 1].to_i, board[position2-1, 1].to_i, board[position3-1, 1].to_i
+          if a + b + c == opponent_number * 2
+            return a.zero? ? position1 : b.zero? ? position2 : position3
+          end
+        end
+      end
+    end
+    
+    def imperative_move?
+      !!imperative_move
+    end
+    
+    def board
+      game.board
+    end
+    
+    def opponent_number
+      player_number == 1 ? 2 : 1
+    end
+  end
+end

data/lib/ttt/game.rb

@@ -0,0 +1,129 @@
+module TTT
+  class Game
+    
+    DEFAULT_BOARD = '0'*9
+    attr_writer :board
+    
+    def initialize(board=DEFAULT_BOARD)
+      self.board = board.dup
+    end
+    
+    def turn
+      return if over?
+      board.scan('1').size - board.scan('2').size + 1
+    end
+    
+    def mark(position)
+      board[position-1] = turn.to_s
+    end
+    
+    def board(style=nil)
+      return @board unless style
+      "  %s | %s | %s  \n----|---|----\n  %s | %s | %s  \n----|---|----\n  %s | %s | %s  " % @board.gsub('0', ' ').split('')
+    end
+    
+    def over?
+      winner || board.split(//).all? { |char| char == '1' || char == '2' }
+    end
+    
+    def status(player_number)
+      return nil unless over?
+      (winner == player_number) ? :wins  :
+                         winner ? :loses :
+                                  :ties
+    end
+    
+    def tie?
+      over? && !winner
+    end
+    
+    def winner
+      return if winning_positions.empty?
+      self[winning_positions.first]
+    end
+    
+    def available_moves
+      return [] if over?
+      to_return = []
+      board.split(//).each_with_index do |char, index| 
+        to_return << index.next if char != '1' && char != '2'
+      end
+      to_return
+    end
+    
+    def pristine_mark(position)
+      marked = self.class.new board.dup
+      marked.mark position
+      marked
+    end
+    
+    def winning_states(&block)
+      self.class.winning_states(&block)
+    end
+    
+    def winning_positions
+      winning_states do |pos1, pos2, pos3|
+        next unless board[pos1, 1] == board[pos2, 1]
+        next unless board[pos1, 1] == board[pos3, 1]
+        next unless board[pos1, 1] =~ /^(1|2)$/
+        return [pos1+1, pos2+1, pos3+1]
+      end
+      []
+    end
+    
+    def [](position)
+      player = board[position-1, 1].to_i
+      return player if player == 1 || player == 2
+    end
+    
+  end
+end
+
+
+
+module TTT
+  class << Game
+    def congruent?(board1, board2)
+      each_congruent(board2).any? { |congruent| board1 == congruent }
+    end
+    
+    def each_congruent(board)
+      return to_enum(:each_congruent, board) unless block_given?
+      each_rotation(board)               { |congruent| yield congruent }
+      each_rotation(reflect_board board) { |congruent| yield congruent }
+    end
+    
+    def reflect_board(board)
+      board = board.dup
+      board[0..2], board[6..8] = board[6..8], board[0..2]
+      board
+    end
+    
+    def each_rotation(board)
+      return to_enum(:each_rotation, board) unless block_given?
+      board = board.dup
+      4.times do
+        yield board.dup
+        board = rotate_board(board)
+      end
+    end
+    
+    def rotate_board(board)
+      board = board.dup
+      board[0], board[1], board[2], board[3], board[5], board[6], board[7], board[8] =
+      board[6], board[3], board[0], board[7], board[1], board[8], board[5], board[2]
+      board
+    end
+    
+    def winning_states
+      yield 0, 1, 2
+      yield 3, 4, 5
+      yield 6, 7, 8
+      yield 0, 3, 6
+      yield 1, 4, 7
+      yield 2, 5, 8
+      yield 0, 4, 8
+      yield 2, 4, 6
+    end
+  end
+end

data/lib/ttt/interface.rb

@@ -0,0 +1,22 @@
+module TTT
+  module Interface
+    def self.registered
+      @registered_interfaces ||= Hash.new
+    end
+    
+    def self.registered?(name)
+      registered.has_key? name
+    end
+    
+    def self.registered_names
+      registered.keys
+    end
+    
+    def self.register(name, interface)
+      registered[name] = interface
+    end
+  end
+end
+
+require 'ttt/interface/cli'
+require 'ttt/interface/limelight'

data/lib/ttt/interface/cli.rb

@@ -0,0 +1,95 @@
+require 'ttt/interface/cli/players'
+require 'ttt/interface/cli/views'
+
+module TTT
+  module Interface
+    class CLI
+      Interface.register 'cli', self
+      
+      X = 'X'
+      O = 'O'
+      
+      attr_accessor :game, :filein, :fileout, :fileerr, :player1, :player2, :turn
+      
+      def initialize(options={})
+        self.filein  = options.fetch :filein,  $stdin
+        self.fileout = options.fetch :fileout, $stdout
+        self.fileerr = options.fetch :fileerr, $stderr
+        self.turn    = 0
+      end
+      
+      def play
+        fileout.puts "Welcome to Tic Tac Toe"
+        fileout.flush
+        create_game
+        create_player1
+        create_player2
+        until game.over?
+          display_board          
+          take_current_turn
+        end
+        display_results
+      end
+      
+      def display_results
+        display_board
+        if game.tie?
+          puts "The game ended in a tie."
+        else
+          puts "Player #{game.winner} won the game."
+        end
+        puts "Play again soon :)"
+      end
+      
+      def take_current_turn
+        current_player.take_turn
+        self.turn += 1
+      end
+      
+      def current_player
+        turn.even? ? player1 : player2
+      end
+      
+      def create_game
+        self.game = Game.new
+      end
+      
+      def create_player1
+        self.player1 = create_player X, 'first'
+      end
+      
+      def create_player2
+        self.player2 = create_player O, 'second'
+      end
+      
+      def create_player(letter, position)
+        type = prompt "#{letter} will go #{position}, would you like #{letter} to be a human or a computer? (h/c) ", :validate => /^[hc]$/i
+        if type =~ /c/i
+          ComputerPlayer.new game, self, letter
+        else
+          HumanPlayer.new game, self, letter
+        end
+      end
+      
+      def prompt(message, validation={})
+        validation[:validate] ||= //
+        fileout.print message
+        input = filein.gets
+        until input =~ validation[:validate]
+          fileout.puts "Invalid, input."
+          fileout.print message
+          input = filein.gets
+        end
+        input
+      end
+      
+      def display_board
+        Views.new(self).display_board
+      end
+      
+      def board
+        game.board
+      end
+    end
+  end
+end

data/lib/ttt/interface/cli/players.rb

@@ -0,0 +1,56 @@
+require 'ttt/computer_player'
+require 'forwardable'
+
+module TTT
+  module Interface
+    class CLI
+        
+            
+      class Player
+        attr_accessor :game, :cli, :marker
+        
+        extend Forwardable
+        def_delegators :cli, :fileout, :filein, :fileerr, :prompt
+        
+        def initialize(game, cli, marker)
+          self.game   = game
+          self.cli    = cli
+          self.marker = marker
+        end
+      end
+      
+      
+      class ComputerPlayer < Player
+        attr_accessor :computer
+        def initialize(*args)
+          super
+          self.computer = TTT::ComputerPlayer.new game
+        end
+        def take_turn
+          computer.take_turn
+        end
+      end
+      
+      
+      class HumanPlayer <Player
+        def take_turn
+          fileout.puts "The nine squares consecutively map to a number. "\
+            "Topleft starts at 1, topright continues with 3, and bottomright ends with 9."
+          move = prompt "Where would you like to move? (#{list_available_moves}) ", :validate => available_moves_regex
+          game.mark move.to_i
+        end
+        
+        def list_available_moves
+          game.available_moves.join(', ')
+        end
+        
+        def available_moves_regex
+          moves = game.available_moves
+          /^[#{moves.join}]$/
+        end
+      end
+
+      
+    end
+  end
+end

data/lib/ttt/interface/cli/views.rb

@@ -0,0 +1,124 @@
+require 'ttt/interface/cli/players'
+require 'ttt/interface/cli/views'
+
+module TTT
+  module Interface
+    class CLI
+      class Views
+        
+        attr_accessor :cli
+        
+        def initialize(cli)
+          self.cli = cli
+        end
+      
+        def method_missing(meth, *args, &block)
+          super unless cli.respond_to? meth
+          cli.send meth, *args, &block
+        end
+      
+        def display_board
+          fileout.print row(0) << horizontal_separator <<
+                        row(1) << horizontal_separator <<
+                        row(2) << "\n\n"
+        end
+        
+        def row(n)
+          n *= 3
+          line(n) << line(n+1) << line(n+2)
+        end
+        
+        def line(n)
+          offset, col = (n/3)*3, (n%3)
+          square(offset+1, col) << vertical_separator <<
+          square(offset+2, col) << vertical_separator <<
+          square(offset+3, col) << "\n"
+        end
+        
+        def horizontal_separator
+          "-----|-----|-----\n"
+        end
+        
+        def vertical_separator
+          "|"
+        end
+        
+        def square(num, line)
+          send "line#{line}_for", num
+        end
+        
+        def line0_for(square)
+          if forward_diagonal_winner?(square)
+            "\\    "
+          elsif backward_diagonal_winner?(square)
+            "    /"
+          elsif vertical_winner? square
+            "  |  "
+          else
+            "     "
+          end
+        end
+        
+        def line1_for(square)
+          if horizontal_winner? square
+            "--%s--"
+          else
+            "  %s  "
+          end % char_for(square)
+        end
+        
+        def line2_for(square)
+          if forward_diagonal_winner?(square)
+            "    \\"
+          elsif backward_diagonal_winner?(square)
+            "/    "
+          elsif vertical_winner? square
+            "  |  "
+          else
+            "     "
+          end
+        end
+        
+        def winner?(square)
+          game.over? && !game.tie? && game.winning_positions.include?(square)
+        end
+        
+        def forward_diagonal_winner?(square)
+          return false unless winner? square
+          [[1, 5], [5, 9], [9, 5]].any? do |s1, s2|
+            square == s1 && winner?(s2)
+          end
+        end
+        
+        def backward_diagonal_winner?(square)
+          return false unless winner? square
+          [[3, 5], [5, 7], [7, 5]].any? do |s1, s2|
+            square == s1 && winner?(s2)
+          end
+        end
+        
+        def vertical_winner?(square)
+          return false unless winner? square
+          winner? (square + 2) % 9 + 1
+        end
+        
+        def horizontal_winner?(square)
+          return false unless winner? square
+          winner?(square+1) || winner?(square-1)
+        end
+        
+        def char_for(position)
+          case game[position]
+          when nil
+            ' '
+          when 1
+            player1.marker
+          when 2
+            player2.marker
+          end
+        end
+        
+      end      
+    end
+  end
+end