metro 0.2.1 → 0.2.2

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

@@ -0,0 +1,113 @@
+module Metro
+  class Model
+
+    #
+    # A song property maintains a Gosu::Song.
+    #
+    # A song is stored in the properties as the path in the assets folder and is converted into
+    # a Gosu::Song when it is retrieved within the system. When retrieving a song the Song
+    # Property will attempt to use a song that already exists that meets that criteria.
+    #
+    # The songs are cached within the song property to help performance by reducing the unncessary
+    # creation of similar song.
+    #
+    # @example Defining a song property
+    #
+    #     class Song < Metro::Model
+    #       property :song
+    #     end
+    #
+    # @example Defining a song property providing a default
+    #
+    #     class Song < Metro::Model
+    #       property :song, path: 'happy-song.wav'
+    #     end
+    #
+    # @example Using a song property with a different property name
+    #
+    #     class Song < Metro::Model
+    #       property :intro, type: :song, path: 'intro-song.wav'
+    #     end
+    #
+    class SongProperty < Metro::Model::Property
+
+      # By default, getting an unsupported value will return the default song
+      get do |value|
+        default_song
+      end
+
+      # By default, setting an unsupported value will save the default song
+      set do |value|
+        default_song_name
+      end
+
+      # Generate a song from the specified string filepath
+      get String do |filename|
+        self.class.song_for path: filename, window: model.window
+      end
+
+      # The assumption here is that the string is a song filepath
+      set String do |filename|
+        filename
+      end
+
+      # Setting the song value with a Metro::Song will save the string filepath
+      set Metro::Song do |song|
+        song.path
+      end
+
+      #
+      # @return the default song for the song property. This is based on the default
+      #   song name.
+      #
+      def default_song
+        self.class.song_for path: default_song_name, window: model.window
+      end
+
+      #
+      # @return a string song name that is default. If the property was not created with
+      #   a default value the the default song is the missing song found in Metro.
+      #
+      def default_song_name
+        options[:path] || metro_asset_path('missing.mp3')
+      end
+
+      #
+      # Returns a Metro::Song. This is composed of the metadata provided and a Gosu::Song.
+      #
+      # Songs are cached within the property to increase performance.
+      #
+      # @param [Hash] options the path, window, and other parameters necessary to generate
+      #   a song.
+      #
+      def self.song_for(options)
+        options.symbolize_keys!
+        relative_path = options[:path]
+        window = options[:window]
+
+        absolute_path = path = options[:path]
+        absolute_path = asset_path(absolute_path) unless absolute_path.start_with? "/"
+
+        gosu_song = songs[relative_path]
+
+        unless gosu_song
+          gosu_song = create_song(window,absolute_path)
+          songs[relative_path] = gosu_song
+        end
+
+        Metro::Song.new gosu_song, relative_path
+      end
+
+      def self.songs
+        @songs ||= {}
+      end
+
+      private
+
+      def self.create_song(window,filename)
+        Gosu::Song.new(window, filename)
+      end
+
+    end
+  end
+end

data/lib/metro/scene.rb

@@ -250,6 +250,7 @@ module Metro
     def register_actor(actor_factory)
       registering_actor = actor(actor_factory.name)
       registering_actor.window = window
+      registering_actor.show
 
       drawers.push(registering_actor)
       updaters.push(registering_actor)
@@ -338,6 +339,7 @@ module Metro
     #
     def self.inherited(base)
       scenes << base.to_s
+      Scenes.add_scene(base)
     end
 
     #
@@ -358,17 +360,6 @@ module Metro
       updaters.push(updater)
     end
 
-    #
-    # A simplier syntax to enqueue an animation. At the moment this animation is going
-    # to be an implicit animation.
-    #
-    def animate(actor_or_actor_name,options,&block)
-      options[:actor] = actor(actor_or_actor_name)
-      options[:context] = self
-      animation_group = SceneAnimation.build options, &block
-      enqueue animation_group
-    end
-
     #
     # The class defined updaters which will be converted to instance updaters when the scene
     # has started.

data/lib/metro/scenes.rb

@@ -27,6 +27,16 @@ module Metro
   module Scenes
     extend self
 
+    #
+    # Add a scene to the hash of scenes with the scene name of the scene as the key
+    # to retrieving this scene.
+    #
+    # @param [Scene] scene the scene to be added to the hash of Scenes.
+    #
+    def add_scene(scene)
+      all_scenes_for(scene).each { |scene| scenes_hash[scene.scene_name] = scene.to_s }
+    end
+
     #
     # Finds the scene based on the specified scene name.
     #
