shattered_controller 0.3 → 0.3.1

data/lib/actor/actor.rb

@@ -0,0 +1,91 @@
+module ShatteredController
+  module Actor
+	  def self.append_features(base)
+	    super
+	    base.extend(ClassMethods)
+	    base.send(:include, InstanceMethods)
+	  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
+
+   end
+   module InstanceMethods
+     
+     def actors
+       return @actors || []
+     end
+
+     # Used by Base#actor
+     def actor(name=nil, options={})
+       raise Error, "actor needs a name" if name.nil?
+       actor = Actor.new(name,load_actor_classes(name))
+
+       attr_reader(name.to_sym, actor)
+       call_object_function_for_each_key( name.to_sym, options )
+
+       @actors ||= []
+       @actors << actor
+     end
+     
+     private
+     
+     def load_actor_classes(name)
+      actor_options={}
+      ['model', 'view', 'controller'].each do |type|
+        evaled_class = nil
+        begin
+          evaled_class = eval("#{name.to_s.camelize}#{type.camelize}")
+        rescue NameError
+          next
+        end
+        actor_options[type.to_sym] = evaled_class.new 
+      end
+      raise Error, "No Model, View, or Control defined for Actor #{name}." if actor_options == {}
+      return actor_options
+     end
+     
+   end
+
+   # An actor is a delegator to a controller game object.
+   class Actor
+     attr_reader :controller
+     def initialize( name, options = {} )
+       @actor_name = name
+       @controller = (options[:controller] || ShatteredController::Base.new)
+       @controller.model = options[:model]
+       @controller.view = options[:view]
+       @controller.view.model = options[:model] unless @controller.view.nil?
+
+       if options[:view].nil? && options[:model].nil? && @controller.nil? && !options[:testing]
+         raise NameError, "No model view or controller found for actor #{name}" 
+       end
+     end
+
+     # Delegate to controller
+     def method_missing(name, *args, &block)
+       @controller.send(name, *args, &block)
+     end
+   end
+ end
+end

data/lib/base.rb

@@ -4,13 +4,41 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
   
 require 'keyboard_input/keyboard_input'
+require 'actor/actor'
 
 module ShatteredController
+	
 	class Base < ShatteredSupport::Base
+	  attr_accessor :model, :view
+
+	  # Controller delegates all unknown methods to the view and model.
+	  def method_missing(method_name, *args, &block)
+	    raise_no_method_error = true
+	    result = nil
+	    [view, model].each do |delegate|
+	      if delegate.method_defined?(method_name)
+	        result = delegate.send(method_name, *args, &block) 
+	        raise_no_method_error = false
+        end
+	    end
+	    raise NoMethodError, "Model, View, and Controller have no method defined named '#{method_name}'" if raise_no_method_error
+	    return result
+	  end
+    
+    
+    def update_timer(time_elapsed)
+      timer.update(time_elapsed)
+      model.timer.update(time_elapsed)
+      view.timer.update(time_elapsed)
 unless view.nil?
+    end
 	end
+	
+	class Error < StandardError
+  end
 end
 
 ShatteredController::Base.class_eval do
 	include ShatteredController::KeyboardInput
+	include ShatteredController::Actor
 end
 

data/lib/keyboard_input/{input.rb → key_converter.rb}

@@ -1,7 +1,7 @@
 module ShatteredController
 # This is a wrapper around Ogre's input listener.
 # It allows us to query the status of each device every frame.
-class Input
+class KeyConverter
 
   def initialize( ogre_input )
     @ogre_input = ogre_input

data/lib/keyboard_input/keyboard_input.rb

@@ -1,7 +1,7 @@
 $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-require 'input'
+require 'key_converter'
 
 module ShatteredController
   module KeyboardInput
@@ -36,6 +36,14 @@ module ShatteredController
 	  end
 	
 	  module InstanceMethods
+	    def pre_initialize
+	      # update our keyboard input
+	      timer.every(:frame) do |time_elapsed|
+	        update_input(time_elapsed, ShatteredController::Runner.environment[:input])
+        end
+	      super
+      end
+	    
 	    def key_types
 	      [:pressed, :released, :held]
 	    end
