metro 0.1.5 → 0.1.6

data/lib/metro/models/properties/scale.rb

@@ -0,0 +1,89 @@
+module Metro
+  class Model
+
+    #
+    # A scale property maintains an x and y scaling factor. This scale is not applied to any
+    #
+    # A font property also defines a `font_size` property and a `font_name` property which allows a
+    # more direct interface. Changing these values will update the font the next time that it is drawn.
+    #
+    # A font is stored in the properties as a hash representation and is converted into
+    # a Gosu::Font when it is retrieved within the system. When retrieving a font the Font
+    # Property will attempt to use a font that already exists that meets that criteria.
+    #
+    # The fonts are cached within the font property to help performance by reducing the unncessary
+    # creation of similar fonts.
+    #
+    # @example Defining a font property
+    #
+    #     class Scoreboard < Metro::Model
+    #       property :font
+    #
+    #       def draw
+    #         font.draw text, x, y, z_order, x_factor, y_factor, color
+    #       end
+    #
+    #     end
+    #
+    # @example Defining a font property providing a default
+    #
+    #     class Hero < Metro::Model
+    #       property :font, default: { name: 'Comic Sans', size: 80 }
+    #     end
+    #
+    # @example Using the `font_size` and `font_name` properties
+    #
+    #     class Hero < Metro::Model
+    #       property :color, default: "rgba(255,0,0,1.0)"
+    #
+    #       def dignified
+    #         self.font_size = 45
+    #         self.font_name = 'Helvetica'
+    #       end
+    #     end
+    #
+    # @example Using a font property with a different property name
+    #
+    #     class Hero < Metro::Model
+    #       property :alt_font, type: :font, default: "rgba(255,0,255,1.0)"
+    #
+    #       def draw
+    #         puts "Font: #{alt_font_name}:#{alt_font_size}"
+    #         alt_font.draw text, x, y, z_order, x_factor, y_factor, color
+    #       end
+    #     end
+    #
+    class ScaleProperty < Property
+
+      define_property :x_factor
+
+      define_property :y_factor
+
+      get do |value|
+        default_scale
+      end
+
+      get String do |value|
+        Scale.parse(value)
+      end
+
+      set do |value|
+        default_scale.to_s
+      end
+
+      set String do |value|
+        value
+      end
+
+      set Scale do |value|
+        value.to_s
+      end
+
+      def default_scale
+        (options[:default] and options[:default].is_a? Scale) ? options[:default] : Scale.one
+      end
+
+    end
+
+  end
+end

data/lib/metro/models/properties/text.rb

@@ -0,0 +1,66 @@
+module Metro
+  class Model
+
+    #
+    # A text property maintains a string of text
+    #
+    # Text is stored as text in properties. When retrieving the text, the contents of the text will
+    # be evaluated within the instance of the model's scene. Which means that text may contain
+    # escaped variables referencing anything in the scene or the game.
+    #
+    # @example Defining a text property
+    #
+    #     class Scoreboard < Metro::Model
+    #       property :text
+    #
+    #       def draw
+    #         font.draw text, x, y, z_order, x_factor, y_factor, color
+    #       end
+    #
+    #     end
+    #
+    # @example Defining with a default and text that will be instance evaluated.
+    #
+    #     class ScoreBoard < Metro::Model
+    #       property :font, default: 'Score is #{player.score}'
+    #     end
+    #
+    # @example Using a text property with a different property name
+    #
+    #     class Hero < Metro::Model
+    #       property :description, type: :text
+    #
+    #       def draw
+    #         description_font.draw text, x, y, z_order, x_factor, y_factor, color
+    #       end
+    #     end
+    #
+    class TextProperty < Property
+
+      # When no text is found for the field use the default text.
+      get do |value|
+        evalute_within_scene default_text
+      end
+
+      # When getting the text, evaluate the text within the scene.
+      get String do |value|
+        evalute_within_scene(value)
+      end
+
+      # When saving, simply save whatever is given as text.
+      set do |value|
+        value.to_s
+      end
+
+      def evalute_within_scene(text)
+        model.scene.instance_eval( "\"#{text}\"" )
+      end
+
+      def default_text
+        options[:default] || 'Text for #{model} not specified!'
+      end
+
+    end
+
+  end
+end

data/lib/metro/models/properties/velocity.rb

