ensign_erratic 1.0.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,41 @@
+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 = "ensign_erratic"
+PKG_VERSION = "1.0.2"
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.files = FileList['**/*'].to_a
+  s.require_path = 'lib'
+  s.test_files = Dir.glob('spec/*_spec.rb')
+  s.bindir = 'bin'
+  s.executables = []
+  s.summary = "Battleship Player:Ensign Erratic"
+  s.rubyforge_project = "sparring"
+  s.homepage = "http://sparring.rubyforge.org/"
+
+  s.description = "Relatively simple Battleship AI that utilizes random targeting and ship placement"
+  s.author = "Jim Suchy"
+  s.email = "jim@8thlight.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/ensign_erratic/board.rb

@@ -0,0 +1,56 @@
+module EnsignErratic
+  class Board
+    
+    attr_reader :placed_ship_sectors
+  
+    def initialize
+      @placed_ship_sectors = []
+    end
+
+    Row = %w{ A B C D E F G H I J }
+    PlacementRegex = /(([A-J])([1-9]|10)) (HORIZONTAL|VERTICAL)/i
+    CoordinatesRegex = /([A-J])([1-9|10])/i
+    
+    def clear
+      @placed_ship_sectors = []
+    end
+  
+    def place_ship(size, placement)
+      @possible_ship_sectors = []
+      
+      match = PlacementRegex.match(placement)
+      start_coordinates = match[1]
+      row = match[2]
+      column = match[3].to_i
+      orientation = match[4].upcase
+      
+      add_sector(start_coordinates)
+      (size - 1).times do |index|
+        new_coordinates = orientation == "HORIZONTAL" ? move_right(row, column, index) : move_down(row, column, index)
+        add_sector(new_coordinates)
+      end
+      
+      @placed_ship_sectors.concat(@possible_ship_sectors)
+    end
+    
+    private ###############################################
+    
+    def add_sector(coordinates)
+      raise "Ships overlap at #{coordinates}" if @placed_ship_sectors.include?(coordinates)
+      @possible_ship_sectors << coordinates
+    end
+    
+    def move_right(row, column, number)
+      new_column = column + number + 1
+      raise "Ship would fall off right edge" if new_column > 10
+      return "#{row}#{new_column}"
+    end
+    
+    def move_down(row, column, number)
+      new_row = Row[Row.index(row) + number + 1]
+      raise "Ship would fall off bottom edge" if new_row.nil?
+      return "#{new_row}#{column}"
+    end
+    
+  end
+end

data/lib/ensign_erratic/ensign_erratic.rb

