interferoman 1.2

data/Battleship.Rakefile

@@ -0,0 +1,12 @@
+#
+# DO NOT tamper with this file.  It will lead to disqualification.
+
+require 'rake'
+require 'spec/rake/spectask'
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('spec_with_rcov') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.rcov = true
+  t.rcov_opts = ['-t', '--exclude', 'spec', '--no-html']
+end

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rake'
+require 'rake/gempackagetask'
+require 'spec/rake/spectask'
+require 'battleship_tournament/submit'
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.rcov = false
+end
+
+PKG_NAME = "interferoman"
+PKG_VERSION   = "1.2"
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.files = FileList['**/*'].to_a.reject!{ |f| f =~ /pkg/ }
+  s.require_path = 'lib'
+  s.test_files = Dir.glob('spec/*_spec.rb')
+  s.bindir = 'bin'
+  s.executables = []
+  s.summary = "Battleship Player:interferoman"
+  s.rubyforge_project = "sparring"
+  s.homepage = "http://sparring.rubyforge.org/"
+
+  ###########################################
+  ##
+  ## You are encouraged to modify the following
+  ## spec attributes.
+  ##
+  ###########################################
+  s.description = "A decent yet still flawed battleship player"
+  s.author = "Alf Mikula"
+  s.email = "amikula@gmail.com"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = false
+  pkg.need_tar = false
+end
+
+desc "Submit your player"
+task :submit do
+  submitter = BattleshipTournament::Submit.new(PKG_NAME)
+  submitter.submit
+end

data/lib/interferoman/battleship_board.rb

@@ -0,0 +1,123 @@
+module Interferoman
+  class BattleshipBoard
+    @@sizes = {:carrier => 5,
+               :battleship => 4,
+               :destroyer => 3,
+               :submarine => 3,
+               :patrolship => 2}
+
+    def initialize
+      @board = []
+    end
+
+    def place(ship, row, column, orientation)
+      for_ship(ship, row, column, orientation) do |r, c|
+        self[r, c] = ship
+      end
+    end
+
+    def collides?(ship, row, column, orientation)
+      for_ship(ship, row, column, orientation) do |r, c|
+        return true unless self[r, c].nil?
+      end
+
+      false
+    end
+
+    def size_of(ship)
+      @@sizes[ship]
+    end
+
+    def []=(row, column, value)
+      @board[index_for(row, column)] = value
+    end
+
+    def [](row, column)
+      @board[index_for(row, column)]
+    end
+
+    def is_blank?(row, column, direction=nil)
+      if direction == nil
+        self[row, column] == nil
+      else
+        begin
+          self[*get_position(row, column, direction)] == nil
+        rescue
+          false
+        end
+      end
+    end
+
+    def get_position(row, column, movement)
+      case movement
+      when :north
+        return [row-1, column] if row > 0
+      when :south
+        return [row+1, column] if row < 9
+      when :east
+        return [row, column+1] if column < 9
+      when :west
+        return [row, column-1] if column > 0
+      end
+
+      raise ArgumentError.new("Invalid movement: #{row}, #{column}, #{movement}")
+    end
+
+    def first_blank(row, column)
+      [:east, :south, :west, :north].each do |direction|
+        if is_blank?(row, column, direction)
+          return get_position(row, column, direction) << direction
+        end
+      end
+
+      nil
+    end
+
+    def has_room_for_ship(row, column, size)
+      return false unless self[row, column].nil?
+
+      blanks_to_east = number_of_blanks_in_direction(row, column, :east)
+      blanks_to_west = number_of_blanks_in_direction(row, column, :west)
+      return true if blanks_to_east + blanks_to_west + 1 >= size
+
+      blanks_to_north = number_of_blanks_in_direction(row, column, :north)
+      blanks_to_south = number_of_blanks_in_direction(row, column, :south)
+      return true if blanks_to_north + blanks_to_south + 1 >= size
+
+      false
+    end
+
+    def number_of_blanks_in_direction(row, column, direction)
+      begin
+        next_position = get_position(row, column, direction)
+        if self[*next_position].nil?
+          return 1 + number_of_blanks_in_direction(next_position[0],
+                                                   next_position[1], direction)
+        else
+          return 0
+        end
+      rescue
+        return 0
+      end
+    end
+
+    private
+    def index_for(row, column)
+      row*10 + column
+    end
+
+    def for_ship(ship, row, column, orientation)
+      if (orientation == :vertical)
+        last_row = row + size_of(ship) - 1
+        (row..last_row).each do |r|
+          yield(r, column)
+        end
+      else
+        last_column = column + size_of(ship) - 1
+        (column..last_column).each do |c|
+          yield(row, c)
+        end
+      end
+    end
+  end
+end

data/lib/interferoman/interferoman.rb

