alpha 1.7

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 = "alpha"
+PKG_VERSION   = "1.7"
+
+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:alpha"
+  s.rubyforge_project = "sparring"
+  s.homepage = "http://sparring.rubyforge.org/"
+
+  ###########################################
+  ##
+  ## You are encouraged to modify the following
+  ## spec attributes.
+  ##
+  ###########################################
+  s.description = "The Alpha bot"
+  s.author = "Paul W Pagel"
+  s.email = "paul@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/alpha/alpha.rb

@@ -0,0 +1,217 @@
+require 'alpha/grid'
+require "alpha/randomizer"
+require "alpha/mover"
+
+module Alpha
+    
+  # 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 Alpha
+    
+    # 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 accomidate 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 bothe ships are trying to occupy the square A1.
+    #
+    # Invalid ship placements will result in disqualification of the player.
+    #
+    
+    def get_placement(block_number)
+      placement = "#{@randomizer.rand_column}#{@randomizer.rand_row} #{@randomizer.rand_direction}"
+      square, direction = parse_placement(placement)
+      return get_placement(block_number) unless @my_grid.can_place_block?(square, direction, block_number)
+      return placement
+    end
+    
+    def parse_placement(placement)
+      parts = placement.split(" ")
+      return  parts[0], parts[1]
+    end
+    
+    def place(occupied_squares)
+      placement = get_placement(occupied_squares)
+      square, direction = parse_placement(placement)
+      @my_grid.place_block(square, direction, occupied_squares) 
+      return placement
+    end
+    
+    def carrier_placement
+      return place(5)
+    end
+
+    # Returns the placement of the battleship. A battleship consumes 4 squares.
+    def battleship_placement
+      return place(4)
+    end
+
+    # Returns the placement of the destroyer. A destroyer consumes 3 squares.
+    def destroyer_placement
+      return place(3)
+    end
+
+    # Returns the placement of the submarine. A submarine consumes 3 squares.
+    def submarine_placement
+      return place(3)
+    end
+
+    # Returns the placement of the patrolship. A patrolship consumes 2 squares.
+    def patrolship_placement
+      return place(2)
+    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 illegal to target a sector more than once.  Doing so will also result in disqualification.
+    #
+    def next_target
+      target = target_for_current_shot
+      @shots_taken += 1
+      return target
+    end
+
+    # target_result will be called by the system after a call to next_target.  The paramters 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
+    #     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)
+      result = nil
+      if was_hit
+        result = :hit
+        @red_zone = true unless ship_sunk
+      else
+        result = :miss
+      end
+      @red_zone = false if ship_sunk
+      
+      @opponents_grid.place(coordinates, result)
+    end
+
+    # enemy_targeting is called by the system to inform a player of their apponents move.  When the opponent targets
+    # a square, this method is called with the coordinates.
+    #
+    # Players may use this information to understand an opponents 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 #:nodoc:
+    attr_reader :battle_queue, :opponents_grid, :red_zone
+
+    def initialize #:nodoc:
+      reset
+    end
+
+    private ###############################################
+
+    def reset
+      @shots_taken = 0
+      @randomizer = Randomizer.new
+      @my_grid = Grid.new
+      @opponents_grid = Grid.new
+      @red_zone = false 
+    end
+
+    def target_for_current_shot
+      if @red_zone
+        mover = Mover.new
+        last_move = @opponents_grid.moves.last
+        row = @opponents_grid.get_row(last_move)
+        column =  @opponents_grid.get_column(last_move)
+        
+        result = mover.go_right(row, column, @opponents_grid)
+        return result if result
+        
+        result = mover.go_left(row, column, @opponents_grid)
+        return result if result
+        
+        result = mover.go_down(row, column, @opponents_grid)
+        return result if result
+        
+        result = mover.go_up(row, column, @opponents_grid)
+        return result if result
+      end
+      return shot_candidate
+      
+    end
+    
+    def shot_candidate
+      candidate = "#{@randomizer.rand_column}#{@randomizer.rand_row}"
+      return shot_candidate unless @opponents_grid.query(candidate) == :empty
+      return candidate
+    end
+  end
+  
+end

data/lib/alpha/grid.rb