@@ -46,11 +54,11 @@ module ShatteredController
 	    def reaction_from(options)
 	      # Define the method to send the actions when the keys are pressed/clicked/released.
 	      key_types.each do |reaction|
-	        return [reaction, options[reaction],options[:action]] if !options[reaction].nil?
+	        return [reaction, options[reaction].to_sym, options[:action]] if !options[reaction].nil?
 	      end
-	      raise ArgumentError, "Reaction to key input must be pressed, released, or held. #{options.inspect}" if options[:reaction].nil?
+	      raise Error, "Reaction to key input must be pressed, released, or held. #{options.inspect}" if options[:reaction].nil?
 	    end
-	    # Todo: when we refactor before_init_set to not use ='s optionally, we need to allow non *args
+	    # See KeyboardInput::key
 	    def key(actions={})
 	      key_actions << reaction_from(actions)
 	    end
@@ -58,9 +66,9 @@ module ShatteredController
 	    # are defined.
 	    def key_action(reaction, action, time_elapsed)
 	      if reaction == :held
-	        actor.send(action, time_elapsed)
+	        send(action, time_elapsed)
 	      else
-	        actor.send(action)
+	        send(action)
 	      end
 	    end
 	    def key_actions
@@ -72,6 +80,7 @@ module ShatteredController
 	        key_action( reaction, action, time_elapsed ) if input.key_event?(reaction,key)
 	      end
 	    end
+	    
 	  end
 	end
 end

data/lib/runner.rb

@@ -5,14 +5,13 @@ module ShatteredController
   class Runner
     def initialize( options = {} )
       @@environment ||= options
-      @@environment[:input] = ShatteredController::Input.new(@@environment[:input])
+      @@environment[:input] = ShatteredController::KeyConverter.new(@@environment[:input])
     end
     #Every time this exits, a game dies.
     def start_game
       each_frame do |time_elapsed|
-        @@environment[:state].update_input(time_elapsed, @@environment[:input])
+        @@environment[:state].update_timers(time_elapsed)
         @@environment[:input].flush
-        @@environment[:state].update_actors time_elapsed
       end
     end
     def each_frame

data/lib/shattered_controller.rb

@@ -1,5 +1,4 @@
 begin
-#  require File.dirname(__FILE__)+"/../../shattered_support/lib/shattered_support"
   require 'shattered_support'
 rescue MissingSourceFile
   require 'rubygems'

data/lib/state.rb

@@ -35,7 +35,8 @@ module ShatteredController
       before_init_set( "self", { :"sky" => [type, options[:material]] })
     end
   end
-  class State < ShatteredSupport::Base      
+  class State < ShatteredController::Base      
+    
     def pre_initialize
       ShatteredSupport::Configuration.environment[:state] = self
       super
@@ -47,8 +48,11 @@ module ShatteredController
       call_object_function_for_each_key(:camera, args[0])
     end
     
-    def update_input(time_elapsed, input)
-      actors.each { |actor| actor.update_input(time_elapsed, input) }
+    # This is called every frame by the main game loop.  All update events are now
+    # run through Timers.
+    def update_timers(time_elapsed)
+      update_timer(time_elapsed)
+      actors.each { |actor| actor.update_timer(time_elapsed) }
     end
     
     def unload!

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: shattered_controller
 version: !ruby/object:Gem::Version 
-  version: "0.3"
-date: 2006-04-23
+  version: 0.3.1
+date: 2006-05-16
 summary: "Shattered Controller: Controls the game states and objects in Shattered."
 require_paths: 
   - lib
@@ -26,14 +26,14 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 authors: []
 files: 
-  - lib/auto_require.rb
   - lib/base.rb
   - lib/mock_camera.rb
   - lib/runner.rb
   - lib/shattered_controller.rb
   - lib/shattered_controller_tester.rb
   - lib/state.rb
-  - lib/keyboard_input/input.rb
+  - lib/actor/actor.rb
+  - lib/keyboard_input/key_converter.rb
   - lib/keyboard_input/keyboard_input.rb
 test_files: []
 rdoc_options: []

data/lib/auto_require.rb

@@ -1,2 +0,0 @@
-require File.dirname(__FILE__)+'/runner'
-require File.dirname(__FILE__)+'/state'