@@ -0,0 +1,463 @@
+require 'interferoman/battleship_board'
+
+module Interferoman
+
+  # Battleship Player
+  #
+  # Battleship is board game between two players.  See
+  # http://en.wikipedia.org/wiki/Battleship for more information
+  # and game rules.
+  #
+  # A player represents the conputer AI to play a game of Battleship.
+  # It should know how to place ships and target the opponents
+  # ships.
+  #
+  # This version of Battleship is played on a 10 x 10 grid where
+  # rows are labled by the letters A - J and columns are labled by
+  # the numbers 1 - 10.  At the start of the game, each player will
+  # be asked for ship placements.  Once the ships are placed, play
+  # proceeeds by each player targeting one square on their opponents
+  # map.  A player may only target one square, reguardless of whether
+  # it resulted in a hit or not, before changing turns with her
+  # opponent.
+  #
+  class Interferoman
+
+    # This method is called at the beginning of each game.  A player
+    # may only be instantiated once and used to play many games.
+    # So new_game should reset any internal state acquired in
+    # previous games so that it is prepared for a new game.
+    #
+    # The name of the opponent player is passed in.  This allows
+    # for the possibility to learn opponent strategy and play the
+    # game differently based on the opponent.
+    #
+    def new_game(opponent_name)
+      reset
+    end
+
+    # Returns the placement of the carrier. A carrier consumes 5 squares.
+    #
+    # The return value is a string that describes the placements of the ship.
+    # The placement string must be in the following format:
+    #
+    #   "#{ROW}#{COL} #{ORIENTATION}"
+    #
+    # eg
+    #
+    #   A1 horizontal # the ship will occupy A1, A2, A3, A4, and A5
+    #   A1 vertical # the ship will occupy A1, B1, C1, D1, and E1
+    #   F5 horizontal # the ship will occupy F5, F6, F7, F8, and F9
+    #   F5 vertical # the ship will occupy F5, G5, H5, I5, and J5
+    #
+    # The ship must not fall off the edge of the map.  For example,
+    # a carrier placement of 'A8 horizontal' would not leave enough
+    # space in the A row to accomodate the carrier since it requires
+    # 5 squares.
+    #
+    # Ships may not overlap with other ships.  For example a carrier
+    # placement of 'A1 horizontal' and a submarine placement of 'A1
+    # vertical' would be invalid because both ships are trying to
+    # occupy the square A1.
+    #
+    # Invalid ship placements will result in disqualification of the player.
+    #
+    def carrier_placement
+      return random_placement(:carrier)
+    end
+
+    # Returns the placement of the battleship. A battleship consumes 4 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def battleship_placement
+      return random_placement(:battleship)
+    end
+
+    # Returns the placement of the destroyer. A destroyer consumes 3 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def destroyer_placement
+      return random_placement(:destroyer)
+    end
+
+    # Returns the placement of the submarine. A submarine consumes 3 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def submarine_placement
+      return random_placement(:submarine)
+    end
+
+    # Returns the placement of the patrolship. A patrolship consumes 2 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def patrolship_placement
+      return random_placement(:patrolship)
+    end
+
+    # Returns the coordinates of the players next target.  This
+    # method will be called once per turn.  The player should return
+    # target coordinates as a string in the form of:
+    #
+    #   "#{ROW}#{COL}"
+    #
+    # eg
+    #
+    #   A1 # the square in Row A and Column 1
+    #   F5 # the square in Row F and Column 5
+    #
+    # Since the map contains only 10 rows and 10 columns, the ROW
+    # should be A, B, C, D, E, F, G H, I, or J. And the COL should
+    # be 1, 2, 3, 4, 5, 6, 7, 8, 9, or 10
+    #
+    # Returning coordinates outside the range or in an invalid
+    # format will result in the players disqualification.
+    #
+    # It is illegal to target a sector more than once.  Doing so
+    # will also result in disqualification.
+    #
+    def next_target
+      target_for_current_shot
+    end
+
+    # target_result will be called by the system after a call to
+    # next_target.  The parameters supplied inform the player of the
+    # results of the target.
+    #
+    #   coordinates : string. The coordinates targeted.  It will
+    #                 be the same value returned by the previous call
+    #                 to next_target
+    #   was_hit     : boolean.  true if the target was occupied by
+    #                 a ship.  false otherwise.
+    #   ship_sunk   : symbol.  nil if the target did not result in
+    #                 the sinking of a ship.  If the target did result in
+    #                 the sinking of a ship, the ship type is supplied
+    #                 (:carrier, :battleship, :destroyer, :submarine,
+    #                 :patrolship).
+    #
+    # An intelligent player will use the information to better play
+    # the game.  For example, if the result indicates a hit, a
+    # player my choose to target neighboring squares to hit and
+    # sink the remainder of the ship.
+    #
+    def target_result(coordinates, was_hit, ship_sunk)
+      row, column = *from_coord(coordinates)
+
+      target_result_internal(row, column, was_hit, ship_sunk)
+    end
+
+    # enemy_targeting is called by the system to inform a player
+    # of their opponent's move.  When the opponent targets a square,
+    # this method is called with the coordinates.
+    #
+    # Players may use this information to understand an opponent's
+    # targeting strategy and place ships differently in subsequent
+    # games.
+    #
+    def enemy_targeting(coordinates)
+    end
+
+    # Called by the system at the end of a game to inform the player
+    # of the results.
+    #
+    #   result  : 1 of 3 possible values (:victory, :defeate, :disqualified)
+    #   disqualification_reason : nil unless the game ended as the
+    #                 result of a disqualification.  In the event of a
+    #                 disqualification, this paramter will hold a string
+    #                 description of the reason for disqualification.  Both
+    #                 players will be informed of the reason.
+    #   :victory # indicates the player won the game
+    #   :defeat # indicates the player lost the game
+    #   :disqualified # indicates the player was disqualified
+    #
+    def game_over(result, disqualification_reason=nil)
+    end
+
+    # Non API methods #####################################
+
+    attr_reader :opponent, :targets, :enemy_targeted_sectors, :result,
+      :disqualification_reason, :unknown_hits #:nodoc:
+
+    attr_accessor :state
+
+    def initialize #:nodoc:
+      reset
+    end
+
+    private ###############################################
+
+    def target_result_internal(row, column, was_hit, ship_sunk)
+      @opponent_board[row, column] = was_hit
+
+      if (ship_sunk)
+        previous_smallest = @ships[0]
+
+        @ships.delete(ship_sunk)
+
+        if @ships.size > 0
+          if @ships[0] != previous_smallest
+            @target_list = target_list(@opponent_board.size_of(@ships[0]))
+          end
+        end
+
+        remove_ship_targets(row, column, @state, ship_sunk)
+        transition_to_unknown_hit
+        return
+      elsif (was_hit)
+        unknown_hits << [row, column]
+      end
+
+      case self.state
+      when :east_2
+        if (was_hit)
+          if @opponent_board.is_blank?(row, column, :east)
+            set_next_target(row, column+1)
+          else
+            transition_to_west(row, column)
+          end
+        else
+          transition_to_west(row, column)
+        end
+      when :south_2
+        if (was_hit)
+          if @opponent_board.is_blank?(row, column, :south)
+            set_next_target(row+1, column)
+          else
+            transition_to_north(row, column)
+          end
+        else
+          transition_to_north(row, column)
+        end
+      when :random
+        if (was_hit)
+          result = @opponent_board.first_blank(row, column)
+          unless result.nil?
+            next_row, next_column, direction = *result
+
+            self.state = direction
+            set_next_target(next_row, next_column)
+          end
+        end
+      when :east
+        if (was_hit)
+          if @opponent_board.is_blank?(row, column, :east)
+            self.state = :east_2
+            set_next_target(row, column+1)
+          else
+            transition_to_west(row, column)
+          end
+        else
+          transition_to_first_blank(row, column-1)
+        end
+      when :west
+        if (was_hit)
+          if (@opponent_board.is_blank?(row, column, :west))
+            set_next_target(row, column-1)
+          else
+            transition_to_first_blank(row, column)
+          end
+        else
+          transition_to_first_blank(row, column+1)
+        end
+      when :south
+        if (was_hit)
+          if (row < 9)
+            self.state = :south_2
+            set_next_target(row+1, column)
+          else
+            transition_to_north(row, column)
+          end
+        else
+          transition_to_first_blank(row-1, column)
+        end
+      when :north
+        if was_hit
+          set_next_target(row-1, column)
+        else
+          transition_to_first_blank(row+1, column)
+        end
+      end
+    end
+
+    def set_next_target(row, column)
+      if (0..9).include?(row) && (0..9).include?(column) &&
+                                      @opponent_board.is_blank?(row, column)
+        target = to_coord(row, column)
+        @target_list.push(target)
+        @specified_target = true
+      else
+        transition_to_unknown_hit
+      end
+    end
+
+    def transition_to_unknown_hit
+      while self.unknown_hits.size > 0 &&
+        @opponent_board.first_blank(*self.unknown_hits[0]) == nil
+        self.unknown_hits.shift
+      end
+
+      if self.unknown_hits.size > 0
+        transition_to_first_blank(*self.unknown_hits[0])
+      else
+        @state = :random
+      end
+    end
+
+    def remove_ship_targets(row, column, state, ship_sunk)
+      case state
+      when :east, :east_2
+        (0...@opponent_board.size_of(ship_sunk)).each do |i|
+          self.unknown_hits.delete([row, column-i])
+        end
+      when :south, :south_2
+        (0...@opponent_board.size_of(ship_sunk)).each do |i|
+          self.unknown_hits.delete([row-i, column])
+        end
+      when :west
+        (0...@opponent_board.size_of(ship_sunk)).each do |i|
+          self.unknown_hits.delete([row, column+i])
+        end
+      when :north
+        (0...@opponent_board.size_of(ship_sunk)).each do |i|
+          self.unknown_hits.delete([row+i, column])
+        end
+      end
+    end
+
+    def transition_to_first_blank(row, column)
+      transition_info = @opponent_board.first_blank(row, column)
+      if transition_info.nil?
+        transition_to_unknown_hit
+      else
+        next_row, next_column, direction = transition_info
+        self.state = direction
+        set_next_target(next_row, next_column)
+      end
+    end
+
+    def reset
+      self.state = :random
+      @target_list = target_list(2)
+      @specified_target = false
+      @my_board = BattleshipBoard.new
+      @opponent_board = BattleshipBoard.new
+      @ships = [:patrolship, :destroyer, :submarine, :battleship, :carrier]
+      @unknown_hits = []
+    end
+
+    SEARCH_PATTERNS = [
+      [
+        []
+      ],
+      [
+        [true]
+      ],
+      [
+        [false, true],
+        [true, false]
+      ],
+      [
+        [true, false, false],
+        [false, true, false],
+        [false, false, true]
+      ],
+      [
+        [false, false, false, true],
+        [false, true, false, false],
+        [false, false, true, false],
+        [true, false, false, false]
+      ],
+      [
+        [false, false, false, false, true],
+        [false, false, true, false, false],
+        [true, false, false, false, false],
+        [false, false, false, true, false],
+        [false, true, false, false, false]
+      ]
+    ]
+
+    def target_list(pattern)
+      retval = []
+
+      (0..9).each do |row|
+        (0..9).each do |column|
+          retval << to_coord(row, column) if SEARCH_PATTERNS[pattern][row%pattern][column%pattern]
+        end
+      end
+
+      retval.sort_by{|e| rand}
+    end
+
+    ROWS = %w{ A B C D E F G H I J }
+    ORIENTATIONS = [:horizontal, :vertical]
+    def target_for_current_shot
+      while (target=@target_list.pop)
+        row, column = *from_coord(target)
+        break if @opponent_board.is_blank?(row, column) &&
+          (@specified_target ||
+           @opponent_board.
+             has_room_for_ship(row, column, @opponent_board.size_of(@ships[0])))
+      end
+
+      if (target == nil)
+        @target_list = target_list(1)
+
+        while (target=@target_list.pop)
+          break if @opponent_board.is_blank?(*from_coord(target))
+        end
+      end
+
+      @specified_target = false
+
+      return target
+    end
+
+    def random_placement(ship)
+      size = @my_board.size_of(ship)
+      while(true)
+        row = rand(10-size+1)
+        column = rand(10-size+1)
+        orientation = ORIENTATIONS[rand(2)]
+
+        unless @my_board.collides?(ship, row, column, orientation)
+          @my_board.place(ship, row, column, orientation)
+          return to_coord(row, column) + " " + orientation.to_s
+        end
+      end
+    end
+
+    def to_coord(row, column)
+      "" << (?A+row) << (column+1).to_s
+    end
+
+    def from_coord(coordinates)
+      row = coordinates[0] - ?A
+      column = coordinates[1..-1].to_i - 1
+
+      [row, column]
+    end
+
+    def transition_to_west(row, column)
+      column -= 1
+      while (@opponent_board[row, column])
+        column -= 1
+      end
+      set_next_target(row, column)
+      self.state = :west
+    end
+
+    def transition_to_north(row, column)
+      row -= 1
+      while (@opponent_board[row, column])
+        row -= 1
+      end
+      set_next_target(row, column)
+      self.state = :north
+    end
+
+  end
+
+end

