berlin-ai 0.0.1

data/LICENSE

@@ -0,0 +1,6 @@
+COPYLEFT
+
+0. the freedom to use the work,
+1. the freedom to study the work,
+2. the freedom to copy and share the work with others,
+3. the freedom to modify the work, and the freedom to distribute modified and therefore derivative works.

data/berlin-ai.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+ 
+require 'lib/version'
+ 
+Gem::Specification.new do |s|
+  s.name        = "berlin-ai"
+  s.version     = Berlin::AI::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Christian Blais", "Guillaume Malette", "Jodi Giordano"]
+  s.email       = ["christ.blais@gmail.com", "gmalette@gmail.com", "giordano.jodi@gmail.com"]
+  s.homepage    = "http://github.com/christianblais/berlin-ai"
+  s.summary     = "Berlin Artificial Intelligence"
+  s.description = "Berlin Artificial Intelligence"
+ 
+  s.files = [
+    'LICENSE',
+    'README',
+    'berlin-ai.gemspec',
+    'lib/berlin-ai.rb',
+    'lib/version.rb',
+    'lib/ai/game.rb',
+    'lib/ai/map.rb',
+    'lib/ai/node.rb',
+    'test/test_ai.rb']
+  
+  s.require_paths = ['lib', 'test']
+end

data/lib/ai/game.rb

@@ -0,0 +1,51 @@
+module Berlin
+  module AI
+    class Game
+      attr_reader :id
+      
+      @@games = {}
+      
+      def self.create_or_update action, infos, map, state
+        # Check for params and quit on errors
+        return nil 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 )
+
+        # Then, let's see if we can find that game. If not, register it.
+        game_id = infos['game_id']
+        @@games[game_id] ||= Berlin::AI::Game.new game_id, map, infos
+        game = @@games[game_id]
+
+        if action == "game_over"
+          # Release the game to avoid memory leaks
+          @@games[game_id] = nil
+        elsif state
+          # Now, we want to update the current state of the game with the new content
+          game.update state
+        end
+
+        game
+      end
+      
+      # @id = Uniq game ID (params[:game])
+      # @map = Current state of the game (params[:json])
+      def initialize id, map, infos
+        @id         = id
+        @map        = Berlin::AI::Map.new map, infos
+      end
+
+      # Let's update the map with the latest state
+      def update state
+        @map.update state
+      end
+      
+      # Must be overwritten
+      def turn_moves
+        raise "Please... overwrite me!"
+      end
+    end
+  end
+end

data/lib/ai/map.rb

@@ -0,0 +1,66 @@
+module Berlin
+  module AI
+    # Map will keep track of all the useful information needed to play, such as
+    # 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
+      attr_accessor :nodes
+      attr_reader :player_id
+
+      def initialize map, infos
+        @player_id  = infos['player_id']
+        @nodes      = {}
+        @directed   = infos['directed'] || false
+
+        # Let's parse json['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.
+        # json['nodes'] => [{:id => STRING}, ...]
+        map['nodes'].each do |node|
+          @nodes[node['id']] = Berlin::AI::Node.new node['id']
+        end
+
+        # Same thing here, with paths.
+        # json['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
+
+      # By checking node.player_id, we are able to know if we own the node or not.
+      def owned_nodes
+        @nodes.select do |id, node|
+          node.player_id == player_id
+        end
+      end
+
+      # We can now loop on our owned nodes in order to find our controlled nodes.
+      def controlled_nodes
+        owned_nodes.select do |id, node|
+          node.occupied?
+        end
+      end
+
+      # Is the map directed?
+      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/node.rb

@@ -0,0 +1,37 @@
+module Berlin
+  module AI
+    # Node will help us to keep track of possible moves.
+    # 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
+
+      def initialize id
+        @id                 = id
+        @number_of_soldiers = 0
+        @player_id          = 0
+        @links              = []
+      end
+
+      # Register a given node as an adjacent one.
+      def link_to other_node
+        @links << other_node
+      end
+
+      # Is other_node adjacents to current node?
+      def adjacent? other_node
+        @links.include? other_node
+      end
+      
+      # Is there anybody out there?
+      def occupied?
+        @number_of_soldiers > 0
+      end
+
+      # What are current node's neighbors?
+      def adjacent_nodes
+        @links.dup
+      end
+    end
+  end
+end

data/lib/berlin-ai.rb

@@ -0,0 +1,23 @@
+%w(game map node).each do |file|
+  require File.expand_path( File.dirname( __FILE__ ) ) + "/ai/#{file}"
+end
+
+post '/' do
+  begin
+    if ['turn', 'game_start', 'game_over'].include? params[:action]
+      game = Berlin::AI::Game.create_or_update params[:action], params[:infos], params[:map], params[:state]
+
+      if params[:action] == 'turn'
+        # Respond with a json of our moves
+        return game.turn_moves.to_json
+      end
+    else
+      p params.inspect
+    end
+
+    # For every other type of request, respond with 200 OK
+    200
+  rescue Exception => e
+    500
+  end
+end

data/lib/version.rb

@@ -0,0 +1,9 @@
+module Berlin
+  module AI
+    MAJOR = 0
+    MINOR = 0
+    BUILD = 1
+
+    VERSION = "#{MAJOR}.#{MINOR}.#{BUILD}"
+  end
+end

data/test/test_ai.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'sinatra'
+require 'yajl/json_gem'
+
+%w(berlin-ai).each do |file|
+  require File.expand_path( File.dirname( __FILE__ ) ) + "/../lib/#{file}"
+end
+
+module Berlin
+  module AI
+    class Game
+      def turn_moves
+        p "salut"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: berlin-ai
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Christian Blais
+- Guillaume Malette
+- Jodi Giordano
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-19 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Berlin Artificial Intelligence
+email: 
+- christ.blais@gmail.com
+- gmalette@gmail.com
+- giordano.jodi@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- README
+- berlin-ai.gemspec
+- lib/berlin-ai.rb
+- lib/version.rb
+- lib/ai/game.rb
+- lib/ai/map.rb
+- lib/ai/node.rb
+- test/test_ai.rb
+has_rdoc: true
+homepage: http://github.com/christianblais/berlin-ai
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- test
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Berlin Artificial Intelligence
+test_files: []
+