white_horseman 1.3

data/spec/white_horseman/fleet_admiral_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'white_horseman/fleet_admiral'
+require 'white_horseman/battlefield'
+
+describe WhiteHorseman::FleetAdmiral do
+  before(:each) do
+    @ship_placement = WhiteHorseman::FleetAdmiral.new
+  end
+  
+  it "should raise error if calculate hasn't been called" do
+    lambda{@ship_placement.destroyer}.should raise_error("Call calculate first")
+    lambda{@ship_placement.battleship}.should raise_error("Call calculate first")
+    lambda{@ship_placement.submarine}.should raise_error("Call calculate first")
+    lambda{@ship_placement.carrier}.should raise_error("Call calculate first")
+    lambda{@ship_placement.patrolship}.should raise_error("Call calculate first")
+  end
+  
+  it "should place all ships" do
+    @ship_placement.heat_map = WhiteHorseman::Battlefield.new([
+      #   1   2   3   4   5   6   7   8   9   10
+        [100,100,100,100,100,100, 10, 10, 10, 10], # A
+        [100,100,100,100,  0,  0,  0,  0,  0,100], # B
+        [100,100,100,100,100,100,100,100,100,100], # C
+        [100,100,100,100,100,100,100,100,100,100], # D
+        [100,100,100,100, 30,100,100,100,100,100], # E
+        [ 15,100,100,100, 30,100,100,100,100,100], # F
+        [ 15,100,100,100,100,100,100,100,100,100], # G
+        [ 15,100,100,100,100,100,100, 20,100,100], # H
+        [100,100,100,100,100,100,100, 20,100,100], # I
+        [100,100,100,100,100,100,100, 20,100,100], # J
+        ])
+    
+    @ship_placement.calculate
+    @ship_placement.carrier.should == "B5 horizontal"
+    @ship_placement.carrier.should == "B5 horizontal"
+    @ship_placement.battleship.should == "A7 horizontal"
+    
+    ["F1 vertical", "H8 vertical"].should include(@ship_placement.submarine)
+    ["F1 vertical", "H8 vertical"].should include(@ship_placement.destroyer)
+    @ship_placement.patrolship.should == "E5 vertical"
+  end
+  
+  it "should randomize placement when there are multiple equal options" do
+    map = WhiteHorseman::Battlefield.new
+    map.set_all(0.0)
+    @ship_placement.heat_map = map
+    @ship_placement.calculate
+    first_carrier = @ship_placement.carrier
+    
+    @ship_placement.calculate
+    @ship_placement.carrier.should_not == first_carrier
+  end
+  
+end

data/spec/white_horseman/opponent_spec.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'white_horseman/opponent'
+describe WhiteHorseman::Opponent do
+
+  before(:each) do
+    WhiteHorseman::Opponent.clear_all
+    @opponent = WhiteHorseman::Opponent.new("dr_evil")
+  end
+
+  it "should have name" do
+    @opponent.name.should == "dr_evil"
+  end
+  
+  it "should create a new game" do
+    id = @opponent.new_game
+    id.should == 1
+    @opponent.number_of_games.should == 1
+  end
+  
+  it "should create multiple games" do
+    @opponent.new_game.should_not == @opponent.new_game
+    @opponent.number_of_games.should == 2
+  end
+  
+  it "should grids for multiple games" do
+    mockfield = mock("Battlefield")
+    WhiteHorseman::Battlefield.should_receive(:new).and_return(mockfield)
+    mockfield.should_receive(:record_target).with("J10")
+    id = @opponent.new_game
+    @opponent.record_target("J10")    
+  end
+  
+  it "should save the game" do
+    @opponent.new_game
+    @opponent.save
+    
+    loaded = WhiteHorseman::Opponent.new("dr_evil")
+    loaded.number_of_games.should == 1    
+  end
+  
+  it "should have heat map" do
+    mockfield1 = mock("Battlefield1")
+    mockfield2 = mock("Battlefield2")
+    mockfield3 = mock("Battlefield3")
+    WhiteHorseman::Battlefield.should_receive(:new).exactly(3).and_return(mockfield1, mockfield2, mockfield3)
+    3.times {@opponent.new_game}
+    average_field = mock("Battlefield ave")
+    WhiteHorseman::Battlefield.should_receive(:average).with([mockfield1, mockfield2, mockfield3]).and_return(average_field)
+
+    @opponent.heat_map.should == average_field
+  end
+  
+  it "should zeroed heat map when there are no games" do
+    @opponent.heat_map["A1"].should == 0
+  end
+      
+end