@@ -0,0 +1,91 @@
+
+module Alpha 
+  class Grid
+    attr_reader :moves
+    @@LETTERS = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]
+    def initialize
+      @grid = {}
+      @moves = []
+      
+      @@LETTERS.each do |letter|
+        10.times {|times| @grid["#{letter}#{times + 1}"] = :empty } 
+      end
+    end
+    
+    def letters
+      return @@LETTERS
+    end
+    
+    def place(key, value)
+      @moves << key
+      return @grid[key] = value
+    end
+    
+    def query(criteria)
+      return @grid[criteria]
+    end
+    
+    def last_a_hit?
+      return @grid[@moves.last] == :hit
+    end
+    
+    def place_block(placement, direction, occupied_squares)
+      if direction == "horizontal"
+        row = get_row(placement)
+        column = get_column(placement)
+
+        occupied_squares.times do |col|
+          place("#{row}#{col + column}", :placed)
+        end
+      else
+        row = index_of(get_row(placement))
+        column = get_column(placement)
+        occupied_squares.times do |new_row|
+          place("#{@@LETTERS[(row + new_row)] }#{column}", :placed)
+        end
+      end
+      
+    end
+    
+    def can_place_block?(placement, direction, occupied_squares)
+      if direction == "horizontal"
+        row = get_row(placement)
+        column = get_column(placement)
+        
+        occupied_squares.times do |col|
+          return false if query("#{row}#{(column + col)}") != :empty
+        end
+      else
+        row = index_of(get_row(placement))
+        column = get_column(placement)
+        occupied_squares.times do |new_row|
+          return false if query("#{@@LETTERS[(row + new_row)] }#{column}") != :empty
+        end
+      end
+      return true
+    end
+    
+    
+    def get_row(placement)
+      return placement[0,1] 
+    end
+    
+    def get_column(placement)
+      if placement.size == 2 
+        return placement[1,2].to_i 
+      else
+        return placement[1,3].to_i 
+      end
+    end
+    
+    
+    def index_of(item)
+      @@LETTERS.each_with_index do |letter, index|
+        return index if letter == item
+      end
+      
+      raise "ITEM #{item} is not in LETTERS LIST"
+    end
+  end
+end
+

data/lib/alpha/mover.rb

@@ -0,0 +1,51 @@
+module Alpha
+  
+  class Mover
+    
+    def go_right(row, column, grid)
+      i = 1
+      while true
+        square_candidate_value = grid.query("#{row}#{column + i}")
+        return "#{row}#{column + i}" if square_candidate_value == :empty
+        break unless square_candidate_value == :hit
+        i += 1
+      end
+    end    
+
+    def go_left(row, column, grid)
+      i = 1
+      while true
+        square_candidate_value = grid.query("#{row}#{column - i}")
+        return "#{row}#{column - i}" if square_candidate_value == :empty
+        break unless square_candidate_value == :hit
+        i += 1
+      end
+    end
+
+    def go_down(row, column, grid)
+      i = 1
+      while true
+        index = grid.index_of(row)
+
+        square_candidate_value = grid.query("#{grid.letters[index + i]}#{column}")
+        return "#{grid.letters[index + i]}#{column}" if square_candidate_value == :empty
+        break unless square_candidate_value == :hit
+        i += 1
+      end
+    end
+
+    def go_up(row, column, grid)
+      i = 1
+      while true
+        index = grid.index_of(row)
+
+        square_candidate_value = grid.query("#{grid.letters[index - i]}#{column}")
+        return "#{grid.letters[index - i]}#{column}" if square_candidate_value == :empty
+        break unless square_candidate_value == :hit
+        i += 1
+      end
+    end
+
+  end
+  
+end

data/lib/alpha/randomizer.rb

@@ -0,0 +1,39 @@
+module Alpha
+  class Randomizer
+
+    def rand_row
+      return random.to_s
+    end
+    
+    def rand_column
+      return @@LETTERS[random]
+    end
+    
+    def rand_direction
+      return @@DIRECTIONS[Kernel.rand(2)]
+    end
+    
+    def random
+      return Kernel.rand(10)
+    end
+
+    @@DIRECTIONS = {
+      0 => "horizontal",
+      1 => "vertical" 
+    }
+    
+    @@LETTERS = {
+      0 =>  "A",
+      1 =>  "B",
+      2 =>  "C",
+      3 =>  "D",
+      4 =>  "E",
+      5 =>  "F",
+      6 =>  "G",
+      7 =>  "H",
+      8 =>  "I",
+      9 => "J"
+    }
+  end
+  
+end

data/spec/alpha/alpha_spec.rb

