white_horseman 1.3

data/lib/white_horseman/ship.rb

@@ -0,0 +1,45 @@
+module WhiteHorseman
+  class Ship
+    attr_accessor :symbol
+    def initialize(symbol)
+      @symbol = symbol.to_sym
+    end
+    
+    def size
+      case @symbol
+      when :battleship
+        return 4
+      when :carrier
+        return 5
+      when :patrolship
+        return 2
+      when :submarine
+        return 3
+      when :destroyer
+        return 3
+      else
+        raise "bad ship type #{@symbol}"
+      end
+    end
+    
+    def ==(other)
+      self.symbol == other.symbol
+    end
+    
+    class << self
+      def each(&block)
+        [:carrier, :battleship, :destroyer, :submarine, :patrolship].each do |symbol|
+          yield(Ship.new(symbol))
+        end
+      end
+      
+      def all
+        ships = []
+        self.each{|ship| ships << ship}
+        return ships
+      end
+    end
+
+  end
+
+end

data/lib/white_horseman/white_horseman.rb

@@ -0,0 +1,187 @@
+unless defined?(DATA_DIR)
+  require 'tmpdir'
+  DATA_DIR = "#{Dir.tmpdir}/white_horseman_battleship_data"
+end
+
+require 'white_horseman/opponent'
+require 'white_horseman/fleet_admiral'
+require 'white_horseman/captain'
+
+module WhiteHorseman
+
+  # 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 WhiteHorseman
+
+    # 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)             
+      unless @opponent && @opponent.name == opponent_name
+        @opponent = Opponent.new(opponent_name)
+      end
+      
+      @admiral = FleetAdmiral.new
+      @admiral.heat_map = @opponent.heat_map
+      @admiral.calculate
+      @opponent.new_game
+      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 carrier_placement
+      return @admiral.carrier
+    end
+
+    # Returns the placement of the battleship. A battleship consumes 4 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def battleship_placement
+      return @admiral.battleship
+    end
+
+    # Returns the placement of the destroyer. A destroyer consumes 3 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def destroyer_placement
+      return @admiral.destroyer
+    end
+
+    # Returns the placement of the submarine. A submarine consumes 3 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def submarine_placement
+      return @admiral.submarine
+    end
+
+    # Returns the placement of the patrolship. A patrolship consumes 2 squares.
+    #
+    # See carrier_placement for details on ship placement
+    #
+    def patrolship_placement
+      return @admiral.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 illegal to target a sector more than once.  Doing so will also result in disqualification.
+    #
+    def next_target
+      return @captain.next_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)
+      @captain.target_result(coordinates, was_hit, ship_sunk)
+    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)
+      @opponent.record_target(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)
+      @opponent.save
+    end
+
+    # Non API methods #####################################
+
+    attr_reader :opponent, :targets, :enemy_targeted_sectors, :result, :disqualification_reason #:nodoc:
+
+    def initialize #:nodoc:
+      reset
+    end
+
+    private ###############################################
+
+    def reset
+      @captain = Captain.new
+    end
+
+    ROWS = %w{ A B C D E F G H I J }
+    def target_for_current_shot
+      row = ROWS[(@shots_taken) / 10]
+      col = @shots_taken % 10 + 1
+      return "#{row}#{col}"
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$: << File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require 'rubygems'
+require 'spec'
+
+DATA_DIR = File.expand_path(File.dirname(__FILE__)) + "/../test_data" unless defined?(DATA_DIR)

