metro-ld26 0.3.4

data/lib/metro/transitions/transition_scene.rb

@@ -0,0 +1,19 @@
+module Metro
+  class TransitionScene < Scene
+
+    attr_accessor :next_scene, :previous_scene, :options
+
+    def prepare_transition_from(old_scene)
+      next_scene.prepare_transition_from(old_scene)
+      @previous_scene = old_scene
+    end
+
+    def prepare_transition_to(new_scene)
+      previous_scene.prepare_transition_to(new_scene)
+    end
+
+  end
+end
+
+require_relative 'fade_transition_scene'
+require_relative 'edit_transition_scene'

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

@@ -0,0 +1,74 @@
+module Metro
+  module Units
+    module CalculationValidations
+
+      #
+      # @param [Object] value the other object that needs to be validated.
+      #
+      def check_calculation_requirements(value)
+        if calculation_requirements.find { |method| ! value.respond_to?(method) }
+          raise "Unable to perform operation with #{value} #{value.class} It is missing a property #{calculation_requirements.join(",")}"
+        end
+      end
+
+      #
+      # @return [Array] an array of methods that are required to be on the
+      #   object for it to be correctly calculated.
+      #
+      # @note this method is intended to be defined in the including class. This
+      #   method is included here when one has not been provided.
+      def calculation_requirements
+        []
+      end
+
+      #
+      # Add this object to another object.
+      #
+      # @return a new object that is the sum of the two objects
+      #
+      def +(value)
+        self.class.new *calculate(value,:+)
+      end
+
+      #
+      # Subtract the other object from this object.
+      #
+      # @return a new object that is the difference of the original object
+      #   and the value specified.
+      #
+      def -(value)
+        self.class.new *calculate(value,:-)
+      end
+
+      #
+      # Multiply this object and another object.
+      #
+      # @return a new object that is the product of the two objects.
+      #
+      def *(value)
+        self.class.new *calculate(value,:*)
+      end
+
+      #
+      # This generic method will perform the calculation defined by the
+      # operation for all the calculation requirements defined.
+      #
+      # @param [value] value this is the other value that is being added,
+      #   subtracted, etc. to the current object.
+      # @param [Symbol] operation this is the mathematical operation that
+      #   is being performed between all the calc requirements of the current
+      #   object and other value.
+      #
+      # @return [Array] an array of reults from the calculations of all the
+      #   requirements.
+      #
+      def calculate(value,operation)
+        check_calculation_requirements(value)
+        calculation_requirements.map do |requirement|
+          send(requirement).send(operation,value.send(requirement))
+        end
+      end
+
+    end
+  end
+end

data/lib/metro/units/dimensions.rb

@@ -0,0 +1,60 @@
+module Metro
+  module Units
+
+    #
+    # Represents an object that contains both the width and height.
+    #
+    class Dimensions < Struct.new(:width,:height)
+      include CalculationValidations
+
+      #
+      # Create a dimensions objects with zero width and zero height.
+      #
+      def self.none
+        of 0.0, 0.0
+      end
+
+      #
+      # 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.to_s.split(",",2).map(&:to_f)
+      end
+
+
+      #
+      # 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=0.0,height=0.0)
+        new width.to_f, height.to_f
+      end
+
+      def to_s
+        "#{width},#{height}"
+      end
+
+      #
+      # Compare the dimension to another dimensions-like structure.
+      #
+      # @return [Fixnum] -1 if the dimensions is smaller than the other dimension,
+      #   0 if the dimensions are exactly the same, 1 if the dimensions are bigger
+      #   then the other dimensions.
+      #
+      def <=>(value)
+        check_calculation_requirements(value)
+        (width * height) <=> (value.width * value.height)
+      end
+
+      private
+
+      def calculation_requirements
+        [ :width, :height ]
+      end
+
+    end
+  end
+end

data/lib/metro/units/point.rb

@@ -0,0 +1,51 @@
+module Metro
+  module Units
+
+    #
+    # Represents and object that contains the x, y, and z position.
+    #
+    class Point < Struct.new(:x,:y,:z)
+      include CalculationValidations
+
+      #
+      # 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=0.0,y=0.0,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.to_s.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=
+
+      def to_s
+        "#{x},#{y},#{z}"
+      end
+
+      private
+
+      def calculation_requirements
+        [ :x, :y, :z ]
+      end
+
+    end
+  end
+end

data/lib/metro/units/rectangle_bounds.rb