data/spec/white_horseman/placement_spec.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'white_horseman/placement'
+require 'white_horseman/battlefield'
+
+describe WhiteHorseman::Placement do
+  before(:each) do
+    @placement = WhiteHorseman::Placement.new(:row => "A", :column => 1, :orientation => :horizontal, :size => 5)
+  end
+  
+  it "should print" do
+    @placement.to_s.should == "A1 horizontal"
+  end
+  
+  it "should have readers" do
+    @placement.row.should == "A"
+    @placement.column.should == 1
+    @placement.orientation.should == :horizontal
+    @placement.size.should == 5
+  end
+  
+  it "should be valid" do
+    WhiteHorseman::Placement.new(:row => "A",:column => 1, :orientation => :vertical, :size => 5).should be_valid
+    WhiteHorseman::Placement.new(:row => "A",:column => 7, :orientation => :vertical, :size => 5).should be_valid
+    WhiteHorseman::Placement.new(:row => "A",:column => 7, :orientation => :horizontal, :size => 4).should be_valid
+    WhiteHorseman::Placement.new(:row => "H",:column => 1, :orientation => :horizontal, :size => 5).should be_valid
+  end
+  
+  it "should be invalid" do
+    WhiteHorseman::Placement.new(:row => "G",:column => 1, :orientation => :vertical, :size => 5).should_not be_valid
+    WhiteHorseman::Placement.new(:row => "A",:column => 7, :orientation => :horizontal, :size => 5).should_not be_valid
+    WhiteHorseman::Placement.new(:row => "H",:column => 1, :orientation => "bleck", :size => 5).should_not be_valid
+  end
+    
+  it "should overlap" do
+    @placement = WhiteHorseman::Placement.new(:row => "C", :column => 1, :orientation => :horizontal, :size => 5)
+    @placement2 = WhiteHorseman::Placement.new(:row => "A", :column => 3, :orientation => :vertical, :size => 4)
+    
+    @placement.should be_overlap(@placement2)
+    @placement2.should be_overlap(@placement)    
+  end
+  
+  it "should have cells" do
+    @placement.cells.should == ["A1", "A2", "A3", "A4", "A5"]
+    WhiteHorseman::Placement.new(:row => "A", :column => 3, :orientation => :vertical, :size => 4).cells.should == ["A3", "B3", "C3", "D3"]
+  end
+  
+  it "should not overlap" do
+    @placement = WhiteHorseman::Placement.new(:row => "C", :column => 1, :orientation => :horizontal, :size => 5)
+    @placement2 = WhiteHorseman::Placement.new(:row => "D", :column => 3, :orientation => :vertical, :size => 4)
+    
+    @placement.should_not be_overlap(@placement2)
+    @placement2.should_not be_overlap(@placement)        
+  end
+  
+  it "should initialize with coordinates" do
+    coord = WhiteHorseman::Coordinates.new(:row => "G", :column => 6)
+    @placement = WhiteHorseman::Placement.new(:coord => coord, :orientation => :horizontal, :size => 5)
+    @placement.row.should == "G"
+    @placement.column.should == 6
+    @placement.coord.should == coord
+  end
+  
+  it "should include coordinates" do
+    @placement.should include("A1")
+    @placement.should include("A2".to_coord)
+    @placement.should include("A5".to_coord)
+    @placement.should_not include("B1")
+    @placement.should_not include("A7".to_coord)
+  end
+  
+  it "should not increment beyond bounds on horizontal include" do
+    @placement = WhiteHorseman::Placement.new(:row => "A", :column => 6 , :orientation => :horizontal, :size => 5)
+    @placement.should be_valid
+    @placement.should include("A6")
+    @placement.should include("A7")
+    @placement.should include("A8")
+    @placement.should include("A9")
+    @placement.should include("A10")
+    lambda{@placement.should include("A11")}.should raise_error
+  end
+
+  it "should not increment beyond bounds on vertical include" do
+    place = WhiteHorseman::Placement.new(:row => "F", :column => 6 , :orientation => :vertical, :size => 5)
+    place.should be_valid
+
+    place.should include("F6")
+    place.row.should == "F"
+
+    place.should include("G6")
+    place.should include("H6")
+    place.should include("I6")
+    place.should include("J6")
+    lambda{@placement.should include("K6")}.should raise_error
+  end
+  
+  it "should keep its own copy of coordinate" do
+    coordinates = WhiteHorseman::Coordinates.new(:row => "A", :column => 3)
+    place = WhiteHorseman::Placement.new(:coord => coordinates , :orientation => :vertical, :size => 5)
+    coordinates.row = "C"
+    place.row.should == "A"    
+  end
+  
+  it "should do each placement" do
+    num = 0
+    WhiteHorseman::Placement.each(5) do |placement|
+      placement.should be_valid
+      num += 1
+    end
+    num.should == 120
+  end
+end

