uss_monte_carlo 2.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,rcov,test,shoulda', '--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 = "uss_monte_carlo"
+PKG_VERSION   = "2.0.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:USS Monte Carlo"
+  s.rubyforge_project = "sparring"
+  s.homepage = "http://sparring.rubyforge.org/"
+
+  ###########################################
+  ##
+  ## You are encouraged to modify the following
+  ## spec attributes.
+  ##
+  ###########################################
+  s.description = "Flagship of the Monaco Navy"
+  s.author = "Joshua Ballanco"
+  s.email = "jballanc@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/uss_monte_carlo/game_constants.rb

@@ -0,0 +1,12 @@
+SHIPS = [:carrier, :battleship, :destroyer, :submarine, :patrolship]
+SHIP_SIZES = {:carrier => 5, :battleship => 4, :destroyer => 3, :submarine => 3, :patrolship => 2}
+ROWS = %w(A B C D E F G H I J)
+COLUMNS = %w(1 2 3 4 5 6 7 8 9 10)
+ORIENTATIONS = %w(horizontal vertical)
+WIN_RESULT = :victory
+LOOSE_RESULT = :defeat
+DQ_RESULT = :disqualified
+GRID_DIMENSIONS = [ROWS.length, COLUMNS.length]
+GRID_SIZE = ROWS.length
+
+class GunnerError < RuntimeError; end

data/lib/uss_monte_carlo/homing_gunner.rb

@@ -0,0 +1,107 @@
+require 'uss_monte_carlo/game_constants'
+
+class HomingGunner
+  
+  def initialize(targets_remaining, hit_location, shots_fired)
+    @smallest_ship = targets_remaining.inject(5) { |min, s| SHIP_SIZES[s] < min ? SHIP_SIZES[s] : min }
+    @original_hit = @shot = hit_location
+    @shots_fired = shots_fired
+    @hits = [hit_location]
+    pick_direction_and_orientation
+  end
+  
+  def next_shot
+    raise GunnerError.new("All shots have been taken: #{@shots_fired}") if @shots_fired.length >= (ROWS.length * COLUMNS.length)
+    candidate_shot = move_from(@shot)
+    if candidate_shot == @shot
+      self.send next_strategy
+      candidate_shot = move_from(@shot)
+    end
+    @shot = candidate_shot
+      
+    while @shots_fired.include? @shot
+      @shot = @original_hit
+      self.send next_strategy
+      @shot = move_from(@shot)
+    end
+    @shot
+  end
+  
+  def shot_result(coordinates, was_hit, ship_sunk)
+    @shots_fired << coordinates unless @shots_fired.include? coordinates
+    if ship_sunk
+      remove_hits(ship_sunk)
+    elsif was_hit
+      @hits << coordinates
+    else
+      @shot = @original_hit
+      self.send next_strategy
+    end
+  end
+  
+  def unaccounted_hits
+    @hits
+  end
+  
+  
+  private
+  
+  def pick_direction_and_orientation
+    @orientation = [ROWS, COLUMNS][rand(2)]
+    @direction ||= [:+, :-][rand(2)]
+    
+    # Eliminate orientations that can't fit one of the remaining ships
+    check_pos = @shot
+    next_pos = move_from(check_pos)
+    while (check_pos != next_pos) && !(@shots_fired.include? next_pos)
+      check_pos = next_pos
+      next_pos = move_from(check_pos)
+    end
+    reverse_direction
+    gap_size = 0
+    next_pos = move_from(check_pos)
+    while (check_pos != next_pos) && !(@shots_fired.include? next_pos)
+      check_pos = next_pos
+      next_pos = move_from(check_pos)
+      gap_size += 1
+    end
+    reverse_direction
+    reverse_orientation if gap_size < @smallest_ship
+  end
+  
+  def remove_hits(ship_sunk)
+    reverse_direction
+    shot_to_remove = @shot
+    SHIP_SIZES[ship_sunk].times do
+      @hits -= [shot_to_remove]
+      shot_to_remove = move_from(shot_to_remove)
+    end
+  end
+  
+  def reverse_direction
+    @direction = @direction == :+ ? :- : :+
+  end
+  
+  def reverse_orientation
+    @orientation = @orientation == ROWS ? COLUMNS : ROWS
+  end
+  
+  def move_from(shot)
+    row, *column = shot.split('')
+    column = column.join
+    if @orientation == ROWS
+      index = ROWS.index(row).send(@direction, 1)
+      row = ROWS[index] if (0 <= index) && (index < ROWS.length)
+    else
+      index = COLUMNS.index(column).send(@direction, 1)
+      column = COLUMNS[index] if (0 <= index) && (index < COLUMNS.length)
+    end
+    "#{row}#{column}"
+  end
+  
+  def next_strategy
+    @strategy ||= [:reverse_orientation, :reverse_direction]
+    (@strategy << @strategy.shift)[0]
+  end
+  
+end

