metro-ld26 0.3.4

data/lib/metro/models/model_factory.rb

@@ -0,0 +1,32 @@
+module Metro
+  class ModelFactory
+
+    attr_reader :name
+
+    def initialize(name,options)
+      @name = name.to_s.downcase
+      @options = options.symbolize_keys
+    end
+
+    def create
+      actor_class = class_for_actor(model_name)
+      actor_class.new options
+    end
+
+    def load_from_previous_scene?
+      @options[:from] == :previous_scene
+    end
+
+    def options
+      @options.except(:from)
+    end
+
+    def model_name
+      options[:model] || name
+    end
+
+    def class_for_actor(model_name)
+      Models.find(model_name)
+    end
+  end
+end

data/lib/metro/models/models.rb

@@ -0,0 +1,62 @@
+module Metro
+
+
+  module Models
+    extend self
+
+    #
+    # Add a model, and all it's subclasses, to the list of available models.
+    #
+    # A model has several names added so that it accessible in many ways:
+    #
+    # * Model Class Name
+    # * Model Name
+    # * Model Name with slashes replaced with `::` separator
+    #
+    def add(model)
+      all_models_for(model).each do |model|
+        models_hash[model.to_s] = model.to_s
+        name_with_slashes = model.model_name
+        models_hash[name_with_slashes] = model.to_s
+        name_with_colons  = name_with_slashes.gsub('/','::')
+        models_hash[name_with_colons] = model.to_s
+      end
+    end
+
+    #
+    # @param [String] name the name of the model that you want to return.
+    #
+    # @return [String] the name of the model class
+    #
+    def find(name)
+      models_hash[name].constantize
+    end
+
+    #
+    # @return [Array<String>] all the names supported by the models hash.
+    #
+    def list
+      models_hash.keys
+    end
+
+    #
+    # @return [Hash] a hash of the available models. The keys are the various
+    #   supported names, with the values being the names of the model classes.
+    def models_hash
+      @models_hash ||= HashWithIndifferentAccess.new("Metro::UI::Generic")
+    end
+
+    #
+    # @param [Class,Array<Class>] models a model or array of models.
+    # @return [Array] an array that contains the model itself and all of the
+    #   models that are sub-classes of this model on down.
+    #
+    def all_models_for(models)
+      Array(models).map do |model_class_name|
+        model = model_class_name.constantize
+        [ model ] + all_models_for(models.models)
+      end.flatten.compact
+    end
+
+  end
+end

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