@@ -0,0 +1,148 @@
+module Metro
+  module Units
+
+    #
+    # An object that represents a rectanglar bounds.
+    #
+    class RectangleBounds
+      include CalculationValidations
+
+      attr_accessor :left, :right, :top, :bottom
+
+      def self.none
+        new left: 0, right: 0, top: 0, bottom: 0
+      end
+
+      #
+      # Create a bounds with bounds.
+      #
+      def initialize(params = {})
+        @left = params[:left].to_f
+        @top = params[:top].to_f
+        @right = params[:right].to_f
+        @bottom = params[:bottom].to_f
+      end
+
+      #
+      # Move the bounds by the amount specified in the point.
+      #
+      def shift(point)
+        self.left = self.left + point.x
+        self.right = self.right + point.x
+        self.top = self.top + point.y
+        self.bottom = self.bottom + point.y
+      end
+
+      #
+      # Create a new RectangleBounds that is larger than the
+      # current bounds, given the specifed hash of parameters
+      # that contain the amount to expand in the four directions
+      # left, right, top, bottom.
+      #
+      def enlarge(params = {})
+        self.class.new(left: left - params[:left].to_i,
+            right: right + params[:right].to_i,
+            top: top - params[:top].to_i,
+            bottom: bottom + params[:bottom].to_i)
+      end
+
+      def shrink(params = {})
+        self.class.new(left: left + params[:left].to_i,
+            right: right - params[:right].to_i,
+            top: top + params[:top].to_i,
+            bottom: bottom - params[:bottom].to_i)
+      end
+
+      def clamp(point)
+        return point if contains?(point)
+
+        new_point = Point.new(point.x,point.y)
+
+        if point.x < left
+          new_point.x = left
+        end
+
+        if point.x > right
+          new_point.x = right
+        end
+
+        if point.y < top
+          new_point.y = top
+        end
+
+        if point.y > bottom
+          new_point.y = bottom
+        end
+
+        new_point
+      end
+
+      def top_left
+        point_at left, top
+      end
+
+      def top_right
+        point_at right, top
+      end
+
+      def bottom_right
+        point_at right, bottom
+      end
+
+      def bottom_left
+        point_at left, bottom
+      end
+
+      def width
+        (right - left)
+      end
+
+      def height
+        (bottom - top)
+      end
+
+      def center
+        top_left + point_at(width/2,height/2)
+      end
+
+      def dimensions
+        Dimensions.of width, height
+      end
+
+      def ==(value)
+        check_calculation_requirements(value)
+        left == value.left and right == value.right and top == value.top and bottom == value.bottom
+      end
+
+      #
+      # Does this bounds contain the following point?
+      #
+      def contains?(point)
+        point.x > left and point.x < right and point.y > top and point.y < bottom
+      end
+
+      #
+      # Does this rectanglular bounds intersect with another rectanglular bounds?
+      #
+      def intersect?(b)
+        not(b.left > right or b.right < left or b.top > bottom or b.bottom < top)
+      end
+
+      def to_s
+        "(#{left},#{top}) to (#{right},#{bottom})"
+      end
+
+      private
+
+      def point_at(x,y)
+        Point.at(x,y)
+      end
+
+      def calculation_requirements
+        [ :left, :right, :top, :bottom ]
+      end
+
+    end
+
+  end
+end

data/lib/metro/units/scale.rb

@@ -0,0 +1,46 @@
+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)
+      include CalculationValidations
+
+      #
+      # 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
+
+      def to_s
+        "#{x_factor},#{y_factor}"
+      end
+
+      private
+
+      def calculation_requirements
+        [ :x_factor, :y_factor ]
+      end
+
+    end
+  end
+end

data/lib/metro/units/units.rb

@@ -0,0 +1,6 @@
+require_relative 'calculation_validations'
+require_relative 'point'
+require_relative 'dimensions'
+require_relative 'scale'
+require_relative 'rectangle_bounds'
+require_relative 'bounds'

data/lib/metro/version.rb

@@ -0,0 +1,32 @@
+module Metro
+  VERSION = "0.3.4"
+  WEBSITE = "https://github.com/burtlo/metro"
+  CONTACT_EMAILS = ["dev@rubymetro.com"]
+  
+  def self.changes_for_version(version)
+
+    change = Struct::Changes.new(nil,[])
+
+    grab_changes = false
+
+    changelog_filename = "#{File.dirname(__FILE__)}/../../changelog.md"
+
+    File.open(changelog_filename,'r') do |file|
+      while (line = file.gets) do
+
+        if line =~ /^##\s*#{version.gsub('.','\.')}\s*\/\s*(.+)\s*$/
+          grab_changes = true
+          change.date = $1.strip
+        elsif line =~ /^##\s*.+$/
+          grab_changes = false
+        elsif grab_changes
+          change.changes.push line
+        end
+
+      end
+    end
+
+    change
+  end
+  
+end