data/spec/white_horseman/scout_spec.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'white_horseman/scout'
+require 'white_horseman/battlefield'
+require "white_horseman/cell_status"
+
+describe WhiteHorseman::Scout do
+  before(:each) do
+    @scout = WhiteHorseman::Scout.new
+    @hit_board = WhiteHorseman::Battlefield.new
+    @hit_board.set_all(WhiteHorseman::CellStatus.new)
+  end
+
+  it "should calculate possible placements" do
+    @scout.possible_placements(2, ["F5"], @hit_board).should == 4
+    @scout.possible_placements(3, ["F5"], @hit_board).should == 6
+    @scout.possible_placements(4, ["F5"], @hit_board).should == 8
+    @scout.possible_placements(5, ["F5"], @hit_board).should == 10
+  end
+
+  it "should have no possible placements if coords aren't colinear" do
+    @scout.possible_placements(2, ["F5", "G7"], @hit_board).should == 0    
+  end
+
+  it "should calculate possible placements for multiple cells" do
+    @scout.possible_placements(2, ["F5", "F6"], @hit_board).should == 1
+    @scout.possible_placements(3, ["F5", "F6"], @hit_board).should == 2
+    @scout.possible_placements(4, ["F5", "F6"], @hit_board).should == 3
+    @scout.possible_placements(5, ["F6", "F7"], @hit_board).should == 4
+
+    @scout.possible_placements(2, ["F5", "G5"], @hit_board).should == 1
+    @scout.possible_placements(3, ["F5", "G5"], @hit_board).should == 2
+    @scout.possible_placements(4, ["F5", "G5"], @hit_board).should == 3
+    @scout.possible_placements(5, ["F5", "G5"], @hit_board).should == 4
+  end
+  
+  it "should calculate possible placements for cells with gaps" do
+    @scout.possible_placements(2, ["F5", "F7"], @hit_board).should == 0
+    @scout.possible_placements(3, ["F5", "F7"], @hit_board).should == 1
+    @scout.possible_placements(4, ["F5", "F7"], @hit_board).should == 2
+    @scout.possible_placements(5, ["F5", "H5"], @hit_board).should == 3
+  end
+  
+  it "should exclude placements containing misses from possible placements" do
+      @hit_board["F6"] = WhiteHorseman::CellStatus.new(false)
+      @scout.possible_placements(2, ["F5"], @hit_board).should == 3
+  end
+  
+  it "should excule placements that would leave the battlefield" do
+    @scout.possible_placements(5, ["A1"], @hit_board).should == 2
+    @scout.possible_placements(5, ["J10"], @hit_board).should == 2
+  end
+  
+  it "should be boxed in" do
+    @hit_board["G4"] = WhiteHorseman::CellStatus.new(false)
+    @hit_board["F5"] = WhiteHorseman::CellStatus.new(false)
+    @hit_board["G6"] = WhiteHorseman::CellStatus.new(false)
+    @scout.possible_placements(2, ["G5"], @hit_board).should == 1    
+  end
+  
+  it "should have possible placements for sunken ships" do
+    @hit_board["G4"] = WhiteHorseman::CellStatus.new(true)
+    @hit_board["G5"] = WhiteHorseman::CellStatus.new(true)
+    @hit_board["G6"] = WhiteHorseman::CellStatus.new(true)
+    @hit_board["G7"] = WhiteHorseman::CellStatus.new(true)
+    
+
+    placements = @scout.salvage_placements(4, "G5", @hit_board)
+    placements.size.should == 1
+    placements[0].should include("G4")
+    placements[0].should include("G5")
+    placements[0].should include("G6")
+    placements[0].should include("G7")
+  end
+  
+  it "should exclude placements containing hits from sunken ships" do
+    @hit_board["E6"] = WhiteHorseman::CellStatus.new(true)    
+    @hit_board["E6"].ship = :patrolship
+    @hit_board["F6"] = WhiteHorseman::CellStatus.new(true)    
+    @hit_board["F6"].ship = :patrolship
+    
+    @scout.possible_placements(2, ["F5"], @hit_board).should == 3
+  end
+  
+
+end

