shattered_pack 0.3.3 → 0.4

data/lib/mock_objects/shattered_ogre/input.rb

@@ -0,0 +1,6 @@
+module ShatteredOgre
+  class Input
+    def initialize
+    end
+  end
+end

data/lib/mock_objects/shattered_ogre/light.rb

@@ -0,0 +1,4 @@
+module ShatteredOgre
+  class Light
+  end
+end

data/lib/mock_objects/shattered_ogre/mesh.rb

@@ -0,0 +1,17 @@
+module ShatteredOgre # :nodoc:all
+  class Mesh
+    def initialize(file_name)
+    end
+    def getPosition
+      v(0,0,0)
+    end
+    def setPosition(x)
+    end
+    def getNumberOfAnimations
+      0
+    end
+    def setMaterial(material)
+    end
+    
+  end
+end

data/lib/mock_objects/shattered_ogre/node.rb

@@ -0,0 +1,17 @@
+module ShatteredOgre #:nodoc:all
+  class Node
+    def attachTo(object)
+    end
+    def createChildNode()
+    end
+    def setPosition(v)
+    end
+    def scale(amount)
+    end
+    def setVisible(vis)
+    end
+    def rotate(axis, amount)
+    end
+    
+  end
+end

data/lib/mock_objects/shattered_ogre/renderer.rb

@@ -0,0 +1,11 @@
+module ShatteredOgre
+  class Renderer
+    def initialize
+    end
+    def failed
+      false
+    end
+    def nextFrame
+    end
+  end
+end

data/lib/mock_objects/shattered_ogre/resource_handler.rb

@@ -0,0 +1,9 @@
+module ShatteredOgre
+  class ResourceHandler
+    def self.getSingleton
+      @@resource_handler ||= ResourceHandler.new
+    end
+    def addCustomMaterial(name, material)
+    end
+  end
+end

data/lib/mock_objects/shattered_ogre/scene.rb

@@ -0,0 +1,28 @@
+module ShatteredOgre
+  class Scene
+    def initialize(*args)
+    end
+    def createMesh(*args)
+      Mesh.new("fake")
+    end
+    def self.getSingleton
+      new
+    end
+    def createSceneNode
+      Node.new
+    end
+    def getRootSceneNode
+      Node.new
+    end
+    def createLight
+      ShatteredOgre::Light.new
+    end
+    def hideOverlay(name)
+    end
+    def showOverlay(name)
+    end
+    def getCamera
+      Node.new
+    end
+  end
+end

data/lib/mock_objects.rb

@@ -0,0 +1,5 @@
+path = File.dirname(__FILE__) + "/mock_objects/shattered_ogre"
+Dir.foreach(path) do |mock_object|
+  path_to_mock = "#{path}/#{mock_object}"
+  require path_to_mock if mock_object.ends_with? ".rb"
+end

data/lib/shattered_controller/actor/actor.rb

@@ -38,70 +38,31 @@ module ShatteredController
      #
      # See ShatteredController::Base for more detail.
      def actor( name, options = {} )
-       before_init_call( :actor, name, options )
+       before_init_call( :actor, name, options, true )
      end
 
    end
    module InstanceMethods
-     
-     # This returns all of the actors created by this controller.
-     def actors
-       return @actors || []
-     end
+
+     private
 
      # 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))
-
+     def actor(name, options={}, created_by_meta_function=false )
+       unless created_by_meta_function
+         raise Error, "Use #{name.to_s.camelize}.new instead of actor :#{name} at the instance level" 
+       end
+       begin
+         actor = eval(name.to_s.camelize).new(options)
+       rescue NameError
+         raise Error, "Actor #{name.to_s.camelize} is not defined."
+       end
        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/runner.rb

@@ -5,28 +5,34 @@ module ShatteredController
   class Runner #:nodoc:
     def initialize( options = {} )
       @@environment ||= options
-      @@environment[:input] = ShatteredController::KeyConverter.new(@@environment[:input])
+      @@environment[:input] = ShatteredPack::KeyConverter.new(@@environment[:input])
     end
+
     #Every time this exits, a game dies.
-    def start_game
+    def start_game(env)
+      @@environment = env
       each_frame do |time_elapsed|
         @@environment[:state].update_timers(time_elapsed)
         @@environment[:input].flush
+        @@environment[:renderer].quit if @@environment[:quit]
       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