@@ -101,7 +111,7 @@ module Metro
     #   as well as the class name constants to allow for the scenes to be found.
     #
     def scenes_hash
-      @scenes_hash ||= build_map_of_scenes(Scene.scenes)
+      @scenes_hash ||= hash_with_missing_scene_default
     end
 
     #
@@ -114,22 +124,19 @@ module Metro
     # @see #scenes_hash
     #
     def build_map_of_scenes(scenes)
-      hash = hash_with_missing_scene_default
-      all_scenes_for(scenes).inject(hash) do |hash,scene|
-        hash[scene.scene_name] = scene.to_s
-        hash
-      end
     end
 
     #
     # Create a hash that will return a setup missing scene by default.
     #
     def hash_with_missing_scene_default
-      ActiveSupport::HashWithIndifferentAccess.new do |hash,key|
+      hash = HashWithIndifferentAccess.new do |hash,key|
         missing_scene = scene_class(hash[:missing_scene])
         missing_scene.missing_scene = key.to_sym
         missing_scene
       end
+      hash[:missing_scene] = "Metro::MissingScene"
+      hash
     end
 
     #

data/lib/metro/transitions/fade_transition_scene.rb

@@ -10,7 +10,14 @@ module Metro
     def show
       rectangle.color = starting_color
 
-      animate :rectangle, to: { color: final_color }, interval: interval do
+      color = final_color
+
+      animate :rectangle, to: { red: color.red,
+                                green: color.green,
+                                blue: color.blue,
+                                alpha: color.alpha },
+                          interval: interval do
+
         transition_to next_scene
       end
     end

data/lib/metro/units/bounds.rb

@@ -0,0 +1,8 @@
+module Metro
+  module Units
+
+    # Rectangle Bounds are common enough to be considered simply Bounds.
+    Bounds = RectangleBounds
+
+  end
+end

data/lib/metro/units/dimensions.rb

@@ -1,17 +1,35 @@
 module Metro
   module Units
+
+    #
+    # Represents an object that contains both the width and height.
+    #
     class Dimensions < Struct.new(:width,:height)
 
+      #
+      # Create a dimensions objects with zero width and zero height.
+      #
       def self.none
-        new 0.0, 0.0
+        of 0.0, 0.0
       end
 
-      def self.of(width,height)
-        new width.to_f, height.to_f
+      #
+      # Parse a string representation of a dimensions object. The
+      # supported formated is a comma-delimited string that contains
+      # two attributes width and height.
+      #
+      def self.parse(string)
+        of *string.split(",",2).map(&:to_f)
       end
 
-      def self.parse(string)
-        to *string.split(",",2).map(&:to_f)
+
+      #
+      # An alternate way of creating a dimensions object which
+      # will enforce that the values added are converted to floating
+      # point numbers.
+      #
+      def self.of(width,height)
+        new width.to_f, height.to_f
       end
 
       def to_s

data/lib/metro/units/point.rb

@@ -1,18 +1,37 @@
 module Metro
   module Units
+
+    #
+    # Represents and object that contains the x, y, and z position.
+    #
     class Point < Struct.new(:x,:y,:z)
+
+      #
+      # Generate a point at 0,0,0.
+      #
       def self.zero
         new 0.0, 0.0, 0.0
       end
 
+      #
+      # An alternate way of creating a point. Creation here converts
+      # all inputs to floating point and assumes that the z-value is
+      # zero (as this is a 2D universe).
+      #
       def self.at(x,y,z=0.0)
         new x.to_f, y.to_f, z.to_f
       end
 
+      #
+      # Parse a string representation of a point object. The
+      # supported formated is a comma-delimited string that contains
+      # either "x,y" or "x,y,z".
+      #
       def self.parse(string)
         at *string.split(",",3).map(&:to_f)
       end
 
+      # As this is a 2D world, the Z is often refered to as a the z-ordering
       alias_method :z_order, :z
       alias_method :z_order=, :z=
 
@@ -20,9 +39,15 @@ module Metro
         "#{x},#{y},#{z}"
       end
 
+      #
+      # Add the point to another point-like structure. Anything that also has
+      # the methods x, y, and z.
+      #
+      # @return a new point which is the sum of the point and the provided value.
+      #
       def +(value)
         raise "Unabled to add point to #{value} #{value.class}" if [ :x, :y, :z ].find { |method| ! value.respond_to?(method) }
-        self.class.new((x + value.x),(y + value.y),(z + value.z))
+        self.class.at((x + value.x),(y + value.y),(z + value.z))
       end
 
     end

