shattered_support 0.3 → 0.3.1

data/lib/base.rb

@@ -1,198 +1,168 @@
-module ShatteredSupport
-  
-  BEFORE_INIT_CALL_VALUES = :before_init_call_values
-  BEFORE_INIT_SET_VALUES = :before_init_set_values
-
-
-  def self.append_features(base)
-    super
-    base.extend(ClassMethods)
-  end
-  module ClassMethods
-    # An actor is the MVC encapsulated into one object.
-    # With actors, you can send requests to each of the model, view and control
-    # objects, and even retrieve results from the MVC objects.
-    #
-    # Here is how it works:  You specify a actor in a game state with some starting
-    # attributes:
-    # 
-    #   actor :napolean, :mood => 'snobbish'
-    #
-    # The options are the same as the camera options, except they propogate through
-    # the MVC object(as all commands do).
-    #
-    # When obtaining a result, the result will be the a response in the following order
-    # - Model
-    # - View
-    # - Controller
-    #
-    # They are sorted so that you get the most useful response first.
-    def actor( name, options = {} )
-      before_init_call( :actor, name, options )
-    end
-    
-    def before_init_set(variable, options={})
-      self.write_inheritable_array(BEFORE_INIT_SET_VALUES, [[ variable, options ]] )
-    end
-    
-    def before_init_call(function, *arguments)
-      self.write_inheritable_array(BEFORE_INIT_CALL_VALUES, [[function, [*arguments]]])
-    end
-  end
-  class Base
-    attr_writer :actor
-    def self.new(*options)
-      new_base = allocate
-      new_base.pre_initialize
-      new_base.send(:initialize, *options)
-      return new_base
-    end
-    def state
-      Configuration.environment[:state]
-    end
-    def pre_initialize
-      pre_initialize_set
-      pre_initialize_call
-    end
-    
-    def each_init_value(name)
-      startup_attributes = self.class.read_inheritable_attribute( name ) || []
-      startup_attributes.each do |actor, options|
-        next if options.nil?
-        yield actor, options
-      end
-    end
-    
-    def pre_initialize_set
-      each_init_value(BEFORE_INIT_SET_VALUES) do |variable, options|
-        call_object_function_for_each_key( variable, options )  
-      end
-#      self.class.write_inheritable_attribute(BEFORE_INIT_SET_VALUES, nil)
-    end
-    
-    def pre_initialize_call
-        each_init_value(BEFORE_INIT_CALL_VALUES) do |function, args|
-          call_object_function( :self, function, args )  
-        end
-#      self.class.write_inheritable_attribute(BEFORE_INIT_CALL_VALUES, nil)
-    end
-  
-    def actors
-      return @actors || []
-    end
-    
-    # There are two uses for the instance class actor function:
-    #  The first is to access the actor that the base object is a part of.
-    #  The second is to create a new actor with the same arguments
-    #   ShatteredSupport::Base.actor 
-    def actor(*args)
-      return @actor if args.length == 0
-      
-      name, options = args
-      actor_options={}
-      ['model', 'view', 'controller'].each do |type|
-        begin
-          require "#{SHATTERED_ROOT}/app/#{type.pluralize}/#{name}_#{type}"
-          class_name = "#{name.to_s.camelize}#{type.camelize}"
-          actor_options[type.to_sym] = eval(class_name).new	
-        rescue MissingSourceFile
-        end
-      end
-      actor_options[:testing] = options.delete(:testing)
-      actor = Actor.new(name,actor_options)
-      
-      attr_reader(name.to_sym, actor)
-      call_object_function_for_each_key( name.to_sym, options )
-      
-      options[:testing] = actor_options[:testing] if !actor_options[:testing].nil?
-      
-      @actors ||= []
-      @actors << actor
-    end
-    
-    # Overwrite this function to recieve an update event every frame, with the
-    # seconds elapsed since last update.
-    def update_event(time_elapsed)
-      actors.each do |actor|
-        actor.update_actors(time_elapsed)
-        actor.update(time_elapsed)
-      end
-    end
-    
-    # remove_from_scene? should just be defined in model.
-    # Refactor?
-    def remove_from_scene?
-      return false
-    end
-    
-    def update_actors(time_elapsed)
-      update_event time_elapsed
-      remove_dead_actors
-    end
-    
-    def update(time_elapsed)
-    end
-  
-    def remove_dead_actors
-      actors.each do |actor|
-        remove_from_scene actor if actor.remove_from_scene?
-      end
-    end  
-
-    def remove_from_scene(actor)
-      actors.delete actor
-      actor.unload!
-    end
-
-    protected
-    def call_object_function_for_each_key( actor, options )
-      call_object_function(actor, :position=, options.delete(:position)) if options.has_key? :position
-      options.each_pair do |action, params|
-        call_object_function actor, "#{action}=", params
-      end
-    end
-    def call_object_function(actor, action, params)
-      begin
-        if params.is_a? Symbol #|| (params.length == 1 && params[0].is_a?(Symbol)) this will allow substitution in before_init_call. This may not be intended behavior.
-          params = eval(params.to_s) 
-        end
-      rescue NameError
+
+$:.unshift(File.dirname(__FILE__)) unless
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+  
+require 'timer/timer'
+require 'vector'
+
+module ShatteredSupport
+  
+  BEFORE_INIT_CALL_VALUES = :before_init_call_values
+  BEFORE_INIT_SET_VALUES = :before_init_set_values
+
+
+  def self.append_features(base)
+    super
+    base.extend(ClassMethods)
+  end
+  module ClassMethods 
+    def before_init_set(variable, options={})
+      self.write_inheritable_array(BEFORE_INIT_SET_VALUES, [[ variable, options ]] )
+    end
+    
+    def before_init_call(function, *arguments)
+      self.write_inheritable_array(BEFORE_INIT_CALL_VALUES, [[function, [*arguments]]])
+    end
+  end
+  class Base
+    def self.new(*options)
+      new_base = allocate
+      new_base.pre_initialize
+      new_base.send(:initialize, *options)
+      return new_base
+    end
+    def state
+      Configuration.environment[:state]
+    end
+    def pre_initialize
+      pre_initialize_set
+      pre_initialize_call
+    end
+    
+    def each_init_value(name)
+      startup_attributes = self.class.read_inheritable_attribute( name ) || []
+      startup_attributes.each do |actor, options|
+        next if options.nil?
+        yield actor, options
+      end
+    end
+    
+    def pre_initialize_set
+      each_init_value(BEFORE_INIT_SET_VALUES) do |variable, options|
+        call_object_function_for_each_key( variable, options )  
+      end
+#      self.class.write_inheritable_attribute(BEFORE_INIT_SET_VALUES, nil)
+    end
+    
+    def pre_initialize_call
+        each_init_value(BEFORE_INIT_CALL_VALUES) do |function, args|
+          call_object_function( :self, function, args )  
+        end
+#      self.class.write_inheritable_attribute(BEFORE_INIT_CALL_VALUES, nil)
+    end
+
+    
+    # Overwrite this function to recieve an update event every frame, with the
+    # seconds elapsed since last update.
+    def update_event(time_elapsed)
+      actors.each do |actor|
+        actor.update_actors(time_elapsed)
+        actor.update(time_elapsed)
+      end
+    end
+    
+    # remove_from_scene? should just be defined in model.
+    # Refactor?
+    def remove_from_scene?
+      return false
+    end
+    
+    def update_actors(time_elapsed)
+      update_event time_elapsed
+      remove_dead_actors
+    end
+    
+    def update(time_elapsed)
+    end
+  
+    def remove_dead_actors
+      actors.each do |actor|
+        remove_from_scene actor if actor.remove_from_scene?
+      end
+    end  
+
+    def remove_from_scene(actor)
+      actors.delete actor
+      actor.unload!
+    end
+
+    protected
+    def call_object_function_for_each_key( actor, options )
+      call_object_function(actor, :position=, options.delete(:position)) if options.has_key? :position
+      options.each_pair do |action, params|
+        call_object_function actor, "#{action}=", params
+      end
+    end
+    def call_object_function(actor, action, params)
+      begin
+        if params.is_a? Symbol #|| (params.length == 1 && params[0].is_a?(Symbol)) this will allow substitution in before_init_call. This may not be intended behavior.
+          params = eval(params.to_s) 
+        end
+      rescue NameError
         puts "It is not advisable to pass #{params.inspect} to #{action.inspect} for #{actor.inspect}."
         puts "  It will try to be evaluated.  Use a string instead."
