metro 0.3.2 → 0.3.3

data/README.md

@@ -7,7 +7,10 @@
 
 ```
 
-Metro is a framework built around [gosu](https://github.com/jlnr/gosu) (the 2D game development library in Ruby). The goal of Metro is to enforce common conceptual structures and conventions making it easier to quickly generate a game.
+Metro is a framework built around [gosu](https://github.com/jlnr/gosu) (the 2D
+game development library in Ruby). The goal of Metro is to enforce common
+conceptual structures and conventions making it easier to quickly generate a
+game.
 
 [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/burtlo/metro)
 
@@ -21,42 +24,62 @@ You want to develop games in Ruby.
 
 ### Why not just use Gosu?
 
-Gosu does a lot of great work bringing OpenGL to Ruby. However, when you finish the [initial tutorial](https://github.com/jlnr/gosu/wiki/Ruby-Tutorial) you are left with a brittle game that is very resistant to changes or new features.
+Gosu does a lot of great work bringing OpenGL to Ruby. However, when you finish
+the [initial tutorial](https://github.com/jlnr/gosu/wiki/Ruby-Tutorial) you are
+left with a brittle game that is very resistant to changes or new features.
 
-* Metro provides the concept of a [Scene](https://github.com/burtlo/metro/wiki/Scenes) which is the first abstraction you would likely build after completing the tutorial.
+* Metro provides the concept of a
+  [Scene](https://github.com/burtlo/metro/wiki/Scenes) which is the first
+  abstraction you would likely build after completing the tutorial.
 
-> Developing your game in individual scenes will make it easier to logically layout your game.
+> Developing your game in individual scenes will make it easier to logically
+layout your game.
 
-* Sane management of images, animations, fonts, songs, and samples through [model properties](https://github.com/burtlo/metro/wiki/Model-properties).
+* Sane management of images, animations, fonts, songs, and samples through
+  [model properties](https://github.com/burtlo/metro/wiki/Model-properties).
 
-> Having to load and cache fonts and images in every one of your models is tedious. It is also is wasteful as several of the same fonts are being used all over the place.
+> Having to load and cache fonts and images in every one of your models is
+tedious. It is also is wasteful as several of the same fonts are being used all
+over the place.
 
 * [Key-frame animations](https://github.com/burtlo/metro/wiki/Animations)
 
-> Metro makes it simple to move an actor from one position to another position. So simple movements, fades, color changes, and really any property change over time is defined very simply.
+> Metro makes it simple to move an actor from one position to another position.
+So simple movements, fades, color changes, and really any property change over
+time is defined very simply.
 
 * [Event Handling](https://github.com/burtlo/metro/wiki/Events)
 
-> Delete those huge `if ... elsif ... else` input checking structures for keyboard, gamepad, and mouse button presses (down,up, and held). Metro makes it easy to define them and an attach a course of action to take when the event happens.
+> Delete those huge `if ... elsif ... else` input checking structures for
+keyboard, gamepad, and mouse button presses (down,up, and held). Metro makes it
+easy to define them and an attach a course of action to take when the event
+happens.
 
 ### Why not use Chingu or Gamebox?
 
 Both [Gamebox](https://github.com/shawn42/gamebox) and
-[Chingu](https://github.com/ippa/chingu) are much more mature libraries with a
-larger set of features.
+[Chingu](https://github.com/ippa/chingu) are more mature libraries with a
+larger set of features. I encourage you to check out those libraries.
 
-With Metro the focus is on a smaller set of features with an emphasis on an
-implementation that leads to joyful development. An emphasis has been applied to creating elegant solutions which have documentation and examples.
+Metro's primary goal is to be a framework of features that make game development
+joyful.
 
 * Active Reloading while building your scenes.
 
 > Adjustments to your game code while working on a scene will automatically
-reload your game code. The template game sets up a shortcut key (**Ctrl+R**) that allows you to explicitly reload the game and the current scene.
+reload your game code. The template game sets up a shortcut key (**Ctrl+R**)
+that allows you to explicitly reload the game and the current scene.
 
 * Scene Edit Support
 
-> All scenes can have their visual component layout re-adjusted through an edit
-mode. The edit mode layout works for all labels, images, and menus.
+> Scenes can enter an edit mode which allows you to re-position actors within
+the scene. The changes can then be saved back to the view. This allows you to
+fine tune the layout of those scene elements, making it easier to get things
+pixel perfect.
+
+Metro's secondary goal is to make it easier for individuals familiar with Rails
+get into game development. That is the reason for some of the design choices,
+the opinionated structure, and generators that come with Metro.
 
 ### Why you shouldn't use Metro?
 
@@ -64,11 +87,16 @@ Metro has some the following limitations:
 
 * Limited to the gems defined within Metro
 
-> At this point in time you are not able to define and package additional dependencies with your game. This means if you are using a gem that is not already defined by Metro you will run into trouble when running it on alternate systems. This will likely be addressed in the future when more demand arises.
+> At this point in time you are not able to define and package additional
+dependencies with your game. This means if you are using a gem that is not
+already defined by Metro you will run into trouble when running it on alternate
+systems. This will likely be addressed in the future when more demand arises.
 
 * Difficult Deployment
 
-> For individuals to play your game, they will also have to install Metro. However, work is being made to bring some simple packaging to Metro games to make them stand-along executables.
+> For individuals to play your game, they will also have to install Metro.
+However, work is being made to bring some simple packaging to Metro games to
+make them stand-along executables.
 
 ## Installation
 
@@ -80,7 +108,8 @@ $ gem install metro
 
 ### Running a Game
 
-By default `metro` will look for a file named 'metro' within the current working directory if no *gamefilename* has been provided.
+By default `metro` will look for a file named 'metro' within the current working
+directory if no *gamefilename* has been provided.
 
 ```bash
 $ metro GAMEFILENAME
