metro 0.2.5 → 0.2.6

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

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

@@ -0,0 +1,125 @@
+module Metro
+  class Model
+
+    #
+    # An options property is a property that takes scene or view defined values
+    # and converts them into an Options object.
+    #
+    # @see Metro::Model::OptionsProperty::Options
+    #
+    # @example A simple array of option names
+    #
+    #     options: [ 'Start Game', 'Exit' ]
+    #
+    #
+    # @example A set of option names with a selection
+    #
+    #       options:
+    #         selected: 0
+    #         items: [ 'Start Game', 'Exit' ]
+    #
+    # @example A complex set of options
+    #
+    #       options:
+    #         selected: 1
+    #         items:
+    #         -
+    #           model: "metro::ui::label"
+    #           text: "Start Game"
+    #           action: start_game
+    #         -
+    #           model: metro::ui::label
+    #           text: Exit
+    #           action: exit_game
+    #
+    class OptionsProperty < Property
+
+      get do |options|
+        Options.empty
+      end
+
+      # This is the basic set of options
+      get Array do |options|
+        parse_array(options)
+      end
+
+      # This is the complex set of options
+      get Hash do |options|
+        parse(options)
+      end
+
+      # This is setting the options with the basic set of options
+      set Array do |array|
+        array
+      end
+
+      # This is setting the options with the complex options
+      set Hash, HashWithIndifferentAccess do |hash|
+        hash.to_hash
+      end
+
+      private
+
+      def parse_array(array)
+        hash = { items: array }
+        parse(hash)
+      end
+
+      #
+      # Convert the hash of parameters into an Options object which contains the visual
+      # representation of each item within the menu as well as the current selected item.
+      #
+      def parse(hash)
+        hash = hash.with_indifferent_access
+        options = create_options(hash[:items])
+        options.current_selected_index = hash[:selected]
+        options
+      end
+
+      def create_options(items)
+        create_options_with_items convert_simple_items(items)
+      end
+
+      #
+      # As menu options can be defined in many ways, this method will convert the simple
+      # versions of the content to match the full robust version by converting them to a
+      # hash and adding the remaining fields.
+      #
+      def convert_simple_items(items)
+        return items if items.first.is_a?(Hash)
+        items.map { |text| { model: "metro::ui::label", text: text } }
+      end
+
+      #
+      # Generate an Options object with the options specified.
+      #
+      # @see Options
+      #
+      def create_options_with_items(options)
+        Options.new options.map { |option| create_model_from_item(option) }
+      end
+
+      #
+      # From the options provided create the models that will be managed by the Options
+      # object.
+      #
+      def create_model_from_item(options)
+        options = options.symbolize_keys
+        options[:action] = actionize(options[:action] || options[:text])
+        model.create options[:model], options
+      end
+
+      #
+      # @return [Symbol] convert a text string into a name which would be a sane method name.
+      #
+      def actionize(text)
+        text.to_s.downcase.gsub(/\s/,'_').gsub(/^[^a-zA-Z]*/,'').gsub(/[^a-zA-Z0-9\s_]/,'').to_sym
+      end
+
+    end
+
+  end
+end
+
+require_relative 'options'
+require_relative 'no_option'

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

@@ -27,8 +27,11 @@ module Metro
       end
 
       # Define a filter block for getting a value of that type.
-      def self.get(type=NilClass,&block)
-        gets[type.to_s] = block
+      def self.get(*types,&block)
+        types = [ NilClass ] if types.empty?
+        types.each do |type|
+          gets[type.to_s] = block
+        end
       end
 
       # All get filter blocks defined
@@ -44,8 +47,11 @@ module Metro
       end
 
       # Define a filter block for setting a value of the type.
-      def self.set(type=NilClass,&block)
-        sets[type.to_s] = block
+      def self.set(*types,&block)
+        types = [ NilClass ] if types.empty?
+        types.each do |type|
+          sets[type.to_s] = block
+        end
       end
 
       # All set filter blocks defined
@@ -200,6 +206,8 @@ require_relative 'property_owner'
 
 require_relative 'numeric_property'
 require_relative 'text_property'
+require_relative 'boolean_property'
+require_relative 'array_property'
 require_relative 'animation_property'
 require_relative 'color_property'
 require_relative 'dimensions_property'
@@ -208,4 +216,5 @@ require_relative 'image_property'
 require_relative 'position_property'
 require_relative 'scale_property'
 require_relative 'song_property'
-require_relative 'sample_property'
+require_relative 'sample_property'
+require_relative 'options_property/options_property'

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

@@ -66,6 +66,7 @@ module Metro
         define_method "#{name}=" do |value|
           instance_variable_set("@_property_parsed_#{name}",nil)
           prepared_value = property_class.new(self,options).set(value)
+          send("#{name}_changed",prepared_value) if respond_to? "#{name}_changed"
           properties[name] = prepared_value
         end
 

data/lib/metro/models/ui/generic.rb

@@ -2,18 +2,35 @@ module Metro
   module UI
 
     #
-    # Generic model is used when no model is cannot not be found
-    # when mapping the view content
+    # Generic model is used when no model can be found.
+    #
+    # @example Defining an actor in a scene without the model
+    #
+    #     class IntroScene < GameScene
+    #
+    #       draw :game_title, text: "Super Game Title", position: Game.center
+    #         color: "rgba(255,255,255,1.0)"
+    #
+    #     end
+    #
+    # The above `game_title` actor was likely suppose to be a `metro::ui::label`, but
+    # the model was not specified. So this warning would be generated.
     #
     class Generic < Model
 