-      end
-      begin
-        eval(actor.to_s).send( action.to_sym, *params )
-      rescue NoMethodError => bang
-        raise NoMethodError, "Error upon method #{action} for #{actor} of type #{eval(actor.to_s).class}:   #{bang.message}"
-      end
-    end
-    def unload!
-    end
-    
-    public
-    
-    # attr helpers.  This defines instance level attr_* functions.
-    def attr_reader(*args)
-      name, value = args
-      attr_define(:reader, name, value)
-    end
-    
-    def attr_writer(*args)
-      name, value = args
-      attr_define(:reader, name, value)
-    end
-    
-    def attr_accessor(*args)
-      name, value = args
-      attr_define(:accessor, name, value)
-    end
-    
-    protected
-    
-    def attr_define(accessor_level, name, value)
-      self.class.send(:"attr_#{accessor_level}", :"#{name}")
-      instance_variable_set(:"@#{name}", value) if !value.nil?
-    end
-    
-  end
-end
+      end
+      begin
+        sendee = eval(actor.to_s)
+        sendee.send( action.to_sym, *params )
+      rescue NoMethodError, ArgumentError => bang
+        message="Error upon #{actor.to_s}.send(#{action.to_sym.inspect}, #{params.inspect}):\n\r  #{bang.class}: #{bang.message}"
+        bang = ShatteredSupport::RetossError.new(bang,message)
+        raise bang
+      end
+    end
+    def unload!
+    end
+    
+    public
+    
+    # attr helpers.  This defines instance level attr_* functions.
+    def attr_reader(*args)
+      name, value = args
+      attr_define(:reader, name, value)
+    end
+    
+    def attr_writer(*args)
+      name, value = args
+      attr_define(:writer, name, value)
+    end
+    
+    def attr_accessor(*args)
+      name, value = args
+      attr_define(:accessor, name, value)
+    end
+    
+    protected
+    
+    def attr_define(accessor_level, name, value)
+      self.class.send(:"attr_#{accessor_level}", :"#{name}")
+      instance_variable_set(:"@#{name}", value) if !value.nil?
+    end
+    
+  end
+  
+  class Error < StandardError
+  end
+  
+  class RetossError < StandardError
+    attr_accessor :message 
+    def initialize(error, message)
+      self.message = message
+      set_backtrace error.backtrace
+    end
+  end
+end
+
+ShatteredSupport::Base.class_eval do
+	include ShatteredSupport::Timer
+end