data/lib/metro/units/rectangle_bounds.rb

@@ -0,0 +1,52 @@
+module Metro
+  module Units
+
+    #
+    # An object that represents a rectanglar bounds.
+    #
+    class RectangleBounds < Struct.new(:min_x,:min_y,:max_x,:max_y)
+
+      # Allow the ability to refer to the min, max values with their
+      # other alternate names.
+
+      alias_method :left, :min_x
+      alias_method :left=, :min_x=
+      alias_method :right, :max_x
+      alias_method :right=, :max_x=
+      alias_method :top, :min_y
+      alias_method :top=, :min_y=
+      alias_method :bottom, :max_y
+      alias_method :bottom=, :max_y=
+
+      #
+      # Create a bounds with bounds.
+      #
+      def initialize(params = {})
+        self.min_x = params[:x] || params[:min_x]
+        self.min_y = params[:y] || params[:min_y]
+        self.max_x = (params[:max_x] || (min_x + params[:width]))
+        self.max_y = (params[:max_y] || (min_y + params[:height]))
+      end
+
+      #
+      # Does this bounds contain the following point?
+      #
+      def contains?(x,y)
+        x > min_x and x < max_x and y > min_y and y < max_y
+      end
+
+      #
+      # Does this rectanglular bounds intersect with another rectanglular bounds?
+      #
+      def intersect?(b)
+        not(b.min_x > max_x or b.max_x < min_x or b.min_y > max_y or b.max_y < min_y)
+      end
+
+      def to_s
+        "(#{min_x},#{min_y}) to (#{max_x},#{max_y})"
+      end
+
+    end
+
+  end
+end

data/lib/metro/units/scale.rb

@@ -1,15 +1,31 @@
 module Metro
   module Units
+
+    #
+    # Represents an object that contains the x scale factor, and y scale factor.
+    #
     class Scale < Struct.new(:x_factor,:y_factor)
 
+      #
+      # Create a scale that is 1:1.
+      #
       def self.one
         new 1.0, 1.0
       end
 
+      #
+      # An alternative way to create a scale which will automatically convert
+      # the inputs into floating numbers.
+      #
       def self.to(x,y)
         new x.to_f, y.to_f
       end
 
+      #
+      # Parse a string representation of a scale object. The
+      # supported formated is a comma-delimited string that contains
+      # two attributes x-factor and y-factor.
+      #
       def self.parse(string)
         to *string.split(",",2).map(&:to_f)
       end

data/lib/metro/units/units.rb

@@ -1,3 +1,5 @@
 require_relative 'point'
 require_relative 'dimensions'
-require_relative 'scale'
+require_relative 'scale'
+require_relative 'rectangle_bounds'
+require_relative 'bounds'

data/lib/metro/version.rb

@@ -1,5 +1,5 @@
 module Metro
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
   WEBSITE = "https://github.com/burtlo/metro"
   CONTACT_EMAILS = ["franklin.webber@gmail.com"]
   

data/lib/metro/window.rb

@@ -60,6 +60,13 @@ module Metro
       scene.button_down(id)
     end
 
+    #
+    # @return the dimensions of the current window.
+    #
+    def dimensions
+      Metro::Units::Dimensions.of width, height
+    end
+
     #
     # Define an acessor that enables/disables the use of a cursor
     # within the window. The value should be truthy/falsy.

data/lib/templates/game/README.md.tt

@@ -7,4 +7,23 @@ are creating. This file's intention is to allow a user to
 refer to this for more information related to the game or 
 possibly any notes or caveats about the game.
 
-## Contact
+## Contact
+
+
+## Resources
+
+#### Art
+
+* [Lost Garden](http://www.lostgarden.com/2007/05/dancs-miraculously-flexible-game.html)
+
+#### Books
+
+* [Rules of Play](http://www.amazon.com/dp/0262240459)
+* [Game Programming Gems 8](http://www.amazon.com/dp/1584507020)
+* [Game Feel](http://www.amazon.com/dp/0123743281)
+* [Game Coding Complete](http://www.amazon.com/dp/1584506806)
+* [Game Design Workshop](http://www.amazon.com/dp/0240809742)
+* [Challenges For Game Designers](http://www.amazon.com/dp/158450580X)
+* [The Art of Game Design: A book of lenses](http://www.amazon.com/dp/0123694965)
+* [A Theory of Fun](http://www.theoryoffun.com)
+* [Andrew Rollings and Ernest Adams on Game Design](http://www.amazon.com/dp/1592730019)