+      attr_accessor :warned
+
       def draw
-        raise cannot_draw_message
+        log.warn cannot_draw_message unless warned
+        self.warned = true
       end
 
+      private
+
       def cannot_draw_message
-        [ "Unable to draw #{name} in #{scene}",
-          "The actor named '#{name}' could not find a suitable model so it could not be drawn in the scene #{scene}" ].join("\n")
+        [ "Unable to draw #{name} in #{scene}", "",
+          "  The actor named '#{name}' does not specify a suitable model so it could not be drawn in the scene.",
+          "", "  " + properties.to_s, "" ].join("\n")
       end
 
     end

data/lib/metro/models/ui/grid_drawer.rb

@@ -1,23 +1,26 @@
 module Metro
   module UI
-    
+
+    #
+    # The grid drawer will draw a grid from the specified position out to the specified
+    # dimensions at the spacing interval provided. This is currently used when the edit
+    # mode is enabled.
+    #
+    # @example Drawing a white, translucent, 100 by 100 grid starting at (20,20).
+    #
+    #     class BuildScene < GameScene
+    #       draw :grid, model: "metro::ui::grid_drawer", position: "20,20",
+    #         color: "rgba(255,255,255,0.5)", spacing: 20, dimensions: "100,100"
+    #     end
+    #
     class GridDrawer < Model
 
+      property :position, default: Point.at(20,20,100)
       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 height
-        @height || Game.height
-      end
-
-      def width
-        @width || Game.width
+      property :dimensions do
+        Dimensions.of Game.width, Game.height
       end
 
       def saveable?
@@ -33,20 +36,27 @@ module Metro
         draw_vertical_lines
       end
 
+      private
+
       def draw_vertical_lines
         xs = (width / spacing + 1).to_i.times.map {|segment| segment * spacing }
         xs.each do |x|
-          window.draw_line(x, 1, color, x, height, color, 0, :additive)
+          draw_line(x,1,x,height)
         end
       end
 
       def draw_horizontal_lines
         ys = (height / spacing + 1).to_i.times.map {|segment| segment * spacing }
         ys.each do |y|
-          window.draw_line(1, y, color, width, y, color, 0, :additive)
+          draw_line(1,y,width,y)
         end
       end
 
+      def draw_line(start_x,start_y,finish_x,finish_y)
+        window.draw_line(position.x + start_x, position.y + start_y, color,
+          position.x + finish_x, position.y + finish_y, color, 0, :additive)
+      end
+
     end
   end
 end

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

@@ -2,10 +2,14 @@ module Metro
   module UI
 
     #
-    # Draws an Image
+    # The image will draw an image with the specifie path, color, rotation, and scale.
     #
-    # @example Using the Image in a view file
-    #    model: "metro::ui::image"
+    # @example Drawing the 'player.png' image at (320,240)
+    #
+    #     class MainScene < GameScene
+    #       draw :player, model: "metro::ui::image", position: "320,240",
+    #         image: "player.png"
+    #     end
     #
     class Image < Model
 

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

@@ -2,10 +2,16 @@ module Metro
   module UI
 
     #
-    # Draws a string of text.
+    # The label will draw the specified text with the font, position, color,
+    # and alignment provided.
     #
-    # @example Using the Label in a view file
-    #    model: "metro::ui::label"
+    # @example Drawing a label
+    #
+    #     class TitleScene < GameScene
+    #       draw :game_title, model: "metro::ui::label", position: "320,240",
+    #         vertical_align: "center", align: "center", color: "rgba(255,255,255,1.0)",
+    #         text: "Super Awesome Game\n2"
+    #     end
     #
     class Label < Model
 
@@ -28,7 +34,7 @@ module Metro
 
       def draw
         parsed_text.each_with_index do |line,index|
-          font.draw line, x_position, y_position(index), z_order, x_factor, y_factor, color
+          font.draw line, x_position(index), y_position(index), z_order, x_factor, y_factor, color
         end
       end
 
@@ -46,10 +52,18 @@ module Metro
         font.height
       end
 
+      def line_width(line)
+        font.text_width(line)
+      end
+
       def half_line_height
         line_height / 2
       end
 
+      def longest_line
+        parsed_text.map { |line| line_width(line) }.max
+      end
+
       def line_count
         parsed_text.count
       end
@@ -58,20 +72,16 @@ module Metro
         text.split("\n")
       end
 
-      def longest_line
-        parsed_text.map { |line| font.text_width(line) }.max
-      end
-
-      def x_left_alignment
+      def x_left_alignment(index)
         x
       end
 
-      def x_center_alignment
-        x - width / 2
+      def x_center_alignment(index)
+        x - line_width(parsed_text[index]) / 2
       end
 
-      def x_right_alignment
-        x - width
+      def x_right_alignment(index)
+        x - line_width(parsed_text[index])
       end
 
       def horizontal_alignments
@@ -80,9 +90,9 @@ module Metro
           right: :x_right_alignment }
       end
 
-      def x_position
+      def x_position(index)
         alignment = horizontal_alignments[align.to_sym]
-        send(alignment)
+        send(alignment,index)
       end
 
       def y_top_alignment(index)