shattered_pack 0.3.3

data/lib/shattered_controller.rb

@@ -0,0 +1,3 @@
+%w(runner base state mock_camera).each do |dependency|
+  require "shattered_controller/#{dependency}"
+end

data/lib/shattered_controller/actor/actor.rb

@@ -0,0 +1,107 @@
+module ShatteredController
+  module Actor #:nodoc:
+	  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.
+     #
+     # Here is how it works:  You specify a actor in a game state with some starting
+     # attributes:
+     #   class BattleState
+     #     actor :player
+     #     actor :bullet, :target => :player
+     #   end
+     #
+     # With a model BulletModel defined as:
+     #   class BulletModel
+     #     attr_writer :target
+     #   end
+     #
+     # And our BulletModel will be created, with the target set to the player object.
+     #
+     # Setting values for the actors is done prior to initialization, so:
+     #
+     #   class BulletModel
+     #     attr_writer :target
+     #     def initialize
+     #       target.run_away_from(self)
+     #     end
+     #   end 
+     #
+     # Works fine.
+     #
+     # Actors delegate to ShatteredController::Base objects, and controllers delegate to Model and View.
+     #
+     # See ShatteredController::Base for more detail.
+     def actor( name, options = {} )
+       before_init_call( :actor, name, options )
+     end
+
+   end
+   module InstanceMethods
+     
+     # This returns all of the actors created by this controller.
+     def actors
+       return @actors || []
+     end
+
+     # Same as ShatteredController::Actor::ClassMethods#actor
+     #
+     # Returns a newly created 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
+       return 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 Controller defined for Actor #{name}." if actor_options.empty?
+      return actor_options
+     end
+     
+   end
+
+   # An actor is a delegator to a controller game object.
+   class Actor #:nodoc:all
+     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/shattered_controller/base.rb

@@ -0,0 +1,108 @@
+
+$:.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 #:nodoc:
+	
+	 # Controllers tie together the Model and View.  They are the only objects that know
+	 # about both the model and the view, and as such have the responsibility of events.
+	 #
+	 # By default, when an unknown method is invoked on a controller object, it is delegated
+	 # to the model and the view. IE:
+	 #
+	 #   class BulletController < ...
+	 #     def known_method
+	 #       puts "This will not be delegated to the " + model.inspect + " or the " + view.inspect
+   #     end
+	 #   end
+	 #
+	 #   class BattleState < ...
+	 #     actor :bullet
+	 #     def initialize
+	 #       bullet.known_method # This is not delegated
+	 #       bullet.unknown_method # This is delegated (and will throw an exception if unknown among the view/model)
+	 #     end
+	 #   end
+	 #
+   # When obtaining a result from a delegated method, the result will be the a response in the following order
+   # - Model (first)
+   # - View  (last)
+   #
+   # They are sorted so that you get the most useful response first.
+	class Base < ShatteredPack::Base
+	  attr_accessor :model, :view
+	  
+	  before_init_call :disable_event
+
+		def quit
+		end
+
+	  # Controller delegates all unknown methods to the view and model.
+	  def method_missing(method_name, *args, &block)
+	    return if disabled?
+	    raise_no_method_error = true
+	    result = nil
+	    [view, model].each do |delegate|
+	      if delegate.class.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)#:nodoc:
+      return if @timer == :unloaded
+      [self, model, view].each do |base|
+        next if base.nil?
+        base.time_elapsed = time_elapsed
+        base.timer.update(time_elapsed)
+      end
+    end
+    
+    # This is called to the State every frame by the main game loop.  All update events are now
+    # run through Timers.
+    def update_timers(time_elapsed) #:nodoc:
+      update_timer(time_elapsed)
+      actors.each { |actor| actor.update_timers(time_elapsed) }
+    end
+    
+    # Unloading a controller will completely unload an object from the scene.
+    def unload!
+      super
+    end
+  
+    # An object is disabled when it has been unloaded.
+    def disabled?
+      super
+    end
+    
+    private
+    
+    def disable_event
+      when_unloaded do
+        @disabled = true
+        @timer=:unloaded
+        @model.send(:unload!) if @model
+        @model = nil
+        @view.send(:unload!) if @view
+        @view = nil
+      end
+    end
+	end
+	
+	class Error < StandardError #:nodoc:
+  end
+end
+
+ShatteredController::Base.class_eval do
+	include ShatteredController::KeyboardInput
+	include ShatteredController::Actor
+end
+

