metro 0.1.5 → 0.1.6

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

@@ -0,0 +1,66 @@
+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
+    #
+    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
+        (options[:default] and options[:default].is_a? Dimensions) ? options[:default] : Dimensions.none
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,155 @@
+require_relative 'text'
+
+module Metro
+  class Model
+
+    #
+    # A font property maintains a Gosu::Font.
+    #
+    # 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 FontProperty < Property
+
+      # Define a paired property which allows the setting of the font size
+      define_property :size, prefix: true
+      # Define a paired property which allows the setting of the font name
+      define_property :name, type: :text, prefix: true
+
+      # Return the default font when the value is not supported.
+      get do
+        default_font
+      end
+
+      # Create a font from the specified hash of data.
+      #
+      # @example Format of Hash
+      #
+      #     { name: 'Times New Roman', size: 33 }
+      #
+      get Hash do |value|
+        self.class.font_for value.merge(window: model.window)
+      end
+
+      # Save a hash of the default font when the value is not supported.
+      set do
+        { name: default_font_name, size: default_font_size }
+      end
+
+      # Save a hash representation of the font when given a font
+      set Gosu::Font do |font|
+        { name: font.name, size: font.height }
+      end
+
+      # Save the hash provided. It is assumed to contain the correct font data.
+      set Hash do |hash|
+        hash.symbolize_keys!
+      end
+
+      #
+      # @return the default font to use when a value has not been provided.
+      #
+      def default_font
+        self.class.font_for name: default_font_name,
+          size: default_font_size,
+          window: model.window
+      end
+
+      #
+      # Use the specified default font size or fall back to 40.
+      #
+      def default_font_size
+        (options[:default] and options[:default][:size]) ? options[:default][:size] : 40
+      end
+
+      #
+      # Use the specified default font name or fall back to Gosu's default font name.
+      #
+      def default_font_name
+        (options[:default] and options[:default][:name]) ? options[:default][:name] : Gosu::default_font_name
+      end
+
+      #
+      # Return a font that matches the specified criteria. Usig the name, size, and window a font will be
+      # generated or retrieved from the cache.
+      #
+      # @param [Hash] value the hash that contains the `name`, `size` and `window` that describe the font.
+      #
+      def self.font_for(value)
+        value.symbolize_keys!
+        name = value[:name]
+        size = value[:size]
+        window = value[:window]
+
+        font = fonts["#{name}:#{size}:#{window}"]
+        unless font
+          font = create_font(window,name,size)
+          fonts["#{name}:#{size}:#{window}"] = font
+        end
+
+        font
+      end
+
+      #
+      # @return the fonts currently cached by the FontProperty.
+      #
+      def self.fonts
+        @fonts ||= {}
+      end
+
+      private
+
+      def self.create_font(window,name,size)
+        Gosu::Font.new window, name, size
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,101 @@
+module Metro
+  class Model
+
+    #
+    # A image property maintains a Gosu::Image.
+    #
+    # An image is stored in the properties as a string to the specified image path and is converted into
+    # a Gosu::Image when it is retrieved within the system. When retrieving an image the Image
+    # Property will attempt to use a image at that path that already meets that criteria if it has been
+    # loaded.
+    #
+    # The images are cached within the image property to help performance by reducing the unncessary
+    # creation of similar images.
+    #
+    # @example Defining a image property
+    #
+    #     class Player < Metro::Model
+    #       property :image
+    #
+    #       def draw
+    #         image.draw x, y, z_order, x_factor, y_factor, color, :add)
+    #       end
+    #
+    #     end
+    #
+    # @example Defining an image property providing a default
+    #
+    #     class Player < Metro::Model
+    #       property :image, default: "player.png"
+    #     end
+    #
+    # @example Using an image property with a different property name
+    #
+    #     class Player < Metro::Model
+    #       property :disconnected_image, type: :image, default: "disconnected_player.png"
+    #
+    #       def draw
+    #         disconnected_image.draw x, y, z_order, x_factor, y_factor, color, :add)
+    #       end
+    #     end
+    #
+    class ImageProperty < Property
+
+      # Return the image at the specified path.
+      # @note The path should be the relative path within the game.
+      get String do |path|
+        self.class.image_for_path path: path, window: model.window
+      end
+
+      # Set the image with the specified path.
+      # @note The path should be the relative path within the game.
+      set String do |path|
+        path
+      end
+
+      # Set the image with the given image. A Gosu::Image does not normally
+      # store it's path, however, this functionality has been monkey-patched.
+      set Gosu::Image do |image|
+        image.path
+      end
+
+      #
+      # Return an image 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.image_for_path(options)
+        options.symbolize_keys!
+        path = options[:path]
+        window = options[:window]
+
+        image = images[path]
+        unless image
+          image = create_image(window,path,false)
+          images[path] = image
+        end
+
+        image
+      end
+
+      def self.images
+        @images ||= {}
+      end
+
+      private
+
+      # @TODO The Gosu::Image creation should automatically perform this operation of saving the path
+      #   to the image. This should be monkey-patched onto the image so that images created outside
+      #   of this process will also have a specified path.
+      def self.create_image(window,path,tileable)
+        image = Gosu::Image.new(window,asset_path(path),tileable)
+        image.path = path
+        image
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,29 @@
+module Metro
+  class Model
+
+    #
+    # The numeric property will simply convert any input into a floating
+    # point value. This is the same both on getting and setting.
+    #
+    class NumericProperty < 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_number
+        elsif value.respond_to?(:to_f)
+          value.to_f
+        else
+          default_number
+        end
+      end
+
+      def default_number
+        options[:default].to_f
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,84 @@
+module Metro
+  class Model
+
+    #
+    # A position property maintains a 2D Point.
+    #
+    # A position property also defines an `x` property and a `y` property which allows a
+    # more direct interface.
+    #
+    # A position is stored as a string in the properties and retrieved as a Point object.
+    #
+    # @example Defining a position property, using the x, y and z_order properties
+    #
+    #     class Enemy < Metro::Model
+    #       property :position
+    #
+    #       def draw
+    #         # image.draw position.x, position.y, z_order, x_factor, y_factor, color, :add)
+    #         image.draw x, y, z_order, x_factor, y_factor, color, :add)
+    #       end
+    #     end
+    #
+    # @example Defining a position property providing a default
+    #
+    #     class Enemy < Metro::Model
+    #       property :position, default: Point.at(44,66)
+    #     end
+    #
+    # @example Using a position property with a different property name
+    #
+    #     class Hero < Metro::Model
+    #       property :pos, type: :position, default: Point.zero
+    #
+    #       def draw
+    #         # image.draw pos.x, pos.y, pos.z_order, x_factor, y_factor, color, :add)
+    #         image.draw pos_x, pos_y, pos_z_order, x_factor, y_factor, color, :add)
+    #       end
+    #     end
+    #
+    class PositionProperty < Property
+
+      # Define an x position property
+      define_property :x
+
+      # Define a y position property
+      define_property :y
+
+      # Define a z position property which is used for the z order
+      define_property :z
+      define_property :z_order
+
+      # When no getters match the specified value return the default point
+      get do
+        default_point
+      end
+
+      # When getting a string convert it to a point.
+      get String do |value|
+        Point.parse(value)
+      end
+
+      # When no setters match save the default point.
+      set do
+        default_point.to_s
+      end
+
+      # When given a string, it is assumed to be a well formated point
+      set String do |value|
+        Point.parse(value).to_s
+      end
+
+      # When given a point save the the string value of it.
+      set Point do |value|
+        value.to_s
+      end
+
+      def default_point
+        (options[:default] and options[:default].is_a? Point) ? options[:default] : Point.zero
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,111 @@
+module Metro
+  class Model
+
+    class Property
+      attr_reader :model, :options
+
+      def initialize(model,options={})
+        @model = model
+        @options = options
+      end
+
+      def self.gets
+        @gets ||= begin
+          hash = Hash.new { |hash,key| hash["NilClass"] }
+          hash["NilClass"] = lambda { |value| raise "#{self} is not able to translate the #{value} (#{value.class})" }
+          hash
+        end
+      end
+
+      def self.get(type=NilClass,&block)
+        gets[type.to_s] = block
+      end
+
+      def get(value)
+        get_block = self.class.gets[value.class.to_s]
+        instance_exec(value,&get_block)
+      end
+
+      def self.sets
+        @sets ||= begin
+          hash = Hash.new { |hash,key| hash["NilClass"] }
+          hash["NilClass"] = lambda { |value| raise "#{self} is not able to translate the #{value} (#{value.class})" }
+          hash
+        end
+      end
+
+      def self.set(type=NilClass,&block)
+        sets[type.to_s] = block
+      end
+
+      def set(value)
+        set_block = self.class.sets[value.class.to_s]
+        instance_exec(value,&set_block)
+      end
+
+      def self.get_or_set(type=NilClass,&block)
+        gets[type.to_s] = block
+        sets[type.to_s] = block
+      end
+
+      def self.defined_properties
+        @defined_properties ||= []
+      end
+
+      def self.define_property(name,options = {})
+        defined_properties.push PropertyDefinition.new name, options
+      end
+
+      def self.inherited(subclass)
+        properties << subclass
+      end
+
+      def self.properties
+        @properties ||= []
+      end
+
+      def self.property(name)
+        properties_hash[name]
+      end
+
+      def self.properties_hash
+        @properties_hash ||= begin
+          hash = ActiveSupport::HashWithIndifferentAccess.new(NumericProperty)
+          # TODO: do not store classes within the structure - this will misbehave on reloading
+          properties.each do |prop|
+            prop_name = prop.to_s.gsub(/Property$/,'').split("::").last.underscore
+            hash[prop_name] = prop
+            hash[prop_name.to_sym] = prop
+          end
+          # puts hash
+          hash
+        end
+      end
+
+    end
+
+  end
+
+  class PropertyDefinition
+
+    attr_reader :name, :options
+
+    def initialize(name,options)
+      @name = name
+      @options = options
+    end
+  end
+
+end
+
+require_relative 'angle'
+require_relative 'animation'
+require_relative 'color'
+require_relative 'dimensions'
+require_relative 'font'
+require_relative 'image'
+require_relative 'numeric'
+require_relative 'position'
+require_relative 'scale'
+require_relative 'text'
+require_relative 'velocity'