@@ -0,0 +1,206 @@
+require 'ensign_erratic/board'
+
+module EnsignErratic
+  
+  class EnsignErratic
+    
+    attr_reader :carrier_placement, :battleship_placement, :destroyer_placement, :submarine_placement, :patrolship_placement
+    attr_reader :opponent_name, :result, :disqualification_reason
+    attr_reader :turns, :enemy_targets, :hits
+        
+    def name
+      return "Ensign Erratic"
+    end
+    
+    def new_game(opponent_name)
+      @opponent_name = opponent_name
+      reset
+      setup_ships
+    end
+    
+    def next_target
+      return seek_and_destroy? ? smart_target : random_target
+    end
+    
+    def target_result(coordinates, was_hit, ship_sunk)
+      @turns << coordinates
+      @hits << coordinates if was_hit
+      calculate_seek_and_destroy(was_hit, ship_sunk)
+    end
+    
+    def enemy_targeting(coordinates)
+      @enemy_targets << coordinates
+    end
+    
+    def game_over(result, disqualification_reason=nil)
+      @result = result
+      @disqualification_reason = disqualification_reason
+    end
+    
+    def seek_and_destroy?
+      return @seek_and_destroy
+    end
+    
+    private ###############################################
+    
+    def reset
+      @turns = []
+      @hits = []
+      @enemy_targets = []
+      @seek_and_destroy = false
+      @board = Board.new
+      Kernel.srand      
+    end
+    
+    def random_target
+      coordinates = random_coordinates
+      return already_targeted?(coordinates) ? random_target : coordinates
+    end
+    
+    def smart_target
+      row, column = last_hit_coordinates
+      
+      if @seek_and_destroy_direction == "left"
+        return seek_left(row, column)
+      elsif @seek_and_destroy_direction == "right"
+        return target_right(row, column.to_i)
+      elsif @seek_and_destroy_direction == "up"
+        return seek_up(row, column)
+      elsif @seek_and_destroy_direction == "down"
+        return target_down(row, column)
+      end
+    end
+    
+    def target_left(row, column)
+      return "#{row}#{column.to_i - 1}"
+    end
+    
+    def target_right(row, column)
+      column += 1
+      next_try = "#{row}#{column}"
+      
+      while already_targeted?(next_try)
+        column += 1
+        next_try = "#{row}#{column}"            
+      end
+      
+      return next_try
+    end
+    
+    def target_up(row, column)
+      row_above = Board::Row[Board::Row.index(row) - 1]
+      return "#{row_above}#{column}"
+    end
+    
+    def target_down(row, column)
+      row_below = Board::Row[Board::Row.index(row) + 1]
+      next_try = "#{row_below}#{column}"
+      while already_targeted?(next_try)
+        row_below = Board::Row[Board::Row.index(row_below) + 1]
+        next_try = "#{row_below}#{column}"
+      end
+      
+      return next_try
+    end
+    
+    def seek_left(row, column)
+      next_target = target_left(row, column)
+      if valid_target?(next_target)
+        return next_target
+      else
+        return target_right(row, column.to_i)
+      end
+    end
+    
+    def seek_up(row, column)
+      next_target = target_up(row, column)
+      if valid_target?(next_target)
+        return next_target
+      else
+        return target_down(row, column)
+      end
+    end
+    
+    def calculate_seek_and_destroy(was_hit, ship_sunk)
+      if @seek_and_destroy
+        if ship_sunk
+          @seek_and_destroy = false 
+        elsif !was_hit
+          if @seek_and_destroy_direction == "left"
+            @seek_and_destroy_direction = "right" 
+          elsif @seek_and_destroy_direction == "right"
+            @seek_and_destroy_direction = "up"
+          elsif @seek_and_destroy_direction == "up"
+            @seek_and_destroy_direction = "down"
+          end
+        end
+      elsif was_hit
+        @seek_and_destroy = true
+        @seek_and_destroy_direction = "left"
+      end
+    end
+
+    def valid_target?(coordinates)
+      row, column = row_and_column_for(coordinates)
+      return false if column.to_i <= 0
+      return false if already_targeted?(coordinates)
+      return true
+    end
+    
+    def already_targeted?(coordinates)
+      return @turns.include?(coordinates)
+    end
+    
+    def last_hit_coordinates
+      return row_and_column_for(@hits.last)
+    end
+    
+    def row_and_column_for(coordinates)
+      match = Board::CoordinatesRegex.match(coordinates)
+      return match[1], match[2]
+    end
+    
+    def setup_ships
+      valid_placement = false
+      while !valid_placement
+        randomize_ship_placement
+        begin
+          place_ships
+          valid_placement = true
+        rescue Exception => e
+          # puts e.message
+        end
+      end
+    end
+    
+    def randomize_ship_placement
+      @carrier_placement = random_ship_placement
+      @battleship_placement = random_ship_placement
+      @destroyer_placement = random_ship_placement
+      @submarine_placement = random_ship_placement
+      @patrolship_placement = random_ship_placement
+    end
+    
+    def random_ship_placement
+      return "#{random_coordinates} #{random_orientation}"
+    end
+    
+    def random_coordinates
+      return "#{Board::Row[Kernel.rand(10)]}#{Kernel.rand(10)+1}"
+    end
+  
+    def random_orientation
+      return Kernel.rand(2) == 1 ? "horizontal" : "vertical"
+    end
+    
+    def place_ships
+      @board.clear
+      @board.place_ship(5, @carrier_placement)
+      @board.place_ship(4, @battleship_placement)
+      @board.place_ship(3, @destroyer_placement)
+      @board.place_ship(3, @submarine_placement)
+      @board.place_ship(2, @patrolship_placement)
+    end
+        
+  end
+end

