metro-ld26 0.3.4

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

@@ -0,0 +1,54 @@
+module Metro
+  module UI
+
+    class FPS < Model
+
+      property :placement, type: :text, default: 'top'
+      property :color, default: "rgba(255,255,255,1.0)"
+
+      property :label, type: :model do
+        create "metro::ui::label", text: "FPS: 0", color: color
+      end
+
+      def valid_placements
+        @valid_placements ||= begin
+          {
+           top_left:     { position: Game.bounds.top_left, align: 'left', vertical_align: 'top' },
+           top:          { position: Point.at(Game.center.x, Game.bounds.top), align: 'center', vertical_align: 'top' },
+           top_right:    { position: Game.bounds.top_right, align: 'right', vertical_align: 'top' },
+           right:        { position: Point.at(Game.bounds.right, Game.center.y), align: 'right', vertical_align: 'center' },
+           bottom_right: { position: Game.bounds.bottom_right, align: 'right', vertical_align: 'bottom' },
+           bottom:       { position: Point.at(Game.center.x, Game.bounds.bottom), align: 'right', vertical_align: 'bottom' },
+           bottom_left:  { position: Game.bounds.bottom_right, align: 'left', vertical_align: 'bottom' },
+           left:         { position: Point.at(Game.bounds.left, Game.center.y), align: 'left', vertical_align: 'center' }
+          }
+        end
+
+        @valid_placements.default = :top
+        @valid_placements
+      end
+
+      def show
+        place_label
+      end
+
+      def place_label
+        placement_hash = valid_placements[placement.to_sym]
+        
+        label.align = placement_hash[:align]
+        label.vertical_align = placement_hash[:vertical_align]
+        label.position = placement_hash[:position]
+      end
+
+      def update
+        label.text = "FPS: #{Gosu.fps}"
+      end
+
+      def draw
+        label.draw
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,66 @@
+module Metro
+  module UI
+
+    #
+    # 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
+
+      # @attribute
+      # Sets whether the generic model has warned the user in the logs about it
+      # being a generic model.
+      property :warned, type: :boolean, default: false
+
+      def show
+        self.saveable_to_view = false
+      end
+
+      def draw
+        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}' does not specify a suitable model so it could not be drawn in the scene.
+
+  #{properties}
+
+  Did you mean to use one of the following models:
+
+  Models defined in #{Game.name}:
+
+  #{user_defined_models.join(', ')}
+
+  Models defined in Metro:
+
+  #{metro_models.join(', ')}
+}
+      end
+
+      def metro_models
+        Models.list.find_all {|m| m =~ /metro(::|\/).+(::|\/).+/i }
+      end
+
+      def user_defined_models
+        Models.list - metro_models
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+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
+
+      # @attribute
+      # The position to start drawing the grid
+      property :position, default: Point.at(0,0,100)
+
+      # @attribute
+      # The color of the grid lines
+      property :color, default: "rgba(255,255,255,0.1)"
+
+      # @attribute
+      # The interval which to draw the lines
+      property :spacing, type: :numeric, default: 10
+
+      # @attribute
+      # The dimension of the grid
+      property :dimensions do
+        Dimensions.of Game.width, Game.height
+      end
+
+      # @attribute
+      # This controls whether the grid should be drawn. By default
+      # the grid will be drawn.
+      property :enabled, type: :boolean, default: true
+
+      def show
+        self.saveable_to_view = false
+      end
+
+      def draw
+        return unless enabled
+        draw_horizontal_lines
+        draw_vertical_lines
+      end
+
+      private
+
+      def draw_vertical_lines
+        xs = (width / spacing + 1).to_i.times.map {|segment| segment * spacing }
+        xs.each do |x|
+          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|
+          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

