motel 0.3 → 0.3.1

data/Rakefile

@@ -9,7 +9,7 @@ require 'rake/gempackagetask'
 
 
 GEM_NAME="motel"
-PKG_VERSION='0.3'
+PKG_VERSION='0.3.1'
 SIMRPC_SPEC='conf/motel-schema.xml'
 
 desc "Run all specs"
@@ -23,20 +23,22 @@ Rake::RDocTask.new do |rd|
     rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
 end
 
-PKG_FILES = FileList['bin/**/*', 'conf/motel-schema.xml', 'lib/**/*.rb', 
+PKG_FILES = FileList['conf/motel-schema.xml', 'lib/**/*.rb', 
   'COPYING', 'LICENSE', 'Rakefile', 'README.rdoc', 'spec/**/*.rb' ]
 
 SPEC = Gem::Specification.new do |s|
     s.name = GEM_NAME
     s.version = PKG_VERSION
     s.files = PKG_FILES
+    s.executables << 'motel-server' << 'motel-client' << 'motel-rage-client'
 
     s.required_ruby_version = '>= 1.8.1'
     s.required_rubygems_version = Gem::Requirement.new(">= 1.3.3")
+    s.add_development_dependency('rspec', '~> 1.3.0')
 
     s.author = "Mohammed Morsi"
     s.email = "movitto@yahoo.com"
-    s.date = %q{2010-03-14}
+    s.date = %q{2010-09-05}
     s.description = %q{Motel is a library to track and move the locations of objects in a 3D environment.}
     s.summary = %q{Motel is a library to track and move the locations of objects in a 3D environment.}
     s.homepage = %q{http://morsi.org/projects/motel}

data/bin/motel-client

@@ -0,0 +1,211 @@
+#!/usr/bin/ruby
+# A simple motel client executable
+# Executable to use the motel library to perform operations on
+# a remote location server, simply printing out results
+#
+# Flags: (see below)
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
+
+require 'rubygems'
+require 'optparse'
+require 'motel'
+
+include Motel
+include Motel::MovementStrategies
+
+######################
+
+def main()
+    # command line parameters
+    schema_file = nil
+    location = {:parent_id => nil,
+                :x => nil,
+                :y => nil,
+                :z => nil}
+    other_location_id = nil
+    movement_strategy_type = nil
+    movement_strategy = { :step_delay => nil,
+                          :speed => nil,
+                          :direction_vector_x => nil,
+                          :direction_vector_y => nil,
+                          :direction_vector_z => nil,
+                          :relative_to => nil,
+                          :eccentricity => nil,
+                          :semi_latus_rectum => nil,
+                          :direction_major_x => nil,
+                          :direction_major_y => nil,
+                          :direction_major_z => nil,
+                          :direction_minor_x => nil,
+                          :direction_minor_y => nil,
+                          :direction_minor_z => nil}
+    request_target = nil
+
+    # setup cmd line options
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: main.rb [command] [options]"
+
+      opts.on("-h", "--help", "Print this help message") do
+         puts opts
+         exit
+      end
+
+      opts.on("-s", "--schema [path]", "Motel Schema File") do |path|
+         schema_file = path
+      end
+
+      opts.separator ""
+      opts.separator "Commands:"
+      opts.on("-g", "--get", "get location specified by id")do
+        request_target = :get_location
+      end
+      opts.on("-c", "--create", "create location w/ id")do
+        request_target = :create_location
+      end
+      opts.on("-u", "--update", "update location specified by id w/ specified options")do
+        request_target = :update_location
+      end
+      opts.on("-m", "--subscribe-to-movement", "subscribe to movement updates to location specified by id")do
+        request_target = :subscribe_to_location_movement
+      end
+      opts.on("-r", "--subscribe-to-proximity", "subscribe to locations proximity events")do
+        request_target = :subscribe_to_locations_proximity
+      end
+
+      opts.separator ""
+      opts.separator "Location Options:"
+      opts.on("-i", "--id [location_id]", "Target location id") do |id|
+        location[:id] = id
+      end
+      opts.on("-o", "--other-id [location_id]", "Second location id for actions that require it") do |id|
+        other_location_id = id
+      end
+      opts.on("-p", "--parent-id [location_id]", "Target parent location id") do |id|
+        location[:parent_id] = id
+      end
+      opts.on("-x", "--xcoordinate [coordinate]", "Target location x coordinate") do |x|
+        location[:x] = x
+      end
+      opts.on("-y", "--ycoordinate [coordinate]", "Target location y coordinate") do |y|
+        location[:y] = y
+      end
+      opts.on("-z", "--zcoordinate [coordinate]", "Target location z coordinate") do |z|
+        location[:z] = z
+      end
+
+      opts.separator ""
+      opts.separator "Movement Strategy Options:"
+      opts.on("--movement-strategy-type [type]", "Movement strategy type") do |type|
+        movement_strategy_type = type
+      end
+      opts.on("--step-delay [delay]", "Movement strategy step delay") do |delay|
+        movement_strategy[:step_delay] = delay.to_f
+      end
+      opts.on("--speed [speed]", "Movement strategy speed") do |speed|
+        movement_strategy[:speed] = speed.to_f
+      end
+      opts.on("--direction-vector-x [x]", "Linear movement strategy direction vector x coordinate") do |x|
+        movement_strategy[:direction_vector_x] = x.to_f
+      end
+      opts.on("--direction-vector-y [y]", "Linear movement strategy direction vector y coordinate") do |y|
+        movement_strategy[:direction_vector_y] = y.to_f
+      end
+      opts.on("--direction-vector-z [z]", "Linear movement strategy direction vector z coordinate") do |z|
+        movement_strategy[:direction_vector_z] = z.to_f
+      end
+      opts.on("--relative-to [relative]", "Elliptical movement strategy relative to") do |relative|
+        movement_strategy[:relative_to] = relative
+      end
+      opts.on("--eccentricity [e]", "Elliptical movement strategy eccentricity") do |e|
+        movement_strategy[:eccentricity] = e
+      end
+      opts.on("--semi-latus-rectum [l]", "Elliptical movement strategy semi-latus-rectum") do |l|
+        movement_strategy[:semi_latus_rectum] = l
+      end
+      opts.on("--direction-major-x [x]", "Elliptical movement strategy major direction vector x coordinate") do |x|
+        movement_strategy[:direction_major_x] = x.to_f
+      end
+      opts.on("--direction-major-y [y]", "Elliptical movement strategy major direction vector y coordinate") do |y|
+        movement_strategy[:direction_major_y] = y.to_f
+      end
+      opts.on("--direction-major-z [z]", "Elliptical movement strategy major direction vector z coordinate") do |z|
+        movement_strategy[:direction_major_z] = z.to_f
+      end
+      opts.on("--direction-minor-x [x]", "Elliptical movement strategy minor direction vector x coordinate") do |x|
+        movement_strategy[:direction_minor_x] = x.to_f
+      end
+      opts.on("--direction-minor-y [y]", "Elliptical movement strategy minor direction vector y coordinate") do |y|
+        movement_strategy[:direction_minor_y] = y.to_f
+      end
+      opts.on("--direction-minor-z [z]", "Elliptical movement strategy minor direction vector z coordinate") do |z|
+        movement_strategy[:direction_minor_z] = z.to_f
+      end
+
+    end
+
+    # parse cmd line
+    begin
+      opts.parse!(ARGV)
+    rescue OptionParser::InvalidOption => e
+      puts opts
+      puts e.to_s
+      exit
+    end
+
+    if request_target.nil? || location[:id].nil? || schema_file.nil? #||
+       #request_target == :update && location[:x].nil? && location[:y].nil? && location[:z].nil? && location[:parent_id].nil?
+         puts opts
+         puts "must specify schema, a command to perform, a location id, and other required options"
+         exit
+    end
+
+    lid = location[:id]
+    location = Motel::Location.new :id => location[:id],
+                                   :parent_id => location[:parent_id],
+                                   :x => location[:x],
+                                   :y => location[:y],
+                                   :z => location[:z]
+
+    unless movement_strategy_type.nil?
+      movement_strategy = movement_strategy_type.camelize.constantize.new movement_strategy
+      location.movement_strategy = movement_strategy
+    end
+
+    args = []
+    case(request_target)
+    when :get_location
+      args.push location.id
+    when :create_location
+      args.push location
+    when :update_location
+      args.push location
+    when :subscribe_to_location_movement
+      args.push location.id
+    when :subscribe_to_locations_proximity
+      args.push location.id, other_location_id
+    end
+
+    # FIXME need configurable amqp broker ip/port
+    client = Motel::Client.new :schema_file => schema_file
+    result = client.request request_target, *args
+
+    if request_target == :subscribe_to_location_movement
+      client.on_location_moved = lambda { |loc|
+         puts "location moved:"
+         puts "#{loc}"
+      }
+      client.join
+
+    elsif request_target == :subscribe_to_locations_proximity
+      client.on_locations_proximity = lambda { |loc1, loc2|
+         puts "locations proximity:"
+         puts "#{loc1}/#{loc2}"
+      }
+      client.join
+    end
+
+    puts "server returned #{result}"
+end
+
+main()

data/bin/motel-rage-client

@@ -0,0 +1,80 @@
+#!/usr/bin/ruby
+# A motel client using the Ruby Advanced Gaming Engine library to display location
+#
+# Flags: (see below)
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
+
+require 'rubygems'
+require 'optparse'
+require 'rage'
+require 'motel'
+
+include Motel
+include Motel::MovementStrategies
+
+
+######################
+
+def main()
+    # command line parameters
+    schema_file = nil
+    mesh_file   = nil
+    location_id = nil
+
+    # setup cmd line options
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: main.rb [command] [options]"
+
+      opts.on("-h", "--help", "Print this help message") do
+         puts opts
+         exit
+      end
+
+      opts.on("-s", "--schema [path]", "Motel Schema File") do |path|
+         schema_file = path
+      end
+
+      opts.on("-i", "--id [id]", "ID of location to display") do |id|
+         location_id = id
+      end
+
+      opts.on("-m", "--mesh [uri]", "Mesh to display at location") do |uri|
+         mesh_file = uri
+      end
+    end
+
+    # parse cmd line
+    begin
+      opts.parse!(ARGV)
+    rescue OptionParser::InvalidOption => e
+      puts opts
+      puts e.to_s
+      exit
+    end
+
+    if schema_file.nil? || mesh_file.nil? || location_id.nil?
+      puts "must specify motel schema, location id, and mesh to display"
+      puts opts
+      exit
+    end
+
+    mesh = resource :type => :mesh, :uri => mesh_file
+
+    client = Motel::Client.new :schema_file => schema_file
+    result = client.request :subscribe_to_location_movement, location_id
+    client.on_location_moved = lambda { |loc, d, dx, dy, dz|
+      mesh.show_at :x => loc.x, :y => loc.y, :z => loc.z
+    }
+
+    window(:width => 512, :height => 512) { |win|
+       win.create_viewport
+    }.show
+
+    game.run
+
+    #client.join
+end
+
+main()

data/bin/{server/main.rb → motel-server}

@@ -10,9 +10,6 @@
 # Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
 # Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
 
-CURRENT_DIR=File.dirname(__FILE__)
-$: << File.expand_path(CURRENT_DIR + "/../../lib")
-
 require 'rubygems'
 require 'optparse'
 require 'motel'

data/conf/motel-schema.xml

@@ -38,7 +38,7 @@
     <member name="parent_id" type="int" desc="location id of parent, null if this is a root location" ignore_null="true" />
     <member name="parent"    type="obj" associated="Location" desc="parent location"/>
     <member name="children"  type="array" associated="Location" desc="children locations"/>
-    <member name="movement_strategy" type="obj" desc="associated movement strategy"/>
+    <member name="movement_strategy" type="obj" default="" desc="associated movement strategy"/>
     <member name="entity_id" type="int" desc="id of entity represented by this location" />
     <member name="entity_type" type="str" desc="type of entity represented by this location" />
   </class>
@@ -48,9 +48,9 @@
     <return_value name="location" type="obj" associated="Location" desc="Location corresponding to id or nil"/>
   </method>
 
-  <method name="create_location" desc="create new location w/ specified id">
-    <param name="location_id" type="int" desc="Location identifier"/>
-    <return_value name="success" type="bool" desc="bool success"/>
+  <method name="create_location" desc="create new location">
+    <param name="location" type="obj" associated="Location" desc="Location to create"/>
+    <return_value name="location" type="obj" associated="Location" desc="Location create or nil"/>
   </method>
 
   <method name="update_location" desc="update running location w/ new location sharing the same id">
@@ -60,13 +60,38 @@
 
   <!-- TODO delete_location -->
 
-  <method name="subscribe_to_location" desc="subscribe simrpc endpoint to updates to location of the specified id via the location_moved method">
+  <method name="subscribe_to_location_movement" desc="subscribe simrpc endpoint to location movement updates">
+    <param name="node_id" type="str" desc="Node identifier which to update of location movements"/>
     <param name="location_id" type="int" desc="Location identifier"/>
+    <param name="min_distance" type="float" default="0" desc="Min distance the location needs to have moved before notifying node"/>
+    <param name="min_x" type="float" default="0" desc="Min x-axis-distance the location needs to have moved before notifying node"/>
+    <param name="min_y" type="float" default="0" desc="Min y-axis-distance the location needs to have moved before notifying node"/>
+    <param name="min_z" type="float" default="0" desc="Min z-axis-distance the location needs to have moved before notifying node"/>
+    <return_value name="success" type="bool" desc="bool success"/>
+  </method>
+
+  <method name="subscribe_to_locations_proximity" desc="subscribe simrpc endpoint to location proximity events">
     <param name="node_id" type="str" desc="Node identifier which to update of location movements"/>
+    <param name="location_id1" type="int" desc="First location identifier"/>
+    <param name="location_id2" type="int" desc="Second location identifier"/>
+    <param name="event"        type="str" default="proximity" desc="Proximity event to subscribe to, should be proximity, entered_proxity, or left_proximity" />
+    <param name="max_distance" type="float" default="0" desc="Max distance the locations need to be apart before notifying node"/>
+    <param name="max_x" type="float" default="0" desc="Max x-axis-distance the locations need to be apart before notifying node"/>
+    <param name="max_y" type="float" default="0" desc="Max y-axis-distance the locations need to be apart before notifying node"/>
+    <param name="max_z" type="float" default="0" desc="Max z-axis-distance the locations need to be apart before notifying node"/>
     <return_value name="success" type="bool" desc="bool success"/>
   </method>
 
   <method name="location_moved" desc="inform simrpc endpoint that location was moved">
     <param name="location" type="obj" associated="Location" desc="Location that was moved with new coordinates and original id"/>
+    <param name="distance" type="float" desc="Total distance location moved"/>
+    <param name="x_distance" type="float" desc="Distance location moved along the x axis"/>
+    <param name="y_distance" type="float" desc="Distance location moved along the y axis"/>
+    <param name="z_distance" type="float" desc="Distance location moved along the z axis"/>
+  </method>
+
+  <method name="locations_proximity" desc="inform simrpc endpoint of location proximity event">
+    <param name="location1" type="obj" associated="Location" desc="First location in proximity"/>
+    <param name="location2" type="obj" associated="Location" desc="Second location in proximity"/>
   </method>
 </schema>

data/lib/motel.rb

@@ -4,10 +4,12 @@
 # Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
 
 lib = File.dirname(__FILE__)
+$: << lib + '/motel/'
 
 require lib + '/motel/exceptions'
+require lib + '/motel/callbacks'
 require lib + '/motel/runner'
-require lib + '/motel/simrpc'
+require lib + '/motel/simrpc_adapter'
 
 require lib + '/motel/dsl'
 

data/lib/motel/callbacks.rb

@@ -0,0 +1,139 @@
+# Motel callback definitions
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
+
+require 'motel/common'
+require 'motel/location'
+
+module Motel
+
+module Callbacks
+
+# TODO implement callbacks via callback conditions, optional conditions
+# which may be added to a callback which all or some must be true to
+# invoke callback (eg min movement, max proximity, min time passed, etc)
+
+# Base Motel callback interface, provides access to invocable handler
+class Base
+  # Accessor which will be invoked upon callback event
+  attr_accessor :handler
+
+  def initialize(args = {}, &block)
+    @handler = args[:handler] if args.has_key?(:handler)
+    @handler = block if block_given?
+  end
+
+  # FIXME XXX this should be *args instead of args = [] (remove [] around super calls below)
+  def invoke(args = [])
+    handler.call *args
+  end
+
+end
+
+# Invoked upon specified minimum location movement
+class Movement < Base
+  # Minimum distance the location needs to move to trigger event
+  attr_accessor :min_distance
+
+  # Minimum x,y,z distance the location needs to move to trigger the event
+  attr_accessor :min_x, :min_y, :min_z
+
+  def initialize(args = {}, &block)
+    @min_distance = 0
+    @min_x = 0
+    @min_y = 0
+    @min_z = 0
+
+    @min_distance = args[:min_distance] if args.has_key?(:min_distance)
+    @min_x = args[:min_x] if args.has_key?(:min_x)
+    @min_y = args[:min_y] if args.has_key?(:min_y)
+    @min_z = args[:min_z] if args.has_key?(:min_z)
+
+    # store original coordinates internally,
+    # until minimum distances are satified
+    # and callback is invoked, then clear
+    @orig_x = @orig_y = @orig_z = nil
+
+    super(args, &block)
+  end
+
+  # Calculate distance between location and old coordinates, invoke handler w/ location if minimums are true
+  def invoke(new_location, old_x, old_y, old_z)
+     # unless original coordinates is nil, ignore old coordinates passed in
+     if @orig_x.nil?
+       @orig_x = old_x
+       @orig_y = old_y
+       @orig_z = old_z
+     end
+
+     dx = new_location.x - @orig_x
+     dy = new_location.y - @orig_y
+     dz = new_location.z - @orig_z
+     d  = Math.sqrt(dx ** 2 + dy ** 2 + dz ** 2)
+
+     if d >= @min_distance && dx.abs >= @min_x && dy.abs >= @min_y && dz.abs >= @min_z
+       super([new_location, d, dx, dy, dz])
+       @orig_x = @orig_y = @orig_z = nil
+     end
+  end
+end # class Movement
+
+# Invoked upon specified maximum distance between locations
+class Proximity < Base
+  # location which to compare to
+  attr_accessor :to_location
+
+  # proximity event which to trigger on
+  attr_accessor :event
+
+  # Max distance the locations needs to be apart to trigger event
+  attr_accessor :max_distance
+
+  # Max x,y,z distance the locations need to be to trigger the event
+  attr_accessor :max_x, :max_y, :max_z
+
+  def initialize(args = {}, &block)
+    @max_distance = 0
+    @max_x = 0
+    @max_y = 0
+    @max_z = 0
+    @to_location = nil
+    @event = :proximity
+
+    @max_distance = args[:max_distance] if args.has_key?(:max_distance)
+    @max_x = args[:max_x] if args.has_key?(:max_x)
+    @max_y = args[:max_y] if args.has_key?(:max_y)
+    @max_z = args[:max_z] if args.has_key?(:max_z)
+    @to_location = args[:to_location] if args.has_key?(:to_location)
+    @event = args[:event].intern if args.has_key?(:event)
+
+    # keep track of proximity state internally for different event types
+    @locations_in_proximity = false
+
+    super(args, &block)
+  end
+
+  # Calculate distance between specified location and stored one,
+  # invoke handler w/ specified location if they are within proximity
+  def invoke(location)
+     dx = (location.x - to_location.x).abs
+     dy = (location.y - to_location.y).abs
+     dz = (location.z - to_location.z).abs
+     d  = Math.sqrt(dx ** 2 + dy ** 2 + dz ** 2)
+
+     currently_in_proximity  = (d <= @max_distance) || (dx <= @max_x && dy <= @max_y && dz <= @max_z)
+     trigger_callback = (currently_in_proximity &&  (@event == :proximity ||
+                                                    (@event == :entered_proximity &&
+                                                     !@locations_in_proximity))) ||
+                        (!currently_in_proximity && (@event == :left_proximity &&
+                                                     @locations_in_proximity))
+
+     @locations_in_proximity = currently_in_proximity
+
+     super([location, to_location]) if trigger_callback
+  end
+end # class Proximity
+
+end # module Callbacks
+end # module Motel