shattered_support 0.3

data/lib/actor.rb

@@ -0,0 +1,40 @@
+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

data/lib/base.rb

@@ -0,0 +1,198 @@
+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
+        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

data/lib/runner.rb

@@ -0,0 +1,14 @@
+module ShatteredSupport
+  class Configuration
+    def self.environment
+      begin
+        return @@environment
+      rescue NameError
+        return {}
+      end
+    end
+    def self.environment=(environment)
+      @@environment=environment
+    end
+  end
+end

data/lib/shattered_support.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'active_support'
+
+class Object
+  def method_defined?(method)
+    return self.class.method_defined?(method)
+  end
+end
+
+require File.dirname(__FILE__)+"/base"
+require File.dirname(__FILE__)+"/actor"
+require File.dirname(__FILE__)+"/runner"

metadata

@@ -0,0 +1,40 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: shattered_support
+version: !ruby/object:Gem::Version 
+  version: "0.3"
+date: 2006-04-23
+summary: "Shattered Support:  Allows a common derivation point for shattered MVC."
+require_paths: 
+  - lib
+email: 
+homepage: http://www.hastilymade.com
+rubyforge_project: 
+description: Shattered Support is the base for Shattered MVC.
+autorequire: shattered_support
+default_executable: 
+bindir: bin
+has_rdoc: "true"
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: []
+files: 
+  - lib/actor.rb
+  - lib/base.rb
+  - lib/runner.rb
+  - lib/shattered_support.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: 
+  - Shattered Support is a base for the rest of shattered.
+dependencies: []