white_horseman 1.3

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 = "white_horseman"
+PKG_VERSION   = "1.3"
+
+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:White Horseman"
+  s.rubyforge_project = "sparring"
+  s.homepage = "http://sparring.rubyforge.org/"
+
+  ###########################################
+  ##
+  ## You are encouraged to modify the following
+  ## spec attributes.
+  ##
+  ###########################################
+  s.description = "The apocalypse is here"
+  s.author = "Doug Bradbury"
+  s.email = "doug@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/white_horseman/analyst.rb

@@ -0,0 +1,63 @@
+require 'white_horseman/coordinates'
+require 'white_horseman/scout'
+require 'white_horseman/ship'
+module WhiteHorseman
+  class Analyst
+    def initialize(hit_map, live_ships)
+      @live_ships = live_ships
+      @hit_map = hit_map
+      @scout = Scout.new
+    end
+    
+    def hit_probability(coordinate)
+      probability = probability_from_neighbors(1, coordinate)
+      probability += probability_from_neighbors(2, coordinate)
+      
+      possible_placements_here = 0
+      @live_ships.each do |ship|
+        possible_placements_here += @scout.possible_placements(ship.size, [coordinate], @hit_map)
+      end
+      probability += 0.17 * possible_placements_here / 34.0
+     return probability
+    end
+
+    private
+    
+    def probability_for(coordinate, neighbor, ship)
+      placements_including_coordinate = @scout.possible_placements(ship.size, [coordinate, neighbor], @hit_map)
+      total_placements = @scout.possible_placements(ship.size, [neighbor], @hit_map)
+
+      return (probability_is(ship) * placements_including_coordinate / total_placements) if total_placements != 0
+      return 0.0
+    end
+    
+    def hit?(coordinate)
+      @hit_map[coordinate].hit?
+    end
+    
+    def miss?(coordinate)
+      @hit_map[coordinate].miss?
+    end
+    
+    def probability_is(ship)
+      if @live_ships.include?(ship)
+        return 1.0 / @live_ships.size
+      else
+        return 0.0
+      end
+    end
+    
+    def probability_from_neighbors(degree, coordinate)
+      probability = 0.0
+      coordinate.to_coord.neighbors(degree).each do |neighbor|
+        if hit?(neighbor)
+          Ship.each do |ship|
+            probability += probability_for(coordinate, neighbor, ship)
+          end
+        end
+      end
+      return probability    
+    end
+    
+  end
+end

data/lib/white_horseman/battlefield.rb

@@ -0,0 +1,64 @@
+require 'matrix'
+require 'white_horseman/coordinates'
+
+module WhiteHorseman
+  class Battlefield
+    attr_reader :shots
+    def initialize(grid = [
+        [0,0,0,0,0,0,0,0,0,0],
+        [0,0,0,0,0,0,0,0,0,0],
+        [0,0,0,0,0,0,0,0,0,0],
+        [0,0,0,0,0,0,0,0,0,0],
+        [0,0,0,0,0,0,0,0,0,0],
+        [0,0,0,0,0,0,0,0,0,0],
+        [0,0,0,0,0,0,0,0,0,0],
+        [0,0,0,0,0,0,0,0,0,0],
+        [0,0,0,0,0,0,0,0,0,0],
+        [0,0,0,0,0,0,0,0,0,0],
+        ])
+        @grid = grid
+        @shots = 0
+    end
+
+    class << self
+      def average(battlefields)
+        seed = Battlefield.new
+        seed.set_all(0.0)
+        sum = battlefields.inject(Matrix.rows(seed.grid)) do |accumulator, battlefield|
+          accumulator + Matrix.rows(battlefield.grid)
+        end
+        average = sum / battlefields.size
+        return Battlefield.new(average.to_a)
+      end
+    end
+    
+    def record_target(coordinates)
+      @shots +=1
+      self[coordinates] = 100 - @shots
+    end
+    
+    def [](coordinates)
+      coord = coordinates.to_coord
+      return @grid[coord.row_index][coord.column_index]
+    end
+
+    def []=(coordinates, value)
+      coord = coordinates.to_coord
+      
+      @grid[coord.row_index][coord.column_index] = value
+    end
+    
+    def grid
+      return @grid
+    end
+    
+    def set_all(value)
+      10.times do |row|
+        10.times do |column|
+          @grid[row][column] = value
+        end
+      end
+    end
+    
+  end
+end