+        return @@environment = mock_environment
       end
     end
+
     def self.mock_environment
       retv = {}
-      retv[:camera] = MockCamera.new
+      retv[:camera] = ShatteredView::Node.new
       return retv
     end
   end

data/lib/shattered_controller/state.rb

@@ -1,3 +1,5 @@
+require File.dirname(__FILE__)+'/actor/actor'
+
 module ShatteredController
   def self.append_features(base)
     super
@@ -30,30 +32,53 @@ module ShatteredController
     # This blurs the lines between view and controller.
     # Valid types are [:box]
     def sky(type, options = {})
-      before_init_set( "self", { :"sky" => [type, options[:material]] })
+      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      
+  class State < ShatteredPack::Base      
     before_init_call :activate_state
+    attr_reader :actors
+    
     def activate_state #:nodoc:
       ShatteredPack::Configuration.environment[:state] = self
+      @actors = []
+    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:
+      actors.each { |actor| actor.update_timer(time_elapsed) }
+      self.time_elapsed = time_elapsed
+      timer.update(time_elapsed)
     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
+        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
+    
+    def quit
+      Runner.environment[:quit]=true
+    end
+  end
+  
+  class Error < StandardError # :nodoc:
   end
 end
 
+
+ShatteredController::State.class_eval do
+	include ShatteredController::Actor
+end
+

data/lib/shattered_controller.rb

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

data/lib/shattered_model/base.rb

@@ -12,7 +12,86 @@ module ShatteredModel #:nodoc:
     #
     # Models are useful for unit tests and for making game rules.
     # They are where all logic (AI/collisions/etc) go.
+    #
+    # They can also specify keyboard input.
     class Base < ShatteredPack::Base