@@ -104,9 +133,11 @@ Creating a Game can be done with a single command.
 $ metro new GAMENAME
 ```
 
-This should generate for you a starting game with a branding scene and a title scene. The game allows the player to start the game.
+This should generate for you a starting game with a branding scene and a title
+scene. The game allows the player to start the game.
 
-The game is missing the `first` scene of the game. This can be created with the scene generator:
+The game is missing the `first` scene of the game. This can be created with the
+scene generator:
 
 ```bash
 $ metro generate scene first

data/changelog.md

@@ -1,5 +1,14 @@
 # Metro
 
+## 0.3.3 / 2012-11-28
+
+* Edit Mode - actors within a scene can have their position edited
+  and saved. Actors within the scene that have a valid bounds
+  specified will appear within the scene with name and bounding box.
+* Dimensions can now be defined as strings
+* Game bounds and Game dimensions return objects of that type
+* `metr::ui::fps` added and has some shortcut placements settings
+
 ## 0.3.2 / 2012-11-26
 
 * Debug Mode will now automatically reload the game and scene on source

data/lib/metro/events/hit_list.rb

@@ -27,24 +27,22 @@ module Metro
     end
 
     def update(event)
-      offset_x, offset_y = offset_from_last_event(event)
-
-      list.each { |d| d.offset(offset_x,offset_y) }
+      offset = offset_from_last_event(event)
+      list.each { |d| d.position = d.position + offset }
 
       save_event event
     end
 
     def release(event)
-      offset_x, offset_y = offset_from_last_event(event)
-
-      list.each { |d| d.offset(offset_x,offset_y) }
+      offset = offset_from_last_event(event)
+      list.each { |d| d.position = d.position + offset }
 
       save_event event
       clear
     end
 
     def drawers_at(x,y)
-      hit_drawers = drawers.find_all { |drawer| drawer.contains?(x,y) }
+      hit_drawers = drawers.find_all { |drawer| drawer.bounds.contains?(x,y) }
 
       # assumed that we only want one item
       top_drawer = hit_drawers.inject(hit_drawers.first) {|top,drawer| drawer.z_order > top.z_order ? drawer : top }
@@ -52,7 +50,8 @@ module Metro
     end
 
     def offset_from_last_event(event)
-      [ (event.mouse_x - @last_event.mouse_x).to_i, (event.mouse_y - @last_event.mouse_y).to_i ]
+      return Point.zero unless @last_event
+      Metro::Units::Point.at (event.mouse_x - @last_event.mouse_x).to_i, (event.mouse_y - @last_event.mouse_y).to_i
     end
 
     def save_event(event)

data/lib/metro/font.rb

@@ -10,6 +10,9 @@ module Metro
       super(gosu_font)
     end
 
+    # An alias to Gosu::Font's height method
+    def size ; height ; end
+
     #
     # Return a font that matches the specified criteria. Using the name, size,
     # and window a font will be generated or retrieved from the cache.

data/lib/metro/game.rb

@@ -32,10 +32,10 @@ module Metro
     attr_reader :window
 
     #
-    # @return [Scene,NilClass] the current scene that is being displayed. If 
+    # @return [Scene,NilClass] the current scene that is being displayed. If
     #   this is called before the window is being displayed when this will return
     #   a nil value.
-    # 
+    #
     def current_scene
       window ? window.scene : nil
     end