@@ -0,0 +1,115 @@
+module Metro
+  class Model
+
+    #
+    # An animation property manages an Animation, which is an array of
+    # Gosu::Images and some metadata.
+    #
+    # @see Animation
+    #
+    # A animation is stored in the properties as a hash representation and is
+    # converted into an Animation when it is retrieved within the system.
+    #
+    # The animate images are cached within the animation property to help
+    # performance by reducing the unncessary creation of similar animations.
+    #
+    # @example Defining an animation property (will default to the missing animation)
+    #
+    #     class Scoreboard < Metro::Model
+    #       property :animation
+    #
+    #       def draw
+    #         animation.image.draw text, x, y, z_order, x_factor, y_factor, color
+    #       end
+    #     end
+    #
+    # @example Defining an animation with a path.
+    #
+    #     class Hero < Metro::Model
+    #       property :animation, path: "star.png", dimensions: Dimensions.of(25,25)
+    #         dimensions: Dimensions.of(25,25) }
+    #
+    #       def draw
+    #         animation.image.draw text, x, y, z_order, x_factor, y_factor, color
+    #       end
+    #     end
+    #
+    # @example Using an animation property with a different property name
+    #
+    #     class Hero < Metro::Model
+    #       property :walking, type: :animation, path: "star.png",
+    #         dimensions: Dimensions.of(25,25)
+    #
+    #       def draw
+    #         walking.image.draw text, x, y, z_order, x_factor, y_factor, color
+    #       end
+    #     end
+    #
+    class AnimationProperty < Property
+
+      # By default return the default animation when getting a nil or
+      # other unsupported value.
+      get do
+        create_animation default_properties
+      end
+
+      # When getting a hash, create the animation with the properties.
+      get Hash do |loaded|
+        create_animation default_properties.merge(loaded)
+      end
+
+      # Setting the animation with a nil or other unsupported value
+      # will default to the default animation.
+      set do
+        defaults.except(:window)
+      end
+
+      # Setting with an animation will convert it to it's hash representation.
+      set Animation do |image|
+        image.to_hash
+      end
+
+      # Setting with a hash will assume the hash defines an animation.
+      set Hash, HashWithIndifferentAccess do |value|
+        value.except(:window)
+      end
+
+      private
+
+      def create_animation(properties)
+        self.class.animation_for properties
+      end
+
+      def default_properties
+        { window: model.window,
+          path: default_image_filename,
+          width: default_dimensions.width,
+          height: default_dimensions.height,
+          time_per_image: default_time_per_image,
+          tileable: false }
+      end
+
+      def default_image_filename
+        options[:path] or "missing_animation.png"
+      end
+
+      def default_dimensions
+        if options[:dimensions]
+          Dimensions.parse options[:dimensions]
+        else
+          Dimensions.of 16.0, 16.0
+        end
+      end
+
+      def default_time_per_image
+        options[:time_per_image] or 50
+      end
+
+      def self.animation_for(options)
+        Metro::Animation.find_or_create(options)
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,24 @@
+module Metro
+  class Model
+
+    #
+    # The array property will simply store or retrieve an array.
+    #
+    class ArrayProperty < Property
+
+      get do |value|
+        value.is_a?(NilClass) ? default_value : Array(value)
+      end
+
+      set do |value|
+        Array(value).map {|item| item }
+      end
+
+      def default_value
+        options[:default] or []
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,27 @@
+module Metro
+  class Model
+
+    #
+    # The boolean property will simply convert any input into a true or
+    # false value.
+    #
+    class BooleanProperty < Property
+
+      # For all cases the value is converted to floating point when it can
+      # otherwise the default number is used.
+      get_or_set do |value|
+        if value.is_a?(NilClass)
+          default_value
+        else
+          !!value
+        end
+      end
+
+      def default_value
+        !!options[:default]
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,116 @@
+module Metro
+  class Model
+
+    #
+    # A color property maintains a Gosu::Color.
+    #
+    # A color property also defines an alpha property which allows a more direct interface
+    # to setting the alpha property on the color. This is useful in cases for images where
+    # the color remains as white but the alpha value needs to be adjusted.
+    #
+    # A color is stored in the properties as a string representation and is converted into
+    # a Gosu::Color when it is retrieved within the system.
+    #
+    # @example Defining a color property using the color properties default
+    #
+    #     class Hero < Metro::Model
+    #       property :color
+    #
+    #       def draw
+    #         image.draw x, y, z_order, x_factor, y_factor, color, :add)
+    #       end
+    #
+    #     end
+    #
+    # @example Defining a color property providing a default
+    #
+    #     class Hero < Metro::Model
+    #       property :color, default: "rgba(255,0,0,1.0)"
+    #     end
+    #
+    # @example Using the alpha property
+    #
+    #     class Hero < Metro::Model
+    #       property :color, default: "rgba(255,0,0,1.0)"
+    #
+    #       def become_ghost!
+    #         self.alpha = 127
+    #       end
+    #     end
+    #
+    # @example Using a color property with a different property name
+    #
+    #     class Hero < Metro::Model
+    #       property :color
+    #       property :invincible_color, type: :color, default: "rgba(255,0,255,1.0)"
+    #
+    #       def draw
+    #         if invincible?
+    #           image.draw x, y, z_order, x_factor, y_factor, invincible_color, :add)
+    #         else
+    #           image.draw x, y, z_order, x_factor, y_factor, color, :add)
+    #         end
+    #       end
+    #     end
+    #
+    class ColorProperty < Property
+
+      define_property :alpha
+      define_property :red
+      define_property :green
+      define_property :blue
+
+      # By default convert the value to the default color if it
+      # cannot be processed by the other get filters.
+      get do |value|
+        default_color
+      end
+
+      # A color should remain a color.
+      get Gosu::Color do |value|
+        value
+      end
+
+      # A string representation of a color will be converted to a color.
+      # If Gosu::Color does not support the format, then it will default to white.
+      get String do |value|
+        create_color value
+      end
+
+      # By default save the default color string.
+      set do |value|
+        default_color_string
+      end
+
+      # When given a string assume that it is a string representation of color.
+      set String do |value|
+        value
+      end
+
+      # When given a color, convert it into the string representation.
+      set Gosu::Color do |value|
+        value.to_s
+      end
+
+      #
+      # @return the default color of the color property. This can be set during initialization
+      #   by usign the option `default`.
+      #
+      def default_color
+        create_color(default_color_string)
+      end
+
+      private
+
+      def default_color_string
+        options[:default] || "rgba(255,255,255,1.0)"
+      end
+
+      def create_color(value)
+        Gosu::Color.new value
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,84 @@
+module Metro
+  class Model
+
+    #
+    # A dimensions property maintains an width and height.
+    #
+    # A dimensions property also defines a `width` property and a `height`
+    # property which allows a more direct interface. Changing these values
+    # will update the dimensions the next time that it is drawn.
+    #
+    # Dimensions is stored in the properties as a string and is converted into
+    # a Dimensions when it is retrieved within the system. When retrieving the dimensions.
+    #
+    # @example Defining a dimensions property
+    #
+    #     class Hero < Metro::Model
+    #       property :dimensions
+    #     end
+    #
+    # @example Defining a dimensions providing a default
+    #
+    #     class Hero < Metro::Model
+    #       property :dimensions, default: Dimensions.of(100.0, 100.0)
+    #     end
+    #
+    # @example Using a dimensions property with a different property name
+    #
+    #     class Hero < Metro::Model
+    #       property :box, type: dimensions, default: Dimensions.of(100.0, 100.0)
+    #       # box_width, box_height
+    #     end
+    #
+    # @example Using a dimensions property providing a default block (to be calculated
+    #   when the model retrieves the value - allowing for the model's scene and window
+    #   to be set.)
+    #
+    #     class Hero < Metro::Model
+    #       property :dimensions do
+    #         # Return the dimensions of the current window for the hero
+    #         model.window.dimensions
+    #       end
+    #     end
+    #
+    class DimensionsProperty < Property
+
+      define_property :width
+
+      define_property :height
+
+      get do |value|
+        default_dimensions
+      end
+
+      get String do |value|
+        Dimensions.parse(value)
+      end
+
+      set do |value|
+        default_dimensions.to_s
+      end
+
+      set String do |value|
+        value
+      end
+
+      set Dimensions do |value|
+        value.to_s
+      end
+
+      def default_dimensions
+        Dimensions.parse default_dimensions_params.to_s
+      end
+
+      private
+
+      def default_dimensions_params
+        block ? model.instance_eval(&block) : options[:default]
+      end
+
+
+    end
+
+  end
+end