+      attr_accessor :view
+      before_init_call :setup_view
+      before_init_call :register_with_state
+      
+      private
+      
+      # Registers an actor with a state, Called when the model is created
+      def register_with_state
+        return if state.nil?
+        state.actors << self 
+      end
+      
+      
+      # Creates a view object and ties it directly into the model through method redefiniton
+      def setup_view
+        @view = eval("#{self.class}View").new if eval("defined? #{self.class}View")
+        
+        methods.each do |method|
+          next if( method =~ /^model_/ || Base.instance_methods.include?(method))
+          redefine_method_for_view(method)
+        end
+        
+        @view.model = self if @view
+      end
+      
+      # Uses meta-programming to redefine methods to also call view methods
+      # old methods are aliased to model_#{method}
+      def redefine_method_for_view(method)
+        self.class.instance_eval do
+          @@model_method ||= {}
+        
+          module_eval <<-EOF
+            unless @@model_method[:#{method}]
+              @@model_method[:#{method}] = instance_method(:#{method})
+              def #{method}(*args, &block)
+                retv = @@model_method[:#{method}].bind(self).call(*args, &block)
+                view.send(:#{method},*args, &block) if (!view.nil? && view.class.method_defined?(:#{method}))
+                return retv
+              end
+            end
+          EOF
+          # We cannot use this method because we will lose the power of blocks inside our code.
+          # This should be fixed in Ruby 1.9, but for now we use eval (evil) and string interpolation
+          # define_method(method) do |*args|
+          #   retv = model_method.bind(self).call(*args)
+          #   view.send(method,*args) if (!view.nil? && view.class.method_defined?(method))
+          #   return retv
+          # end
+        end
+      end
+      
+      public
+      
+      # Propogates events to view as well.
+      def update_timer(time_elapsed)#:nodoc:
+        return if @timer == :unloaded
+        [self, view].each do |base|
+          next if base.nil?
+          base.time_elapsed = time_elapsed
+          base.timer.update(time_elapsed)
+        end
+      end
+      
+      # Unloading a controller will completely unload an object from the scene.
+      def unload!
+        super
+        @disabled = true
+        @timer=:unloaded
+        @view.send(:unload!) if @view
+        self.view = nil
+      end
+      
+      # An object is disabled when it has been unloaded.
+      def disabled?
+        super
+      end
+      
       def fuzzy_logic=(file) #:nodoc:
         @fuzzy_logic = FuzzyLogic.new
         @fuzzy_logic.parse_fuzzy_file(File.dirname(__FILE__)+"/#{file}")
@@ -20,5 +99,7 @@ module ShatteredModel #:nodoc:
       def update_fuzzy_logic #:nodoc:
         @fuzzy_logic.update(self)
       end
+      
     end
 end
+

data/lib/shattered_model.rb

@@ -1,3 +1,4 @@
 %w(base fuzzy_logic linear_interpolator).each do |dependency|
-  require "shattered_model/#{dependency}"
+  dependency = "shattered_model/#{dependency}"
+  require dependency
 end

data/lib/shattered_pack/base.rb

@@ -4,6 +4,7 @@ $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname
   
 require 'timer/timer'
 require 'pre_initialize/pre_initialize'
+require 'keyboard_input/keyboard_input'
 
 module ShatteredPack #:nodoc:
 
@@ -12,10 +13,10 @@ module ShatteredPack #:nodoc:
     alias_method :per_second, :time_elapsed
     
     # This is overwritten to allow for a pre_initialize before initialize
-    def self.new(*options) #:nodoc
+    def self.new(options={}) #:nodoc
       new_base = allocate
-      new_base.pre_initialize
-      new_base.send(:initialize, *options)
+      new_base.pre_initialize(options)
+      new_base.send(:initialize)
       return new_base
     end
     
@@ -124,4 +125,5 @@ end
 ShatteredPack::Base.class_eval do
 	include ShatteredPack::Timer
 	include ShatteredPack::PreInitialize
+	include ShatteredPack::KeyboardInput
 end

data/lib/shattered_pack/keyboard_input/key_converter.rb

@@ -0,0 +1,51 @@
+module ShatteredPack
+	# 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 )
+		  ogre_key_method = "isKey#{type.to_s.capitalize}".to_sym
+			return @ogre_input.send(ogre_key_method, 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 → shattered_pack}/keyboard_input/keyboard_input.rb

@@ -3,7 +3,7 @@ $:.unshift(File.dirname(__FILE__)) unless
 
 require 'key_converter'
 
-module ShatteredController
+module ShatteredPack
   module KeyboardInput #:nodoc:
 	  def self.append_features(base)
 	    super
@@ -36,7 +36,7 @@ module ShatteredController
 	  end
 	
 	  module InstanceMethods
-	    def pre_initialize
+	    def pre_initialize(options)
 	      # update our keyboard input
 	      timer.every(:frame) do |time_elapsed|
 	        update_input(time_elapsed, ShatteredController::Runner.environment[:input])
@@ -72,20 +72,24 @@ module ShatteredController
 	      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|

data/lib/shattered_pack/pre_initialize/pre_initialize.rb

@@ -44,9 +44,11 @@ module ShatteredPack
       # This function is called after an object is allocated, but before it's initialized.
       #
       # See ShatteredPack::ClassMethods#before_init_call for usage.
-      def pre_initialize #:nodoc:
+      def pre_initialize(options) #:nodoc:
         pre_initialize_set
         pre_initialize_call
+        # Set the options for new(...) without evaluating symbols
+        call_object_function_for_each_key("self",options, false)
       end
   
       # Used in pre_initialize
@@ -72,15 +74,15 @@ module ShatteredPack
           end
       end
   
-      def call_object_function_for_each_key( actor, options )
+      def call_object_function_for_each_key( actor, options, evaluate_symbols=true )
         options.each_pair do |action, params|
-          call_object_function actor, "#{action}=", params
+          call_object_function actor, "#{action}=", params, evaluate_symbols
         end
       end
   
-      def call_object_function(actor, action, params)
+      def call_object_function(actor, action, params, evaluate_symbols=true)
         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.
+          if params.is_a?(Symbol) && evaluate_symbols 
             params = eval(params.to_s) 
           end
         rescue NameError

data/lib/shattered_pack/timer/timed_event.rb

@@ -3,14 +3,19 @@ module ShatteredPack
     
     class Timer
       attr_reader :events_remaining
-      def initialize
+      def initialize(context)
         @events_remaining = []
+        @context = context
       end
-      def in(seconds, &block)
-        @events_remaining << TimedEvent.new(seconds, &block)
+      def in(seconds, options = {}, &block)
+        event = TimedEvent.new(@context, seconds, options, &block)
+        @events_remaining << event
+        return event
       end
-      def every(seconds, &block)
-        @events_remaining << ContinuousTimedEvent.new(seconds,&block)
+      def every(seconds, options = {}, &block)
+        event = ContinuousTimedEvent.new(@context, seconds, options, &block)
+        @events_remaining << event
+        return event
       end
       def update(time_elapsed)
         events_for_update = @events_remaining.dup
@@ -23,8 +28,10 @@ module ShatteredPack
 
     class TimedEvent
       attr_accessor :time_remaining
-      def initialize(seconds, &block)
+      def initialize(context, seconds, options={}, &block)
+        @context=context
         @event = block
+        @options = options
         if(seconds != :frame)
           @time_remaining = seconds
           @initial_time = @time_remaining
@@ -34,7 +41,7 @@ module ShatteredPack
         end
       end
       def update(time_elapsed)
-        return if processed?
+        return if processed? || stopped?
         @time_remaining -= time_elapsed
         if time_up?
           process_event
@@ -47,17 +54,38 @@ module ShatteredPack
       def reset
         @time_remaining = @initial_time
       end
+      # Stop the timer
+      def stop
+        @stopped = true
+      end
+      def stopped?
+        !@stopped.nil?
+      end
       private
       def process_event
-        @event.call(@initial_time - @time_remaining)
+        @event.call(@initial_time - @time_remaining) if satisfies_condition?
       end
       def time_up?
         return @time_remaining <= 0
       end
+      def satisfies_condition?
+        return true if(@options[:if].nil? && @options[:unless].nil?)
+        unless @options[:if].nil?
+          result=@options[:if]
+          result=@context.send(result) if(result.is_a? Symbol)
+          return result
+        end
+        unless @options[:unless].nil?
+          result=@options[:unless]
+          result=@context.send(result) if(result.is_a? Symbol)
+          return !result
+        end
+      end
     end
 
     class ContinuousTimedEvent < TimedEvent
       def update(time_elapsed)
+        return if stopped?
         @time_remaining -= time_elapsed
         if(time_up?)
           process_event

data/lib/shattered_pack/timer/timer.rb

@@ -35,22 +35,17 @@ module ShatteredPack
         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?
+        before_init_call(:create_timer, :in, time, action, options) unless options[:in].nil?
+        before_init_call(:create_timer, :every, time, action, options) unless options[:every].nil?
       end
     end
     module InstanceMethods
       def timer
-        @timer ||= Timer.new
+        @timer ||= Timer.new(self)
       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|
+        def create_timer(type, time, action, options)
+          timer.send(type, time, options) do |time_elapsed| 
             timer_enactment(action, time_elapsed)
           end
         end
@@ -66,7 +61,7 @@ module ShatteredPack
                 send(action.to_sym)
               end
             rescue ArgumentError => argument_error
-              raise argument_error unless argument_error.message.to_sym == :"wrong number of arguments (0 for 1)"
+              raise argument_error unless argument_error.message.to_sym == "wrong number of arguments (0 for 1)".to_sym
               send(action.to_sym,time_elapsed)
             end
         end

data/lib/shattered_pack.rb

@@ -1,7 +1,8 @@
 $: << File.expand_path(File.dirname(__FILE__))
 
 %w( base runner ).each do |component|
-  require "shattered_pack/#{component}"
+  dependency = "shattered_pack/#{component}"
+  require dependency
 end
 
 require 'shattered_support'

data/lib/shattered_view/base.rb

@@ -42,10 +42,10 @@ module ShatteredView #:nodoc:
     #               directions equally.
     #   Example:  light :fireplace, :position => [0,-5,20], :diffuse => [1,0.5,0.5], :specular => [1,0,0], :attenuation => [8000,0,4,0.3]  
     #   Parameters:
-    #   :position: the x,y,z position or vector position
-    #   :diffuse: the r,g,b value of the diffuse color 
-    #   :specular: the r,g,b value of the specular color
-    #   :attenuation:  arguments are range, constant, linear, quadratic 
+    #   position:: the x,y,z position or vector position
+    #   diffuse:: the r,g,b value of the diffuse color 
+    #   specular:: the r,g,b value of the specular color
+    #   attenuation::  arguments are range, constant, linear, quadratic 
     #     range is how far the light will extend
     #     constant 	The constant factor in the attenuation formula: 1.0 means never attenuate, 0.0 is complete attenuation
     #     linear 	The linear factor in the attenuation formula: 1 means attenuate evenly over the distance
@@ -53,18 +53,19 @@ module ShatteredView #:nodoc:
     #
     #   Directional Light - this light is like the positional light, except instead of position it has only direction
     #   Example:  light :sun, :direction => [0,-1,-1], :diffuse => [1,1,1], :specular => [1,1,1]
-    #   :direction:  the direction light emanates from
-    #   : other : same as point light above.
+    #   direction::  the direction light emanates from
+    #   other:: same as point light above.
     #
+    #   Note: The following type of light is not currently implemented in shattered.
     #   Spotlight - this light has both a direction and a position, as well as other factors.
     #   Example:  light :flashlight...
-    #   TODO: This type of light is not currently implemented in shattered.
 
     def light(name, options = {})
       before_init_set "self", {:new_light => [name]}
       before_init_set name, options
     end
 
+    #  The following is not yet implemented:
     #  Particle systems are defined in .particle files 
     #  - This works for first order particle systems --
     #  - We need to look into second and third order particle systems
@@ -78,8 +79,12 @@ module ShatteredView #:nodoc:
   end
 
   class Base < ShatteredPack::Base
-    attr_reader :meshes
-    attr_accessor :model
+    attr_accessor :controller, :model
+    attr_reader :lights
+    
+    def visible=(visible)
+      node.visible=(visible)
+    end
     
     def rotate(vector, amount)
       node.rotate(vector, amount)
@@ -107,13 +112,20 @@ module ShatteredView #:nodoc:
     end
 
     def new_light=(name)
-      define_accessor("@lights", ShatteredView::Light.new, name)
+      #define_accessor("@lights", ShatteredView::Light.new, name)
+      @lights ||= {}
+      name = name.to_sym 
+      @lights[name] = Light.new 
+      self.class.send(:define_method, name) do 
+        @lights[name] 
+      end
     end
 
     def new_particle_system=(name, template) 
       define_accessor("@particle_systems", ShatteredView::ParticleSystem.new(template), name)
     end
-    
    
+    
+    
     #Return all of the children attached to this view's scene node
     def children
       node.children

data/lib/shattered_view/light.rb

@@ -1,11 +1,12 @@
 module ShatteredView
+  
   class Light
     def light
-      @light ||= Scene.getSingleton().createLight
+      @light ||= ShatteredOgre::Scene.getSingleton().createLight
     end
     def direction=(*direction)
       light.setType(ShatteredOgre::Light::LT_DIRECTIONAL) 
-      light.setDirection(direction.to_v)
+      light.setDirection(direction.to_v3)
     end
     def diffuse=(r,g,b)
       light.setDiffuseColour(r,g,b)
@@ -15,10 +16,10 @@ module ShatteredView
     end
     def position=(pos)
       light.setType(ShatteredOgre::Light::LT_POINT) 
-      light.setPosition(pos.to_v)
+      light.setPosition(pos.to_v3)
     end
     def ambient=(r,g,b)
-      Scene.getSingleton().setAmbientLight(r,g,b);
+      ShatteredOgre::Scene.getSingleton().setAmbientLight(r,g,b);
     end
     def attenuation=(range, const, linear, quad)
       light.setType(ShatteredOgre::Light::LT_POINT)

data/lib/shattered_view/mesh/mesh.rb

@@ -35,6 +35,7 @@ module ShatteredView
         before_init_call( :mesh, file, options )
       end
 
+      # Note: The following is broken in 0.4
       # Animations declare helper functions for mesh animations.
       #
       #   class AnimatedRubyView < ...
@@ -59,6 +60,14 @@ module ShatteredView
     
     module InstanceMethods
       
+      public
+      
+      #TODO - Should it be a list like this, or a hash with the name as the index?
+      def meshes
+#        children.collect { |child| child if child.is_a? Mesh }
+        @meshes
+      end
+
       private
       def mesh(file, options={})
         mesh = Mesh.new(file)
@@ -68,10 +77,9 @@ module ShatteredView
         call_object_function_for_each_key(name, options)
         #keep track of the meshes we create
         mesh.attach_to(node)
-      end
-
-      def meshes
-        children.collect { |child| child.is_a? Mesh }
+        @meshes ||= []
+        @meshes << mesh
+        mesh
       end
       
       def animation(name, options={})
@@ -83,7 +91,7 @@ module ShatteredView
             end
           end
           EOF
-          call_object_function_for_each_key(:"#{mesh.name}.#{name}", options)
+          call_object_function_for_each_key("#{mesh.name}.#{name}".to_sym, options)
         end
       end
 
@@ -114,6 +122,15 @@ module ShatteredView
         return @animations[animation]
       end
       
+      #Set the material on this mesh.  Accepts a string or a rmaterial 
+      def material=( material )
+        if material.is_a? RMaterial
+          scene_node.generateTangents if material.tangent_space
+          material = material.name
+        end
+        scene_node.setMaterial(material.to_s)
+      end
+      
       # Remove the Ogre Mesh from the scene
       def remove_from_scene
         scene_node.removeFromScene

data/lib/shattered_view/node.rb

@@ -90,14 +90,6 @@ module ShatteredView
       scene_node.scale amount
     end
   
-    def material=( material )
-      if material.is_a? RMaterial
-        scene_node.generateTangents if material.tangent_space
-        material = material.name
-      end
-      scene_node.setMaterial(material.to_s)
-    end
-  
     def visible=(visible)
       scene_node.setVisible(visible)
     end

data/lib/shattered_view/overlay.rb

@@ -0,0 +1,20 @@
+module ShatteredView
+  class Overlay
+    attr_reader :name
+    def initialize(name)
+      @name = name
+      hide
+    end
+    def show
+      ShatteredOgre::Scene::getSingleton.showOverlay(name)
+      @visible = true
+    end
+    def hide
+      ShatteredOgre::Scene::getSingleton.hideOverlay(name)
+      @visible = false
+    end
+    def visible?
+      @visible
+    end
+  end
+end

data/lib/shattered_view/rmaterial.rb

@@ -14,7 +14,7 @@ module ShatteredView
       ShatteredOgre::ResourceHandler.getSingleton.addCustomMaterial(name.to_s, result)
     end
     def create_ogre_material=(*args)
-      load!("#{SHATTERED_ROOT}/media/templates/#{template}.rmaterial")
+      load!("#{SHATTERED_ROOT}/app/media/common/templates/#{template}.rmaterial")
       create_ogre_material!
     end
     def method_missing(name, *args)
@@ -22,7 +22,7 @@ module ShatteredView
       if name.to_s[-1].chr == "="
         name = name.to_s[0...-1].to_sym
         # Set the instance variable to the sent variable
-        ivar = :"@#{ name }"
+        ivar = "@#{ name }".to_sym
         instance_variable_set(ivar, args[0])
       else
         begin

data/lib/shattered_view/runner.rb

@@ -4,14 +4,14 @@ module ShatteredView
   class Runner #:nodoc:
     def initialize(options = {})
       generate_plugin_config
-      Resources.instance.add_resource_paths("/app/views", "/media")
+      Resources.instance.add_resource_paths("/media", "/app/media", "/app/views")
       @renderer = ShatteredOgre::Renderer.new
       raise Error, "Renderer failed to initialize Ogre" if @renderer.failed
       @scene = ShatteredOgre::Scene.new(translate_to_scene_type(options[:scene_manager]))
     end
     def generate_plugin_config
-      plugin_directory = SHATTERED_ROOT+"/config/"
-      generated_plugin = plugin_directory+ "plugins."
+      plugin_directory = SHATTERED_ROOT+"/config/"
+      generated_plugin = plugin_directory+ "plugins."
       generator = plugin_directory + "ogre_plugins.rcfg"
       if PLATFORM =~ /mswin/
         generated_plugin += "win32"
@@ -22,13 +22,13 @@ module ShatteredView
       end
       process_plugin(generator, generated_plugin+".cfg")
     end
-    def process_plugin(base, generate_to)
+    def process_plugin(base, generate_to)
       puts "Generating #{generate_to} from #{base}, #{File.exists?(base)}"
       return unless File.exists?(base)
       generated_banner = "\n\r//=== This file is generated.  Modify the .rcfg instead. ===\n\r\n\r"
       to_write = generated_banner + ERB.new(File.open(base,"r").read).result + generated_banner
-      output = File.open(generate_to, "w")
-      output.syswrite(to_write)
+      output = File.open(generate_to, "w")
+      output.syswrite(to_write)
       output.close
     end
     def translate_to_scene_type( symbol )

data/lib/shattered_view/vector.rb

@@ -36,6 +36,11 @@ class Symbol #:nodoc:
   def *(number)
     return to_v * number
   end
+  
+  # Addition for vectors
+  def +(number)
+    return to_v + number
+  end
 end
 
 class Array #:nodoc:
@@ -223,18 +228,29 @@ class Vector
 	# Equality test.  This method will return true if all components of both vectors are
 	# indentical.
 	def ==(vector)
+	  vector = vector.to_v if vector.is_a?(Symbol)
 		vector.kind_of?(Vector) && 
 		x == vector.x           && 
 		y == vector.y           &&
 		z == vector.z
 	end
 	
+	# Create a unique identifier based on x, y and z.
+	def hash
+	  return self.to_a.hash
+  end
+  
+  # Equality test for hash indexes.
+  def eql?(other)
+    return self.to_a.eql?(other.to_a)
+  end
+	
 private
 	
 	def convert_args_to_vector(*args)
 		args.flatten!
-		if args.first.is_a? Vector
-			args.first
+		if(args.first.is_a?(Vector) || args.first.is_a?(Symbol))
+			args.first.to_v
 		else
 			args.to_v
 		end

data/lib/shattered_view.rb

@@ -2,6 +2,7 @@ require 'shattered_ogre'
 require 'shattered_pack'
 raise( ShatteredPack::Error, "Could not find ShatteredOgre (a ShatteredView dependency)" ) unless defined? ShatteredOgre
 
-%w(vector utilities node camera extensions runner rmaterial base resources).each do |dependency|
-  require "shattered_view/#{dependency}"
+%w(vector utilities node camera overlay light extensions runner rmaterial base resources).each do |dependency|
+  dependency = "shattered_view/#{dependency}"
+  require dependency
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: shattered_pack
 version: !ruby/object:Gem::Version 
-  version: 0.3.3
-date: 2006-07-18 00:00:00 -06:00
+  version: "0.4"
+date: 2006-09-10 00:00:00 -06:00
 summary: "Shattered Pack: The combination of model/view/controllers and the domain specific language for each."
 require_paths: 
 - lib
@@ -28,22 +28,28 @@ cert_chain:
 authors: []
 
 files: 
+- lib/mock_objects.rb
 - lib/shattered_controller.rb
 - lib/shattered_model.rb
 - lib/shattered_pack.rb
 - lib/shattered_view.rb
-- lib/shattered_controller/base.rb
-- lib/shattered_controller/mock_camera.rb
+- lib/mock_objects/shattered_ogre/input.rb
+- lib/mock_objects/shattered_ogre/light.rb
+- lib/mock_objects/shattered_ogre/mesh.rb
+- lib/mock_objects/shattered_ogre/node.rb
+- lib/mock_objects/shattered_ogre/renderer.rb
+- lib/mock_objects/shattered_ogre/resource_handler.rb
+- lib/mock_objects/shattered_ogre/scene.rb
 - lib/shattered_controller/runner.rb
 - lib/shattered_controller/state.rb
 - lib/shattered_controller/actor/actor.rb
-- lib/shattered_controller/keyboard_input/key_converter.rb
-- lib/shattered_controller/keyboard_input/keyboard_input.rb
 - lib/shattered_model/base.rb
 - lib/shattered_model/fuzzy_logic.rb
 - lib/shattered_model/linear_interpolator.rb
 - lib/shattered_pack/base.rb
 - lib/shattered_pack/runner.rb
+- lib/shattered_pack/keyboard_input/key_converter.rb
+- lib/shattered_pack/keyboard_input/keyboard_input.rb
 - lib/shattered_pack/pre_initialize/pre_initialize.rb
 - lib/shattered_pack/timer/timed_event.rb
 - lib/shattered_pack/timer/timer.rb
@@ -52,6 +58,7 @@ files:
 - lib/shattered_view/extensions.rb
 - lib/shattered_view/light.rb
 - lib/shattered_view/node.rb
+- lib/shattered_view/overlay.rb
 - lib/shattered_view/resources.rb
 - lib/shattered_view/rmaterial.rb
 - lib/shattered_view/runner.rb

data/lib/shattered_controller/base.rb

@@ -1,108 +0,0 @@
-
-$:.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

@@ -1,43 +0,0 @@
-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/mock_camera.rb

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