metro-ld25 0.3.3

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

@@ -0,0 +1,130 @@
+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 :font, default: { name: 'Comic Sans', size: 80 }
+    #       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: { name: 'Helvetica', size: 80 }
+    #
+    #       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 Metro::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, HashWithIndifferentAccess do |hash|
+        hash.to_hash
+      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)
+        Font.find_or_create(value)
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,96 @@
+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.
+    #
+    # @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 path
+    #
+    #     class Player < Metro::Model
+    #       property :image, path: "player.png"
+    #     end
+    #
+    # @example Using an image property with a different property name
+    #
+    #     class Player < Metro::Model
+    #       property :disconnected_image, type: :image, path: "disconnected_player.png"
+    #
+    #       def draw
+    #         disconnected_image.draw x, y, z_order, x_factor, y_factor, color, :add)
+    #       end
+    #     end
+    #
+    class ImageProperty < Property
+
+      # By default, getting will use the the default image.
+      get do
+        default_image
+      end
+
+      # Return the image at the specified path.
+      get String do |path|
+        self.class.image_for path: path, window: model.window
+      end
+
+      # By default, setting will use the path of the default image.
+      set do
+        default_image.path
+      end
+
+      # Set the image with the specified path.
+      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 Metro::Image do |image|
+        image.path
+      end
+
+      #
+      # @return the default image based on the default image path specified.
+      #
+      def default_image
+        self.class.image_for path: default_image_path, window: model.window
+      end
+
+      #
+      # @return the path provided as the default or if one has not been specified
+      # the default "missing.png"
+      #
+      def default_image_path
+        options[:path] or "missing.png"
+      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(options)
+        Metro::Image.find_or_create(options)
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,84 @@
+module Metro
+  class Model
+
+    #
+    # A model property maintains a reference to another model. This property
+    # allows for an existing model to be more easily composed with other models.
+    #
+    # The model is stored as a hash which describes the model.
+    #
+    # @example Defining a model property with a block
+    #
+    #     class ScoreBoard < Metro::Model
+    #       property :position
+    #       property :score
+    #       property :label, type: :model do
+    #         create "metro::ui::label", text: "", position: position
+    #       end
+    #     end
+    #
+    # @example Defining a model property with a hash
+    #
+    #     class ScoreBoard < Metro::Model
+    #       property :position
+    #       property :score
+    #       property :label, type: :model, default: { model: "metro::ui::label",
+    #         text: "", position: position }
+    #       end
+    #     end
+    #
+    class ModelProperty < Property
+
+      # When retrieving a model and the type is unsupported generate the
+      # model instance from the default.
+      get do
+        default_model
+      end
+
+      # When retrieving a hash representation of the model, convert it into
+      # a Metro::Model instance.
+      get Hash do |params|
+        create_model params
+      end
+
+      # When setting the property with an unsupported type, simply save an
+      # empty hash. Which later, if retrieved, it will generate a generic
+      # model.
+      set do
+        {}
+      end
+
+      # When setting the property with a hash, assume that the hash is a
+      # valid description of a Metro::Model.
+      set Hash, HashWithIndifferentAccess do |hash|
+        hash
+      end
+
+      # When setting the property with a Metro::Model, convert the model into
+      # a hash.
+      set Metro::Model do |model|
+        model.to_hash
+      end
+
+      #
+      # Allow for a model property to be defined with a block initialization or
+      # a default hash.
+      #
+      def default_model
+        if block
+          model.instance_eval(&block)
+        else
+          create_model options[:default]
+        end
+      end
+
+      # @return [Metro::Model] return a model created by the current model that
+      #   owns the property.
+      def create_model
+        model.create params[:model], params.except(:model)
+      end
+
+    end
+
+  end
+end

data/lib/metro/models/properties/numeric_property.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/options_property/no_option.rb

@@ -0,0 +1,29 @@
+module Metro
+  class Model
+    class OptionsProperty
+
+      #
+      # When the options cannot find a selected menu option then this no option
+      # is returned instead of a nil value. This allows for a warning to be generated
+      # if any methods target this item.
+      # 
+      # Also if the option will send a 'missing_menu_action' if the options were to
+      # ask for the selected action.
+      # 
+      class NoOption
+        def method_missing(name,*args,&block)
+          log.warn warning_message
+        end
+        
+        def warning_message
+          "No valid options were found in the menu"
+        end
+
+        def properties
+          { action: :missing_menu_action }
+        end
+      end
+
+    end
+  end
+end

data/lib/metro/models/properties/options_property/options.rb

@@ -0,0 +1,94 @@
+module Metro
+  class Model
+    class OptionsProperty
+
+      #
+      # Options maintains the list of menu options that would be displayed in a menu.
+      # Each option is a component that can be rendered during the draw phase.
+      #
+      # Also, options maintains the currently selected item and has the ability to manage
+      # the changes from the previous.
+      #
+      class Options < SimpleDelegator
+
+        #
+        # Generate an empty set of options.
+        #
+        def self.empty
+          new []
+        end
+
+        #
+        # Create options with the provided array of options.
+        #
+        # @param [Array] options the array of options that this object will maintain
+        #   as it's list of options.
+        #
+        def initialize(options)
+          super(options)
+        end
+
+        #
+        # @return [Fixnum] the index of the current selected option.
+        #
+        def current_selected_index
+          @current_selected_index ||= 0
+        end
+
+        #
+        # Set the index of the currently selected item. Values that exceed the possible
+        # count of options will reset to the beginning of the list of options.
+        # Values that proceed the start of of the list of options will fallback to the last option.
+        #
+        def current_selected_index=(value)
+          @current_selected_index = value || 0
+          @current_selected_index = 0 if @current_selected_index >= count
+          @current_selected_index = count - 1 if @current_selected_index <= -1
+          @current_selected_index
+        end
+
+        #
+        # @return [Array] a list of all the options that are currently not selected.
+        #
+        def unselected
+          self - [ selected ]
+        end
+
+        #
+        # @return [Object] the currently selected option.
+        #
+        def selected
+          at(current_selected_index) || NoOption.new
+        end
+
+        #
+        # @return [Symbol] the action name of the currently selected option. If no
+        #   option is currently selected then the NoOption 'missing_menu_action' will be
+        #   returned.
+        #
+        def selected_action
+          if selected.respond_to?(:properties) && selected.properties[:action]
+            selected.properties[:action]
+          else
+            selected.to_sym
+          end
+        end
+
+        #
+        # Move the current selected item to the next item
+        #
+        def next!
+          self.current_selected_index += 1
+        end
+
+        #
+        # Move the current selected item to the previous item
+        #
+        def previous!
+          self.current_selected_index -= 1
+        end
+      end
+
+    end
+  end
+end