data/lib/white_horseman/captain.rb

@@ -0,0 +1,58 @@
+require "white_horseman/battlefield"
+require "white_horseman/placement"
+require "white_horseman/coordinates"
+require "white_horseman/analyst"
+require "white_horseman/cell_status"
+
+module WhiteHorseman
+  
+  class Captain
+    attr_accessor :hit_map
+    attr_accessor :live_ships
+
+    def initialize
+      @hit_map = Battlefield.new
+      @hit_map.set_all(CellStatus.new)
+      @live_ships = Ship.all
+    end
+    
+    def target_result(coordinates, was_hit, ship_sunk)
+      @hit_map[coordinates] = CellStatus.new(was_hit)
+      unless ship_sunk.nil?
+        ship = Ship.new(ship_sunk)
+        live_ships.delete(ship)
+        scout = Scout.new
+        salvage = scout.salvage_placements(ship.size, coordinates, @hit_map)
+        intersection = salvage.first.cells
+        salvage.each do |placement|
+          intersection &= placement.cells
+        end
+        
+        intersection.each do |cell|
+          @hit_map[cell].ship = ship_sunk
+        end
+        
+        @hit_map[coordinates].ship = ship_sunk
+      end
+    end    
+            
+    def next_target
+      analyst = Analyst.new(@hit_map, @live_ships)
+      max_probability = 0.0
+      top_shots = []
+      Coordinates.each do |coordinate|
+        if @hit_map[coordinate].empty?
+          probability = analyst.hit_probability(coordinate)
+          if probability > max_probability
+            max_probability = probability
+            top_shots = [coordinate]
+          elsif probability == max_probability
+            top_shots << coordinate
+          end
+        end
+      end
+      return top_shots[rand(top_shots.size)].to_s
+    end
+    
+  end
+end

data/lib/white_horseman/cell_status.rb

@@ -0,0 +1,45 @@
+module WhiteHorseman
+  class CellStatus
+  
+    attr_accessor :ship
+    
+    def initialize(was_hit=nil)
+      @ship = :none
+      
+      case was_hit
+      when nil
+        @status = :none
+      when true
+        hit
+      when false
+        miss
+      end
+    end
+    
+    def hit
+      @status = :hit
+    end
+    
+    def miss
+      @status = :miss
+    end
+    
+    def hit?
+      @status == :hit
+    end
+  
+    def miss?
+      @status == :miss
+    end
+    
+    def empty?
+      @status == :none
+    end
+    
+    def has_ship?
+      return @ship != :none
+    end
+    
+  
+  end
+end

data/lib/white_horseman/coordinates.rb

@@ -0,0 +1,87 @@
+class String
+  def to_coord
+    return WhiteHorseman::Coordinates.new(:string => self)
+  end
+end
+  
+module WhiteHorseman
+  class Coordinates
+    attr_reader :row, :column
+    def initialize(options={:row => "A", :column => 1})
+      options.each do |option, value|
+        send("#{option}=".to_sym, value)
+      end
+    end
+    
+    def string=(coord_string)
+      self.row = "%c" % coord_string.upcase[0]
+      self.column = (coord_string[1..-1]).to_i
+    end
+    
+    def column=(value)
+      raise "Column out of range: #{value}" if value > 10 || value < 1
+      @column = value
+    end
+
+    def inc_column(delta = 1)
+      self.column = @column + delta
+      return self
+    end
+    
+    def row=(value)
+      raise "Row out of range: #{value}" if value > "J" || value < "A"
+      @row = value
+    end
+    
+    def inc_row(delta=1)
+      self.row = "%c" % (self.row[0] += delta)
+      return self
+    end
+    
+    def to_s
+      "#{row}#{column}"
+    end
+    
+    def row_index
+      row[0] - 65
+    end
+    
+    def column_index
+      @column - 1
+    end
+    
+    def to_coord
+      return self
+    end
+    
+    def ==(other)
+      return self.column == other.to_coord.column && self.row == other.to_coord.row
+    end
+    
+    def neighbors(distance=1)
+      neighbors = []
+      neighbors << Coordinates.new(:string => self.to_s).inc_row(distance) unless self.row_index > 9 - distance
+      neighbors << Coordinates.new(:string => self.to_s).inc_row(-1*distance) unless self.row_index < distance
+      neighbors << Coordinates.new(:string => self.to_s).inc_column(distance) unless self.column_index > 9 - distance
+      neighbors << Coordinates.new(:string => self.to_s).inc_column(-1*distance) unless self.column_index < distance
+      return neighbors
+    end
+    
+    
+    def self.colinear?(coordinates, orientation=nil)
+      first = coordinates.first.to_coord      
+      return colinear?(coordinates, :vertical) || colinear?(coordinates, :horizontal) if orientation. nil?
+      return coordinates.all?{|coord| coord.to_coord.column == first.column} if orientation.to_sym == :vertical
+      return coordinates.all?{|coord| coord.to_coord.row == first.row} if orientation.to_sym == :horizontal
+    end
+    
+    def self.each(&block)
+      ("A".."J").each do |row|
+        (1..10).each do |column|
+          yield(Coordinates.new(:row => row, :column => column))
+        end
+      end
+    end
+    
+  end
+end

data/lib/white_horseman/fleet_admiral.rb

@@ -0,0 +1,79 @@
+require 'white_horseman/placement'
+require 'white_horseman/coordinates'
+module WhiteHorseman
+  class FleetAdmiral
+    attr_accessor :heat_map
+    
+    def calculate
+      @min_placements = {}
+      [["carrier", 5], ["battleship", 4], ["destroyer", 3], ["submarine", 3], ["patrolship", 2]].each do |ship|
+        placement = place_ship(ship[1])
+        raise "Couldn't place #{ship[0]}!" if placement.nil?
+        @min_placements[ship[0]] = placement
+      end      
+    end
+    
+    def carrier
+      check_for_calculate
+      return @min_placements["carrier"].to_s
+    end
+
+    def battleship
+      check_for_calculate
+      return @min_placements["battleship"].to_s
+    end
+
+    def destroyer
+      check_for_calculate
+      return @min_placements["destroyer"].to_s
+    end
+
+    def submarine
+      check_for_calculate
+      return @min_placements["submarine"].to_s
+    end
+
+    def patrolship
+      check_for_calculate
+      return @min_placements["patrolship"].to_s
+    end
+    
+    private #####################################################################################################
+
+    def place_ship(size)
+      min_threat = 999999999999
+      min_placements = []
+      Placement.each(size) do |placement|
+        unless overlaps_another_ship?(placement)
+          threat = threat(placement)
+        
+          if threat < min_threat
+            min_threat = threat
+            min_placements = [placement]
+          elsif threat == min_threat
+            min_placements << placement
+          end
+        end            
+      end
+
+      return min_placements[rand(min_placements.size)]
+    end
+
+    def check_for_calculate
+      raise "Call calculate first" if @min_placements.nil?
+    end
+    
+    def overlaps_another_ship?(placement)
+      @min_placements.each do |ship, existing_placement|
+        return true if placement.overlap?(existing_placement)
+      end
+      return false
+    end
+    
+    def threat(placement)
+      return placement.cells.inject(0) {|threat, cell| threat + @heat_map[cell]}
+    end
+
+  end
+  
+end

data/lib/white_horseman/opponent.rb

@@ -0,0 +1,70 @@
+require 'white_horseman/battlefield'
+require 'yaml'
+
+module WhiteHorseman
+  class Opponent
+    attr_reader :name
+    
+    class << self
+      def clear_all      
+        Dir.glob("#{self.data_path}/*").each do |filename|
+          File.delete filename
+        end
+      end      
+    end
+  
+  
+    def initialize(name)
+      @name = name
+      if File.exists?(filename)
+        @games = YAML.load_file(filename)
+      else
+        @games = []
+      end
+    end
+    
+    def new_game
+      @games << Battlefield.new      
+      return @games.size
+    end
+    
+    def record_target(coordinates)
+      @games.last.record_target(coordinates)
+    end
+    
+    def number_of_games
+      return @games.size
+    end
+        
+    def game_grid(id)
+      @games[id - 1].grid
+    end
+    
+    def save
+      Dir.mkdir(self.class.data_path) unless File.exists?(self.class.data_path)
+      data_file = File.new(filename, "w")
+      data_file.write @games.to_yaml
+      data_file.close
+    end
+    
+    def heat_map
+      if @games.empty?
+        return Battlefield.new
+      else
+        return Battlefield.average(@games)
+      end
+    end
+    
+    
+    private
+    
+    def self.data_path
+      return DATA_DIR
+    end
+    
+    def filename
+      "#{self.class.data_path}/#{@name}.data"
+    end
+        
+  end
+end

data/lib/white_horseman/placement.rb

@@ -0,0 +1,97 @@
+require 'white_horseman/coordinates'
+
+module WhiteHorseman
+  class Placement
+    attr_accessor :orientation, :size, :coord
+
+    def initialize(options)
+      @coord = Coordinates.new
+      options.each do |option, value| 
+        self.send("#{option}=".to_sym, value)
+      end
+    end
+    
+    def self.each(size, &block)
+      Coordinates.each do |coordinate|
+        [:horizontal, :vertical].each do |orientation|
+          placement = Placement.new(:coord => coordinate, :orientation => orientation, :size => size)
+          if placement.valid?
+            yield(placement)
+          end
+        end
+      end
+    end
+    
+    def coord=(coord)
+      @coord = Coordinates.new(:string => coord.to_s)
+    end
+    
+    def row=(row)
+      @coord.row = row
+    end
+    
+    def column=(column)
+      @coord.column = column
+    end
+    
+    def row
+      @coord.row
+    end
+    
+    def column
+      @coord.column
+    end    
+    
+    def to_s
+      "#{row}#{column} #{orientation}"
+    end
+    
+    def valid?
+      return false unless [:horizontal, :vertical].include?(@orientation)
+      return false if end_row > "J" && @orientation == :vertical
+      return false if end_column > 10 && @orientation == :horizontal
+      return true
+    end
+    
+    def end_row
+      return "%c" % (@coord.row[0] + @size - 1) 
+    end
+    
+    def end_column
+      return @coord.column + @size - 1
+    end
+        
+    def overlap?(other)
+      return !(self.cells & other.cells).empty?
+    end
+
+    def cells
+      cells = []
+      for_each_cell {|cell| cells << cell.to_s}
+      return cells
+    end
+    
+    def include?(coord)
+      return cells.include?(coord.to_s)
+    end
+    
+    private #########################################################
+    def for_each_cell(&block)
+      coord_copy = Coordinates.new(:string => @coord.to_s)
+      if @orientation == :horizontal
+        yield(coord_copy)
+        (size-1).times do
+          coord_copy.inc_column
+          yield(coord_copy)
+        end
+      elsif @orientation == :vertical
+        yield(coord_copy)
+        (size-1).times do
+          coord_copy.inc_row
+          yield(coord_copy)
+        end
+      end
+    end
+        
+  end
+end

data/lib/white_horseman/scout.rb

@@ -0,0 +1,66 @@
+require "white_horseman/coordinates"
+require "white_horseman/placement"
+
+module WhiteHorseman
+  class Scout    
+    def possible_placements(size, coordinates, hit_board)
+      placements = []
+      first = coordinates.first.to_coord
+      placements += placements(size, first.clone, coordinates, :horizontal)
+      placements += placements(size, first.clone, coordinates, :vertical)
+      scrub(placements, hit_board)
+      
+      return placements.size
+    end
+    
+    def salvage_placements(size, coordinate, hit_board)
+      placements = []
+      first = coordinate.to_coord
+      placements += placements(size, first.clone, [coordinate], :horizontal)
+      placements += placements(size, first.clone, [coordinate], :vertical)
+      return select_all_hits(placements, hit_board)
+    end
+    
+
+    private ################################################################################
+
+    def placements(size, start, coordinates, orientation)
+      return [] unless Coordinates.colinear?(coordinates, orientation)
+      
+      itr = Coordinates.new(:string => start.to_s)
+      placements = []
+      size.times do
+        placement = Placement.new(:coord => itr, :orientation => orientation, :size => size)
+        if placement.valid? && coordinates.all?{|cell| placement.include?(cell)}
+          placements << placement
+        end
+        itr.inc_row -1 if orientation == :vertical rescue break
+        itr.inc_column -1 if orientation == :horizontal rescue break
+      end 
+      return placements
+    end
+
+    def scrub(placements, hit_board)
+      doomed = []
+      placements.each do |placement|
+        placement.cells.each do |cell|
+          if (hit_board[cell].miss? || hit_board[cell].has_ship?)
+            doomed << placement
+          end
+        end
+      end
+      doomed.each {|dead| placements.delete(dead) }
+    end
+    
+    def select_all_hits(placements, hit_board)
+      all_hits = []
+      placements.each do |placement|
+        if placement.cells.all?{|cell| hit_board[cell].hit?}
+          all_hits << placement
+        end
+      end
+      return all_hits
+    end
+    
+  end
+end