data/spec/white_horseman/analyst_spec.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'white_horseman/analyst'
+require 'white_horseman/battlefield'
+require 'white_horseman/cell_status'
+
+describe WhiteHorseman::Analyst do
+  before(:each) do
+    @hit_map = WhiteHorseman::Battlefield.new
+    @hit_map.set_all(WhiteHorseman::CellStatus.new)
+    @live_ships = WhiteHorseman::Ship.all
+    @analyst = WhiteHorseman::Analyst.new(@hit_map, @live_ships)
+  end
+  
+  it "should zero probability if it's already been missed" do
+    @hit_map["G5"] = WhiteHorseman::CellStatus.new(false)
+    @analyst.hit_probability("G5").should == 0.0
+  end
+  
+  it "should have starting probablity" do
+    @analyst.hit_probability("F5").should == 0.17
+  end
+    
+  it "should have a sure hit" do    
+    @hit_map["D5"] = WhiteHorseman::CellStatus.new(false)
+    @hit_map["E5"] = WhiteHorseman::CellStatus.new(true)
+    @hit_map["E6"] = WhiteHorseman::CellStatus.new(false)
+    @hit_map["E4"] = WhiteHorseman::CellStatus.new(false)
+    @analyst.hit_probability("F5").should be >= 1.0
+  end
+  
+  it "should no chance if nothing will fit there" do
+    @hit_map["A2"] = WhiteHorseman::CellStatus.new(false)
+    @hit_map["B1"] = WhiteHorseman::CellStatus.new(false)
+    @analyst.hit_probability("A1").should == 0.0
+  end
+  
+  it "should have no chance if the only ship that will fit there has already been sunk" do
+    @live_ships.delete(WhiteHorseman::Ship.new(:patrolship))
+    @hit_map["A2"] = WhiteHorseman::CellStatus.new(false)
+    @hit_map["B2"] = WhiteHorseman::CellStatus.new(false)
+    @hit_map["C1"] = WhiteHorseman::CellStatus.new(false)
+    
+    @analyst.hit_probability("A1").should == 0.0
+    @analyst.hit_probability("B1").should == 0.0
+  end
+  
+  it "should have a greater probability when there is a hit two cells away" do
+    prob = @analyst.hit_probability("G7")
+    @hit_map["G5"] = WhiteHorseman::CellStatus.new(true)
+    @analyst.hit_probability("G7").should be > prob    
+  end
+end

data/spec/white_horseman/battlefield_spec.rb

@@ -0,0 +1,121 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'white_horseman/battlefield'
+describe WhiteHorseman::Battlefield do
+  before(:each) do
+    @battlefield = WhiteHorseman::Battlefield.new
+  end
+  it "should have the grid" do
+    @battlefield.record_target("A1")
+    @battlefield.record_target("B4")
+    @battlefield.record_target("F8")
+    
+    @battlefield.shots.should == 3
+    @battlefield.grid.should == [
+      [99,0,0,0,0,0,0,0,0,0],
+      [0,0,0,98,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,97,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],
+      ]
+  end
+  
+  it "should grids for multiple games" do
+    @battlefield.record_target("J10")
+    @battlefield.record_target("G4")
+    @battlefield.record_target("f1")
+    @battlefield.record_target("B9")
+    
+    @battlefield.shots.should == 4
+    @battlefield.grid.should == [
+      [0,0,0,0,0,0,0,0,0,0],
+      [0,0,0,0,0,0,0,0,96,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],
+      [97,0,0,0,0,0,0,0,0,0],
+      [0,0,0,98,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,99],
+      ]
+  end
+
+  it "should build with a grid" do
+    @battlefield = WhiteHorseman::Battlefield.new([
+     [0,0,0,0,0,0,0,0,0,0],
+     [0,0,0,0,0,0,0,0,96,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],
+     [97,0,0,0,0,0,0,0,0,0],
+     [0,0,0,98,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,99],
+     ])
+     
+    @battlefield.grid.should ==  [
+      [0,0,0,0,0,0,0,0,0,0],
+      [0,0,0,0,0,0,0,0,96,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],
+      [97,0,0,0,0,0,0,0,0,0],
+      [0,0,0,98,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,99],
+      ] 
+  end
+  
+  it "should set cells" do
+    @battlefield["A1"] = 124
+    @battlefield["A1"].should == 124
+  end
+  
+  it "should set all" do
+    @battlefield.set_all(100)
+    @battlefield.grid.flatten.all?{ |cell| cell == 100}.should == true
+  end
+  
+  it "should average multiple battlefields" do
+    battlefield1 = WhiteHorseman::Battlefield.new([
+        [5,0,0,0,0,0,0,0,0,0],
+        [0,10,0,0,0,0,0,0,0,0],
+        [0,0,15,0,0,0,0,0,0,0],
+        [0,20,0,0,0,0,0,0,0,0],
+        [25,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],
+        ])
+    battlefield2 = WhiteHorseman::Battlefield.new([
+        [10,0,0,0,0,0,0,0,0,0],
+        [0,10,0,0,0,0,0,0,0,0],
+        [0,0,25,0,0,0,0,0,0,0],
+        [0,0,0,0,0,0,0,0,0,0],
+        [100,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],
+        ])
+    average = WhiteHorseman::Battlefield.average([battlefield1, battlefield2])
+    average["A1"].should == 7.5
+    average["B2"].should == 10
+    average["C3"].should == 20
+    average["D2"].should == 10
+    average["E1"].should == 62.5
+
+  end
+  
+  
+end