data/lib/shattered_support.rb

@@ -5,8 +5,58 @@ class Object
   def method_defined?(method)
     return self.class.method_defined?(method)
   end
+  
+  def v(x, y, z) 
+    Vector.new(x, y, z) 
+  end
+end
+
+class File
+  # File.each_in_path will recursively look for all files, starting at the given path.
+  # It will yield with each result.
+  def self.each_in_path(path)
+    Dir.each_in_path(path) do |directory|
+      Dir.foreach( directory ) do |filename|
+        resource = directory + "/#{filename}"
+        yield(resource) if File.file? resource
+      end
+    end
+  end
+  
+  # This finds all files in paths (an array or string) matching the given extensions:
+  #
+  # Usage:
+  #   -File.find_by_extensions(SHATTERED_ROOT,"ogg","mp3","wav")
+  #   -File.find_by_extension(["apps","media","plugins"], "rmaterial")
+  def self.find_by_extensions(paths, *extensions)
+    paths = [paths] if paths.is_a? String
+    extensions.collect! { |ext| ext[0].chr == "." ? ext[1..-1] : ext } # get rid of "." in ".ogg"
+    reg_exp = /\.(#{extensions.join("|")})$/
+    files = []
+    paths.each do |path|
+      each_in_path(path) do |filename|
+        files << filename if filename =~ reg_exp
+      end
+    end
+    return files
+  end
+  # See File#find_by_extensions
+  def self.find_by_extension(paths, extension)
+    find_by_extensions(paths, extension)
+  end
+end
+
+class Dir
+  # Dir.each_in_path will recursively yield all non-hidden directories from the given path.
+  def self.each_in_path(path, &block)
+    return unless File.directory? path
+    yield path
+    foreach(path) do |directory|
+      next if directory =~ /\..*/
+      each_in_path("#{path}/#{directory}", &block)
+    end
+  end
 end
 
 require File.dirname(__FILE__)+"/base"
-require File.dirname(__FILE__)+"/actor"
 require File.dirname(__FILE__)+"/runner"

data/lib/timer/timed_event.rb

@@ -0,0 +1,77 @@
+module ShatteredSupport
+  module Timer
+    
+    class Timer
+      attr_reader :events_remaining
+      def initialize
+        @events_remaining = []
+      end
+      def in(seconds, &block)
+        @events_remaining << TimedEvent.new(seconds, &block)
+      end
+      def every(seconds, &block)
+        @events_remaining << ContinuousTimedEvent.new(seconds,&block)
+      end
+      def update(time_elapsed)
+        events_for_update = @events_remaining.dup
+        events_for_update.each do |event|
+          event.update(time_elapsed)
+          @events_remaining.delete(event) if event.processed?
+        end
+      end
+    end
+
+    class TimedEvent
+      attr_accessor :time_remaining
+      def initialize(seconds, &block)
+        @event = block
+        if(seconds != :frame)
+          @time_remaining = seconds
+          @initial_time = @time_remaining
+        else
+          @time_remaining = 0
+          @initial_time = 0
+        end
+      end
+      def update(time_elapsed)
+        return if processed?
+        @time_remaining -= time_elapsed
+        if time_up?
+          process_event
+          @processed=true
+        end
+      end
+      def processed?
+        return @processed == true
+      end
+      def reset
+        @time_remaining = @initial_time
+      end
+      private
+      def process_event
+        @event.call(@initial_time - @time_remaining)
+      end
+      def time_up?
+        return @time_remaining <= 0
+      end
+    end
+
+    class ContinuousTimedEvent < TimedEvent
+      def update(time_elapsed)
+        @time_remaining -= time_elapsed
+        if(time_up?)
+          process_event
+          reset
+        end
+      end
+      def reset
+        @time_remaining += @initial_time
+        @time_remaining = 0 if @time_remaining < 0
+      end
+      def processed?
+        false
+      end
+    end
+
+  end
+end

data/lib/timer/timer.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__)+'/timed_event'
+
+module ShatteredSupport
+  module Timer
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+    end
+    module ClassMethods
+      # Timers are controller events that occur after a specified period of time.
+      # The time values are seconds by default.
+      #
+      # timer :in
+      #  If you want an event to occur once after a specified amount of time, use
+      #     timer :in => 3.seconds, :action => :method_to_call
+      #
+      # timer :every
+      #  If you want an event to occur once every specified amount of time, use
+      #     timer :every => 3.seconds, :action => :method_to_call
+      #  If you want to be notified of every frame update, use
+      #     timer :every => :frame, :action => :method_to_call
+      #
+      # Inside the instance, you can still create timer events, using the timer object:
+      #    timer.in( 3.seconds ) { ... }
+      #    timer.every( 3.seconds ) { ... }
+      def timer(options = {})
+        if options[:action].nil?
+          throw ShatteredSupport::Error, 
+            "Timer event must specify an :action => :method" 
+        end
+        if options[:in].nil? && options[:every].nil?
+          throw ShatteredSupport::Error,
+            "Timer event must specify a time.  (timer :in or timer :every)"
+        end
+        time = options[:in] || options[:every]
+        action = options[:action]
+        before_init_call(:timer_in, time, action) unless options[:in].nil?
+        before_init_call(:timer_every, time, action) unless options[:every].nil?
+      end
+    end
+    module InstanceMethods
+      def timer
+        @timer ||= Timer.new
+      end
+      private
+        def timer_in(time, action)
+          timer.in(time) do |time_elapsed| 
+            timer_enactment(action, time_elapsed)
+          end
+        end
+        def timer_every(time, action)
+          timer.every(time) do |time_elapsed|
+            timer_enactment(action, time_elapsed)
+          end
+        end
+        def timer_enactment(action, time_elapsed)
+            begin
+              send(action.to_sym)
+            rescue ArgumentError => argument_error
+              raise argument_error unless argument_error.message.to_sym == :"wrong number of arguments (0 for 1)"
+              send(action.to_sym,time_elapsed)
+            end
+        end
+    end
+  end
+end