@@ -0,0 +1,87 @@
+module Metro
+  module UI
+
+    #
+    # The image will draw an image with the specifie path, color, rotation, and scale.
+    #
+    # @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
+
+      # @attribute
+      # The position of the image
+      property :position
+
+      # @attribute
+      # The scale of the image
+      property :scale, default: Scale.one
+
+      # @attribute
+      # The color of the image, by default this is white to display the image
+      # as normal, but this can be used to augment the look of the image. Mostly
+      # color is use for the sub-property :alpha which allows an image to be
+      # faded-in and faded-out
+      property :color
+
+      # @attribute
+      # The angle at which to draw the image
+      property :angle, type: :numeric, default: 0
+
+      # @attribute
+      # The center x position of the image as expressed in a scale of from left
+      # to right (0.0 to 1.0).
+      property :center_x, type: :numeric, default: 0.5
+
+      # @attribute
+      # The center y position of the image as expressed in a scale of from top
+      # to bottom (0.0 to 1.0).
+      property :center_y, type: :numeric, default: 0.5
+
+      # @attribute
+      # The image asset to draw.
+      property :image
+
+      # @attribute
+      # The dimensions of the image.
+      property :dimensions do
+        image.dimensions
+      end
+
+      def bounds
+        Bounds.new left: left_x, right: right_x, top: top_y, bottom: bottom_y
+      end
+
+      def draw
+        image.draw_rot x, y, z_order,
+          angle.to_f,
+          center_x, center_y,
+          x_factor, y_factor,
+          color
+      end
+
+      private
+
+      def left_x
+        x - (width * center_x)
+      end
+
+      def right_x
+        left_x + width
+      end
+
+      def top_y
+        y - (height * center_y)
+      end
+
+      def bottom_y
+        top_y + height
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,175 @@
+module Metro
+  module UI
+
+    #
+    # The label will draw the specified text with the font, position, color,
+    # and alignment provided.
+    #
+    # @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
+
+      # @attribute
+      # The position of the label
+      property :position
+
+      # @attribute
+      # The scale of the text
+      property :scale, default: Scale.one
+
+      # @attribute
+      # The text color
+      property :color, default: "rgba(255,255,255,1.0)"
+
+      # @attribute
+      # The font to use for the label text
+      property :font, default: { size: 20 }
+
+      # @attribute
+      # The text to appear on the label
+      property :text
+
+      # @attribute
+      # The alignment for the label. This influences where the text draws in
+      # relation to the specified position. Your choices are 'left', 'center',
+      # and 'right'. The default is 'left'.
+      property :align, type: :text, default: "left"
+
+      # @attribute
+      # The vertical alignment for the label. This influences where the text
+      # draws in relation to the specified position. Your choices are 'top',
+      # 'center', and 'bottom'. This default is 'top'
+      property :vertical_align, type: :text, default: "top"
+
+      # @attribute
+      # When calculating the dimensions of the label, this is the minimum
+      # dimensions. This is necessary in cases when the text is blank. This 
+      # allows for the label to have size when in the edit mode.
+      property :minimum_dimensions, type: :dimensions, default: "16,16"
+
+      # @attribute
+      # The dimensions of label. If the label text is blank, then the dimensions
+      # of the label will return a minimum dimension.
+      property :dimensions do
+        calculated = Dimensions.of (longest_line * x_factor), (line_height * line_count * y_factor)
+        [ calculated, minimum_dimensions ].max
+      end
+
+      def bounds
+        Bounds.new left: left_x, right: right_x, top: top_y, bottom: bottom_y
+      end
+
+      def draw
+        parsed_text.each_with_index do |line,index|
+          font.draw line, x_position(index), y_position(index), z_order, x_factor, y_factor, color
+        end
+      end
+
+      private
+
+      def left_x
+        line_count.times.map { |index| x_position(index) }.min
+      end
+
+      def right_x
+        left_x + width
+      end
+
+      def top_y
+        y_position(0)
+      end
+
+      def bottom_y
+        top_y + height
+      end
+
+      def line_height
+        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 || 0
+      end
+
+      def line_count
+        parsed_text.count
+      end
+
+      def parsed_text
+        text.split("\n")
+      end
+
+      def x_left_alignment(index)
+        x
+      end
+
+      def x_center_alignment(index)
+        x - line_width(parsed_text[index]) / 2
+      end
+
+      def x_right_alignment(index)
+        x - line_width(parsed_text[index])
+      end
+
+      def horizontal_alignments
+        { left: :x_left_alignment,
+          center: :x_center_alignment,
+          right: :x_right_alignment }
+      end
+
+      def x_position(index)
+        alignment = horizontal_alignments[align.to_sym]
+        send(alignment,index)
+      end
+
+      def y_top_alignment(index)
+        y + (index * line_height)
+      end
+
+      def y_bottom_alignment(index)
+        y - line_height * (line_count - index)
+      end
+
+      def y_center_alignment(index)
+        if line_count.even?
+          full_height = (line_count / 2 - index) * line_height
+        else
+          offset = (line_count / 2 - index)
+          if offset < 0
+            full_height = (offset + 1) * line_height - half_line_height
+          else
+            full_height = offset * line_height + half_line_height
+          end
+        end
+
+        y - full_height
+      end
+
+      def vertical_alignments
+        { top: :y_top_alignment,
+          center: :y_center_alignment,
+          bottom: :y_bottom_alignment }
+      end
+
+      def y_position(index)
+        alignment = vertical_alignments[vertical_align.to_sym]
+        send(alignment,index)
+      end
+
+    end
+  end
+end