data/spec/white_horseman/ship_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'white_horseman/ship'
+
+describe WhiteHorseman::Ship do
+  it "should have symbol and size" do
+    ship = WhiteHorseman::Ship.new(:battleship)
+    ship.symbol.should == :battleship
+    ship.size.should == 4
+  end
+  
+  it "should have the correct size for all ships" do
+    ship = WhiteHorseman::Ship.new(:patrolship).size.should == 2
+    ship = WhiteHorseman::Ship.new(:carrier).size.should == 5
+    ship = WhiteHorseman::Ship.new(:submarine).size.should == 3
+    ship = WhiteHorseman::Ship.new(:destroyer).size.should == 3
+  end
+  
+  it "should have each ship" do
+    ships = []
+    WhiteHorseman::Ship.each do |ship|
+      ships << ship
+    end
+    check_ships(ships)
+  end
+  
+  it "should have all the ships" do
+    ships = WhiteHorseman::Ship.all
+    ships.size.should == 5
+    check_ships(ships)
+  end
+  
+  def check_ships(ships)
+    ships.size.should == 5
+    ships[0].symbol.should == :carrier
+    ships[1].symbol.should == :battleship
+    ships[2].symbol.should == :destroyer
+    ships[3].symbol.should == :submarine
+    ships[4].symbol.should == :patrolship
+  end
+  
+  it "should have equality operator" do
+    WhiteHorseman::Ship.new(:battleship).should == WhiteHorseman::Ship.new(:battleship)
+  end
+end

data/spec/white_horseman/white_horesman_integration_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'white_horseman/white_horseman'
+require 'white_horseman/opponent'
+
+describe WhiteHorseman::WhiteHorseman, "integration" do
+  it "should work" do
+    WhiteHorseman::Opponent.clear_all
+    @horseman = WhiteHorseman::WhiteHorseman.new
+    @horseman.new_game("testman")
+    
+    @horseman.battleship_placement.should_not be_nil
+    @horseman.carrier_placement.should_not be_nil
+    @horseman.submarine_placement.should_not be_nil
+    @horseman.patrolship_placement.should_not be_nil
+    @horseman.destroyer_placement.should_not be_nil
+    
+    @horseman.enemy_targeting("A1")
+    
+    @horseman.game_over(:victory)
+  end
+
+end

data/spec/white_horseman/white_horseman_spec.rb