data/spec/ensign_erratic/board_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require 'ensign_erratic/board'
+
+describe EnsignErratic::Board do
+
+  before(:each) do
+    @board = EnsignErratic::Board.new
+  end
+  
+  it "should place ship horizontally" do
+    @board.place_ship(5, "A1 horizontal")
+    
+    @board.placed_ship_sectors.size.should == 5
+    @board.placed_ship_sectors.should include("A1")
+    @board.placed_ship_sectors.should include("A2")
+    @board.placed_ship_sectors.should include("A3")
+    @board.placed_ship_sectors.should include("A4")
+    @board.placed_ship_sectors.should include("A5")
+  end
+  
+  it "should place ship vertically" do
+    @board.place_ship(3, "B1 vertical")
+    
+    @board.placed_ship_sectors.size.should == 3
+    @board.placed_ship_sectors.should include("B1")
+    @board.placed_ship_sectors.should include("C1")
+    @board.placed_ship_sectors.should include("D1")
+  end
+  
+  it "should raise exception if ships would overlap" do
+    @board.place_ship(5, "B2 horizontal")
+    
+    lambda {@board.place_ship(3, "A3 vertical")}.should raise_error("Ships overlap at B3")
+    @board.placed_ship_sectors.size.should == 5
+  end
+  
+  it "should raise exception if ship would fall off right edge" do
+    lambda {@board.place_ship(5, "A9 horizontal")}.should raise_error("Ship would fall off right edge")
+    @board.placed_ship_sectors.size.should == 0
+  end
+  
+  it "should raise exception if ship would fall off bottom edge" do
+    lambda {@board.place_ship(5, "I3 vertical")}.should raise_error("Ship would fall off bottom edge")
+    @board.placed_ship_sectors.size.should == 0
+  end
+  
+  it "should clear placed ship sectors" do
+    @board.place_ship(3, "B1 vertical")
+    
+    @board.clear
+    
+    @board.placed_ship_sectors.size.should == 0
+  end
+
+end

data/spec/ensign_erratic/ensign_erratic_spec.rb