data/lib/uss_monte_carlo/random_gunner.rb

@@ -0,0 +1,39 @@
+require 'uss_monte_carlo/game_constants'
+
+class RandomGunner
+  
+  def initialize(targets_remaining, shots_fired)
+    @targets_remaining = targets_remaining
+    @shots_fired = shots_fired
+    @shot = @shots_fired.last || ROWS[rand(ROWS.length)] + COLUMNS[rand(COLUMNS.length)]
+  end
+  
+  def next_shot
+    raise GunnerError.new("All shots have been taken: #{@shots_fired}") if @shots_fired.length >= (ROWS.length * COLUMNS.length)
+    @shot = random_coord
+    while @shots_fired.include? @shot
+      @shot = random_coord
+    end
+    @shot
+  end
+  
+  def shot_result(coordinates, was_hit, ship_sunk)
+    @shots_fired << coordinates unless @shots_fired.include? coordinates
+  end
+  
+  private
+  
+  def random_coord
+    last_row, *last_column = @shot.split('')
+    last_column = last_column.join
+    row_num = ( ROWS.index(last_row) + random_offset ) % GRID_SIZE
+    column_num = ( COLUMNS.index(last_column) + random_offset ) % GRID_SIZE
+    "#{ROWS[row_num]}#{COLUMNS[column_num]}"
+  end
+  
+  def random_offset
+    random_ship = @targets_remaining[rand(@targets_remaining.length)]
+    [SHIP_SIZES[random_ship], 1][rand(2)]
+  end
+  
+end

data/lib/uss_monte_carlo/uss_monte_carlo.rb