@@ -0,0 +1,133 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'alpha/alpha'
+
+
+describe Alpha::Alpha, "placement" do
+  
+  before(:each) do
+    @alpha = Alpha::Alpha.new
+  end
+  
+  it "should find a random column" do
+
+    @alpha.carrier_placement.should_not be(nil)
+    @alpha.battleship_placement.should_not be(nil)
+    @alpha.destroyer_placement.should_not be(nil)
+    @alpha.submarine_placement.should_not be(nil)
+    @alpha.patrolship_placement.should_not be(nil)
+  end
+end
+
+describe Alpha::Alpha do
+
+  before(:each) do
+    @alpha = Alpha::Alpha.new
+  end
+  
+  it "should remember results of a miss" do
+    @alpha.target_result("A1", false, false)
+    @alpha.opponents_grid.query("A1").should == :miss
+  end
+  
+  it "should remember results of a hit" do
+    @alpha.target_result("A1", true, false)
+    @alpha.opponents_grid.query("A1").should == :hit
+  end
+
+  it "should remember results of many hits" do
+    @alpha.target_result("A1", true, false)
+    @alpha.opponents_grid.query("A1").should == :hit
+    @alpha.target_result("A2", true, false)
+    @alpha.opponents_grid.query("A2").should == :hit
+    @alpha.target_result("A3", true, false)
+    @alpha.opponents_grid.query("A3").should == :hit
+  end
+  
+  it "should flag if it is a hit and not sink" do
+    @alpha.target_result("A1", true, false)
+    @alpha.red_zone.should == true
+    @alpha.target_result("A1", true, true)
+    @alpha.red_zone.should == false
+  end
+  
+  it "should move right if it has a hit" do
+    @alpha.target_result("A1", true, false)
+    @alpha.opponents_grid.query("A1").should == :hit
+    @alpha.next_target.should == "A2"
+  end
+  
+  it "should not move right if it is off the board" do
+    @alpha.target_result("A10", true, false)
+    @alpha.opponents_grid.query("A10").should == :hit
+    @alpha.next_target.should == "A9"
+  end
+  
+  it "should not move right if it is off the board" do
+    @alpha.target_result("A10", true, false)
+    @alpha.opponents_grid.query("A10").should == :hit
+    @alpha.next_target.should == "A9"
+  end
+  
+  it "should continue to move right if there are hits" do
+    @alpha.opponents_grid.place("A6", :hit)
+    @alpha.target_result("A5", true, false)
+    @alpha.next_target.should == "A7"
+  end
+  
+  it "should continue to move right until it hits a miss, then try left" do
+    @alpha.opponents_grid.place("A6", :hit)
+    @alpha.opponents_grid.place("A7", :miss)
+    @alpha.target_result("A5", true, false)
+    @alpha.next_target.should == "A4"
+  end
+
+  it "should continue to move right until it hits a miss, then try left" do
+    @alpha.opponents_grid.place("A6", :hit)
+    @alpha.opponents_grid.place("A7", :hit)
+    @alpha.target_result("A5", true, false)
+    @alpha.next_target.should == "A8"
+  end
+  
+  it "should continue left if right dowesn't work" do
+    @alpha.opponents_grid.place("A9", :hit)
+    @alpha.opponents_grid.place("A8", :hit)
+    @alpha.target_result("A10", true, false)
+    @alpha.next_target.should == "A7"
+  end
+  
+  it "should go DOWN if left and right don't work" do
+    @alpha.opponents_grid.place("C5", :miss)
+    @alpha.opponents_grid.place("C3", :miss)
+    @alpha.target_result("C4", true, false)
+    @alpha.next_target.should == "D4"
+  end
+  
+  it "should go UP if left and right and down don't work" do
+    @alpha.opponents_grid.place("C5", :miss)
+    @alpha.opponents_grid.place("C3", :miss)
+    @alpha.opponents_grid.place("D4", :miss)
+    @alpha.target_result("C4", true, false)
+    @alpha.next_target.should == "B4"
+  end
+  
+  # it "should not go more than once in a bad direction" do
+  #   @alpha.target_result("C4", true, false)
+  #   @alpha.next_target.should == "C5"
+  #   @alpha.target_result("C5", false, false)
+  #   @alpha.next_target.should == "C3"
+  # end
+  
+  
+end
+
+#      A  B  C  D  E  F  G  H  I  J
+#  1 |  |  |  |  |  |  |  |  |  |  |
+#  2 |  |  |  |  |  |  |  |  |  |  |
+#  3 |  |  |  |  |  |  |  |  |  |  |
+#  4 |  |  |  |  |  |  |  |  |  |  |
+#  5 |  |  |  |  |  |  |  |  |  |  |
+#  6 |  |  |  |  |  |  |  |  |  |  |
+#  7 |  |  |  |  |  |  |  |  |  |  |
+#  8 |  |  |  |  |  |  |  |  |  |  |
+#  9 |  |  |  |  |  |  |  |  |  |  |
+#  10|  |  |  |  |  |  |  |  |  |  |