data/spec/interferoman/battleship_board_spec.rb

@@ -0,0 +1,208 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'interferoman/battleship_board'
+
+describe Interferoman::BattleshipBoard do
+  before :each do
+    @board = Interferoman::BattleshipBoard.new
+  end
+
+  describe(:place) do
+    it "should allow placements of ships" do
+      lambda{@board.place(:carrier, 0, 0, :vertical)}.should_not raise_error
+    end
+
+    describe "should place the symbol for the ship in the proper squares" do
+      it "(vertically)" do
+        @board.place(:carrier, 0, 0, :vertical)
+        (0..4).each do |row|
+          @board[row,0].should == :carrier
+          @board[row,1].should_not == :carrier
+        end
+
+        @board[5, 0].should_not == :carrier
+      end
+
+      it "(horizontally)" do
+        @board.place(:patrolship, 4, 4, :horizontal)
+        (4..5).each do |column|
+          @board[3,column].should_not == :patrolship
+          @board[4,column].should == :patrolship
+          @board[5,column].should_not == :patrolship
+        end
+
+        @board[4, 3].should_not == :patrolship
+        @board[4, 6].should_not == :patrolship
+      end
+    end
+  end
+
+  describe :size_of do
+    it "should know the sizes of the ships" do
+      @board.size_of(:carrier).should == 5
+      @board.size_of(:battleship).should == 4
+      @board.size_of(:destroyer).should == 3
+      @board.size_of(:submarine).should == 3
+      @board.size_of(:patrolship).should == 2
+    end
+  end
+
+  describe(:collides?) do
+    it "should return true if pieces collide" do
+      @board.place(:carrier, 1, 1, :vertical)
+      @board.collides?(:battleship, 2, 0, :horizontal).should be_true
+    end
+
+    it "should return false if pieces do not collide" do
+      @board.place(:carrier, 1, 1, :vertical)
+      @board.collides?(:battleship, 2, 0, :vertical).should be_false
+    end
+  end
+
+  describe :[] do
+    it "should store and return the value set" do
+      @board[0,0] = :foo
+      @board[1,3] = :bar
+
+      @board[0,0].should == :foo
+      @board[1,3].should == :bar
+    end
+  end
+
+  describe :is_blank? do
+    it "should return true if the location at the coordinates has a nil value" do
+      @board.is_blank?(5, 5).should be_true
+    end
+
+    it "should return false if the location at the coordinates is not nil" do
+      @board[5, 5] = true
+
+      @board.is_blank?(5, 5).should be_false
+    end
+
+    describe "with direction argument" do
+      before :each do
+        @board[5, 5] = true
+      end
+
+      it "should return false if current position is 5, 5 and direction is north, south, east, or west" do
+        @board.is_blank?(5, 5, :north).should be_true
+        @board.is_blank?(5, 5, :south).should be_true
+        @board.is_blank?(5, 5, :east).should be_true
+        @board.is_blank?(5, 5, :west).should be_true
+      end
+
+      it "should return true if current position is one of from 5, 5 and direction takes us to 5, 5" do
+        @board.is_blank?(6, 5, :north).should be_false
+        @board.is_blank?(4, 5, :south).should be_false
+        @board.is_blank?(5, 4, :east).should be_false
+        @board.is_blank?(5, 6, :west).should be_false
+      end
+
+      it "should return false if current position is at edge and direction takes us off the edge" do
+        @board.is_blank?(0, 5, :north).should be_false
+        @board.is_blank?(9, 5, :south).should be_false
+        @board.is_blank?(5, 9, :east).should be_false
+        @board.is_blank?(5, 0, :west).should be_false
+      end
+    end
+  end
+
+  describe :get_position do
+    it "should know how to move the cursor north, south, east, or west" do
+      @board.get_position(7, 3, :north).should == [6, 3]
+      @board.get_position(3, 8, :south).should == [4, 8]
+      @board.get_position(3, 2, :east).should == [3, 3]
+      @board.get_position(6, 2, :west).should == [6, 1]
+    end
+
+    it "should throw an exception when at the edge of the board and asked to move off" do
+      lambda{@board.get_position(0, 3, :north)}.should raise_error(ArgumentError)
+      lambda{@board.get_position(9, 8, :south)}.should raise_error(ArgumentError)
+      lambda{@board.get_position(3, 9, :east)}.should raise_error(ArgumentError)
+      lambda{@board.get_position(6, 0, :west)}.should raise_error(ArgumentError)
+    end
+  end
+
+  describe :first_blank do
+    it "should return the first blank found by looking clockwise starting with :east" do
+      @board[5, 5] = true
+      @board.first_blank(5, 5).should == [5, 6, :east]
+      @board.first_blank(5, 4).should == [6, 4, :south]
+    end
+
+    it "should return nil if no blank is found" do
+      @board[5, 5] = true
+      @board[5, 7] = true
+      @board[4, 6] = true
+      @board[6, 6] = true
+
+      @board.first_blank(5, 6).should == nil
+    end
+  end
+
+  describe :has_room_for_ship do
+    it "should always return false if the space specified is not nil" do
+      @board[5, 5] = false
+
+      @board.has_room_for_ship(5, 5, 2).should == false
+    end
+
+    it "should see the correct horizontal space when there are no limits" do
+      @board[4, 5] = false
+      @board[6, 5] = false
+
+      @board.has_room_for_ship(5, 5, 5).should == true
+    end
+
+    it "should see the correct horizontal space when there is a limit" do
+      @board[5, 2] = false
+      @board[5, 7] = false
+      @board[4, 5] = false
+      @board[6, 5] = false
+
+      @board.has_room_for_ship(5, 5, 5).should == false
+      @board.has_room_for_ship(5, 5, 4).should == true
+      @board.has_room_for_ship(5, 5, 3).should == true
+    end
+
+    it "should see the correct horizontal space when it's against the edge" do
+      @board[5, 3] = false
+      @board[4, 0] = false
+      @board[6, 0] = false
+
+      @board.has_room_for_ship(5, 0, 5).should == false
+      @board.has_room_for_ship(5, 0, 4).should == false
+      @board.has_room_for_ship(5, 0, 3).should == true
+      @board.has_room_for_ship(5, 0, 2).should == true
+    end
+
+    it "should see the correct vertical space when there are no limits" do
+      @board[5, 4] = false
+      @board[5, 6] = false
+
+      @board.has_room_for_ship(5, 5, 5).should == true
+    end
+
+    it "should see the correct horizontal space when there is a limit" do
+      @board[2, 5] = false
+      @board[7, 5] = false
+      @board[5, 4] = false
+      @board[5, 6] = false
+
+      @board.has_room_for_ship(5, 5, 5).should == false
+      @board.has_room_for_ship(5, 5, 4).should == true
+      @board.has_room_for_ship(5, 5, 3).should == true
+    end
+
+    it "should see the correct vertical space when it's against the edge" do
+      @board[3, 5] = false
+      @board[0, 4] = false
+      @board[0, 6] = false
+
+      @board.has_room_for_ship(0, 5, 5).should == false
+      @board.has_room_for_ship(0, 5, 4).should == false
+      @board.has_room_for_ship(0, 5, 3).should == true
+      @board.has_room_for_ship(0, 5, 2).should == true
+    end
+  end
+end