@@ -0,0 +1,204 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require 'ensign_erratic/ensign_erratic'
+require 'ensign_erratic/board'
+
+describe EnsignErratic do
+
+  before(:each) do
+    EnsignErratic::Board.stub!(:new).and_return(mock("board", :place_ship => nil, :clear => nil))
+    
+    @player = EnsignErratic::EnsignErratic.new    
+    @player.new_game("some player")
+  end
+  
+  it "should have a name" do
+    @player.name.should == "Ensign Erratic"
+  end
+  
+  it "should store opponent's name" do
+    @player.new_game("your opponent")
+    
+    @player.opponent_name.should == "your opponent"
+  end
+  
+  it "should seed rng for each new game" do
+    Kernel.should_receive(:srand)
+    
+    @player.new_game("foo")
+  end
+  
+  it "should have game over" do
+    @player.game_over(:disqualified, "no reason")
+    
+    @player.result.should == :disqualified
+    @player.disqualification_reason.should == "no reason"
+  end
+  
+  it "should target a random location" do
+    Kernel.should_receive(:rand).with(10).twice.and_return(3, 7)
+    
+    @player.next_target.should == "D8"
+  end
+  
+  it "should not fire at a location that has already been fired at" do
+    @player.target_result("D8", false, nil)
+    @player.target_result("C6", false, nil)
+    Kernel.should_receive(:rand).with(10).and_return(3, 7, 2, 5, 1, 6)
+    
+    @player.next_target.should == "B7"
+  end
+  
+  it "should store whether opponent's target was a hit" do
+    @player.target_result("A1", true, nil)
+    @player.target_result("C8", false, nil)
+    @player.target_result("F4", true, nil)
+    
+    @player.hits.size.should == 2
+    @player.hits[0].should == "A1"
+    @player.hits[1].should == "F4"
+  end
+  
+  it "should store taken turns" do
+    @player.target_result("A1", true, nil)
+    @player.target_result("C8", false, nil)
+    @player.target_result("F4", true, nil)
+    
+    @player.turns[0].should == "A1"
+    @player.turns[1].should == "C8"
+    @player.turns[2].should == "F4"
+    @player.hits[0].should == "A1"
+    @player.hits[1].should == "F4"
+  end
+  
+  it "should store opponent's targets" do
+    @player.enemy_targeting("B7")
+    @player.enemy_targeting("A3")
+    
+    @player.enemy_targets[0].should == "B7"
+    @player.enemy_targets[1].should == "A3"
+  end
+  
+  it "should go to seek and destroy mode after first hit of a ship" do
+    @player.target_result("A1", true, nil)
+    
+    @player.seek_and_destroy?.should == true
+  end
+  
+  it "should stay in seek and destroy after missing next shot" do
+    @player.target_result("A7", true, nil)
+    @player.target_result("A6", false, nil)
+    
+    @player.seek_and_destroy?.should == true
+  end
+  
+  it "should go out of seek and destroy mode after ship is sunk" do
+    @player.target_result("A2", true, nil)
+    
+    @player.target_result("A1", true, :patrolship)
+    
+    @player.seek_and_destroy?.should == false
+  end
+  
+  it "should first target to the left of the hit" do
+    @player.target_result("D3", true, nil)
+    
+    @player.next_target.should == "D2"
+  end
+  
+  it "should target right if missed to the left" do
+    @player.target_result("D3", true, nil)
+    @player.target_result("D2", false, nil)
+    
+    @player.next_target.should == "D4"
+  end
+
+  it "should continue to the left if hit" do
+    @player.target_result("D3", true, nil)
+    @player.target_result("D2", true, nil)
+    
+    @player.next_target.should == "D1"
+  end
+  
+  it "should target to the right if hit was on the left edge" do
+    @player.target_result("A1", true, nil)
+    
+    @player.next_target.should == "A2"
+  end
+  
+  it "should target to the right if sector to left of hit was already targeted" do
+    @player.target_result("D4", false, nil)
+    @player.target_result("D5", true, nil)
+    
+    @player.next_target.should == "D6"
+  end
+  
+  it "should target up if no hits to left or right" do
+    @player.target_result("C5", true, nil)
+    @player.target_result("C4", false, nil)
+    @player.target_result("C6", false, nil)
+    
+    @player.next_target.should == "B5"
+  end
+  
+  it "should target down if no hits left, right or up" do
+    @player.target_result("C5", true, nil)
+    @player.target_result("C4", false, nil)
+    @player.target_result("C6", false, nil)
+    @player.target_result("B5", false, nil)
+    
+    @player.next_target.should == "D5"
+  end
+  
+  it "should target down after hitting one above then missing above that" do
+    @player.target_result("C5", true, nil)
+    @player.target_result("C4", false, nil)
+    @player.target_result("C6", false, nil)
+    @player.target_result("B5", true, nil)
+    @player.target_result("A5", false, nil)
+    
+    @player.next_target.should == "D5"
+  end
+  
+  it "should target down if sector above hit was already targeted" do
+    @player.target_result("B5", false, nil)
+    @player.target_result("C5", true, nil)
+    @player.target_result("C4", false, nil)
+
+    @player.next_target.should == "C6"
+  end
+    
+  it "should target right if sector above and below already targeted" do
+    @player.target_result("B5", false, nil)
+    @player.target_result("D5", false, nil)
+    @player.target_result("C4", false, nil)
+    @player.target_result("C5", true, nil)
+    
+    @player.next_target.should == "C6"
+  end
+  
+  # it "should not try to the right when already know the ship is vertical" do
+  #   @player.target_result("C8", true, nil)
+  #   @player.target_result("C7", false, nil)
+  #   @player.target_result("B8", true, nil)
+  #   @player.target_result("A8", false, nil)
+  #   
+  #   @player.next_target.should == "D8"
+  # end
+  
+  # it "should handle initial hit in top corner" do
+  #   @player.target_result("A10", true, nil)
+  #   @player.target_result("A9", false, nil)
+  #   
+  #   @player.next_target.should == "B10"
+  # end
+  # 
+  # it "should handle initial hit on right edge" do
+  #   @player.target_result("D10", true, nil)
+  #   @player.target_result("D9", false, nil)
+  #   @player.target_result("C10", false, nil)
+  #   
+  #   @player.next_target.should == "E10"
+  # end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+extensions: []
+homepage: http://sparring.rubyforge.org/
+executables: []
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+post_install_message: 
+date: 2008-12-01 06:00:00 +00:00
+files: 
+- Battleship.Rakefile
+- lib
+- pkg
+- Rakefile
+- spec
+- lib/ensign_erratic
+- lib/ensign_erratic/board.rb
+- lib/ensign_erratic/ensign_erratic.rb
+- pkg/ensign_erratic-1.0.0.1.gem
+- pkg/ensign_erratic-1.0.0.2.gem
+- pkg/ensign_erratic-1.0.0.3.gem
+- pkg/ensign_erratic-1.0.0.gem
+- pkg/ensign_erratic-1.0.1.gem
+- spec/ensign_erratic
+- spec/spec_helper.rb
+- spec/ensign_erratic/board_spec.rb
+- spec/ensign_erratic/ensign_erratic_spec.rb
+rubygems_version: 1.2.0
+rdoc_options: []
+signing_key: 
+cert_chain: []
+name: ensign_erratic
+has_rdoc: false
+platform: ruby
+summary: Battleship Player:Ensign Erratic
+default_executable: 
+bindir: bin
+required_rubygems_version: !ruby/object:Gem::Requirement
+  version: 
+  requirements: 
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: !str 0
+required_ruby_version: !ruby/object:Gem::Requirement
+  version: 
+  requirements: 
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: !str 0
+require_paths: 
+- lib
+specification_version: 2
+test_files: []
+dependencies: []
+description: Relatively simple Battleship AI that utilizes random targeting and ship
+  placement
+email: jim@8thlight.com
+authors: 
+- Jim Suchy
+extra_rdoc_files: []
+requirements: []
+rubyforge_project: sparring
+autorequire: