commodore_cox 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/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 = "commodore_cox"
+PKG_VERSION   = "1.0"
+
+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:Commodore Cox"
+  s.rubyforge_project = "sparring"
+  s.homepage = "http://sparring.rubyforge.org/"
+
+  ###########################################
+  ##
+  ## You are encouraged to modify the following
+  ## spec attributes.
+  ##
+  ###########################################
+  s.description = "Commodore Cox"
+  s.author = "Andrew Cox"
+  s.email = "3coxy4@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/commodore_cox/ai.rb

@@ -0,0 +1,264 @@
+class Array
+  def random
+    self[size*rand]
+  end
+end
+
+module CommodoreCox
+  
+  class AI
+    
+    SHIPS = {
+      :carrier    => 5, 
+      :battleship => 4, 
+      :destroyer  => 3, 
+      :submarine  => 3,
+      :patrolship => 2
+    }
+    
+    OPPOSITE = {
+      :north => :south,
+      :east  => :west,
+      :south => :north,
+      :west  => :east
+    }
+    
+    attr_accessor :placestack, :direction, :hitstack
+    
+    def setup
+      @hitstack           = []
+      @placestack         = []
+      @taken_squares      = []
+      @backtracking_stack = []
+      @direction          = nil
+      a = (1..10).to_a
+      a.each do |x|
+        a.each do |y|
+          Grid[y,x] = Square.new(y,x)
+        end
+      end
+    end
+    
+    def hit_in_progress?
+      @hitstack.any?
+    end
+    
+    def backtracking?
+      @backtracking_stack.any?
+    end
+    
+    def direction?
+      !@direction.nil?
+    end
+    
+    def ships
+      SHIPS
+    end
+    
+    def opposite
+      OPPOSITE
+    end
+    
+    def last_placement
+      @placestack.last.to_s
+    end
+    
+    def change_direction
+      @direction = opposite[@direction]
+    end
+    
+    def pick_from_random_neighbour(square,set_direction=true)
+      neighbour = nil
+      neighbours = square.neighbours
+      if neighbours.any?
+        neighbour  = neighbours.random
+        @direction = neighbour[0] if set_direction
+        neighbour  = neighbour[1]
+        Grid.delete(neighbour)
+      end
+      neighbour
+    end
+    
+    def pick_from_backtrack
+      return nil unless backtracking?
+      
+      square = if direction?
+        @backtracking_stack.last.send(@direction)
+      else
+        pick_from_random_neighbour(@backtracking_stack.last,false)
+      end
+      if square.nil?
+        @backtracking_stack.pop
+        square = pick_from_backtrack
+      end
+      square
+    end
+    
+    def pick_from_direction
+      square = @hitstack.last.send(@direction)
+      if square.nil?
+        change_direction
+        square = @hitstack.first.send(@direction)
+        if square.nil?
+          @direction = nil
+          square = smart_next_square
+        end
+      end
+      square
+    end
+      
+    def smart_next_square
+      return nil unless hit_in_progress?
+      square = if backtracking?
+        pick_from_backtrack
+      elsif direction?
+        pick_from_direction
+      else
+        pick_from_random_neighbour(@hitstack.last)
+      end
+      unless square.nil?
+        Grid.delete(square)
+      end
+      square
+    end
+    
+    def next_target(force=nil)
+      square = nil
+      unless force.nil?
+        square = Grid[force]
+        Grid.delete(force)
+      else
+        square = smart_next_square || Grid.pick
+      end
+      @placestack << square
+      square.to_s unless square.nil?
+    end
+    
+    def target_result(coordinates, was_hit, ship_sunk)
+      if was_hit
+        @hitstack << @placestack.last
+      end
+      if ship_sunk
+        # assuming the ship sunk was the last n squares on the stack
+        SHIPS[ship_sunk].times{@hitstack.pop}
+        @backtracking_stack = @hitstack.reverse
+        if @hitstack.size > 1
+          change_direction
+        else
+          @direction = nil
+        end
+      end
+    end
+      
+    
+      
+    def place(ship,square=false,direction=false)
+      length = SHIPS[ship]
+      directions = {:x=>"horizontal",:y=>"vertical"}
+      direction ||= directions.keys.random
+      square = if square
+        Grid[square]
+      else
+        Grid.slice(length,direction,@taken_squares).random
+      end    
+      @taken_squares << square.to_s
+      trying_squares = []
+      next_square = square
+      (length-1).times do
+        next_square = next_square.send(directions[direction])
+        return place(ship) if @taken_squares.include?(next_square.to_s)
+        trying_squares << next_square.to_s
+      end
+      @taken_squares += trying_squares
+      "#{square.to_s} #{directions[direction]}"
+    end
+    
+  end
+
+  class Grid
+    
+    @@ROWS    = %w{ A B C D E F G H I J }
+    @@squares = {}
+    
+    class << self
+      def [](y,x=nil)
+        y = index(y.ceil) unless y.is_a? String
+        x = x.ceil unless x.nil?
+        squares["#{y}#{x}"]
+      end
+      def []=(y,x,s)
+        y = index(y.ceil) unless y.is_a? String
+        squares["#{y}#{x.ceil}"] = s
+      end
+      
+      def random
+        s = squares.to_a
+        s.random unless s.nil?
+      end
+      
+      def pick
+        s = random
+        unless s.nil?
+          delete(s[0])
+          s[1]
+        end
+      end
+      
+      def slice(length,direction,taken_squares=[])
+        n = 9 - length
+        @@squares.values.find_all do |square|
+          (1..n).include?(square.send(direction)) && !taken_squares.include?(square.to_s)
+        end
+      end
+      
+      def delete(square)
+        @@squares.delete(square.to_s)
+      end
+      
+      def squares
+        @@squares
+      end
+      def index(n)
+        @@ROWS[n-1] unless n < 1
+      end
+      
+    end
+    
+  end
+  
+  class Square
+    
+    attr_accessor :y, :x
+        
+    def initialize(y,x)
+      @y, @x = y, x
+    end
+    
+    def north
+      Grid[y-1,x]
+    end
+    def east
+      Grid[y,x+1]
+    end  
+    def south
+      Grid[y+1,x]
+    end
+    def west
+      Grid[y,x-1]
+    end
+    
+    # for use in ship placements
+    alias :horizontal :east 
+    alias :vertical :south
+    
+    def neighbours
+      h = { :north => north, :east => east, :west => west, :south => south }
+      h.delete_if{ |k,v| v.nil? }
+      h.to_a
+    end
+    def to_s
+      "#{Grid.index(y)}#{x}"
+    end
+  end
+  
+end

data/lib/commodore_cox/commodore_cox.rb

@@ -0,0 +1,55 @@
+require 'commodore_cox/ai'
+module CommodoreCox
+
+  class CommodoreCox
+
+    def new_game(opponent_name)
+      @AI.setup
+    end
+
+    def carrier_placement
+      @AI.place :carrier
+    end
+
+    def battleship_placement
+      @AI.place :battleship
+    end
+
+    def destroyer_placement
+      @AI.place :destroyer
+    end
+
+    def submarine_placement
+      @AI.place :submarine
+    end
+
+    def patrolship_placement
+      @AI.place :patrolship
+    end
+
+    def next_target
+      @AI.next_target
+    end
+
+    def target_result(coordinates, was_hit, ship_sunk)
+      @AI.target_result(coordinates, was_hit, ship_sunk)
+    end
+
+    def enemy_targeting(coordinates)
+    end
+
+    def game_over(result, disqualification_reason=nil)
+    end
+
+    # Non API methods #####################################
+
+    attr_reader :opponent, :targets, :enemy_targeted_sectors, :result, :disqualification_reason #:nodoc:
+
+    def initialize #:nodoc:
+      @AI = AI.new
+      @AI.setup
+    end
+
+  end
+
+end

data/spec/commodore_cox/ai_spec.rb

@@ -0,0 +1,108 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'commodore_cox/ai'
+
+describe CommodoreCox::AI do
+  
+  before(:each) do
+    @ai = CommodoreCox::AI.new
+    @ai.setup
+  end
+  
+  it "should create random placements for all ships" do
+    @ai.ships.keys.each do |ship|
+      @ai.place(ship).should match /^[A-Z][0-9]{1,2}\s(horizontal|vertical)$/
+    end
+  end
+  
+  it "should not overlap 2 ships" do
+    @ai.place(:carrier,"A6",:y).should eql("A6 vertical")
+    @ai.place(:destroyer,"D5",:x).should_not eql("D5 horizontal")
+  end
+  
+  it "should generate a next target 100 times" do
+    100.times{ @ai.next_target.should_not be_nil }
+  end
+  
+  it "should not generate a 101st target" do
+    100.times{ @ai.next_target.should_not be_nil }
+    @ai.next_target.should be_nil
+  end
+  
+  it "should choose a neighbour on hit" do
+    @ai.next_target
+    square = @ai.placestack.last
+    neighbours = square.neighbours.map{ |e| e[1].to_s }
+    @ai.target_result(square.to_s,true,nil)
+    neighbours.should include(@ai.next_target)
+  end
+  
+  it "should choose a neighbour in the correct direction in 2 successive hits" do
+    square = nil
+    2.times do
+      @ai.next_target
+      square = @ai.placestack.last
+      @ai.target_result("",true,nil)
+    end
+    @ai.direction.should_not be_nil
+    next_square = square.send(@ai.direction)
+    @ai.next_target.should eql(next_square.to_s) unless next_square.nil?
+  end
+  
+  it "should change direction and go back to the first hit on 2 successive hits, then a miss" do
+    @ai.next_target("E5")
+    @ai.target_result("",true,nil)
+    @ai.next_target
+    @ai.target_result("",true,nil)
+    direction = @ai.direction
+    @ai.next_target
+    @ai.target_result("",false,nil)
+    @ai.next_target
+    @ai.direction.should eql(@ai.opposite[direction])
+  end
+  
+  it "should reset on sink" do
+    @ai.next_target("I2")
+    @ai.target_result("",true,nil)
+    @ai.next_target("J2")
+    @ai.target_result("",true,nil)
+    @ai.direction = :south
+    @ai.next_target
+    @ai.last_placement.should eql("H2")
+    @ai.target_result("",true,nil)
+    @ai.next_target
+    @ai.last_placement.should eql("G2")
+    @ai.target_result("",true,:battleship)
+    @ai.hitstack.size.should eql(0)
+  end
+  
+  it "should backtrack to one of first hit's neighbours after sink with remaining hit" do
+    @ai.next_target("A2")
+    @ai.target_result("",true,nil)
+    @ai.next_target("A3")
+    @ai.target_result("",true,nil)
+    @ai.direction = :east
+    @ai.next_target("A4")
+    @ai.target_result("",true,nil)
+    @ai.next_target("A5")
+    @ai.target_result("",true,:submarine)
+    @ai.backtracking?.should be_true
+    @ai.next_target
+    ["A1","B2"].should include(@ai.last_placement)
+  end
+  
+  it "should backtrack in reverse direction after sink with remaining hits" do
+    @ai.next_target("A2")
+    @ai.target_result("",true,nil)
+    @ai.next_target("A3")
+    @ai.target_result("",true,nil)
+    @ai.direction = :east
+    @ai.next_target("A4")
+    @ai.target_result("",true,nil)
+    @ai.next_target("A5")
+    @ai.target_result("",true,:patrolship)
+    @ai.backtracking?.should be_true
+    @ai.next_target
+    @ai.last_placement.should eql("A1")
+  end
+  
+end

data/spec/commodore_cox/commodore_cox_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'commodore_cox/commodore_cox'
+
+describe CommodoreCox::CommodoreCox do
+
+  before(:each) do
+    @cc = CommodoreCox::CommodoreCox.new
+  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,64 @@
+--- !ruby/object:Gem::Specification 
+name: commodore_cox
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Andrew Cox
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-21 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: Commodore Cox
+email: 3coxy4@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Battleship.Rakefile
+- lib
+- lib/commodore_cox
+- lib/commodore_cox/ai.rb
+- lib/commodore_cox/commodore_cox.rb
+- pkg
+- Rakefile
+- spec
+- spec/commodore_cox
+- spec/commodore_cox/ai_spec.rb
+- spec/commodore_cox/commodore_cox_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.1
+signing_key: 
+specification_version: 2
+summary: Battleship Player:Commodore Cox
+test_files: []
+