metro-ld26 0.3.4

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

@@ -0,0 +1,214 @@
+module Metro
+  module UI
+
+    #
+    # Draws a a menu of options. A menu model inserts itself into the scene as an event
+    # target as it needs to maintain the state of the menu. When an option is selected
+    # an event is fired based on the name of the option.
+    #
+    # @note Only one 'menu' can be defined for a given scene
+    #
+    # @example Creating a menu with basic options
+    #
+    #     menu:
+    #       model: metro::ui::menu
+    #       position: "472.0,353.0,5.0"
+    #       alpha: 0
+    #       unselected_color: "rgba(119,119,119,1.0)"
+    #       selected_color: "rgba(255,255,255,1.0)"
+    #       options: [ 'Start Game', 'Exit' ]
+    #
+    # @example Creating a menu with a selected item
+    #
+    #     menu:
+    #       model: metro::ui::menu
+    #       position: "472.0,353.0,5.0"
+    #       alpha: 0
+    #       unselected_color: "rgba(119,119,119,1.0)"
+    #       selected_color: "rgba(255,255,255,1.0)"
+    #       options:
+    #         selected: 0
+    #         items: [ 'Start Game', 'Exit' ]
+    #
+    #
+    # @example Creating a menu with complex options
+    #
+    #     menu:
+    #       model: metro::ui::menu
+    #       position: "472.0,353.0,5.0"
+    #       alpha: 0
+    #       layout: vertical
+    #       # layout: horizontal
+    #       unselected_color: "rgba(119,119,119,1.0)"
+    #       selected_color: "rgba(255,255,255,1.0)"
+    #       options:
+    #         selected: 1
+    #         items:
+    #         -
+    #           model: "metro::ui::label"
+    #           text: "Start Game"
+    #           action: start_game
+    #         -
+    #           model: metro::ui::label
+    #           text: Exit
+    #           action: exit_game
+    #
+    #
+    class Menu < Model
+
+      # @attribute
+      # The position of the menu
+      property :position, default: Game.center
+
+      # @attribute
+      # The alpha level of the menu from 0 to 255.
+      property :alpha, default: 255
+
+      # @attribute
+      # The scale at which the menu should be drawn.
+      property :scale, default: Scale.one
+
+      # @attribute
+      # The distance between each of the menu items
+      property :padding, default: 20
+
+      # @attribute
+      # The dimensions of the menu. This is based on the items within the
+      # menu.
+      property :dimensions do
+        Dimensions.of (right_x - left_x), (bottom_y - top_y)
+      end
+
+      # @attribute
+      # The options that are displayed in the menu. These are by default
+      # 'metro::ui::labels' But can be defined more dynamically as neeeded.
+      #
+      # @see Metro::Model::Property::OptionsProperty
+      property :options
+
+      # @attribute
+      # The color for all the currently unselected items.
+      property :unselected_color, type: :color, default: "rgba(119,119,119,1.0)"
+
+      # @attribute
+      # The color of the item that currently has focus.
+      property :selected_color, type: :color, default: "rgba(255,255,255,1.0)"
+
+      def alpha_changed(alpha)
+        adjust_alpha_on_colors(alpha)
+        options.each { |option| option.alpha = alpha.floor }
+      end
+
+      def adjust_alpha_on_colors(alpha)
+        self.selected_color_alpha = alpha
+        self.unselected_color_alpha = alpha
+      end
+
+      # @attribute
+      # The sample sound that plays when a selection has been made.
+      property :selection_sample, type: :sample, path: "menu-selection.wav"
+
+      # @attribute
+      # The sample sound when moving between the different options in the menu.
+      property :movement_sample, type: :sample, path: "menu-movement.wav"
+
+      # @attribute
+      # Determines whether the menu is currently enabled or disabled.
+      property :enabled, type: :boolean, default: true
+
+      # @attribute
+      # Allows the menu to be layouted out in a 'horizontal' or 'vertical'
+      # fashion. By default this is 'vertical'
+      property :layout, type: :text, default: "vertical"
+
+      def bounds
+        Bounds.new left: left_x, right: right_x, top: top_y, bottom: bottom_y
+      end
+
+      #
+      # When the position has changed on every other time beside the first time
+      # we want to update the position of all the options defined in the menu.
+      #
+      def position_changed(new_position)
+        return unless properties[:position]
+        difference = Point.parse(new_position) - Point.parse(properties[:position])
+        options.each { |option| option.position += difference }
+      end
+
+      def left_x
+        options.map {|option| option.bounds.left }.min
+      end
+
+      def right_x
+        options.map {|option| option.bounds.right }.max
+      end
+
+      def top_y
+        options.map {|option| option.bounds.top }.min
+      end
+
+      def bottom_y
+        options.map {|option| option.bounds.bottom }.max
+      end
+
+      # @TODO: enable the user to define the events for this interaction
+      #################################################################
+
+      event :on_up, KbLeft, GpLeft, KbUp, GpUp do
+        if enabled
+          movement_sample.play
+          options.previous!
+          update_options
+        end
+      end
+
+      event :on_up, KbRight, GpRight, KbDown, GpDown do
+        if enabled
+          movement_sample.play
+          options.next!
+          update_options
+        end
+      end
+
+      event :on_up, KbEnter, KbReturn, GpButton0 do
+        if enabled
+          selection_sample.play
+          scene.send options.selected_action
+        end
+      end
+
+      #################################################################
+
+      def show
+        adjust_alpha_on_colors(alpha)
+
+        previous_width = 0
+
+        options.each_with_index do |option,index|
+          option.color = unselected_color
+          option.scale = scale
+
+          option_x = x + (layout == "horizontal" ? (previous_width + padding) * index : 0)
+          previous_width = option.width
+          option_y = y + (layout == "vertical" ? (option.height + padding) * index : 0)
+          option_z = z
+
+          option.position = option.position + Point.at(option_x,option_y,option_z)
+
+        end
+
+        options.selected.color = selected_color
+      end
+
+      def update_options
+        options.unselected.each { |option| option.color = unselected_color }
+        options.selected.color = selected_color
+      end
+
+      def draw
+        options.each { |label| label.draw }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Metro
+  module UI
+
+    #
+    # The model label will draw a bounding box and label around another model
+    #
+    # The model label is used by the model labeler which is a facet of the
+    # edit scene
+    #
+    class ModelLabel < Model
+
+      # Stores the model that is currently being labeled.
+      attr_accessor :target
+
+      def bounds=(bounds)
+        bounding_box.position = bounds.top_left
+        label.position = bounds.top_left + Point.at(4,2,label_z_order)
+        label_background.position = label.position - Point.at(2,0,1)
+      end
+
+      property :bounding_box_color, type: :color, default: "rgba(255,0,0,0.5)"
+      property :font, default: { size: 16 }
+      property :label_color, type: :color, default: "rgba(255,255,255,1.0)"
+      property :label_background_color, type: :color, default: "rgba(255,0,0,0.5)"
+
+      property :should_draw_bounding_box, type: :boolean, default: true
+      property :should_draw_label, type: :boolean, default: true
+
+      property :bounding_box, type: :model do
+        create "metro::ui::border", color: bounding_box_color,
+          dimensions: target.bounds.dimensions
+      end
+
+      property :label, type: :model do
+        create "metro::ui::label", text: target.name, font: font,
+          position: target.bounds.top_left + Point.at(4,2,label_z_order)
+      end
+
+      def label_z_order
+        target.respond_to?(:z_order) ? target.z_order + 2 : 0
+      end
+
+      property :label_background, type: :model do
+        create "metro::ui::rectangle", color: label_background_color,
+          position: label.position - Point.at(2,0,1),
+          dimensions: label.dimensions + Dimensions.of(6,4)
+      end
+
+      def draw
+        draw_bounding_box if should_draw_bounding_box
+        draw_label if should_draw_label
+      end
+
+      def draw_bounding_box
+        bounding_box.draw
+      end
+
+      def draw_label
+        label_background.draw
+        label.draw
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,79 @@
+module Metro
+  module UI
+
+    #
+    # The model labeler will draw a bounding box and label around all the
+    # scene's drawers.
+    #
+    # The model labeler is used in the edit transition scene to generate
+    # the bounding boxes and labeles around all the actors within the scene
+    # being edited.
+    #
+    class ModelLabeler < Model
+
+      # @attribute
+      # The color use for the border surrounding each actor and the background
+      # behind the model's name.
+      property :color, default: "rgba(255,0,0,0.5)"
+
+      # @attribute
+      # Sets whether to draw the bounding boxes around the actors.
+      property :should_draw_bounding_boxes, type: :boolean, default: true
+
+      # @attribute
+      # The color of the model name text.
+      property :label_color, default: "rgba(255,255,255,1.0)"
+
+      # @attribute
+      # The font of the model name label.
+      property :font, default: { name: 'Arial', size: 16 }
+
+      # @attribute
+      # Sets whether to draw the model name labels
+      property :should_draw_labels, type: :boolean, default: true
+
+      # @attribute
+      # For actors that have no bounds, like sound or custom models without
+      # a position, they are normally hidden but can be shown. Currently they
+      # appear all overlapped in the upper-left corner of the screen.
+      #
+      # @todo when enabled the boundless actors should be presented in a cleaner
+      #   way to allow for easier viewing of them.
+      property :should_hide_boundless_actors, type: :boolean, default: true
+
+      # Store the labels that are being drawn in the scene. This hash of labels
+      # acts as a cache around the items that are being labeled based on the
+      # name of the objects that are being labeled.
+      def labels
+        @labels ||= {}
+      end
+
+      def show
+        self.saveable_to_view = false
+      end
+
+      def update
+        scene.drawers.each do |drawer|
+          next if (drawer.bounds == Bounds.none and should_hide_boundless_actors)
+          label = labels[drawer.name]
+
+          unless label
+            label = create "metro::ui::model_label", target: drawer
+            labels[drawer.name] = label
+          end
+
+          label.should_draw_label = should_draw_labels
+          label.should_draw_bounding_box = should_draw_bounding_boxes
+          label.bounds = drawer.bounds
+        end
+
+      end
+
+      def draw
+        labels.values.each { |label| label.draw }
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,59 @@
+module Metro
+  module UI
+
+    #
+    # The rectangle will draw a rectangle from the specified position out to the specified
+    # dimensions in the specified color.
+    #
+    # @example Drawing a red rectangle that starts at (20,20) and is 200 by 200
+    #
+    #     class IntroScene < GameScene
+    #       draw :backdrop, model: "metro::ui::rectangle", position: "20,20",
+    #         color: "rgba(255,0,0,1.0)", dimensions: "200,200"
+    #     end
+    #
+    class Rectangle < Model
+
+      # @attribute
+      # The position of the upper-left corner of the rectangle
+      property :position
+
+      # @attribute
+      # The color to rectangle
+      property :color
+
+      # @attribute
+      # The dimensions of the rectangle
+      property :dimensions do
+        window.dimensions
+      end
+
+      def draw
+        window.draw_quad(left_x,top_y,color,
+          right_x,top_y,color,
+          right_x,bottom_y,color,
+          left_x,bottom_y,color,
+          z_order)
+      end
+
+      private
+
+      def left_x
+        x
+      end
+
+      def right_x
+        x + width
+      end
+
+      def top_y
+        y
+      end
+
+      def bottom_y
+        y + height
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module Metro
+  module UI
+
+    #
+    # A sprite is a Metro model that is specially designed to draw and manage
+    # an image. A sprite maintains an image, location information, and rotation.
+    #
+    class Sprite < Model
+
+      # @attribute
+      # The image that will be drawn for the sprite
+      property :image
+
+      # @attribute
+      # The point at which the sprite should be drawn
+      property :position
+
+      # @attribute
+      # This is the color of the spirte. The color usually remains white, and
+      # the color property is implemented by the `alpha` value is the one thing
+      # that is altered to fade in and fade out the sprite.
+      property :color
+
+      # @attribute
+      # The scale at which to draw the sprite. This is default scale of 1.
+      property :scale
+
+      # @attribute
+      # The center, horizontal position, as expressed in a ratio, of the image.
+      property :center_x, type: :numeric, default: 0.5
+
+      # @attribute
+      # The center, vertical position, as expressed in a ratio, of the image.
+      property :center_y, type: :numeric, default: 0.5
+
+      # @attribute
+      # The angle at which the sprite should be drawn. This is by default 0.
+      property :angle
+
+      # @attribute
+      # The height and width of the sprite is based on the image of the sprite.
+      property :dimensions do
+        image.dimensions
+      end
+
+      # @return [RectangleBounds] the bounds of the sprite.
+      def bounds
+        Bounds.new left: left, right: right, top: top, bottom: bottom
+      end
+
+      # @return [Float] the left-most x position of the sprite
+      def left
+        x - width * center_x * x_factor
+      end
+
+      # @return [Float] the right-most x position of the sprite
+      def right
+        left + width * x_factor
+      end
+
+      # @return [Float] the top-most y position of the sprite
+      def top
+        y - height * center_y * y_factor
+      end
+
+      # @return [Float] the bottom-most y position of the sprite
+      def bottom
+        top + height * y_factor
+      end
+
+      #
+      # By default the sprite will draw the image defined for it.
+      #
+      def draw
+        image.draw_rot x, y, z_order, angle, center_x, center_y, x_factor, y_factor, color
+      end
+    end
+  end
+end