data/spec/alpha/grid_spec.rb

@@ -0,0 +1,78 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'alpha/grid'
+
+describe Alpha::Grid do
+  
+  before(:each) do
+    @grid = Alpha::Grid.new
+  end
+  
+  it "should mark the spot" do
+    @grid.place("A1", :miss)
+    
+    @grid.query("A1").should == :miss
+  end
+  
+  it "should place a horizontal block on a grid" do
+    @grid.place_block("A1", "horizontal", 5)
+    
+    @grid.query("A1").should == :placed
+    @grid.query("A2").should == :placed
+    @grid.query("A3").should == :placed
+    @grid.query("A4").should == :placed
+    @grid.query("A5").should == :placed
+  end
+  
+  it "should place a horizontal block on a grid" do
+    @grid.place_block("A2", "horizontal", 5)
+    
+    @grid.query("A2").should == :placed
+    @grid.query("A3").should == :placed
+    @grid.query("A4").should == :placed
+    @grid.query("A5").should == :placed
+    @grid.query("A6").should == :placed
+  end
+  
+  it "should place a horizontal block on a grid" do
+    @grid.place_block("C3", "horizontal", 5)
+    
+    @grid.query("C3").should == :placed
+    @grid.query("C4").should == :placed
+    @grid.query("C5").should == :placed
+    @grid.query("C6").should == :placed
+    @grid.query("C7").should == :placed
+  end  
+  
+  it "should place a vertical block" do
+    @grid.place_block("A1", "vertical", 5)
+    
+    @grid.query("A1").should == :placed
+    @grid.query("B1").should == :placed
+    @grid.query("C1").should == :placed
+    @grid.query("D1").should == :placed
+    @grid.query("E1").should == :placed
+  end
+  
+  it "should place a block on a grid" do
+    @grid.can_place_block?("A1", "horizontal", 5).should == true
+    @grid.can_place_block?("A1", "vertical", 5).should == true
+    
+    @grid.can_place_block?("A10", "horizontal", 5).should == false
+    @grid.can_place_block?("J10", "vertical", 5).should == false
+  end
+  
+  it "should keep a queue of moves" do
+    @grid.place("A1", :hit)
+    
+    @grid.moves.size.should == 1
+    @grid.moves[0].should == "A1"
+  end
+  
+  it "should tell me it the last one was a hit" do
+    @grid.place("A1", :miss)
+    @grid.last_a_hit?.should == false
+
+    @grid.place("A2", :hit)    
+    @grid.last_a_hit?.should == true
+  end
+end

data/spec/alpha/randomizer_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require "alpha/randomizer"
+
+describe Alpha::Randomizer do
+  
+  before(:each) do  
+    @randomizer = Alpha::Randomizer.new
+  end
+  
+  it "should randomize numbers between one and ten" do
+    Kernel.should_receive(:rand).with(10)
+    @randomizer.rand_row
+  end
+  
+  it "should randomize colomn numbers" do
+    Kernel.should_receive(:rand).with(10)
+    @randomizer.rand_column    
+  end
+  
+  it "should randomize the direction" do
+    Kernel.should_receive(:rand).with(2)
+    @randomizer.rand_direction
+  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,73 @@
+--- !ruby/object:Gem::Specification 
+name: alpha
+version: !ruby/object:Gem::Version 
+  version: "1.7"
+platform: ruby
+authors: 
+- Paul W Pagel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-01 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: The Alpha bot
+email: paul@8thlight.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Battleship.Rakefile
+- lib
+- lib/alpha
+- lib/alpha/alpha.rb
+- lib/alpha/grid.rb
+- lib/alpha/mover.rb
+- lib/alpha/randomizer.rb
+- pkg
+- pkg/alpha-1.1.gem
+- pkg/alpha-1.2.gem
+- pkg/alpha-1.3.gem
+- pkg/alpha-1.4.gem
+- pkg/alpha-1.5.gem
+- pkg/paul-1.0.gem
+- Rakefile
+- spec
+- spec/alpha
+- spec/alpha/alpha_spec.rb
+- spec/alpha/grid_spec.rb
+- spec/alpha/randomizer_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.3.0
+signing_key: 
+specification_version: 2
+summary: Battleship Player:alpha
+test_files: []
+