data/lib/vector.rb

@@ -0,0 +1,172 @@
+
+class Array
+  # Vector extensions for array.  Allows for coersion of a 3 element Array into a vector.
+  
+  # Randomize the order of an array
+  #
+  #   [1, 2, 3].shuffle #=> [2, 3, 1]
+  #
+  def shuffle
+    sort_by {rand}
+  end
+  
+  # Create a vector from an array.
+  #
+  #   [1, 2, 3].to_v #=> same as Vector.new(1, 2, 3)
+  #
+  def to_v
+    raise StandardError, "vector #{self.inspect} does not have 3 elements" if self.length < 3
+    Vector.new self[0], self[1] ,self[2]
+  end
+  
+  # Returns this Array as an Ogre vector object: Vector3.  Should only be used internally by
+  # Shattered to communicate with the Ogre engine.
+  def to_v3
+    self.to_v.to_v3
+  end
+end
+  
+module ShatteredSupport
+  class Vector
+    
+    attr_reader :x, :y, :z
+    
+    # Create a new Vector object.  It requires exactly 3 arguments: x, y and z.
+    def initialize(x_val, y_val, z_val)
+      @x, @y, @z = x_val.to_f, y_val.to_f, z_val.to_f
+    end
+    
+    # Iterate through x, y and z with a black.  The passed value is the value of the component.
+    def each(&block)
+      self.to_a.each do |item|
+        yield item
+      end
+    end
+    
+    # Returns this Vector as an Ogre vector object: Vector3.  Should only be used internally by
+    # Shattered to communicate with the Ogre engine.
+    def to_v3
+      ShatteredOgre::Vector3.new @x, @y, @z
+    end
+    
+    # Returns self
+    def to_v
+      self
+    end
+    
+    # Returns an array with x, y and z dumped into its elements
+    #
+    #   Vector.new(1, 2, 3).to_a #=> [1, 2, 3]
+    def to_a
+      [@x, @y, @z]
+    end
+    
+    # Add 2 Vectors together.
+    def +(*args)
+      vector = convert_args_to_vector(args)
+      Vector.new(
+        self.x + vector.x,
+        self.y + vector.y,
+        self.z + vector.z
+      )
+    end
+    
+    # Subtract one Vector form another.
+    def -(args)
+      vector = convert_args_to_vector(args)
+      Vector.new(
+        self.x - vector.x,
+        self.y - vector.y,
+        self.z - vector.z
+      )
+    end
+    
+    # Multiply all components of a vector by a scalar amount.
+    def *(value)
+      result = []
+      each do |i|
+        result << i * value
+      end
+      result.to_v
+    end
+    
+    # Divide all components of a vector by a scalar amount
+    def /(value)
+      result = Array.new
+      self.each do |i|
+        result << i/value.to_f
+      end
+      result.to_v
+    end
+    
+    # Returns this Vector but normalized to a length of 1.
+    def normalize
+      self * (1 / length)
+    end
+    alias_method :normalise, :normalize
+    
+    # Same as #normalize but is destructive.
+    def normalize!
+      @x, @y, @z = normalize.to_a
+    end
+    alias_method :normalise!, :normalize!
+    
+    # Return the value specified by bracket notation.
+    def [](index)
+      case
+        when index == 0 || index == :x || index == 'x'
+          @x
+        when index == 1 || index == :y || index == 'y'
+          @y
+        when index == 2 || index == :z || index == 'z'
+          @z
+      end
+    end
+    
+    # Set the value specified by bracket notation.
+    def []=(index, value)
+      case
+        when index == 0 || index == :x || index == 'x'
+          @x = value.to_f
+        when index == 1 || index == :y || index == 'y'
+          @y = value.to_f
+        when index == 2 || index == :z || index == 'z'
+          @z = value.to_f
+      end
+    end
+    
+    def x=(value)
+      @x = value.to_f
+    end
+    
+    def y=(value)
+      @y = value.to_f
+    end
+    
+    def z=(value)
+      @z = value.to_f
+    end
+    
+    
+    # Returns the length of this vector.
+    def length
+      Math.sqrt(x**2 + y**2 + z**2)
+    end
+    
+    def to_s
+      "#<Vector [#@x, #@y, #@z]>"
+    end
+    
+  private
+    
+    def convert_args_to_vector(*args)
+      args.flatten!
+      if args.first.is_a? Vector
+        args.first
+      else
+        args.to_v
+      end
+    end
+    
+  end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: shattered_support
 version: !ruby/object:Gem::Version 