data/spec/white_horseman/captain_spec.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'white_horseman/captain'
+require 'white_horseman/coordinates'
+describe WhiteHorseman::Captain do
+  before(:each) do
+    @analyst = mock("analyst", :hit_probability => 0.17)
+    WhiteHorseman::Analyst.stub!(:new).and_return(@analyst)
+    @captain = WhiteHorseman::Captain.new
+  end
+
+  it "should record a miss" do
+    @captain.target_result("A1", false, nil)
+    @captain.hit_map["A1"].should be_miss
+  end
+  
+  it "should record a hit" do
+    @captain.target_result("C1", true, nil)
+    @captain.hit_map["C1"].should be_hit
+  end
+  
+  it "should select a target" do
+    target = WhiteHorseman::Coordinates.new(:string =>"I5")
+    @analyst.should_receive(:hit_probability).with(target).and_return(1.5)
+    @captain.next_target.should == "I5"
+  end
+  
+  it "should choose randomly from target of equal probablity" do
+    @captain.next_target.should_not == @captain.next_target
+  end
+  
+  it "should not target areas already targeted" do
+    def @analyst.hit_probability(coords)
+      coords.to_s.should_not == "A6"
+      coords.to_s.should_not == "A8"
+      return 0.17
+    end
+    
+    @captain.target_result("A6", true, nil)
+    @captain.target_result("A8", false, nil)
+    
+    @captain.next_target
+  end
+  
+  it "should have live ships" do
+    @captain.live_ships.size.should == 5
+  end
+  
+  it "should record sunken ships" do
+    @captain.target_result("G5", true, nil)
+    @captain.target_result("G6", true, :patrolship)
+    @captain.hit_map["G6"].should have_ship
+    @captain.hit_map["G5"].should have_ship
+    @captain.live_ships.size.should == 4
+  end
+    
+end

data/spec/white_horseman/cell_status_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'white_horseman/cell_status'
+describe WhiteHorseman::CellStatus do
+  before(:each) do
+    @cell = WhiteHorseman::CellStatus.new
+  end
+  it "should hit" do
+    @cell.should_not be_hit
+    @cell.hit
+    @cell.should be_hit
+  end
+  
+  it "should miss" do
+    @cell.should_not be_miss
+    @cell.miss
+    @cell.should be_miss
+  end
+  
+  it "should initailize with hit" do
+    WhiteHorseman::CellStatus.new(true).should be_hit
+    WhiteHorseman::CellStatus.new(false).should be_miss
+  end
+  
+  it "should have no shot" do
+    @cell.should be_empty
+    @cell.hit
+    @cell.should_not be_empty
+  end
+  
+  it "should have ship" do
+    @cell.should_not have_ship
+    @cell.ship = :battleship
+    @cell.should have_ship
+    @cell.ship.should == :battleship
+  end
+  
+end

data/spec/white_horseman/coordinates_spec.rb