@@ -0,0 +1,97 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'white_horseman/white_horseman'
+
+describe WhiteHorseman::WhiteHorseman do
+
+  before(:each) do
+    @mock_opponent = mock("opponent", :heat_map => nil, :new_game => nil, :name => "mr_mad")
+    @mock_admiral = mock("fleet admiral", :heat_map= => nil, :calculate => nil)
+    @mock_captain = mock("captain")
+    WhiteHorseman::Opponent.stub!(:new).and_return(@mock_opponent)
+    WhiteHorseman::FleetAdmiral.stub!(:new).and_return(@mock_admiral)
+    WhiteHorseman::Captain.stub!(:new).and_return(@mock_captain)
+
+    lambda { @horseman = WhiteHorseman::WhiteHorseman.new }.should_not raise_error
+  end
+
+  it "should create opponent" do
+    WhiteHorseman::Opponent.should_receive(:new).with("mr_mad").and_return(@mock_opponent)
+    
+    @horseman.new_game("mr_mad")
+  end
+  
+  it "should not create a new opponent if playing the same person again" do
+    WhiteHorseman::Opponent.should_receive(:new).once.with("mr_mad").and_return(@mock_opponent)
+    
+    @horseman.new_game("mr_mad")
+    @horseman.new_game("mr_mad")
+  end
+  
+  it "should create a new opponent if playing a different person" do
+    WhiteHorseman::Opponent.should_receive(:new).with("mr_mad").and_return(@mock_opponent)
+    WhiteHorseman::Opponent.should_receive(:new).with("new_guy").and_return(@mock_opponent)
+    
+    @horseman.new_game("mr_mad")
+    @horseman.new_game("new_guy")    
+  end
+
+  it "should start a new game" do
+    @mock_opponent.should_receive(:new_game)
+    
+    @horseman.new_game("mr_mad")
+  end
+  
+  it "should record target" do
+    @horseman.new_game("mr_mad")
+    
+    @mock_opponent.should_receive(:record_target).with("A1")
+    
+    @horseman.enemy_targeting("A1")
+  end
+  
+  it "should create an admiral" do
+    WhiteHorseman::FleetAdmiral.should_receive(:new).and_return(@mock_admiral)
+    @horseman.new_game("mr_mad")
+  end
+  
+  it "should give the opponent's heat map to the admiral" do
+    @heat_map = mock("heat map")
+    @mock_opponent.should_receive(:heat_map).and_return(@heat_map)
+    @mock_admiral.should_receive(:heat_map=).with(@heat_map)
+    
+    @horseman.new_game("mr_mad")
+  end
+  
+  it "should calculate admiral" do
+    @mock_admiral.should_receive(:calculate)
+    
+    @horseman.new_game("mr_mad")
+  end
+  
+  it "should save opponent when game ends" do
+    @opponent.should_receive(:save)
+  
+    @horseman.game_over(:victory) 
+  end
+  
+  it "should have a plan capitain" do
+    WhiteHorseman::Captain.should_receive(:new).and_return(@mock_captain)
+    
+    @horseman.new_game("mr_mad")
+  end
+  
+  it "should tell the captain about target results" do
+    @mock_captain.should_receive(:target_result).with("G4", true, :battleship)
+    
+    @horseman.new_game("mr_mad")
+    @horseman.target_result("G4", true, :battleship)
+  end
+  
+  it "should ask the capitan for the next target" do
+    @mock_captain.should_receive(:next_target).and_return("I9")
+
+    @horseman.new_game("mr_mad")
+    @horseman.next_target.should == "I9"
+    
+  end
+end

data/test_data/testman.data

@@ -0,0 +1,104 @@
+--- 
+- !ruby/object:WhiteHorseman::Battlefield 
+  grid: 
+  - - 99
+    - 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
+  shots: 1

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: white_horseman
+version: !ruby/object:Gem::Version 
+  version: "1.3"
+platform: ruby
+authors: 
+- Doug Bradbury
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-01 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: The apocalypse is here
+email: doug@8thlight.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Battleship.Rakefile
+- lib
+- lib/white_horseman
+- lib/white_horseman/analyst.rb
+- lib/white_horseman/battlefield.rb
+- lib/white_horseman/captain.rb
+- lib/white_horseman/cell_status.rb
+- lib/white_horseman/coordinates.rb
+- lib/white_horseman/fleet_admiral.rb
+- lib/white_horseman/opponent.rb
+- lib/white_horseman/placement.rb
+- lib/white_horseman/scout.rb
+- lib/white_horseman/ship.rb
+- lib/white_horseman/white_horseman.rb
+- pkg
+- Rakefile
+- spec
+- spec/spec_helper.rb
+- spec/white_horseman
+- spec/white_horseman/analyst_spec.rb
+- spec/white_horseman/battlefield_spec.rb
+- spec/white_horseman/captain_spec.rb
+- spec/white_horseman/cell_status_spec.rb
+- spec/white_horseman/coordinates_spec.rb
+- spec/white_horseman/fleet_admiral_spec.rb
+- spec/white_horseman/opponent_spec.rb
+- spec/white_horseman/placement_spec.rb
+- spec/white_horseman/scout_spec.rb
+- spec/white_horseman/ship_spec.rb
+- spec/white_horseman/white_horesman_integration_spec.rb
+- spec/white_horseman/white_horseman_spec.rb
+- test_data
+- test_data/testman.data
+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.2.0
+signing_key: 
+specification_version: 2
+summary: Battleship Player:White Horseman
+test_files: []
+