joshua_son_of_nun 1.0

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/README.rdoc

@@ -0,0 +1,15 @@
+== Joshua, Son of Nun
+
+This is my entry for the ruby battleship sparring tournament (http://sparring.rubyforge.org/battleship/index.html).
+
+I also built a game simulator so testing of my player didn't have to depend on LimeLight. You can run 100 games like so:
+
+  ruby game_simulator.rb 100
+  
+You can also specify which strategy you would like each player to have. So, if you want to run 200 games where player 1 uses the Random strategy and player 2 uses the Knight strategy, you would use the following command:
+  
+  ruby game_simulator.rb Random Knight 200
+
+== License
+
+This is mine. Don't steal it! :-)

data/Rakefile

@@ -0,0 +1,54 @@
+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.spec_opts = ['--options', 'spec/spec.opts']
+  t.rcov = false
+end
+task :default => :spec
+
+PKG_NAME = "joshua_son_of_nun"
+PKG_VERSION   = "1.0"
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.files = FileList['**/*'].to_a.reject!{ |f| f =~ /report/ }
+  s.require_path = 'lib'
+  s.test_files = Dir.glob('spec/*_spec.rb')
+  s.bindir = 'bin'
+  s.executables = []
+  s.summary = "Battleship Player:joshua_son_of_nun"
+  s.rubyforge_project = "sparring"
+  s.homepage = "http://sparring.rubyforge.org/"
+
+  ###########################################
+  ##
+  ## You are encouraged to modify the following
+  ## spec attributes.
+  ##
+  ###########################################
+  s.description = "(using scary WWF wrestler voice) Just like the walls of Jericho, the same will happen to all battleship opponents of Joshua, son of Nun!!"
+  s.author = "Steve Iannopollo"
+  s.email = "steve@iannopollo.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
+
+desc 'Locally build the gem'
+task :make_gem do
+  `cd #{File.expand_path(File.dirname(__FILE__))} && rm -f pkg/joshua_son_of_nun-1.0.gem && rake gem && sudo gem uninstall joshua_son_of_nun && sudo gem install pkg/joshua_son_of_nun-1.0.gem`
+end

data/game_simulator.rb

@@ -0,0 +1,151 @@
+require 'init'
+
+OLD_STRATEGIES = JoshuaSonOfNun::Strategy.strategies.dup
+JoshuaSonOfNun::Strategy.module_eval do
+  class << self
+    attr_accessor :strategies
+  end
+end
+JoshuaSonOfNun::Strategy.strategies = OLD_STRATEGIES
+
+def Space(string)
+  coordinates, orientation = string.split(' ')
+  row, column = coordinates.scan(/(\w)(\d{1,2})/).first
+  JoshuaSonOfNun::Space.new(row, column, orientation)
+end
+
+class GameSimulator
+  attr_reader :current_player, :game_over, :opponent,
+              :player_one_strategy, :player_two_strategy,
+              :player_one, :player_two, :players, :results,
+              :ship_placement, :ships
+  
+  alias_method :game_over?, :game_over
+  
+  def initialize(player_one_strategy, player_two_strategy)
+    @player_one_strategy, @player_two_strategy = player_one_strategy, player_two_strategy
+    @player_one = JoshuaSonOfNun::Player.new
+    @player_two = JoshuaSonOfNun::Player.new
+    tag_players!
+    
+    @moves = []
+    @results = {@player_one.name => [], @player_two.name => []}
+  end
+  
+  def determine_damage(target)
+    hit, sunk = nil
+    ship_placement[opponent.name].each do |ship, spaces|
+      space = spaces.delete(target)
+      if space
+        hit = true
+        sunk = spaces.empty?
+        break
+      end
+    end
+    @game_over = ship_placement[opponent.name].values.flatten.empty?
+    [hit, sunk]
+  end
+  
+  def fire_on_opponent
+    target = current_player.next_target
+    ship_hit, ship_sunk = determine_damage(target)
+    
+    current_player.target_result(target.to_s, ship_hit, ship_sunk)
+    opponent.enemy_targeting(target.to_s)
+  end
+  
+  def force_strategy(strategy)
+    JoshuaSonOfNun::Strategy.strategies = [strategy]
+  end
+  
+  def gather_ship_placement
+    players.each do |player|
+      placement = {}
+      ships.each do |ship|
+        placement[ship] = Space(player.send("#{ship}_placement")).spaces_for_placement(player.instance_variable_get("@#{ship}").length)
+      end
+      
+      ship_placement[player.name] = placement
+    end
+  end
+  
+  def prepare_report
+    @filename = File.dirname(__FILE__) + "/reports/#{strategy_name(@player_one)}_vs_#{strategy_name(@player_two)}.csv"
+    `test -f #{@filename} && echo '' || echo '#{strategy_name(@player_one)},#{strategy_name(@player_two)},moves' > #{@filename}`
+  end
+  
+  def report_results
+    result = (@current_player == @player_one ? '1,0,' : '0,1,') + (@moves.last/2.0).ceil.to_s
+    `echo '#{result}' >> #{@filename}`
+    print "\e[32m.\e[0m"; STDOUT.flush
+  end
+  
+  def reset
+    @players = [@player_one, @player_two]
+    
+    force_strategy(player_one_strategy) unless player_one_strategy.nil?
+    @player_one.new_game(@player_two.name)
+    force_strategy(player_two_strategy) unless player_two_strategy.nil?
+    @player_two.new_game(@player_one.name)
+    prepare_report
+    
+    @ship_placement = {}
+    @ships = [:battleship, :carrier, :destroyer, :patrolship, :submarine]
+    gather_ship_placement
+    
+    @moves << 0
+    @game_over = false
+  end
+  
+  def run!
+    reset
+    
+    until game_over?
+      switch_turns
+      fire_on_opponent
+    end
+    
+    @results[@current_player.name] << strategy_name(@current_player)
+    report_results
+  end
+  
+  def strategy_name(player)
+    player.instance_variable_get('@strategy').class.name.split("::").last
+  end
+  
+  def summarized_results
+    summary = results.collect do |player, winning_strategies|
+      output = "#{player}:"
+      output << " #{winning_strategies.size} wins"
+      strategy_count = OLD_STRATEGIES.uniq.collect do |strategy|
+        count = winning_strategies.select {|s| s == strategy}.size
+        "#{strategy} => #{count}"
+      end
+      output << " (#{strategy_count * ', '})"
+    end.reverse * "\n"
+    average_moves = @moves.inject(0) {|sum, n| sum += n} / (2 * @moves.size.to_f)
+    summary << "\n#{average_moves} moves per game\n"
+    summary
+  end
+  
+  def switch_turns
+    @current_player = @players.shift
+    @players << @current_player
+    @opponent = @players.first
+    @moves << @moves.pop + 1
+  end
+  
+  def tag_players!
+    class << player_one
+      def name; 'player_one'; end
+    end
+    class << player_two
+      def name; 'player_two'; end
+    end
+  end
+end
+
+number_of_games = (ARGV.pop || 21).to_i
+simulator = GameSimulator.new(ARGV.shift, ARGV.shift)
+number_of_games.times {simulator.run!}
+puts '', simulator.summarized_results, ''

data/init.rb

@@ -0,0 +1,13 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/lib')
+
+require 'joshua_son_of_nun/ship'
+require 'joshua_son_of_nun/board'
+require 'joshua_son_of_nun/space'
+
+require 'joshua_son_of_nun/strategy/base'
+require 'joshua_son_of_nun/strategy/random'
+require 'joshua_son_of_nun/strategy/diagonal'
+require 'joshua_son_of_nun/strategy/knight'
+require 'joshua_son_of_nun/strategy/targeting_reaction'
+
+require 'joshua_son_of_nun/player'

data/lib/joshua_son_of_nun/board.rb

@@ -0,0 +1,39 @@
+module JoshuaSonOfNun
+  class Board
+    ROWS = ('A'..'J').to_a
+    COLUMNS = ('1'..'10').to_a
+    
+    attr_reader :occupied_spaces, :valid_spaces
+    
+    def initialize
+      @occupied_spaces, @valid_spaces = [], []
+      ROWS.each do |row|
+        COLUMNS.each do |column|
+          @valid_spaces << Space.new(row, column)
+        end
+      end
+    end
+    
+    def adjacent_to_occupied_spaces?(space, ship_length)
+      spaces = space.spaces_for_placement(ship_length)
+      occupied_spaces.inject(false) do |memo, occupied_space|
+        memo |= spaces.inject(false) {|m, s| m |= s.adjacent?(occupied_space)}
+      end
+    end
+    
+    def accomodate?(space, ship_length)
+      space.spaces_for_placement(ship_length).inject(true) do |success, possible_space|
+        success &= !occupied_spaces.include?(possible_space) && valid_spaces.include?(possible_space)
+      end
+    end
+    
+    def placement(ship_length)
+      space = nil
+      while space.nil? || !accomodate?(space, ship_length) || adjacent_to_occupied_spaces?(space, ship_length)
+        space = Space.generate
+      end
+      occupied_spaces.concat(space.spaces_for_placement(ship_length))
+      space.to_s
+    end
+  end
+end

data/lib/joshua_son_of_nun/joshua_son_of_nun.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../init')
+
+module JoshuaSonOfNun
+  JoshuaSonOfNun = Player
+end

data/lib/joshua_son_of_nun/player.rb

@@ -0,0 +1,54 @@
+module JoshuaSonOfNun
+  class Player
+    def battleship_placement
+      @battleship.initial_placement
+    end
+    
+    def carrier_placement
+      @carrier.initial_placement
+    end
+    
+    def destroyer_placement
+      @destroyer.initial_placement
+    end
+    
+    def patrolship_placement
+      @patrolship.initial_placement
+    end
+    
+    def submarine_placement
+      @submarine.initial_placement
+    end
+    
+    def next_target
+      @strategy.next_target.to_s
+    end
+    
+    def target_result(coordinates, was_hit, ship_sunk)
+      @strategy.register_result!(was_hit, ship_sunk)
+    end
+    
+    def enemy_targeting(*args); end
+    def game_over(*args); end
+    
+    private
+      def reset(*args)
+        srand
+        
+        @personal_board = Board.new
+        @opponent_board = Board.new
+        
+        @battleship = Battleship.new(@personal_board)
+        @carrier    = Carrier.new(@personal_board)
+        @destroyer  = Destroyer.new(@personal_board)
+        @patrolship = Patrolship.new(@personal_board)
+        @submarine  = Submarine.new(@personal_board)
+        
+        @strategy = Strategy.select(@opponent_board)
+      end
+    
+    alias_method :initialize, :reset
+    alias_method :new_game, :reset
+    public :initialize, :new_game
+  end
+end

data/lib/joshua_son_of_nun/ship.rb

@@ -0,0 +1,38 @@
+module JoshuaSonOfNun
+  class Ship
+    class << self
+      attr_accessor :length
+    end
+    
+    attr_reader :initial_placement
+    
+    def initialize(board)
+      @board = board
+      @initial_placement = @board.placement(length)
+    end
+    
+    def length
+      self.class.length
+    end
+  end
+  
+  class Battleship < Ship
+    self.length = 4
+  end
+  
+  class Carrier < Ship
+    self.length = 5
+  end
+  
+  class Destroyer < Ship
+    self.length = 3
+  end
+  
+  class Patrolship < Ship
+    self.length = 2
+  end
+  
+  class Submarine < Ship
+    self.length = 3
+  end
+end

data/lib/joshua_son_of_nun/space.rb

@@ -0,0 +1,172 @@
+module JoshuaSonOfNun
+  class Space
+    ROWS = Board::ROWS
+    COLUMNS = Board::COLUMNS
+    
+    def self.directions
+      [:southeast, :southwest, :northeast, :northwest]
+    end
+    
+    def self.generate
+      new(ROWS[rand(10).to_i], COLUMNS[rand(10).to_i], %w(horizontal vertical)[rand(2)])
+    end
+    
+    attr_reader :row, :column, :orientation
+    
+    def initialize(row, column, orientation = nil)
+      raise 'Invalid space' unless ROWS.include?(row) && COLUMNS.include?(column)
+      
+      @row, @column, @orientation = row, column, orientation
+    end
+    
+    def adjacent?(other)
+      adjacent_row_range.include?(other.row_index) && adjacent_column_range.include?(other.column_index)
+    end
+    
+    def column_index
+      COLUMNS.index(column)
+    end
+    
+    def crosswise_spaces
+      top    = (index = row_index - 1) < 0 ? nil : Space.new(ROWS[index], column)
+      right  = (index = column_index + 1) > 9 ? nil : Space.new(row, COLUMNS[index])
+      bottom = (index = row_index + 1) > 9 ? nil : Space.new(ROWS[index], column)
+      left   = (index = column_index - 1) < 0 ? nil : Space.new(row, COLUMNS[index])
+      [top, right, bottom, left].compact
+    end
+    
+    def linear_spaces(other, all_illegal_spaces = [], successful_illegal_spaces = [])
+      top, left, bottom, right = nil
+      illegal_spaces = all_illegal_spaces.dup.concat([self, other]).uniq
+      successful_spaces = successful_illegal_spaces.dup
+      
+      if row_index == other.row_index
+        left, right = assign_left_and_right(other.column_index, illegal_spaces, successful_spaces)
+      elsif column_index == other.column_index
+        top, bottom = assign_top_and_bottom(other.row_index, illegal_spaces, successful_spaces)
+      end
+      
+      [top, left, bottom, right].compact
+    end
+    
+    def linear?(other)
+      row_index == other.row_index || column_index == other.column_index
+    end
+    
+    def row_index
+      ROWS.index(row)
+    end
+    
+    def spaces_for_placement(ship_length)
+      args = case orientation
+      when 'horizontal': lambda {|i| [row, COLUMNS[column_index + i].to_s]}
+      when 'vertical':   lambda {|i| [ROWS[row_index + i].to_s, column]}
+      end
+      
+      (0..(ship_length - 1)).collect {|i| Space.new(*args.call(i)) rescue nil}
+    end
+    
+    def spaces_in_knighted_move(direction)
+      row_offset, column_offset = case direction
+      when :northeast: [[-1, 2], [-2, 1]][rand(2)]
+      when :southeast: [[1, 2], [2, 1]][rand(2)]
+      when :southwest: [[1, -2], [2, -1]][rand(2)]
+      when :northwest: [[-1, -2], [-2, -1]][rand(2)]
+      end
+      
+      r_index, c_index = row_index + row_offset, column_index + column_offset
+      if r_index < 0 || c_index < 0 || r_index > 9 || c_index > 9
+        nil
+      else
+        Space.new(ROWS[r_index], COLUMNS[c_index])
+      end
+    end
+    
+    def spaces_on_diagonal(direction)
+      spaces, boundary_reached = [], false
+      until boundary_reached
+        row_offset, column_offset = case direction
+        when :northeast: [-1, 1]
+        when :southeast: [1, 1]
+        when :southwest: [1, -1]
+        when :northwest: [-1, -1]
+        end
+        
+        seed_space = spaces.last || self
+        r_index, c_index = seed_space.row_index + row_offset, seed_space.column_index + column_offset
+        
+        if r_index < 0 || c_index < 0 || r_index > 9 || c_index > 9
+          boundary_reached = true
+        else
+          spaces << Space.new(ROWS[r_index], COLUMNS[c_index])
+        end
+      end
+      
+      spaces
+    end
+    
+    def to_s
+      [row.to_s + column.to_s, orientation].compact * ' '
+    end
+    alias_method :inspect, :to_s
+    
+    def ==(other)
+      to_s == other.to_s
+    end
+    
+    private
+      def adjacent_column_range
+        ((column_index == 0 ? 0 : column_index-1)..column_index+1)
+      end
+      
+      def adjacent_row_range
+        ((row_index == 0 ? 0 : row_index-1)..row_index+1)
+      end
+      
+      def assign_left_and_right(other_column_index, illegal_spaces, successful_spaces)
+        left_index = (column_index < other_column_index ? column_index : other_column_index)
+        right_index = left_index + 1
+        
+        surrounding_linear_spaces(left_index, right_index, illegal_spaces, successful_spaces) do |i, row, column|
+          Space.new(row, COLUMNS[i])
+        end
+      end
+      
+      def assign_top_and_bottom(other_row_index, illegal_spaces, successful_spaces)
+        top_index = (row_index < other_row_index ? row_index : other_row_index)
+        bottom_index = top_index + 1
+        
+        surrounding_linear_spaces(top_index, bottom_index, illegal_spaces, successful_spaces) do |i, row, column|
+          Space.new(ROWS[i], column)
+        end
+      end
+      
+      def surrounding_linear_spaces(side_one_index, side_two_index, illegal_spaces, successful_spaces, &space_creation_block)
+        side_one_spaces  = (0..side_one_index).collect {|i| space_creation_block.call(i, row, column)}
+        side_two_spaces = (side_two_index..9).collect {|i| space_creation_block.call(i, row, column)}
+        
+        illegal_spaces.each do |space|
+          side_one_spaces.delete(space)
+          side_two_spaces.delete(space)
+        end
+        
+        spaces = {
+          :side_one_space => side_one_spaces.pop,
+          :side_two_space => side_two_spaces.shift
+        }
+        
+        unless illegal_spaces.empty? || successful_spaces.empty?
+          unsuccessful_spaces = illegal_spaces.reject {|s| successful_spaces.include?(s)}
+          
+          [:side_one_space, :side_two_space].each do |key|
+            space = spaces[key]
+            spaces[key] = nil if !space.nil? &&
+                                 unsuccessful_spaces.detect {|s| space.adjacent?(s)} &&
+                                 !successful_spaces.detect {|s| space.adjacent?(s)}
+          end
+        end
+        
+        [spaces[:side_one_space], spaces[:side_two_space]]
+      end
+  end
+end

data/lib/joshua_son_of_nun/strategy/base.rb

@@ -0,0 +1,47 @@
+module JoshuaSonOfNun
+  module Strategy
+    def self.strategies
+      [['Random']*4, 'Diagonal', ['Knight']*2].flatten
+    end
+    
+    def self.select(board)
+      const_get(strategies[rand(strategies.size)]).new(board)
+    end
+    
+    class Base
+      attr_reader :current_target, :expended_targets, :immediate_targets,
+                  :possible_targets, :successful_targets, :targets
+      
+      def initialize(board)
+        @possible_targets = board.valid_spaces.dup
+        @targets = assign_targets
+        @expended_targets, @successful_targets, @immediate_targets = [], [], []
+      end
+      
+      def next_target
+        new_target = immediate_targets.shift || targets.first
+        targets.delete(new_target)
+        
+        @current_target = new_target
+        expended_targets << @current_target
+        @current_target
+      end
+      
+      def register_result!(ship_hit, ship_sunk)
+        if ship_hit
+          successful_targets << current_target
+          @immediate_targets = TargetingReaction.new(self, ship_sunk).react!
+        end
+      end
+      
+      private
+        def choose_target(index = rand(possible_targets.size))
+          possible_targets.delete(possible_targets[index])
+        end
+        
+        def random_direction
+          Space.directions[rand(Space.directions.size)]
+        end
+    end
+  end
+end

data/lib/joshua_son_of_nun/strategy/diagonal.rb

@@ -0,0 +1,19 @@
+module JoshuaSonOfNun
+  module Strategy
+    class Diagonal < Base
+      private
+        def assign_targets
+          targets = []
+          until possible_targets.empty?
+            target = choose_target
+            diagonal_targets = target.spaces_on_diagonal(random_direction)
+            targets << target
+            diagonal_targets.each do |diagonal_target|
+              targets << possible_targets.delete(diagonal_target)
+            end
+          end
+          targets.compact
+        end
+    end
+  end
+end

data/lib/joshua_son_of_nun/strategy/knight.rb

@@ -0,0 +1,17 @@
+module JoshuaSonOfNun
+  module Strategy
+    class Knight < Base
+      private
+        def assign_targets
+          targets = [choose_target]
+          until possible_targets.empty?
+            next_target = targets.last.spaces_in_knighted_move(random_direction)
+            next_target = choose_target if targets.include?(next_target) || next_target.nil?
+            possible_targets.delete(next_target)
+            targets << next_target
+          end
+          targets
+        end
+    end
+  end
+end

data/lib/joshua_son_of_nun/strategy/random.rb

@@ -0,0 +1,14 @@
+module JoshuaSonOfNun
+  module Strategy
+    class Random < Base
+      private
+        def assign_targets
+          targets = []
+          possible_targets.size.times do |n|
+            targets << choose_target(rand(100 - n))
+          end
+          targets
+        end
+    end
+  end
+end

data/lib/joshua_son_of_nun/strategy/targeting_reaction.rb

@@ -0,0 +1,34 @@
+module JoshuaSonOfNun
+  module Strategy
+    class TargetingReaction
+      attr_reader :strategy
+      
+      def initialize(strategy, ship_sunk)
+        @strategy, @ship_sunk = strategy, ship_sunk
+      end
+      
+      def react!
+        return [] if @ship_sunk
+        
+        if targets_lined_up?
+          targets = strategy.successful_targets
+          reject_expended(targets[-2].linear_spaces(targets.last, strategy.expended_targets, strategy.successful_targets))
+        else
+          reject_expended(strategy.current_target.crosswise_spaces)
+        end
+      end
+      
+      protected
+        def reject_expended(spaces)
+          spaces.reject do |space|
+            strategy.expended_targets.include?(space)
+          end
+        end
+        
+        def targets_lined_up?
+          targets = strategy.successful_targets
+          targets.size > 1 && targets[-2].linear?(targets.last)
+        end
+    end
+  end
+end

data/spec/joshua_son_of_nun/board_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe JoshuaSonOfNun::Board do
+  before do
+    @model = JoshuaSonOfNun::Board.new
+  end
+  
+  it "should know about which spaces are valid" do
+    @model.valid_spaces.should include(Space('A1'))
+    @model.valid_spaces.should include(Space('A10'))
+  end
+  
+  it "should calculate whether it can accomodate a ship at a certain space" do
+    @model.accomodate?(Space('A1 horizontal'), 5).should be_true
+    @model.accomodate?(Space('A10 horizontal'), 5).should be_false
+    @model.accomodate?(Space('H1 vertical'), 3).should be_true
+    @model.accomodate?(Space('H1 vertical'), 4).should be_false
+  end
+  
+  it "should keep track of it's occupied spaces" do
+    @model.placement(4)
+    @model.occupied_spaces.size.should == 4
+    
+    @model.placement(5)
+    @model.occupied_spaces.size.should == 9
+  end
+  
+  it "should be able to tell if a space is adjacent to the occupied spaces" do
+    space = Space('D3 horizontal')
+    @model.occupied_spaces.concat(space.spaces_for_placement(5)) # D3, D4, D5, D6, D7
+    
+    @model.adjacent_to_occupied_spaces?(Space('C3 horizontal'), 5).should be_true
+    @model.adjacent_to_occupied_spaces?(Space('E3 horizontal'), 5).should be_true
+    @model.adjacent_to_occupied_spaces?(Space('E3 vertical'), 2).should be_true
+    @model.adjacent_to_occupied_spaces?(Space('C8 vertical'), 2).should be_true
+    @model.adjacent_to_occupied_spaces?(Space('E2 vertical'), 2).should be_true
+    
+    @model.adjacent_to_occupied_spaces?(Space('A1 horizontal'), 5).should be_false
+    @model.adjacent_to_occupied_spaces?(Space('A1 vertical'), 5).should be_false
+    @model.adjacent_to_occupied_spaces?(Space('A4 vertical'), 2).should be_false
+    @model.adjacent_to_occupied_spaces?(Space('C9 vertical'), 5).should be_false
+  end
+end

data/spec/joshua_son_of_nun/player_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe JoshuaSonOfNun::Player do
+  before do
+    @model = JoshuaSonOfNun::Player.new
+  end
+  
+  it "should conform to the battleship API" do
+    @model.carrier_placement.should_not be_nil
+    @model.battleship_placement.should_not be_nil
+    @model.destroyer_placement.should_not be_nil
+    @model.submarine_placement.should_not be_nil
+    @model.patrolship_placement.should_not be_nil
+    
+    100.times do
+      @model.next_target.should_not == ''
+    end
+    
+    lambda {@model.target_result('A1', false, false)}.should_not raise_error
+    lambda {@model.new_game('bob')}.should_not raise_error
+  end
+end

data/spec/joshua_son_of_nun/ship_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Ships" do
+  before do
+    @board = JoshuaSonOfNun::Board.new
+    @model = JoshuaSonOfNun::Battleship.new(@board)
+  end
+  
+  it "should have a length" do
+    @model.length.should == 4
+  end
+  
+  it "should have an initial placement on the board" do
+    @model.initial_placement.should_not be_nil
+    @model.initial_placement.should =~ /[A-Z]\d{1,2} [horizontal|vertical]/
+  end
+end

data/spec/joshua_son_of_nun/space_spec.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe JoshuaSonOfNun::Space do
+  before do
+    @model = Space('A1')
+  end
+  
+  it "should know which spaces are close to other spaces" do
+    @model.adjacent?(Space('A1')).should be_true
+    @model.adjacent?(Space('A2')).should be_true
+    @model.adjacent?(Space('B1')).should be_true
+    @model.adjacent?(Space('B2')).should be_true
+    Space('E5').adjacent?(Space('D6')).should be_true
+    
+    @model.adjacent?(Space('A10')).should be_false
+    @model.adjacent?(Space('C3')).should be_false
+    Space('H7').adjacent?(Space('J7')).should be_false
+  end
+  
+  it "should return the spaces for placement for a ship of given length" do
+    Space('A1 horizontal').spaces_for_placement(4).should ==
+      space_array('A1', 'A2', 'A3', 'A4')
+    
+    Space('A1 vertical').spaces_for_placement(5).should ==
+      space_array('A1', 'B1', 'C1', 'D1', 'E1')
+    
+    Space('A8 horizontal').spaces_for_placement(5).should ==
+      space_array('A8', 'A9', 'A10').concat([nil, nil])
+  end
+  
+  it "should know which spaces are crosswise to the given space" do
+    @model.crosswise_spaces.should == space_array('A2', 'B1')
+    Space('C10').crosswise_spaces.should == space_array('B10', 'D10', 'C9')
+    Space('E5').crosswise_spaces.should == space_array('D5', 'E6', 'F5', 'E4')
+    Space('A7').crosswise_spaces.should == space_array('A8', 'B7', 'A6')
+  end
+  
+  it "should know which spaces are in the diagonal of a given direction" do
+    @model = Space('E5')
+    @model.spaces_on_diagonal(:northeast).should == space_array('D6', 'C7', 'B8', 'A9')
+    @model.spaces_on_diagonal(:southeast).should == space_array('F6', 'G7', 'H8', 'I9', 'J10')
+    @model.spaces_on_diagonal(:southwest).should == space_array('F4', 'G3', 'H2', 'I1')
+    @model.spaces_on_diagonal(:northwest).should == space_array('D4', 'C3', 'B2', 'A1')
+  end
+  
+  it "should know which spaces are in an 'L' shape to the given square and direction" do
+    @model.spaces_in_knighted_move(:northeast).should be_nil
+    space_array('C2', 'B3').should include(@model.spaces_in_knighted_move(:southeast))
+    @model.spaces_in_knighted_move(:southwest).should be_nil
+    @model.spaces_in_knighted_move(:northwest).should be_nil
+    
+    @model = Space('E5')
+    space_array('C6', 'D7').should include(@model.spaces_in_knighted_move(:northeast))
+    space_array('G6', 'F7').should include(@model.spaces_in_knighted_move(:southeast))
+    space_array('F3', 'G4').should include(@model.spaces_in_knighted_move(:southwest))
+    space_array('D3', 'C4').should include(@model.spaces_in_knighted_move(:northwest))
+  end
+  
+  describe "linear spaces" do
+    it "should know which spaces are linear to two given spaces, and return the two immediate closest spaces" do
+      Space('E6').linear_spaces(Space('E5')).should == space_array('E4', 'E7')
+      Space('E5').linear_spaces(Space('D5')).should == space_array('C5', 'F5')
+      @model.linear_spaces(Space('A2')).should == [Space('A3')]
+      @model.linear_spaces(Space('B1')).should == [Space('C1')]
+    end
+    
+    it "should not return spaces that are beyond spaces that have been targeted but were not successful" do
+      expended = space_array('A2', 'A3', 'A4', 'A5', 'A7')
+      successful = space_array('A4', 'A5')
+      Space('A4').linear_spaces(Space('A5'), expended, successful).should == [Space('A6')]
+    end
+  end
+end

data/spec/joshua_son_of_nun/strategy_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe JoshuaSonOfNun::Strategy::Random do
+  before do
+    @board = JoshuaSonOfNun::Board.new
+    @model = JoshuaSonOfNun::Strategy::Random.new(@board)
+  end
+  
+  it "should target all spaces" do
+    @model.targets.uniq.size.should == 100
+  end
+  
+  it "should shift targets out of the array to gather targets" do
+    target = nil
+    lambda do
+      @model.next_target
+      @model.next_target
+      target = @model.next_target
+    end.should change(@model.targets, :size).by(-3)
+    @model.current_target.should == target
+  end
+  
+  it "should receive results of the current target, and react accordingly" do
+    target = @model.targets.delete(Space('E5'))
+    @model.instance_variable_set '@current_target', target
+    @model.register_result! true, false
+    
+    @model.next_target.should == Space('D5') # First crosswise space to attack
+    @model.next_target.should == Space('E6')
+    @model.next_target.should == Space('F5')
+    @model.next_target.should == Space('E4')
+  end
+  
+  it "should not target differently if nothing was hit" do
+    target = @model.targets.delete(Space('E5'))
+    @model.instance_variable_set '@current_target', target
+    next_target = @model.targets.first
+    @model.register_result! false, false
+    
+    @model.next_target.should == next_target
+  end
+  
+  it "should target in a line if two or more targets have been hit" do
+    @model.instance_variable_set '@immediate_targets', [Space('E5')]
+    @model.next_target; @model.register_result! true, false # first shot
+    
+    @model.instance_variable_set '@immediate_targets', [Space('E6')]
+    @model.next_target; @model.register_result! true, false # second shot
+    
+    @model.next_target.should == Space('E4')
+    @model.register_result! false, false
+    
+    @model.next_target.should == Space('E7')
+    @model.register_result! true, false
+    
+    @model.next_target.should == Space('E8')
+  end
+  
+  it "should track successful targets" do
+    target_one = @model.next_target
+    @model.register_result! true, false
+    
+    target_two = @model.next_target
+    @model.register_result! true, false
+    
+    @model.successful_targets.should == [target_one, target_two]
+  end
+end
+
+describe JoshuaSonOfNun::Strategy::Diagonal do
+  before do
+    JoshuaSonOfNun::Space.stub!(:directions).and_return([:southeast])
+    
+    @board = JoshuaSonOfNun::Board.new
+    @model = JoshuaSonOfNun::Strategy::Diagonal.new(@board)
+  end
+  
+  it "should target all spaces" do
+    @model.targets.uniq.size.should == 100
+  end
+  
+  it "should search across the board in a diagonal fashion" do
+    target = Space('E5')
+    expected_next_target = Space('F6')
+    
+    # One of these spaces may have already been placed in the targeting array,
+    # so checking to make sure at least one of these spaces is the next space
+    space_array('F6', 'G7', 'H8', 'I9', 'J10').should include(@model.targets[@model.targets.index(target) + 1])
+  end
+end
+
+describe JoshuaSonOfNun::Strategy::Knight do
+  before do
+    JoshuaSonOfNun::Space.stub!(:directions).and_return([:southeast])
+    
+    @board = JoshuaSonOfNun::Board.new
+    @model = JoshuaSonOfNun::Strategy::Knight.new(@board)
+  end
+  
+  it "should target all spaces" do
+    @model.targets.uniq.size.should == 100
+    # The specifics of this strategy are not tested here because the next move
+    # from space E5 may have already been placed in the targeting array,
+    # making the order very difficult to test since sometimes the test will
+    # pass, other times the test will fail. So, testing whether or not we have
+    # all the targets is good enough.
+    # 
+    # Also, moving like a knight is tested in the space_spec
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,7 @@
+--colour
+--format
+progress
+--loadby
+mtime
+--reverse
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'spec'
+
+require 'init'
+
+module Kernel
+  require 'cgi'
+  
+  def rputs(*args)
+    puts *["<pre>", args.collect {|a| CGI.escapeHTML(a.inspect)}, "</pre>"]
+  end
+end
+
+def Space(string)
+  coordinates, orientation = string.split(' ')
+  row, column = coordinates.scan(/(\w)(\d{1,2})/).first
+  JoshuaSonOfNun::Space.new(row, column, orientation)
+end
+
+def space_array(*coordinates)
+  coordinates.collect {|c| Space(c)}
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: joshua_son_of_nun
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Steve Iannopollo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-29 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: (using scary WWF wrestler voice) Just like the walls of Jericho, the same will happen to all battleship opponents of Joshua, son of Nun!!
+email: steve@iannopollo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Battleship.Rakefile
+- game_simulator.rb
+- init.rb
+- lib
+- lib/joshua_son_of_nun
+- lib/joshua_son_of_nun/board.rb
+- lib/joshua_son_of_nun/joshua_son_of_nun.rb
+- lib/joshua_son_of_nun/player.rb
+- lib/joshua_son_of_nun/ship.rb
+- lib/joshua_son_of_nun/space.rb
+- lib/joshua_son_of_nun/strategy
+- lib/joshua_son_of_nun/strategy/base.rb
+- lib/joshua_son_of_nun/strategy/diagonal.rb
+- lib/joshua_son_of_nun/strategy/knight.rb
+- lib/joshua_son_of_nun/strategy/random.rb
+- lib/joshua_son_of_nun/strategy/targeting_reaction.rb
+- pkg
+- Rakefile
+- README.rdoc
+- spec
+- spec/joshua_son_of_nun
+- spec/joshua_son_of_nun/board_spec.rb
+- spec/joshua_son_of_nun/player_spec.rb
+- spec/joshua_son_of_nun/ship_spec.rb
+- spec/joshua_son_of_nun/space_spec.rb
+- spec/joshua_son_of_nun/strategy_spec.rb
+- spec/spec.opts
+- 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:joshua_son_of_nun
+test_files: []
+