@@ -0,0 +1,171 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'white_horseman/coordinates'
+
+describe WhiteHorseman::Coordinates do
+  it "should have row and column" do
+    @coordinates = WhiteHorseman::Coordinates.new(:string => "A1")
+    @coordinates.row.should == "A"
+    @coordinates.column.should == 1
+  end
+  
+  it "should be A1 by default" do
+    WhiteHorseman::Coordinates.new.to_s.should == "A1"
+  end
+  
+  it "should initialize by row and column" do
+    @coordinates = WhiteHorseman::Coordinates.new(:row => "A", :column => 1)
+    @coordinates.row.should == "A"
+    @coordinates.column.should == 1
+    @coordinates.to_s.should == "A1"
+  end
+  
+  it "should raise an error on out of bounds" do
+    lambda {WhiteHorseman::Coordinates.new(:string => "K9")}.should raise_error("Row out of range: K")
+    lambda {WhiteHorseman::Coordinates.new(:string => "a9")}.should_not raise_error
+    lambda {WhiteHorseman::Coordinates.new(:string => "A0")}.should raise_error("Column out of range: 0")
+    lambda {WhiteHorseman::Coordinates.new(:string => "A11")}.should raise_error("Column out of range: 11")  
+  end
+  
+  it "should have row index" do
+    WhiteHorseman::Coordinates.new(:string => "A1").row_index.should == 0
+    WhiteHorseman::Coordinates.new(:string => "J1").row_index.should == 9
+  end
+
+  it "should have column index" do
+    WhiteHorseman::Coordinates.new(:string => "A1").column_index.should == 0
+    WhiteHorseman::Coordinates.new(:string => "J10").column_index.should == 9
+  end
+  
+  it "should add a to_coord method to the String class" do
+    "A1".to_coord.row.should == "A"
+    "B10".to_coord.column.should == 10
+  end
+  
+  it "should have a to_coord method" do
+    coord = WhiteHorseman::Coordinates.new(:string => "A1")
+    coord.to_coord.should == coord
+  end
+  
+  it "should increment row" do
+    coord = "G5".to_coord
+
+    coord.inc_column
+
+    coord.column.should == 6
+  end
+  
+  it "should increment column" do
+    coord = "G5".to_coord
+
+    coord.inc_row
+
+    coord.row.should == "H"        
+  end
+  
+  it "should handle values on inc row" do
+    coord = "G5".to_coord
+
+    coord.inc_row -2
+
+    coord.row.should == "E"            
+  end
+  
+  it "should handle values on inc column" do
+    coord = "G5".to_coord
+
+    coord.inc_column 4
+
+    coord.to_s.should == "G9"
+  end
+  
+  it "should have equality operator" do
+    ("G5".to_coord == "G5".to_coord).should == true
+    ("G5".to_coord == "A5".to_coord).should == false
+    ("G5".to_coord == "G8".to_coord).should == false
+    ("G5".to_coord != "A5".to_coord).should == true
+    ("G5".to_coord != "G8".to_coord).should == true    
+  end
+  
+  it "should dup" do
+    one = "G5".to_coord
+    two = one.dup
+    two.column.should == 5
+    two.row.should == "G"
+    one.row = "B"
+    two.row.should == "G"
+    one.object_id.should_not == two.object_id
+  end
+  
+  it "should be colinear horizontal" do
+    WhiteHorseman::Coordinates.should be_colinear(["F5", "F6"], :horizontal)
+    WhiteHorseman::Coordinates.should_not be_colinear(["F5", "G5"], :horizontal)
+  end
+  
+  it "should be colinear vertical" do
+    WhiteHorseman::Coordinates.should be_colinear(["F5", "G5"], :vertical)
+    WhiteHorseman::Coordinates.should_not be_colinear(["F5", "F8"], :vertical)
+  end
+  
+  it "should be just plain colinear" do
+    WhiteHorseman::Coordinates.should be_colinear(["F5", "G5"])
+    WhiteHorseman::Coordinates.should be_colinear(["F5", "F6"])    
+  end
+  
+  it "should be colinear with just one point" do
+    WhiteHorseman::Coordinates.should be_colinear(["F5"], :vertical)
+    WhiteHorseman::Coordinates.should be_colinear(["F5"], :horizontal)
+  end
+  
+  it "should do each" do
+    num = 0
+    WhiteHorseman::Coordinates.each do |coordinate|
+      num += 1
+    end
+    num.should == 100
+  end
+  
+  it "should have neighbors" do
+    coord = WhiteHorseman::Coordinates.new(:string => "G5")
+    coord.neighbors.should include("F5")
+    coord.neighbors.should include("H5")
+    coord.neighbors.should include("G4")
+    coord.neighbors.should include("G6")
+  end
+  
+  it "should have neighbors on the borders" do
+    coord = WhiteHorseman::Coordinates.new(:string => "A1")
+    coord.neighbors.size.should == 2
+    coord.neighbors.should include("A2")
+    coord.neighbors.should include("B1")
+  end
+  
+  it "should have neighbors on the south eastern border" do
+    coord = WhiteHorseman::Coordinates.new(:string => "J10")
+    coord.neighbors.size.should == 2
+    coord.neighbors.should include("J9")
+    coord.neighbors.should include("I10")
+  end
+  
+  it "should have neighbors 2 doors down" do
+    coord = WhiteHorseman::Coordinates.new(:string => "G5")
+    coord.neighbors(2).should include("E5")
+    coord.neighbors(2).should include("I5")
+    coord.neighbors(2).should include("G3")
+    coord.neighbors(2).should include("G7")
+  end
+  
+  it "should have neighbors two doors down on the edge" do
+    coord = WhiteHorseman::Coordinates.new(:string => "B2")
+    coord.neighbors(2).size.should == 2
+    coord.neighbors(2).should include("B4")
+    coord.neighbors(2).should include("D2")
+  end
+
+  it "should have neighbors two doors down on the bottom right" do
+    coord = WhiteHorseman::Coordinates.new(:string => "I9")
+    coord.neighbors(2).size.should == 2
+    coord.neighbors(2).should include("I7")
+    coord.neighbors(2).should include("G9")
+  end
+  
+end