data/lib/shattered_controller/keyboard_input/key_converter.rb

@@ -0,0 +1,43 @@
+module ShatteredController
+# This is a wrapper around Ogre's input listener.
+# It allows us to query the status of each device every frame.
+class KeyConverter #:nodoc:
+
+  def initialize( ogre_input )
+    @ogre_input = ogre_input
+  end
+  def key_event?( type, key_symbol )
+    return @ogre_input.send(:"isKey#{type.to_s.capitalize}", self.class.convert(key_symbol))
+  end
+  def flush
+    @ogre_input.flush
+  end
+  
+  def self.back_conversions
+    @@back_conversions ||= conversions.invert
+  end
+  def self.conversions
+    begin 
+      return @@conversions
+    rescue NameError
+    end
+    @@conversions = {}
+    ShatteredOgre.constants.each do |constant|
+      kc_evaled = eval("ShatteredOgre::#{constant}")
+      @@conversions[kc_evaled] = symbolize(constant[3..-1].downcase) if constant.to_s =~ /^KC_/
+    end
+    return @@conversions
+  end
+  def self.convert( kc_character )
+    return self.conversions[kc_character] if kc_character.is_a? Fixnum
+    return self.back_conversions[kc_character]
+  end
+private
+  def self.symbolize( name )
+    exceptions = { 'pgdown' => :page_down,
+    			   'pgup'   => :page_up }
+    return name.to_sym if exceptions[name] == nil
+    return exceptions[name]
+  end
+end
+end

data/lib/shattered_controller/keyboard_input/keyboard_input.rb

@@ -0,0 +1,106 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'key_converter'
+
+module ShatteredController
+  module KeyboardInput #:nodoc:
+	  def self.append_features(base)
+	    super
+	    base.extend(ClassMethods)
+	    base.send(:include, InstanceMethods)
+	  end
+	  module ClassMethods
+	    # Key pressing can take any of the following forms:
+	    #   key :released => :up, :action => :clicked_up
+	    #   key :pressed => :left, :action => :left_pressed
+	    #   key :held => :down, :action => :move_down_fluidly
+	    # where each of the actions correspond to an actor function:
+	    #
+	    # class ExampleView < ShatteredView::Base
+	    #   def clicked_up
+	    #     #called when up is released
+	    #   end
+	    #   def left_pressed
+	    #     #called when left is released
+	    #   end
+	    #   def move_down_fluidly(time_elapsed)
+	    #     #called when down is held
+	    #   end
+	    # end
+	    #
+	    # Only key :pressed recieves the time_elapsed variable (as it is updated per frame)
+	    def key(options = {})
+	      before_init_call(:key, options)
+	    end
+	  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 reaction_types
+	      @reaction_types ||= [:pressed, :released, :held]
+	    end
+	    # Given an input of:
+	    #   key :held=>:up, :action => :key_action
+	    #   This will return [:held, [:up]]
+	    def reaction_from(options) #:nodoc:
+	      # Define the method to send the actions when the keys are pressed/clicked/released.
+	      reaction_types.each do |reaction_type|
+	        if options.has_key?(reaction_type)
+	          return [reaction_type, options[reaction_type]] if options[reaction_type].is_a? Array
+	          return [reaction_type, [options[reaction_type]]]
+	        end
+	      end
+	      raise Error, "Reaction to key input must be #{reaction_types.join(',')}. #{options.inspect}" if options[:reaction].nil?
+	    end
+	    
+	    # Given an input of:
+	    #   1) key :pressed => :up, :action => {:jump => :up}
+	    #   2) key :pressed => :down, :action => :fall
+	    # returns
+	    #   1) [:jump, [:up]]
+	    #   2) [:fall, []]
+	    def action_from(params)
+	      action = params[:action]
+	      return [action, []] unless action.is_a? Hash
+	      return [action.keys[0], action.values[0]]
+      end
+	    # See KeyboardInput::key
+	    def key(actions={})
+	      reaction, keys = reaction_from(actions)
+	      action, params = action_from(actions)
+	      keys.each { |key| key_actions << [reaction, key.to_sym, action, params ] }
+	    end
+	    # Update_key will send each of the events to the actor object for whatever key options
+	    # are defined.
+	    def key_action(reaction, action, time_elapsed, params) #:nodoc:
+	      send(action, *params)
+	    end
+	    def key_actions #:nodoc:
+	      @key_actions ||= []
+	    end
+	    # update_input takes the input object, and sends the actor every key event this frame.
+	    def update_input(time_elapsed, input) #:nodoc:
+	      key_actions.each do |reaction, key, action, params|
+	        key_action( reaction, action, time_elapsed, params) if input.key_event?(reaction,key)
+	      end
+	    end
+	    
+	    # Simulate a key press, release or hold event
+	    def key_event(params = {})
+	      lookup_reaction, keys = reaction_from(params)
+	      lookup_key = keys[0]
+	      key_actions.each do |reaction, key, action, params|
+	        key_action(reaction, action, 0, params) if key == lookup_key && lookup_reaction == reaction
+	      end
+	    end
+	  end
+	end
+end