@@ -0,0 +1,232 @@
+module UssMonteCarlo
+
+  # 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.
+  #
+  require 'uss_monte_carlo/game_constants'
+  require 'uss_monte_carlo/random_gunner'
+  require 'uss_monte_carlo/homing_gunner'
+  
+  class UssMonteCarlo
+
+    # 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
+      @opponent = opponent_name
+    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 carrier_placement
+      @ship_placements ||= place_ships
+      @ship_placements[:carrier]
+    end
+
+    # Returns the placement of the battleship. A battleship consumes 4 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def battleship_placement
+      @ship_placements ||= place_ships
+      @ship_placements[:battleship]
+    end
+
+    # Returns the placement of the destroyer. A destroyer consumes 3 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def destroyer_placement
+      @ship_placements ||= place_ships
+      @ship_placements[:destroyer]
+    end
+
+    # Returns the placement of the submarine. A submarine consumes 3 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def submarine_placement
+      @ship_placements ||= place_ships
+      @ship_placements[:submarine]
+    end
+
+    # Returns the placement of the patrolship. A patrolship consumes 2 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def patrolship_placement
+      @ship_placements ||= place_ships
+      @ship_placements[: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 = @current_gunner.next_shot
+      @shots_fired << target
+      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)
+      @current_gunner.shot_result(coordinates, was_hit, ship_sunk)
+      if ship_sunk
+        @targets_remaining -= [ship_sunk]
+        @unaccounted_hits += @current_gunner.unaccounted_hits
+        
+        # Protect against an infinite loop
+        @unaccounted_hits.uniq!
+        
+        if @unaccounted_hits.empty?
+          @current_gunner = RandomGunner.new(@targets_remaining, @shots_fired)
+        else
+          @current_gunner = HomingGunner.new(@targets_remaining, @unaccounted_hits.shift, @shots_fired)
+        end
+      elsif was_hit && !@current_gunner.kind_of?(HomingGunner)
+        @current_gunner = HomingGunner.new(@targets_remaining, coordinates, @shots_fired)
+      end
+    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)
+      @result = result
+      @disqualification_reason = disqualification_reason
+    end
+
+    # Non API methods #####################################
+    
+    attr_reader :opponent, :result, :targets_remaining, :disqualification_reason, :enemy_targeted_sectors
+
+    def initialize #:nodoc:
+      reset
+    end
+
+    private ###############################################
+
+    def reset
+      @shots_fired = []
+      @unaccounted_hits = []
+      @targets_remaining = SHIPS
+      @current_gunner = RandomGunner.new(@targets_remaining, @shots_fired)
+      
+      @enemy_targeted_sectors = []
+      @result = nil
+      @disqualification_reason = nil
+    end
+    
+    def place_ships
+      placements = {}
+      occupied_squares = []
+      SHIPS.each do |ship|
+        if rand(2) == 0
+          first_coord, second_coord = ROWS, COLUMNS
+        else
+          second_coord, first_coord = ROWS, COLUMNS
+        end
+        first_coord_index = rand(first_coord.length)
+        second_coord_index = rand(second_coord.length - SHIP_SIZES[ship])
+        
+        placed_coords = []
+        if first_coord == COLUMNS
+          SHIP_SIZES[ship].times{|n| placed_coords += ["#{second_coord[second_coord_index + n]}#{first_coord[first_coord_index]}"]}
+          first_coord_index, second_coord_index = second_coord_index, first_coord_index
+          first_coord, second_coord = second_coord, first_coord
+          direction = "vertical"
+        else
+          SHIP_SIZES[ship].times{|n| placed_coords += ["#{first_coord[first_coord_index]}#{second_coord[second_coord_index + n]}"]}
+          direction = "horizontal"
+        end
+        
+        overlap = false
+        placed_coords.each{|coord| overlap ||= occupied_squares.include? coord}
+        if overlap
+          redo
+        else
+          occupied_squares += placed_coords                
+          placements[ship] = "#{first_coord[first_coord_index]}#{second_coord[second_coord_index]} #{direction}"
+        end
+      end
+      placements
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$: << File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require 'rubygems'
+require 'minitest/unit'
+require 'uss_monte_carlo/game_constants'
+
+def valid_placements
+  # Construct list of valid placements
+  @list ||= ROWS.map{|r| COLUMNS.map{|c| ORIENTATIONS.map{|o| r + c + ' ' + o }}}.flatten
+end
+
+def grid_coords
+  # Construct list of valid coordinates
+  @coords ||= ROWS.map{|r| COLUMNS.map{|c| r + c }}.flatten
+end
+

data/spec/uss_monte_carlo/homing_gunner_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'uss_monte_carlo/uss_monte_carlo'
+require 'uss_monte_carlo/game_constants'
+require 'uss_monte_carlo/homing_gunner'
+
+
+class HomingGunnerTest < MiniTest::Unit::TestCase
+  
+  def setup
+    @gunner = HomingGunner.new(SHIPS, "E5", ["E5"])
+  end
+  
+  def test_search
+    adjacent_coords = %w(E4 E6 D5 F5)
+    
+    # Fire a shot and make sure it was adjacent
+    shot = @gunner.next_shot
+    assert_includes(adjacent_coords, shot)
+    
+    # Signal a miss, and check that the search continues
+    3.times do
+      @gunner.shot_result(shot, false, false)
+      adjacent_coords -= [shot]
+      shot = @gunner.next_shot
+      assert_includes(adjacent_coords, shot)
+    end
+  end
+  
+end
+
+MiniTest::Unit.autorun