@@ -0,0 +1,80 @@
+module Metro
+  class Model
+
+    class VectorProperty < Property
+      
+      def get(value)
+        value ? value : Vector.new
+      end
+      
+      def set(value)
+        Vector.new value
+      end
+      
+      class Vector
+        
+        def initialize(angle,velocity)
+          @angle = angle
+          @velocity = velocity
+        end
+        
+        def decay!
+          @velocity.decay!
+        end
+        
+        def accelerate(amount,angle)
+          
+        end
+        
+        def apply_x(x_position)
+          
+        end
+        
+        def apply_y(y_position)
+          
+        end
+        
+        
+      end
+      
+    end
+
+    class VelocityProperty < Property
+
+      def get(value)
+        value ? value : Velocity.new(0.0,0.95)
+      end
+
+      def set(value)
+        Velocity.new value
+      end
+
+      class Velocity
+
+        def initialize(value,decay = default_decay)
+          @value = value.to_f
+          @decay = decay || default_decay
+        end
+
+        def default_decay
+          0.95
+        end
+
+        def decay
+          @value *= @decay
+        end
+
+        def accelerate(amount)
+          @value += amount
+        end
+
+        def to_f
+          @value
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/metro/models/scale.rb

@@ -0,0 +1,21 @@
+module Metro
+  class Scale < Struct.new(:x_factor,:y_factor)
+
+    def self.one
+      new 1.0, 1.0
+    end
+
+    def self.to(x,y)
+      new x.to_f, y.to_f
+    end
+
+    def self.parse(string)
+      to *string.split(",",2).map(&:to_f)
+    end
+
+    def to_s
+      "#{x_factor},#{y_factor}"
+    end
+
+  end
+end

data/lib/metro/scene.rb

@@ -251,6 +251,7 @@ module Metro
       registering_actor.window = window
 
       drawers.push(registering_actor)
+      updaters.push(registering_actor)
 
       register_events_for_target(registering_actor,registering_actor.class.events)
     end
@@ -281,12 +282,29 @@ module Metro
     #
     def self.scene_name(scene_name=nil)
       @scene_name ||= begin
-        to_s.gsub(/_?Scene$/i,'').underscore
+        if to_s == "Metro::Scene"
+          to_s.underscore
+        else
+          to_s.gsub(/_?Scene$/i,'').underscore
+        end
       end
 
       scene_name ? @scene_name = scene_name.to_s : @scene_name
     end
 
+    #
+    # @return a common name that can be used through the system as a common identifier.
+    #
+    def self.metro_name
+      scene_name
+    end
+
+    #
+    # @return an array of all the scene names of all the ancestor scenes
+    #
+    def self.hierarchy
+      ancestors.find_all {|a| a.respond_to? :metro_name }.map(&:metro_name)
+    end
 
     #
     # Allows you to set or retrieve the scene name for the Scene.

data/lib/metro/scenes.rb

@@ -1,5 +1,3 @@
-require_relative 'transitions/scene_transitions'
-
 module Metro
 
   #
@@ -11,7 +9,6 @@ module Metro
   #
   #     Scenes.find("intro")    # => IntroScene
   #     Scenes.find(:intro)     # => IntroScene
-  #     Scenes.find(IntroScene) # => IntroScene
   #
   # @example Creating a scene instance based on the scene name
   #
@@ -21,7 +18,11 @@ module Metro
   #
   #     Scenes.generate("intro")    # => [SCENE: title]
   #     Scenes.generate(:intro)     # => [SCENE: title]
-  #     Scenes.generate(IntroScene) # => [SCENE: title]
+  #
+  # @example Finding a scene that does not exist
+  #
+  #     scene = Scenes.find(:unknown)
+  #     scene.missing_scene            # => :unknown
   #
   module Scenes
     extend self
@@ -33,18 +34,7 @@ module Metro
     # @return the Scene class that is found matching the specified scene name.
     #
     def find(scene_name)
-      found_scene = scenes_hash[scene_name]
-      
-      if found_scene
-        found_scene.constantize
-      else
-        create_missing_scene(scene_name)
-      end
-    end
-
-    def create_missing_scene(scene_name)
-      MissingScene.missing_scene = scene_name
-      MissingScene
+      scene_class( scenes_hash[scene_name] )
     end
 
     #