data/lib/shattered_controller/mock_camera.rb

@@ -0,0 +1,9 @@
+
+module ShatteredController 
+	class MockCamera #:nodoc:
+		attr_reader :position
+		def position=(x,y,z)
+		  @position=[x,y,z]
+		end
+	end
+end

data/lib/shattered_controller/runner.rb

@@ -0,0 +1,33 @@
+
+module ShatteredController
+  #The class Runner is present in model, view, and controller, and signifies the
+  #main entry point into the program.  This is called by script/runner.rb
+  class Runner #:nodoc:
+    def initialize( options = {} )
+      @@environment ||= options
+      @@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_timers(time_elapsed)
+        @@environment[:input].flush
+      end
+    end
+    def each_frame
+      yield @@environment[:renderer].timeSinceLastFrame while @@environment[:renderer].nextFrame
+    end
+    def self.environment
+      begin
+        return @@environment
+      rescue NameError
+        return mock_environment
+      end
+    end
+    def self.mock_environment
+      retv = {}
+      retv[:camera] = MockCamera.new
+      return retv
+    end
+  end
+end

data/lib/shattered_controller/state.rb

@@ -0,0 +1,59 @@
+module ShatteredController
+  def self.append_features(base)
+    super
+    base.extend(ClassMethods)
+  end
+  module ClassMethods
+    # In order to set the initial position of the camera, and any other attributes you would like,
+    # use the following format.
+    #  class CameraTestState < ShatteredController::Base
+    #    camera :position => v(10,0,0), :orientation => [0.5, 0.5, 0.5, 0.5]
+    #  end
+    #  
+    # If you pass a symbol as a value, the symbol will be evaluated.
+    # 
+    # This allows for things such as:
+    #
+    #   class CameraTestState < ShatteredController::Base
+    #     camera :position => :camera_position
+    #     def camera_position
+    #       return [rand*10,0,0]
+    #     end
+    #   end
+    #	
+    # The valid options are any public functions within camera that ends in =
+    # (such as position=, looking_at=)  See ShatteredView::Camera for more.
+    def camera(options = {})
+      before_init_call( 'camera', options )
+    end
+    
+    # This blurs the lines between view and controller.
+    # Valid types are [:box]
+    def sky(type, options = {})
+      before_init_set( "self", { :"sky" => [type, options[:material]] })
+    end
+  end
+  # State is the entry point for your shattered game.
+  #
+  # States define the actors, communications between the actors, and control the camera.
+  # You can choose your starting state in config/environment.rb
+  class State < ShatteredController::Base      
+    before_init_call :activate_state
+    def activate_state #:nodoc:
+      ShatteredPack::Configuration.environment[:state] = self
+    end
+    
+    # Returns the camera used in the state. See ShatteredController::ClassMethods#camera
+    def camera(*args)
+      if args.length == 0
+        return @camera ||= Runner.environment[:camera]
+      end
+      call_object_function_for_each_key(:camera, args[0])
+    end
+    
+    def sky=(type, material) #:nodoc:
+      Runner.environment[:scene].send("setSky#{type.to_s.capitalize}",material)
+    end
+  end
+end
+