data/spec/uss_monte_carlo/random_gunner_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'uss_monte_carlo/uss_monte_carlo'
+require 'uss_monte_carlo/game_constants'
+require 'uss_monte_carlo/random_gunner'
+
+class RandomGunnerTests < MiniTest::Unit::TestCase
+  
+  def setup
+    @gunner = RandomGunner.new(SHIPS, [])
+  end
+  
+  def test_initialization
+    refute_nil @gunner
+  end
+  
+  def test_valid_shots
+    # Make sure we're returning valid coordinates
+    assert_includes(grid_coords, @gunner.next_shot)
+
+    # Make sure that we're not overlapping with pre-existing shots
+    one_shot_gunner = RandomGunner.new(SHIPS, grid_coords[0..-2])
+    assert_equal(grid_coords[-1], one_shot_gunner.next_shot)
+    
+    # Make sure we know when we're out of shots to take
+    one_shot_gunner.shot_result(grid_coords[-1], false, false)
+    assert_raises(GunnerError) { one_shot_gunner.next_shot }
+  end
+  
+end
+
+MiniTest::Unit.autorun

data/spec/uss_monte_carlo/uss_monte_carlo_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'uss_monte_carlo/uss_monte_carlo'
+require 'uss_monte_carlo/game_constants'
+
+OPPONENT_NAME = "Test @player"
+DQ_REASON = "Cheater!"
+
+class UssMonteCarloTests < MiniTest::Unit::TestCase
+  def setup
+    # Create @player, start game
+    @player = UssMonteCarlo::UssMonteCarlo.new
+    @player.new_game(OPPONENT_NAME)    
+  end
+
+  
+  def test_initialization
+    #Test successful creation
+    refute_nil @player
+  end
+  
+  
+  def test_startup    
+    #Test new game parameters
+    assert_equal(OPPONENT_NAME, @player.opponent)
+    assert_equal(SHIPS, @player.targets_remaining)
+    assert_equal([], @player.enemy_targeted_sectors)
+    assert_nil(@player.result)
+    assert_nil(@player.disqualification_reason)
+  end
+  
+  def test_restart
+    # Win game and check results
+    @player.game_over(WIN_RESULT)
+    assert_equal(WIN_RESULT, @player.result)
+    assert_nil(@player.disqualification_reason)
+    
+    # Check game reset
+    @player.new_game(OPPONENT_NAME)
+    assert_nil(@player.result)
+    assert_nil(@player.disqualification_reason)
+    
+    # Loose game and check results
+    @player.game_over(LOOSE_RESULT)
+    assert_equal(LOOSE_RESULT, @player.result)
+    assert_nil(@player.disqualification_reason)
+    
+    # Reset, DQ, and check results
+    @player.new_game(OPPONENT_NAME)
+    @player.game_over(DQ_RESULT, DQ_REASON)
+    assert_equal(DQ_RESULT, @player.result)
+    assert_equal(DQ_REASON, @player.disqualification_reason)
+  end
+  
+  def test_valid_placement
+    assert_includes(valid_placements, @player.carrier_placement)
+    assert_includes(valid_placements, @player.battleship_placement)
+    assert_includes(valid_placements, @player.destroyer_placement)
+    assert_includes(valid_placements, @player.submarine_placement)
+    assert_includes(valid_placements, @player.patrolship_placement)
+  end
+  
+  def test_firing_sequence
+    5.times do
+      assert_includes(grid_coords, @player.next_target)
+      assert_respond_to(@player, :target_result)
+      assert_respond_to(@player, :enemy_targeting)
+    end
+  end
+  
+end
+
+MiniTest::Unit.autorun

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: uss_monte_carlo
+version: !ruby/object:Gem::Version 
+  version: 2.0.2
+platform: ruby
+authors: 
+- Joshua Ballanco
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-01 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Flagship of the Monaco Navy
+email: jballanc@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Battleship.Rakefile
+- lib
+- lib/uss_monte_carlo
+- lib/uss_monte_carlo/game_constants.rb
+- lib/uss_monte_carlo/homing_gunner.rb
+- lib/uss_monte_carlo/random_gunner.rb
+- lib/uss_monte_carlo/uss_monte_carlo.rb
+- Rakefile
+- spec
+- spec/spec_helper.rb
+- spec/uss_monte_carlo
+- spec/uss_monte_carlo/homing_gunner_spec.rb
+- spec/uss_monte_carlo/random_gunner_spec.rb
+- spec/uss_monte_carlo/uss_monte_carlo_spec.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.1
+signing_key: 
+specification_version: 2
+summary: Battleship Player:USS Monte Carlo
+test_files: []
+