@@ -52,8 +52,12 @@ module Metro
       fetch(:height,480)
     end
 
+    def bounds
+      Units::RectangleBounds.new left: 0, right: width, top: 0, bottom: height
+    end
+
     def dimensions
-      [ width, height ]
+      Units::Dimensions.of width, height
     end
 
     def center

data/lib/metro/models/model.rb

@@ -76,6 +76,12 @@ module Metro
     #
     property :name, type: :text
 
+    #
+    # @return [TrueClass,FalseClass] true if the model should be saved to the
+    #   view file, false when the model should not be savedable to the view file.
+    #
+    property :saveable_to_view, type: :boolean, default: true
+
     #
     # The window that this model that this window is currently being
     # displayed.
@@ -130,19 +136,12 @@ module Metro
       mc
     end
 
-    def saveable?
-      true
-    end
-
-    # Belongs to positionable items only
-    def contains?(x,y)
-      false
-    end
-
-    # Belongs to positionable items only
-    def offset(x,y)
-      self.x += x
-      self.y += y
+    #
+    # By default a model has no bounds. Each subclass of model will have to
+    # define how their bounds are defined.
+    #
+    def bounds
+      Bounds.none
     end
 
     #
@@ -241,4 +240,8 @@ require_relative 'ui/menu'
 require_relative 'ui/image'
 require_relative 'ui/rectangle'
 require_relative 'ui/grid_drawer'
+require_relative 'ui/border'
+require_relative 'ui/model_label'
+require_relative 'ui/model_labeler'
+require_relative 'ui/fps'
 require_relative 'audio/song'

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

@@ -94,7 +94,11 @@ module Metro
       end
 
       def default_dimensions
-        options[:dimensions] or Dimensions.of(16.0,16.0)
+        if options[:dimensions]
+          Dimensions.parse options[:dimensions]
+        else
+          Dimensions.of 16.0, 16.0
+        end
       end
 
       def default_time_per_image

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

@@ -68,15 +68,16 @@ module Metro
       end
 
       def default_dimensions
-        if block
-          model.instance_eval(&block)
-        elsif options[:default] and options[:default].is_a? Dimensions
-          options[:default]
-        else
-          Dimensions.none
-        end
+        Dimensions.parse default_dimensions_params.to_s
       end
 
+      private
+
+      def default_dimensions_params
+        block ? model.instance_eval(&block) : options[:default]
+      end
+
+
     end
 
   end

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

@@ -34,6 +34,7 @@ module Metro
     # @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
@@ -45,7 +46,7 @@ module Metro
     # @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)"
+    #       property :alt_font, type: :font, default: { name: 'Helvetica', size: 80 }
     #
     #       def draw
     #         puts "Font: #{alt_font_name}:#{alt_font_size}"

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/property.rb

@@ -217,4 +217,5 @@ require_relative 'position_property'
 require_relative 'scale_property'
 require_relative 'song_property'
 require_relative 'sample_property'
-require_relative 'options_property/options_property'
+require_relative 'options_property/options_property'
+require_relative 'model_property'

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

@@ -0,0 +1,69 @@
+module Metro
+  module UI
+
+    #
+    # Draws a rectanglar border around the specififed position and dimensions
+    # with the width provided. This is an unfilled rectangle.
+    #
+    class Border < Metro::Model
+
+      # @attribute
+      # The starting position of the border.
+      property :position
+
+      # @attribute
+      # The dimension of the border.
+      property :dimensions
+
+      # @attribute
+      # The color which to use to draw the border.
+      property :color, default: "rgba(255,255,255,1.0)"
+
+      # @attribute
+      # The width of the border lines
+      property :border, default: 2
+
+      def draw
+        draw_border
+      end
+
+      def draw_border
+        draw_top
+        draw_bottom
+        draw_left
+        draw_right
+      end
+
+      def draw_top
+        window.draw_quad(x + border,y,color,
+          width + x,y,color,
+          x + width,y + border,color,
+          x + border,y + border,color,z_order)
+      end
+
+      def draw_left
+        window.draw_quad(x,y,color,
+          border + x,y,color,
+          x + border,y + border + height,color,
+          x,y + border + height,color,z_order)
+      end
+
+      def draw_right
+        window.draw_quad(x + width,y,color,
+          x + width + border,y,color,
+          x + width + border,y + border + height,color,
+          x + width,y + border + height,color,z_order)
+
+      end
+
+      def draw_bottom
+        window.draw_quad(x + border,y + height,color,
+          width + x,y + height,color,
+          x + width,y + border + height,color,
+          x + border,y + border + height,color,z_order)
+      end
+
+    end
+
+  end
+end