metro 0.1.5 → 0.1.6

data/lib/metro/models/model_factory.rb

@@ -9,10 +9,9 @@ module Metro
     end
 
     def create
-      contents = {} unless contents
-      actor_class = class_for_actor(model_name(contents))
+      actor_class = class_for_actor(model_name)
       instance = actor_class.new
-      instance._load options.merge(contents)
+      instance._load options
       instance
     end
 
@@ -20,8 +19,8 @@ module Metro
       options[:from] == :previous_scene
     end
 
-    def model_name(contents = {})
-      contents['model'] || contents[:model] || options['model'] || options[:model] || name
+    def model_name
+      options['model'] || options[:model] || name
     end
 
     def class_for_actor(model_name)

data/lib/metro/models/{grid_drawer.rb → models/grid_drawer.rb}

@@ -3,16 +3,15 @@ module Metro
     
     class GridDrawer < Model
 
-      attr_writer :color, :spacing, :height, :width
+      property :color, default: "rgba(255,255,255,0.1)"
+      property :spacing, type: :numeric, default: 10
+
+      attr_writer :spacing, :height, :width
 
       def name
         self.class.name
       end
 
-      def spacing
-        @spacing ||= 10
-      end
-
       def height
         @height || Game.height
       end
@@ -21,10 +20,6 @@ module Metro
         @width || Game.width
       end
 
-      def color
-        @color ||= Gosu::Color.new("rgba(255,255,255,0.1)")
-      end
-
       def saveable?
         false
       end

data/lib/metro/models/{image.rb → models/image.rb}

@@ -9,21 +9,18 @@ module Metro
     #
     class Image < Model
 
-      attr_accessor :x, :y, :angle, :center_x, :center_y, :x_factor, :y_factor, :z_order
-
-      def after_initialize
-        @angle = 0
-        @center_x = @center_y = 0.5
-        @x_factor = @y_factor = 1
-        @z_order = 0
-        @color = Gosu::Color.new "rgba(255,255,255,1.0)"
-        @x = Game.width / 2
-        @y = Game.height / 2
-      end
+      property :position
 
-      def image
-        @image ||= Gosu::Image.new(window,asset_path(path))
-      end
+      property :scale, default: Scale.one
+
+      property :color
+
+      property :angle, type: :numeric, default: 0
+
+      property :center_x, type: :numeric, default: 0.5
+      property :center_y, type: :numeric, default: 0.5
+
+      property :image
 
       def contains?(x,y)
         bounds.contains?(x,y)

data/lib/metro/models/models/label.rb

@@ -0,0 +1,44 @@
+module Metro
+  module Models
+
+    #
+    # Draws a string of text
+    #
+    # @example Using the Label in a view file
+    #    model: "metro::models::label"
+    #
+    class Label < Model
+
+      property :position
+
+      property :scale, default: Scale.one
+
+      property :color, default: "rgba(255,255,255,1.0)"
+
+      property :font, default: { size: 20 }
+
+      property :text
+
+      def bounds
+        Bounds.new x, y, x + width, y + height
+      end
+
+      def width
+        font.text_width(text) * x_factor
+      end
+
+      def height
+        font.height * y_factor
+      end
+
+      def contains?(x,y)
+        bounds.contains?(x,y)
+      end
+
+      def draw
+        font.draw text, x, y, z_order, x_factor, y_factor, color
+      end
+
+    end
+  end
+end

data/lib/metro/models/{menu.rb → models/menu.rb}

@@ -10,6 +10,26 @@ module Metro
     #
     class Menu < Model
 
+      property :position, default: Game.center
+
+      property :scale, default: Scale.one
+
+      property :padding, type: :numeric, default: 40
+
+      property :unselected_color, type: :color, default: "rgba(119,119,119,1.0)"
+      property :selected_color, type: :color, default: "rgba(255,255,255,1.0)"
+
+      def alpha
+        self.unselected_color_alpha
+      end
+
+      def alpha=(value)
+        self.unselected_color_alpha = value.floor
+        self.selected_color_alpha = value.floor
+      end
+
+      property :font
+
       event :on_up, KbLeft, GpLeft, KbUp, GpUp do
         previous_option
       end
@@ -24,12 +44,8 @@ module Metro
 
       attr_reader :selected_index, :menu_options
 
-      attr_accessor :padding, :z_order
-
       def after_initialize
         @selected_index = 0
-        @padding = 40
-        @z_order = 1
       end
 
       def window=(value)
@@ -76,17 +92,6 @@ module Metro
         options.length * font.height + (options.length - 1) * padding
       end
 
-      attr_reader :highlight_color
-
-      def highlight_color=(value)
-        @highlight_color = Gosu::Color.new(value)
-      end
-
-      def alpha=(value)
-        color.alpha = value.floor
-        highlight_color.alpha = value.floor
-      end
-
       def option_at_index(index)
         menu_options[index]
       end
