berlin-ai 0.0.29 → 0.0.32

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://www.rubygems.org"
+ 
+gemspec

data/Gemfile.lock

@@ -0,0 +1,56 @@
+PATH
+  remote: .
+  specs:
+    berlin-ai (0.0.29)
+      rainbow (~> 1.1.4)
+      sinatra (= 1.4.3)
+      sinatra-contrib (= 1.4.1)
+      thin (= 1.5.1)
+      yajl-ruby (= 1.1.0)
+
+GEM
+  remote: http://www.rubygems.org/
+  specs:
+    backports (3.3.3)
+    coderay (1.0.9)
+    daemons (1.1.9)
+    eventmachine (1.0.3)
+    method_source (0.8.2)
+    minitest (4.7.5)
+    multi_json (1.7.9)
+    pry (0.9.12.2)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rack (1.5.2)
+    rack-protection (1.5.0)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rainbow (1.1.4)
+    sinatra (1.4.3)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
+    sinatra-contrib (1.4.1)
+      backports (>= 2.0)
+      multi_json
+      rack-protection
+      rack-test
+      sinatra (~> 1.4.0)
+      tilt (~> 1.3)
+    slop (3.4.6)
+    thin (1.5.1)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    tilt (1.4.1)
+    yajl-ruby (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  berlin-ai!
+  minitest
+  pry

data/README.md

@@ -0,0 +1,117 @@
+# Berlin-Ai
+
+Berlin-Ai is a gem to quickly ramp up on the [Berlin](http://www.berlin-ai.com) game.
+
+## Usage
+
+Create your AI in a simple `.rb` file:
+
+```ruby
+require 'berlin-ai'         # Require the berlin-ai library.
+
+class Berlin::AI::Player
+  def on_turn(game)         # Implement the on_turn method of Berlin::AI::Player.
+    # Do your magic here.
+
+    # Here's an AI that randomly moves soldiers from node to node.
+    game.map.controlled_nodes.each do |node|
+      node.adjacent_nodes.shuffle.each do |other_node|
+        rand(0..(node.available_soldiers))
+        game.add_move(node.id, other_node.id, soldiers)
+      end
+    end
+  end
+end
+```
+
+You're now ready to host your AI locally or with [Heroku](https://devcenter.heroku.com/articles/rack). We use [Sinatra](http://www.sinatrarb.com) in this gem, so a simple `ruby your_ai_file.rb` will launch the web server.
+
+To modify some defaults, you can execute `ruby your_ai_file.rb -h` for a list of available options.
+
+## API
+
+### game (Berlin::AI::Game)
+
+Entry point in the API from `Berlin::AI::Player#on_turn`.
+
+```ruby
+# General information on the game.
+game.id                      # This game unique id.
+game.number_of_players       # Number of players in this game.
+game.maximum_number_of_turns # Maximum number of turns for this game.
+game.player_id               # Your player id for this game.
+game.time_limit_per_turn     # Maximum number of time (ms) to make your moves, per turn.
+
+# Information on the current turn.
+game.current_turn            # The current turn count.
+game.turns_left              # Remaining turns before the end of the game.
+
+# Add a move to perform this turn by your AI.
+# IMPORTANT: 'from' and 'to' must be node objects.
+game.add_move(from, to, number_of_soldiers)
+
+# List of moves to perform this turn by your AI.
+game.moves # => [{ from: node_id, to: node_id, number_of_soldiers: int }]
+
+# The game's map with its own set of useful methods.
+game.map
+```
+
+### map (Berlin::AI::Map)
+
+Helper methods to work with nodes.
+
+```ruby
+map.directed?          # Determine if a path from A to B is A -> B (directed) or A <-> B (not directed)
+map.nodes              # All the nodes.
+map.owned_nodes        # Owned nodes, including those with 0 soldiers.
+map.enemy_nodes        # Enemy nodes.
+map.free_nodes         # Nodes not controlled by anyone.
+map.foreign_nodes      # Nodes not owned (i.e. enemy nodes and free nodes).
+map.controlled_nodes   # Owned nodes, excluding those with 0 soldiers.
+```
+
+### node (Berlin::AI::Node)
+
+Node objects obtained when querying the map.
+
+```ruby
+node.id                       # Id of the node.
+node.type                     # Type of node.
+node.player_id                # Owner of the node.
+node.number_of_soldiers       # Number of soldiers on the node.
+node.incoming_soldiers        # Owned soldiers coming to this node (result from add_move calls).
+node.available_soldiers       # Owned remaining soldiers on this node (result from add_move calls).
+node.==(other)                # Check if two nodes are the same.
+node.adjacent?(other_node)    # Check if two nodes are adjacents.
+node.occupied?                # Check if some soldiers are on the node.
+node.owned?                   # Check if you own the node.
+node.free?                    # Check if no one own the node.
+node.owned_by?(player_id)     # Check if the node is owned by a given player.
+node.adjacent_nodes           # Get a list of adjacent nodes.
+node.adjacent_nodes_and_self  # Get a list of adjacent nodes, including this node.
+node.soldiers_per_turn        # Spawned soldiers per turn if you own this node.
+node.points                   # Given points by this node at the end of the game.
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'berlin-ai'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install berlin-ai
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/berlin-ai.gemspec

@@ -20,6 +20,9 @@ Gem::Specification.new do |s|
   s.add_dependency 'rainbow', '~>1.1.4'
   s.add_dependency 'thin', '1.5.1'
 
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'pry'
+
   s.files = `git ls-files`.split("\n")
 
   s.require_paths = ['lib', 'test']

data/lib/ai/fake.rb

@@ -4,6 +4,8 @@ module Berlin
   module Fake
 
     MAP_DEFINITION = {
+      "directed" => false,
+
       "types" => [
         {"name" => "node", "points" => 0, "soldiers_per_turn" => 0},
         {"name" => "city", "points" => 1, "soldiers_per_turn" => 1}
@@ -228,7 +230,14 @@ class Berlin::Fake::Game
       ai_info['player_id']  = ai_name
       ai_info['game_id']    = n
 
-      Berlin::AI::Game.new(ai_info['game_id'], Berlin::Fake::MAP_DEFINITION, ai_info)
+      ai_game = Berlin::AI::Game.new
+      ai_game.id                       = ai_info['game_id']
+      ai_game.map                      = Berlin::AI::Map.parse(Berlin::Fake::MAP_DEFINITION.merge('player_id' => ai_info['player_id']))
+      ai_game.player_id                = ai_info['player_id']
+      ai_game.time_limit_per_turn      = ai_info['time_limit_per_turn']
+      ai_game.maximum_number_of_turns  = ai_info['maximum_number_of_turns']
+      ai_game.number_of_players        = ai_info['number_of_players']
+      ai_game
     end
 
     player_name = "Player"
@@ -239,7 +248,13 @@ class Berlin::Fake::Game
     node['player_id'] = player_name
     node['number_of_soldiers'] = 5
 
-    @player_game = Berlin::AI::Game.new(player_info['game_id'], Berlin::Fake::MAP_DEFINITION, player_info)
+    @player_game = Berlin::AI::Game.new
+    @player_game.id                       = player_info['game_id']
+    @player_game.map                      = Berlin::AI::Map.parse(Berlin::Fake::MAP_DEFINITION.merge('player_id' => player_info['player_id']))
+    @player_game.player_id                = player_info['player_id']
+    @player_game.time_limit_per_turn      = player_info['time_limit_per_turn']
+    @player_game.maximum_number_of_turns  = player_info['maximum_number_of_turns']
+    @player_game.number_of_players        = player_info['number_of_players']
 
     @state = Berlin::Fake::State.new(Berlin::Fake::GAME_STATE.dup)
   end
@@ -291,15 +306,13 @@ class Berlin::Fake::Game
   end
 
   def generate_moves
-    info = {'current_turn' => @turn}
-
     @ai_games.each do |game|
       game.reset!
-      game.update(info, @state.as_json)
+      game.update(@turn, @state.as_json)
       Berlin::Fake::Random.on_turn(game)
     end
 
-    @player_game.update(info, @state.as_json)
+    @player_game.update(@turn, @state.as_json)
     @player_game.reset!
     Berlin::AI::Player.on_turn(@player_game)
   end

data/lib/ai/game.rb

@@ -2,56 +2,13 @@ module Berlin
   module AI
     # Game keeps track of current games played by the server, indexing them on their uniq id.
     class Game
-      attr_reader :id, :map, :moves, :player_id, :current_turn, :number_of_players, :time_limit_per_turn, :maximum_number_of_turns, :turns_left
-      
-      # Keep track of all current games
-      @@games = {}
-      
-      def self.create_or_update action, infos, map, state
-        # Check for params and quit on errors
-        return if action.nil? || infos.nil? || map.nil? || state.nil?
-        
-        # First, we parse the received request
-        infos  = JSON.parse( infos )
-        map    = JSON.parse( map )
-        state  = JSON.parse( state )
-
-        # Game id, set with player_id as well so an AI can fight with himself
-        game_id = "#{infos['game_id']}-#{infos['player_id']}"
-        
-        # Then, let's see if we can find that game. If not, register it.
-        if action == "ping"
-          game = Berlin::AI::Game.new game_id, map, infos
-        else
-          game = (@@games[game_id] ||= Berlin::AI::Game.new( game_id, map, infos ))
-        end
-        
-        if action == "game_over"
-          # Release the game to avoid memory leaks
-          @@games.delete game_id
-        elsif infos && state
-          # Now, we want to update the current state of the game with the new content, as well as other infos
-          game.update infos, state
-        end
+      include Internal
 
-        game
-      end
+      attr_accessor :id, :map, :moves, :player_id, :current_turn, :number_of_players,
+                  :time_limit_per_turn, :maximum_number_of_turns, :turns_left
       
-      def initialize id, map, infos
-        @id  = id
-        
-        # Extract usefull static informations
-        @player_id                = infos['player_id']
-        @time_limit_per_turn      = infos['time_limit_per_turn']
-        @maximum_number_of_turns  = infos['maximum_number_of_turns'].to_i
-        @number_of_players        = infos['number_of_players']
-        
-        # Create the map
-        @map = Berlin::AI::Map.new map, infos
-      end
-      
-      def add_move from, to, number_of_soldiers        
-         # remove moving soldiers from from node
+      def add_move(from, to, number_of_soldiers)     
+        # remove moving soldiers from from node
         from.available_soldiers -= number_of_soldiers
 
         # adding incoming soldiers to next node
@@ -61,19 +18,6 @@ module Berlin
         @moves << {:from => from.to_i, :to => to.to_i, :number_of_soldiers => number_of_soldiers.to_i}
       end
 
-      def update infos, state
-        # Update turn infos
-        @current_turn = infos['current_turn'].to_i
-        @turns_left   = @maximum_number_of_turns - @current_turn
-        
-        # Update map state
-        @map.update state
-      end
-      
-      def reset!
-        @moves = []
-        @map.nodes.each(&:reset!)
-      end
     end
   end
 end

data/lib/ai/game_internal.rb

@@ -0,0 +1,65 @@
+module Berlin
+  module AI
+    class Game
+      module Internal
+        module ClassMethods
+          # Keep track of all current games
+          @@games = {}
+
+          def create_or_update(action, infos, map, state)
+            # Check for params and quit on errors
+            return if action.nil? || infos.nil? || map.nil? || state.nil?
+
+            # First, we parse the received request
+            infos  = JSON.parse( infos )
+            map    = JSON.parse( map )
+            state  = JSON.parse( state )
+
+            # Game id, set with player_id as well so an AI can fight with himself
+            game_id = "#{infos['game_id']}-#{infos['player_id']}"
+
+            # Then, let's see if we can find that game. If not, register it.
+            game = @@games[game_id] ||= begin
+              game                          = Berlin::AI::Game.new
+              game.id                       = game_id
+              game.map                      = Berlin::AI::Map.parse(map.merge(infos.select{ |k,v| ['directed', 'player_id'].include?(k) }))
+              game.player_id                = infos['player_id']
+              game.time_limit_per_turn      = infos['time_limit_per_turn']
+              game.maximum_number_of_turns  = infos['maximum_number_of_turns']
+              game.number_of_players        = infos['number_of_players']
+              game
+            end
+
+            if action == "game_over"
+              # Release the game to avoid memory leaks
+              @@games.delete(game_id)
+            elsif infos && state
+              # Now, we want to update the current state of the game with the new content, as well as other infos
+              game.update(infos['current_turn'], state)
+            end
+
+            game
+          end
+        end
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        def update(current_turn, state)
+          # Update turn infos
+          @current_turn = current_turn.to_i
+          @turns_left   = @maximum_number_of_turns - @current_turn
+          
+          # Update map state
+          @map.update(state)
+        end
+        
+        def reset!
+          @moves = []
+          @map.nodes.each(&:reset!)
+        end
+      end
+    end
+  end
+end

data/lib/ai/map.rb

@@ -4,39 +4,13 @@ module Berlin
     # nodes, points, soldiers, etc. Game will then be able to pick any information
     # it wants from map to decide what are the best moves to do.
     class Map
-      def initialize map, infos
-        @player_id  = infos['player_id']
-        @nodes      = {}
-        @types      = {}
-        @directed   = infos['directed'] || false
-        
-        # Node types
-        map['types'].each do |type|
-          @types[type['name']] = type
-        end
-        
-        # Let's parse map['nodes'] and register all nodes we can find.
-        # We'll keep track of them in @nodes so we can find them later.
-        # At this step (Map creation...), we still don't know who possess
-        # the node and how many soldiers there is. We'll get back to that later.
-        # map['nodes'] => [{:id => STRING}, ...]
-        map['nodes'].each do |node|
-          @nodes[node['id']] = Berlin::AI::Node.new node, @types[node['type']]
-        end
+      include Internal
 
-        # Same thing here, with paths.
-        # map['paths'] => [{:from => INTEGER, :to => INTEGER}, ...]
-        map['paths'].each do |path|
-          @nodes[path['from']].link_to @nodes[path['to']]
-
-          # Don't forget! If the map is not directed, we must create the reverse link!
-          @nodes[path['to']].link_to @nodes[path['from']] unless directed?
-        end
-      end
+      attr_accessor :player_id, :nodes_hash, :directed
       
       # Returns an array of all nodes of the map
       def nodes
-        @nodes.values
+        @nodes_hash.values
       end
 
       # Returns an array of all owned nodes
@@ -78,18 +52,6 @@ module Berlin
       def directed?
         @directed
       end
-
-      # Let's update the current state with the latest provided info! With this step,
-      # we'll now know who possess the node and how many soldiers there is.
-      # state contains an array of nodes, so we just have to loop on it.
-      # state => [{:node_id => STRING, :number_of_soldiers => INTEGER, :player_id => INTEGER}, ...]
-      def update state
-        state.each do |n|
-          node                    = @nodes[n['node_id']]
-          node.number_of_soldiers = n['number_of_soldiers']
-          node.player_id          = n['player_id']
-        end
-      end
     end
   end
 end

data/lib/ai/map_internal.rb

@@ -0,0 +1,67 @@
+module Berlin
+  module AI
+    class Map
+      module Internal
+        module ClassMethods
+          def parse(data)
+            map = Map.new
+
+            # Map details
+            map.directed = data['directed']
+            map.player_id = data['player_id']
+
+            # Node types
+            types = data['types'].each.with_object({}) do |type, types|
+              types[type['name']] = type
+            end
+            
+            # Let's parse data['nodes'] and register all nodes we can find.
+            # We'll keep track of them in @nodes so we can find them later.
+            # At this step (Map creation...), we still don't know who possess
+            # the node and how many soldiers there is. We'll get back to that later.
+            # map['nodes'] => [{:id => STRING}, ...]
+            data['nodes'].each do |node|
+              map.nodes_hash[node['id']] = Berlin::AI::Node.parse(node.merge(types[node['type']]))
+            end
+
+            # Same thing here, with paths.
+            # map['paths'] => [{:from => INTEGER, :to => INTEGER}, ...]
+            data['paths'].each do |path|
+              map.nodes_hash[path['from']].link_to(map.nodes_hash[path['to']])
+
+              # Don't forget! If the map is not directed, we must create the reverse link!
+              map.nodes_hash[path['to']].link_to(map.nodes_hash[path['from']]) unless map.directed?
+            end
+
+            # and... return the newly created map
+            map
+          end
+        end
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        def initialize(options={})
+          @nodes_hash = {}
+
+          options.each do |k,v|
+            self.send("#{k}=", v)
+          end
+        end
+
+        # Let's update the current state with the latest provided info! With this step,
+        # we'll now know who possess the node and how many soldiers there is.
+        # state contains an array of nodes, so we just have to loop on it.
+        # state => [{:node_id => STRING, :number_of_soldiers => INTEGER, :player_id => INTEGER}, ...]
+        def update(state)
+          state.each do |n|
+            node                    = @nodes_hash[n['node_id']]
+            node.number_of_soldiers = n['number_of_soldiers']
+            node.player_id          = n['player_id']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ai/node.rb

@@ -4,39 +4,10 @@ module Berlin
     # We'll be able to use it in order to know if two
     # nodes are adjacent, how much points worth a node, etc.
     class Node
-      attr_accessor :id, :player_id, :number_of_soldiers, :incoming_soldiers, :available_soldiers, :type
-      attr_reader   :soldiers_per_turn, :points
+      include Internal
 
-      def initialize node, type
-        @id                 = node['id']
-        @type               = node['type']
-        @points             = type['points']
-        @soldiers_per_turn  = type['soldiers_per_turn']
-        @number_of_soldiers = 0
-        @player_id          = nil
-        @links              = []
-      end
-
-      # Reset information for new turn
-      def reset!
-        self.incoming_soldiers  = 0
-        self.available_soldiers = self.number_of_soldiers
-      end
-      
-      # Somewhat useful
-      def to_i
-        @id.to_i
-      end
-
-      # Used to compare if two nodes are the same
-      def ==(other)
-        other.id == @id
-      end
-
-      # Registers a given node as an adjacent one.
-      def link_to(other_node)
-        @links << other_node
-      end
+      attr_accessor :id, :player_id, :number_of_soldiers, :incoming_soldiers,
+                    :available_soldiers, :type, :soldiers_per_turn, :points
 
       # Returns true if other_node is adjacent to self
       def adjacent?(other_node)

data/lib/ai/node_internal.rb

@@ -0,0 +1,59 @@
+module Berlin
+  module AI
+    class Node
+      module Internal
+        module ClassMethods
+          def parse(data)
+            node = Node.new
+
+            node.id                 = data['id']
+            node.type               = data['type']
+            node.points             = data['points']
+            node.soldiers_per_turn  = data['soldiers_per_turn']
+
+            node
+          end
+        end
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        def initialize(options={})
+          @number_of_soldiers = 0
+          @player_id          = nil
+          @links              = []
+
+          options.each do |k,v|
+            self.send("#{k}=", v)
+          end
+        end
+
+        def to_s
+          "<Berlin::AI::Node @id=#{@id} @player_id='#{@player_id}' @type='#{@type}' @points=#{@points} @soldiers_per_turn=#{@soldiers_per_turn} @number_of_soldiers=#{@number_of_soldiers} @incoming_soldiers=#{@incoming_soldiers} @available_soldiers=#{@available_soldiers} @adjacent_nodes=#{adjacent_nodes.map(&:id)}>"
+        end
+
+        # Reset information for new turn
+        def reset!
+          self.incoming_soldiers  = 0
+          self.available_soldiers = self.number_of_soldiers
+        end
+        
+        # Somewhat useful
+        def to_i
+          @id.to_i
+        end
+
+        # Used to compare if two nodes are the same
+        def ==(other)
+          other.id == @id
+        end
+
+        # Registers a given node as an adjacent one.
+        def link_to(other_node)
+          @links << other_node
+        end
+      end
+    end
+  end
+end

data/lib/berlin-ai.rb

@@ -9,7 +9,7 @@ puts "|  _  ||  -__||   _||  |  ||     |    |       |_|   |_ "
 puts "|_____||_____||__|  |__|__||__|__|    |___|___|_______|"
 puts
 
-%w(game map node fake).each do |file|
+%w(game_internal game map_internal map node_internal node fake).each do |file|
   require File.expand_path(File.dirname( __FILE__ )) + "/ai/#{file}"
 end
 

data/lib/version.rb

@@ -2,7 +2,7 @@ module Berlin
   module AI
     MAJOR = 0
     MINOR = 0
-    BUILD = 29
+    BUILD = 32
 
     VERSION = "#{MAJOR}.#{MINOR}.#{BUILD}"
   end

data/test/map_test.rb

@@ -0,0 +1,35 @@
+
+require_relative '../lib/ai/node_internal'
+require_relative '../lib/ai/node'
+require_relative '../lib/ai/map_internal'
+require_relative '../lib/ai/map'
+
+require "test/unit"
+ 
+class MapTest < Test::Unit::TestCase
+
+  def setup
+    @node1 = Berlin::AI::Node.new(:id => 1, :player_id => 1)
+    @node2 = Berlin::AI::Node.new(:id => 2, :player_id => 1)
+    @node3 = Berlin::AI::Node.new(:id => 3, :player_id => nil)
+    @node4 = Berlin::AI::Node.new(:id => 4, :player_id => 2)
+    @node5 = Berlin::AI::Node.new(:id => 5, :player_id => 3)
+
+    @map = Berlin::AI::Map.new
+    @map.player_id = 1
+    @map.nodes = {1 => @node1, 2 => @node2, 3 => @node3, 4 => @node4, 5 => @node5}
+  end
+
+  def test_nodes_returns_an_array_of_all_nodes
+    assert_equal [@node1, @node2, @node3, @node4, @node5], @map.nodes
+  end
+
+  def test_owned_nodes_returns_an_array_of_owned_nodes_for_current_player
+    assert_equal [@node1, @node2], @map.owned_nodes
+  end
+
+  def test_foreign_nodes_returns_and_array_of_nodes_that_the_current_player_does_not_owned
+    assert_equal [@node3, @node4, @node5], @map.foreign_nodes
+  end
+
+end

data/test/node_test.rb

@@ -0,0 +1,77 @@
+require_relative '../lib/ai/node_internal'
+require_relative '../lib/ai/node'
+
+require "test/unit"
+ 
+class NodeTest < Test::Unit::TestCase
+ 
+  def test_equals_returns_true_if_two_nodes_have_the_same_id
+    node1 = Berlin::AI::Node.new(:id => 1)
+    node2 = Berlin::AI::Node.new(:id => 2)
+
+    assert node1 != node2
+
+    node2.id = 1
+
+    assert node1 == node2
+  end
+
+  def test_reset_resets_all_turn_relative_data
+    node = Berlin::AI::Node.new(:number_of_soldiers => 2, :incoming_soldiers => 3, :available_soldiers => 4)
+    node.reset!
+    assert_equal 0, node.incoming_soldiers
+    assert_equal node.number_of_soldiers, node.available_soldiers
+  end
+
+  def test_adjacent_returns_weither_or_not_a_node_is_adjacent
+    node1 = Berlin::AI::Node.new(:id => 1)
+    node2 = Berlin::AI::Node.new(:id => 2)
+    node3 = Berlin::AI::Node.new(:id => 3)
+
+    node1.link_to(node2)
+
+    assert node1.adjacent?(node2)
+    assert !node1.adjacent?(node3)
+  end
+
+  def test_occupied_returns_true_if_the_node_has_at_least_one_soldiers
+    node = Berlin::AI::Node.new
+
+    assert !node.occupied?
+
+    node.number_of_soldiers = 10
+
+    assert node.occupied?
+  end
+
+  def test_free_returns_true_if_the_node_is_not_owned_by_any_player
+    node = Berlin::AI::Node.new
+
+    assert node.free?
+
+    node.player_id = 1
+
+    assert !node.free?
+  end
+
+  def test_owned_by_returns_true_if_owned_by_the_provided_player
+    node = Berlin::AI::Node.new
+
+    assert !node.owned_by?(1)
+
+    node.player_id = 1
+
+    assert node.owned_by?(1)
+  end
+
+  def test_owned_returns_true_if_owned_by_a_player
+    node = Berlin::AI::Node.new
+
+    assert !node.owned?
+
+    node.player_id = 1
+
+    assert node.owned?
+  end
+ 
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: berlin-ai
 version: !ruby/object:Gem::Version
-  version: 0.0.29
+  version: 0.0.32
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-28 00:00:00.000000000 Z
+date: 2013-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -93,6 +93,38 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.5.1
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Berlin Artificial Intelligence
 email:
 - christ.blais@gmail.com
@@ -102,16 +134,23 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- Gemfile
+- Gemfile.lock
 - LICENSE
-- README
+- README.md
 - berlin-ai.gemspec
 - lib/ai/fake.rb
 - lib/ai/game.rb
+- lib/ai/game_internal.rb
 - lib/ai/map.rb
+- lib/ai/map_internal.rb
 - lib/ai/node.rb
+- lib/ai/node_internal.rb
 - lib/ai/player.rb
 - lib/berlin-ai.rb
 - lib/version.rb
+- test/map_test.rb
+- test/node_test.rb
 - test/test_ai.rb
 homepage: http://github.com/thirdside/berlin-ai
 licenses: []