data/spec/interferoman/interferoman_spec.rb

@@ -0,0 +1,379 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'interferoman/interferoman'
+require 'interferoman/battleship_board'
+
+describe Interferoman::Interferoman do
+  before :each do
+    @player = Interferoman::Interferoman.new
+    @player.new_game("test")
+  end
+
+  it "should be instantiable with no parameters" do
+
+    lambda { Interferoman::Interferoman.new }.should_not raise_error
+
+  end
+
+  describe :next_target do
+    it "should only return (A-J)(1-10)" do
+      100.times do
+        target = @player.next_target
+        violated("Invalid coordinates #{target}") unless
+                 target =~ /^[A-J]([1-9]|10)$/
+      end
+    end
+
+    it "should never repeat a target" do
+      board = Interferoman::BattleshipBoard.new
+      100.times do |i|
+        target = @player.next_target
+        row = target[0] - ?A
+        column = target[1..-1].to_i
+        if board[row, column]
+          violated("#{target} targeted a second time on round #{i}")
+        end
+
+        @player.target_result(target, false, nil)
+
+        board[row, column] = true
+      end
+    end
+
+    it "should never repeat a target, even with garbage feedback" do
+      board = Interferoman::BattleshipBoard.new
+      100.times do |i|
+        target = @player.next_target
+        row = target[0] - ?A
+        column = target[1..-1].to_i
+        if board[row, column]
+          violated("#{target} targeted a second time on round #{i}")
+        end
+
+        hit = rand(2) == 0
+        if (hit && rand(10) == 0)
+          ship = [:carrier, :battleship, :submarine, :destroyer,
+            :patrolship][rand(5)]
+        else
+          ship = nil
+        end
+
+        @player.target_result(target, hit, ship)
+
+        board[row, column] = true
+      end
+    end
+  end
+
+  describe :target_result do
+    it "should search for the ship when it gets a hit" do
+      target = @player.next_target
+      hit_row, hit_column = to_coordinates(target)
+      @player.target_result(target, true, nil)
+      next_target = @player.next_target
+
+      next_row, next_column = to_coordinates(next_target)
+      next_row.should be_close(hit_row, 1.001)
+      next_column.should be_close(hit_column, 1.001)
+    end
+
+    it "should start out in the 'random' state" do
+      @player.state.should == :random
+    end
+
+    it "should stay in the 'random' state when it gets a miss" do
+      @player.state = :random
+      @player.target_result('C3', false, nil)
+      @player.state.should == :random
+    end
+
+    it "should transition to the 'east' state when state is 'random' and it gets a hit" do
+      @player.state = :random
+      @player.target_result('A1', true, nil)
+      @player.state.should == :east
+      @player.next_target.should == 'A2'
+    end
+
+    it "should transition to 'east_2' state when it's in east and gets a hit" do
+      @player.state = :east
+      @player.target_result('A5', true, nil)
+      @player.state.should == :east_2
+      @player.next_target.should == 'A6'
+    end
+
+    it "should transition to the 'south' state when state is 'random' and it gets a hit on the right edge" do
+      @player.state = :random
+      @player.target_result('A10', true, nil)
+      @player.state.should == :south
+      @player.next_target.should == 'B10'
+    end
+
+    it "should transition to the 'south' state when state is 'random' and the next square to the right is a known state" do
+      @player.state = :random
+
+      @player.target_result('A10', false, nil)
+
+      @player.target_result('A9', true, nil)
+      @player.state.should == :south
+      @player.next_target.should == 'B9'
+    end
+
+    [:east, :west,
+      :south, :north].each do |state|
+      it "should transition to 'random' when state is '#{state}' and a ship is sunk" do
+        @player.state = state
+        @player.target_result('E5', true, :battleship)
+        @player.state.should == :random
+      end
+    end
+
+    it "should transition to 'west' when state is 'east' and it misses" do
+      @player.state = :east
+      @player.target_result('A9', true, nil)
+
+      @player.state.should == :east_2
+      @player.next_target.should == 'A10'
+      @player.target_result('A10', false, nil)
+
+      @player.state.should == :west
+      @player.next_target.should == 'A8'
+    end
+
+    it "should transition to 'west' when it's in north, gets a miss, and all other directions are known" do
+      @player.target_result('C7', true, nil)
+      @player.target_result('C8', false, nil)
+      @player.target_result('D7', false, nil)
+
+      @player.state = :north
+      @player.target_result('B7', false, nil)
+
+      @player.state.should == :west
+      @player.next_target.should == 'C6'
+    end
+
+    it "should transition to 'south' when state is 'east' and it misses" do
+      @player.target_result('B5', true, nil)
+
+      @player.state = :east
+      @player.target_result('B6', false, nil)
+
+      @player.state.should == :south
+      @player.next_target.should == 'C5'
+    end
+
+    it "should transition to 'south' when state is 'random' and it hits, but squares to the right and left are known states" do
+      @player.target_result('C4', false, nil)
+      @player.target_result('C6', false, nil)
+      @player.target_result('C5', true, nil)
+
+      @player.state.should == :south
+      @player.next_target.should == 'D5'
+    end
+
+    it "should transition to 'west' when state is 'east' and it reaches the edge" do
+      @player.state = :east
+      @player.target_result('A9', true, nil)
+
+      @player.state.should == :east_2
+      @player.next_target.should == 'A10'
+      @player.target_result('A10', true, nil)
+
+      @player.state.should == :west
+      @player.next_target.should == 'A8'
+    end
+
+    it "should transition to 'west' when state is 'east' and it reaches a known state (hit or miss)" do
+      @player.target_result('A5', false, nil)
+
+      @player.state = :east
+      @player.target_result('A4', true, nil)
+
+      @player.state.should == :west
+      @player.next_target.should == 'A3'
+    end
+
+    it "should stay in 'west' when it hits" do
+      @player.state = :west
+      @player.target_result('B6', true, nil)
+
+      @player.state.should == :west
+      @player.next_target.should == 'B5'
+    end
+
+    it "should transition to 'south' when state is 'west' and it misses" do
+      @player.target_result('B6', true, nil)
+      @player.state = :west
+
+      @player.target_result('B5', true, nil)
+      @player.state.should == :west
+      @player.next_target.should == 'B4'
+
+      @player.target_result('B4', false, nil)
+      @player.state.should == :south
+      @player.next_target.should == 'C5'
+    end
+
+    it "should transition to 'south' when state is 'west' and it reaches the edge" do
+      @player.target_result('B2', true, nil)
+      @player.state = :west
+
+      @player.target_result('B1', true, nil)
+      @player.state.should == :south
+      @player.next_target.should == 'C1'
+    end
+
+    it "should transition to 'south_2' when it gets a hit" do
+      @player.state = :south
+
+      @player.target_result('B3', true, nil)
+      @player.state.should == :south_2
+      @player.next_target.should == 'C3'
+    end
+
+    it "should transition to 'north' when it's in south and gets a miss" do
+      @player.state = :south
+
+      @player.target_result('B4', true, nil)
+      @player.state.should == :south_2
+      @player.next_target.should == 'C4'
+
+      @player.target_result('C4', false, nil)
+      @player.state.should == :north
+      @player.next_target.should == 'A4'
+    end
+
+    it "should transition to 'north' when it's in random, and it gets a hit but east, south, and west are known" do
+      @player.target_result('B4', false, nil)
+      @player.target_result('C3', false, nil)
+      @player.target_result('B2', false, nil)
+
+      @player.target_result('B3', true, nil)
+      @player.state.should == :north
+      @player.next_target.should == 'A3'
+    end
+
+    it "should transition to 'north' when it reaches the edge" do
+      @player.state = :south
+
+      @player.target_result('J9', true, nil)
+      @player.state.should == :north
+      @player.next_target.should == 'I9'
+    end
+
+    it "should stay in 'north' when it gets a hit" do
+      @player.state = :north
+
+      @player.target_result('J8', true, nil)
+      @player.state.should == :north
+      @player.next_target.should == 'I8'
+    end
+
+    it "should seek out the unknown ship when it sinks a ship and another ship has also been hit" do
+      @player.target_result('J7', true, nil)
+      @player.state = :north
+      @player.target_result('I7', true, nil)
+      @player.target_result('H7', true, :patrolship)
+      
+      @player.state.should == :east
+      @player.next_target.should == 'J8'
+    end
+  end
+
+  describe "ship placements" do
+    it "should not collide" do
+      board = Interferoman::BattleshipBoard.new
+
+      [:carrier,:battleship,:destroyer,:submarine,:patrolship].each do |ship|
+        placement = [ship,
+          *coordinates_for(@player.send(ship.to_s + "_placement"))]
+        board.collides?(*placement).should_not be_true
+        board.place(*placement)
+      end
+    end
+
+    def coordinates_for(placement)
+      coords, orientation = placement.split(' ')
+      row = coords[0] - ?A
+      column = coords[1..-1].to_i
+      orientation = orientation.to_sym
+
+      [row, column, orientation]
+    end
+  end
+
+  describe :unknown_hits do
+    it "should start out as an empty array" do
+      @player.unknown_hits.should == []
+    end
+
+    it "should keep track of hits for which we don't know the target" do
+      @player.target_result('D4', true, nil)
+      @player.unknown_hits.should == [[3,3]]
+
+      @player.target_result('B5', true, nil)
+      @player.unknown_hits.should == [[3,3], [1, 4]]
+    end
+
+    it "should remove hits when a ship is sunk" do
+      @player.target_result('D4', true, nil)
+      @player.target_result('D5', true, nil)
+      @player.target_result('D6', true, nil)
+
+      @player.unknown_hits.should == [[3,3], [3,4], [3,5]]
+      @player.state = :east
+      @player.target_result('D7', true, :submarine)
+
+      @player.unknown_hits.should == [[3,3]]
+    end
+  end
+
+  describe :remove_ship_targets do
+    it "should remove targets to the west if the state is :east" do
+      @player.unknown_hits << [1,2] << [1,3]
+      @player.send(:remove_ship_targets, 1, 4, :east, :submarine)
+
+      @player.unknown_hits.should == []
+    end
+
+    it "should remove targets to the west if the state is :east_2" do
+      @player.unknown_hits << [3,4] << [3,5]
+      @player.send(:remove_ship_targets, 3, 6, :east_2, :patrolship)
+
+      @player.unknown_hits.should == [[3,4]]
+    end
+
+    it "should remove targets to the north if the state is :south" do
+      @player.unknown_hits << [3,5] << [4,5] << [5,5]
+      @player.send(:remove_ship_targets, 6, 5, :south, :battleship)
+
+      @player.unknown_hits.should == []
+    end
+
+    it "should remove targets to the north if the state is :south_2" do
+      @player.unknown_hits << [3,8] << [4,8] << [5,8] << [6,8] << [7,8]
+      @player.send(:remove_ship_targets, 8, 8, :south_2, :carrier)
+
+      @player.unknown_hits.should == [[3,8]]
+    end
+
+    it "should remove targets to the east if the state is :west" do
+      @player.unknown_hits << [3,5] << [3,6] << [3,7]
+      @player.send(:remove_ship_targets, 3, 4, :west, :destroyer)
+
+      @player.unknown_hits.should == [[3,7]]
+    end
+
+    it "should remove targets to the south if the state is :north" do
+      @player.unknown_hits << [3,5] << [4,5] << [5,5]
+      @player.send(:remove_ship_targets, 2, 5, :north, :battleship)
+
+      @player.unknown_hits.should == []
+    end
+  end
+
+  def to_coordinates(target)
+    row = target[0] - ?A
+    column = target[1..-1].to_i
+
+    [row, column]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$: << File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require 'rubygems'
+require 'spec'

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: interferoman
+version: !ruby/object:Gem::Version 
+  version: "1.2"
+platform: ruby
+authors: 
+- Alf Mikula
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-28 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: A decent yet still flawed battleship player
+email: amikula@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Battleship.Rakefile
+- lib
+- lib/interferoman
+- lib/interferoman/battleship_board.rb
+- lib/interferoman/interferoman.rb
+- Rakefile
+- spec
+- spec/interferoman
+- spec/interferoman/battleship_board_spec.rb
+- spec/interferoman/interferoman_spec.rb
+- spec/spec_helper.rb
+has_rdoc: false
+homepage: http://sparring.rubyforge.org/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: sparring
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Battleship Player:interferoman
+test_files: []
+