@@ -96,11 +101,11 @@ module Metro
 
           option_name = option_at_index(index).name
 
-          draw_color = color
-          draw_color = highlight_color if index == selected_index
+          draw_color = unselected_color
+          draw_color = selected_color if index == selected_index
 
           y_position = y + padding * index
-          font.draw option_name, x, y_position, z_order, 1.0, 1.0, draw_color
+          font.draw option_name, x, y_position, z_order, x_factor, y_factor, draw_color
         end
       end
 

data/lib/metro/models/{rectangle.rb → models/rectangle.rb}

@@ -3,12 +3,13 @@ module Metro
 
     class Rectangle < ::Metro::Model
 
-      attr_accessor :x, :y, :z_order, :width, :height
+      property :position
 
-      def after_initialize
-        @x = @y = 0
-        @z_order = 1
-      end
+      property :z_order, type: :numeric, default: 0
+
+      property :color
+
+      attr_writer :width, :height
 
       def width
         @width || window.width

data/lib/metro/models/point.rb

@@ -0,0 +1,23 @@
+module Metro
+  class Point < Struct.new(:x,:y,:z)
+    def self.zero
+      new 0.0, 0.0, 0.0
+    end
+
+    def self.at(x,y,z=0.0)
+      new x.to_f, y.to_f, z.to_f
+    end
+
+    def self.parse(string)
+      at *string.split(",",3).map(&:to_f)
+    end
+
+    alias_method :z_order, :z
+    alias_method :z_order=, :z=
+
+    def to_s
+      "#{x},#{y},#{z}"
+    end
+
+  end
+end

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

@@ -0,0 +1,43 @@
+module Metro
+  class Model
+
+    class AngleProperty < Property
+
+      def get(value)
+        value ? value : Angle.new(0.0, options[:step])
+      end
+
+      def set(value)
+        Angle.new(value.to_f, options[:step])
+      end
+
+      class Angle
+
+        attr_reader :value
+
+        def initialize(value = 0.0,step = 1.0)
+          @value = value.to_f
+          @step = step || 1.0
+        end
+
+        def turn(direction)
+          send(direction) if [ :left, :right ].include?(direction)
+        end
+
+        def left
+          @value -= @step
+        end
+
+        def right
+          @value += @step
+        end
+
+        def to_f
+          @value.to_f
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+require_relative '../../animation/animation'
+
+module Metro
+  class Model
+
+    #
+    # A 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 default.
+    #
+    #     class Hero < Metro::Model
+    #       property :animation, default: { path: "star.png",
+    #         dimensions: Metro::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, default: { path: "star.png",
+    #         dimensions: Metro::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
+        default_animation
+      end
+
+      # When getting a hash, create the animation with the properties.
+      get Hash do |value|
+        self.class.animation_for value.merge(window: model.window)
+      end
+
+      # Setting the animation with a nil or other unsupported value
+      # will default to the default animation.
+      set do
+        default_animation.to_hash
+      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 do |value|
+        value
+      end
+
+      def default_animation
+        self.class.animation_for window: model.window,
+          path: default_image_path,
+          width: default_dimensions.width,
+          height: default_dimensions.height,
+          tileable: false
+      end
+
+      def default_image_path
+        if options[:default] and options[:default][:path]
+          asset_path(options[:default][:path])
+        else
+          metro_asset_path("missing_animation.png")
+        end
+      end
+
+      def default_dimensions
+        if options[:default] and options[:default][:dimensions]
+          options[:default][:dimensions]
+        else
+          Dimensions.of 16.0, 16.0
+        end
+      end
+
+      #
+      # Return an animation for the specified path. On first request it will be loaded from
+      # the file-system. On subsequent requests it will be pulled from the cache.
+      #
+      # @param [Hash] options the relative `path` to the image and the window for which it
+      #   will be displayed.
+      #
+      def self.animation_for(options)
+        options.symbolize_keys!
+        window = options[:window]
+
+        absolute_path = path = options[:path]
+        absolute_path = asset_path(absolute_path) unless absolute_path.start_with? "/"
+
+        width = options[:width].to_i
+        height = options[:height].to_i
+        tileable = options[:tileable]
+
+        animation_images = images[path]
+        unless animation_images
+          animation_images = create_image(window,absolute_path,width,height,tileable)
+          images[path] = animation_images
+        end
+
+        Animation.new options.merge(images: animation_images)
+      end
+
+      def self.images
+        @images ||= {}
+      end
+
+      private
+
+      def self.create_image(window,path,width,height,tileable)
+        Gosu::Image.load_tiles(window,path,width,height,tileable)
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,113 @@
+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
+
+      # 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