@@ -55,16 +45,18 @@ module Metro
     # @return an instance of Scene that is found matching the specified scene name
     #
     def generate(scene_or_scene_name,options = {})
-      new_scene = use_scene_or_generate_scene(scene_or_scene_name)
-
-      post_filters.inject(new_scene) {|scene,post| post.filter(scene,options) }
+      new_scene = generate_scene_from(scene_or_scene_name)
+      apply_post_filters(new_scene,options)
     end
 
     #
     # If we have been given a scene, then we simply want to use it otherwise
     # we need to find and generate our scene from the scene name.
-    # 
-    def use_scene_or_generate_scene(scene_or_scene_name)
+    #
+    # @param [String,Sybmol,Class] scene_or_scene_name the name of the scene or an instance
+    #   of Scene.
+    #
+    def generate_scene_from(scene_or_scene_name)
       if scene_or_scene_name.is_a? Scene
         scene_or_scene_name
       else
@@ -75,27 +67,95 @@ module Metro
     #
     # Post filters are applied to the scene after it has been found. These are
     # all objects that can respond to the #filter method.
-    # 
+    #
     def post_filters
-      [ SceneTransitions ]
+      @post_filters ||= []
+    end
+
+    #
+    # Register a filter that will be executed after a scene is found and generated. This
+    # allows for the scene to be modified or changed based on the provided options.
+    #
+    # A filter is any object that responds to #filter and accepts two parameters: the
+    # scene and a hash of options.
+    #
+    # @param [#filter] post_filter a filter is an object that can act as a filter.
+    #
+    def register_post_filter(post_filter)
+      post_filters.push(post_filter)
     end
 
     private
 
+    #
+    # Apply all the post filtering to the specified scene with the given options
+    #
+    # @return a Scene object that has been filtered.
+    #
+    def apply_post_filters(new_scene,options)
+      post_filters.inject(new_scene) {|scene,post| post.filter(scene,options) }
+    end
+
     #
     # @return a Hash that allows for accessing  symbol names of the scenes
     #   as well as the class name constants to allow for the scenes to be found.
     #
     def scenes_hash
-      @scenes_hash ||= Scene.scenes.inject({}) do |dict,scene_classname|
-        scene = scene_classname.constantize
-        name = scene.scene_name
-        dict[name] = scene_classname
-        dict[name.to_sym] = scene_classname
-        dict[scene] = scene_classname
-        dict
+      @scenes_hash ||= build_map_of_scenes(Scene.scenes)
+    end
+
+    #
+    # Generate a map from the scene or scenes to include all the sub-classes of
+    # these scenes.
+    #
+    # @param [Scene,Array<Scene>] scenes a scene or scene subclass or an array of
+    #   scene subclasses.
+    #
+    # @see #scenes_hash
+    #
+    def build_map_of_scenes(scenes)
+      hash = hash_with_missing_scene_default
+      all_scenes_for(scenes).inject(hash) do |hash,scene|
+        hash[scene.scene_name] = scene.to_s
+        hash
+      end
+    end
+
+    #
+    # Create a hash that will return a setup missing scene by default.
+    #
+    def hash_with_missing_scene_default
+      ActiveSupport::HashWithIndifferentAccess.new do |hash,key|
+        missing_scene = scene_class(hash[:missing_scene])
+        missing_scene.missing_scene = key.to_sym
+        missing_scene
       end
     end
 
+    #
+    # Returns all subclassed scenes of the scene or scenes provided. This method is
+    # meant to be called recursively to generate the entire list of all the scenes.
+    #
+    # @param [Scene,Array<Scene>] scenes a scene or scene subclass or an array of
+    #   scene subclasses.
+    #
+    def all_scenes_for(scenes)
+      Array(scenes).map do |scene_class_name|
+        scene = scene_class(scene_class_name)
+        [ scene ] + all_scenes_for(scene.scenes)
+      end.flatten.compact
+    end
+
+    #
+    # @param [String,Symbol] class_name the name of the class that you want the class
+    #
+    # @return the class with the given class name
+    #
+    def scene_class(class_or_class_name)
+      class_or_class_name.class == Class ? class_or_class_name : class_or_class_name.constantize
+    end
+
   end
-end
+end
+
+require_relative 'transitions/scene_transitions'