-  version: "0.3"
-date: 2006-04-23
+  version: 0.3.1
+date: 2006-05-16
 summary: "Shattered Support:  Allows a common derivation point for shattered MVC."
 require_paths: 
   - lib
@@ -26,10 +26,12 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 authors: []
 files: 
-  - lib/actor.rb
   - lib/base.rb
   - lib/runner.rb
   - lib/shattered_support.rb
+  - lib/vector.rb
+  - lib/timer/timed_event.rb
+  - lib/timer/timer.rb
 test_files: []
 rdoc_options: []
 extra_rdoc_files: []

data/lib/actor.rb

@@ -1,40 +0,0 @@
-module ShatteredSupport
-  # An actor is a delegator to a model view control game object.
-  class Actor
-    attr_accessor :view, :model, :controller
-    def initialize( name, options = {} )
-      @actor_name = name
-      @view = options[:view]
-      @model = options[:model]
-      @controller = options[:controller]
-
-      [@view,@model,@controller].each do |component| 
-        component.actor = self if not component.nil?
-      end
-      
-      if @view.nil? and @model.nil? and @controller.nil? and not options[:testing]
-        raise NameError, "No model view or controller found for actor #{name}" 
-      end
-    end
-    # Whenever an function is called on the actor, it will call that function on it's
-    # respective model, view, and control objects.
-    def method_missing(name, *args)
-      retv=nil
-      called=false
-      [@controller, @view, @model].each do |callee|
-        if(callee.method_defined? name)
-          retv = callee.send(name,*args) 
-          called = true
-        end
-      end
-      raise NoMethodError, "Could not find method #{name} for actor #{@actor_name}" if !called
-      return retv
-    end
-    # The actor should not normally know of the functions used in it's mvc components.
-    # is this incorrect behaviour?
-    def update_input(time_elapsed, input)
-      return if @controller.nil?
-      @controller.update_input(time_elapsed, input)
-    end
-  end
-end