metro-ld26 0.3.4

data/lib/metro/animation.rb

@@ -0,0 +1,135 @@
+module Metro
+
+  #
+  # The animation is an wrapper object for an array of Gosu::Images that also contains
+  # the additional information on the path, height, width, and tileability.
+  #
+  class Animation
+
+    attr_accessor :images, :path, :height, :width, :tileable, :time_per_image
+
+    def initialize(params = {})
+      @images = Array(params[:images])
+      @path = params[:path]
+      @height = params[:height]
+      @width = params[:width]
+      @tileable = params[:tileable]
+      @time_per_image = params[:time_per_image]
+    end
+
+    #
+    # @return a hash representation of the Animation
+    #
+    def to_hash
+      { path: path,
+        width: width.to_i, height: height.to_i,
+        tileable: !!tileable,
+        time_per_image: time_per_image }
+    end
+
+    #
+    # @return [Fixnum] the game time when the animation started to display.
+    #
+    def start_time
+      @start_time ||= current_time
+    end
+
+    #
+    # @return [Fixnum] the current time in the game.
+    #
+    def current_time
+      Gosu::milliseconds
+    end
+
+    #
+    # @return [Fixnum] the age of the animation.
+    #
+    def age
+      current_time - start_time
+    end
+
+    #
+    # @return the current animation image count.
+    #
+    def current_index
+      age / time_per_image
+    end
+
+    #
+    # @return the current animation image to display.
+    #
+    def current_image_index
+      current_index % images.size
+    end
+
+    #
+    # @return the animation is complete if it the current index exceeds the
+    #   number of images.
+    #
+    def complete?
+      current_index > (images.size - 1)
+    end
+
+    #
+    # @return a Gosu::Image to be displayed in a animation sequence.
+    #
+    def image
+      images[current_image_index]
+    end
+
+    #
+    # Finds an existing image or creates a new image given the window, path,
+    # width, height and tileablilty.
+    #
+    # @example Finding or creating an Animation image
+    #
+    #     Metro::Animation.find_or_create window: model.window,
+    #       path: "asset_path", tileable: tileable, width: 64, height: 64,
+    #       time_per_image: 50
+    #
+    def self.find_or_create(options)
+      new options.merge(images: find_or_create_gosu_images(options))
+    end
+
+    #
+    # Create an animation image given the window, path, width, height,
+    #  and tileability.
+    #
+    # @example Creating an Animation Image
+    #
+    #     Metro::Animation.create window: model.window,
+    #       path: "asset_path", tileable: tileable, width: 64, height: 64,
+    #       time_per_image: 50
+    #
+    def self.create(options)
+      new options.merge(images: create_gosu_images(options))
+    end
+
+    private
+
+    def self.create_gosu_images(options)
+      path = AssetPath.with(options[:path]).to_s
+      images[path] = Gosu::Image.load_tiles(*create_params(options))
+    end
+
+    def self.find_or_create_gosu_images(options)
+      path = AssetPath.with(options[:path]).to_s
+      images[path] or create_gosu_images(options)
+    end
+
+    def self.create_params(options)
+      options.symbolize_keys!
+      window = options[:window]
+      asset_path = AssetPath.with(options[:path]).filepath
+      width = options[:width].to_i
+      height = options[:height].to_i
+      tileable = !!options[:tileable]
+      [ window, asset_path, width, height, tileable ]
+    end
+
+    def self.images
+      @images ||= {}
+    end
+
+  end
+end

data/lib/metro/animation/after_interval_factory.rb

@@ -0,0 +1,12 @@
+module Metro
+  
+  class AfterIntervalFactory
+    attr_reader :ticks, :block
+    
+    def initialize(ticks,&block)
+      @ticks = ticks
+      @block = block
+    end
+  end
+
+end

data/lib/metro/animation/animation_factory.rb

@@ -0,0 +1,15 @@
+module Metro
+
+  class AnimationFactory
+
+    attr_reader :actor, :options, :on_complete_block
+
+    def initialize(actor,options = {},&block)
+      @actor = actor
+      @options = options
+      @on_complete_block = block
+    end
+
+  end
+
+end

data/lib/metro/animation/easing/ease_in.rb

@@ -0,0 +1,15 @@
+module Metro
+  class Easing
+
+    #
+    # Perform a ease-in motion between the start position and the final position.
+    #
+    class EaseIn < Easing
+      def self.calculation(moment,start,change,interval)
+        change * (moment = moment / interval) * moment + start
+      end
+    end
+
+    register :ease_in, EaseIn
+  end
+end

data/lib/metro/animation/easing/easing.rb

@@ -0,0 +1,51 @@
+module Metro
+
+  #
+  # An easing is a means to calculate the steps between the start and the final
+  # over an interval.
+  #
+  class Easing
+
+    #
+    # The calculate method is called within the ImplicitAnimation and will create
+    # an array of all the states between the start and the final value.
+    #
+    def self.calculate(start,final,interval)
+      change = final - start
+      (1..interval).map { |time| calculation(time.to_f,start,change,interval) }
+    end
+
+    #
+    # The calculation method is to be overriden in the Easing subclasses.
+    # This calculation figures out the value at the current moemnt.
+    #
+    def self.calculation(moment,start,change,interval) ; 0 ; end
+
+    #
+    # Register an easing within the game system.
+    #
+    def self.register(name,easing_class)
+      easings[name] = easing_class.to_s
+    end
+
+    #
+    # @return the easing class based on the specified easing name.
+    #
+    def self.easing_for(easing)
+      easing_classname = easings[easing]
+      easing_classname.constantize
+    end
+
+    #
+    # A hash of all the supported easings within metro or game.
+    #
+    def self.easings
+      @easings_hash ||= HashWithIndifferentAccess.new("Metro::Easing::Linear")
+    end
+
+  end
+
+end
+
+require_relative 'linear'
+require_relative 'ease_in'

data/lib/metro/animation/easing/linear.rb

@@ -0,0 +1,15 @@
+module Metro
+  class Easing
+
+    #
+    # Perform a linear motion between the start position and the final position.
+    #
+    class Linear < Easing
+      def self.calculation(moment,start,change,interval)
+        change * moment / interval + start
+      end
+    end
+
+    register :linear, Linear
+  end
+end

data/lib/metro/animation/has_animations.rb

@@ -0,0 +1,70 @@
+require_relative 'animation_factory'
+
+module Metro
+  module HasAnimations
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    #
+    # Define an animation from within another animation block, an event block
+    # or a method.
+    #
+    # @example Defining an animation that fades out the hero when they have
+    #   died.
+    #
+    #     class HellScene
+    #       draws :hero
+    #
+    #       def update
+    #         if hero.dead?
+    #           animate :hero, to: { alpha: 0 }, interval: 60.ticks do
+    #             transition_to :game_over
+    #           end
+    #         end
+    #       end
+    #
+    #     end
+    #
+    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
+
+    # An alternative to stating `animate` syntax.
+    alias_method :change, :animate
+
+    module ClassMethods
+
+      #
+      # Define an animation to execute when the scene starts.
+      #
+      # @example Defining an animation that fades in and moves a logo when it is
+      #   done, transition to the title scene.
+      #
+      #     animate :logo, to: { y: 80, alpha: 50 }, interval: 120.ticks do
+      #       transition_to :title
+      #     end
+      #
+      def animate(actor_name,options,&block)
+        scene_animation = AnimationFactory.new actor_name, options, &block
+        animations.push scene_animation
+      end
+
+      # Provide an alternative to the `animate` syntax.
+      alias_method :change, :animate
+
+      #
+      # All the animations that are defined for the scene to be run the scene starts.
+      #
+      def animations
+        @animations ||= []
+      end
+
+    end
+
+  end
+end

data/lib/metro/animation/implicit_animation.rb

@@ -0,0 +1,100 @@
+require_relative 'easing/easing'
+
+module Metro
+
+  #
+  # An Implicit Animation is an animation without all the work.
+  # This little animation will take care of figuring out moving an
+  # actor from one position to another, the rotation, the alpha,
+  # etc.
+  #
+  # @example Creating an explicit animation that moves a player
+  #
+  #     animation = ImplicitAnimation.new actor: player,
+  #       to: { x: final_x, y: final_y },
+  #       interval: 80,
+  #       easing: :ease_in,
+  #       context: scene
+  #
+  #     animation.on_complete do
+  #       transition_to :main
+  #     end
+  #
+  # Here an animation is created that will move the player to the
+  # position (final_x,final_y), specified in the :to hash that is
+  # provided, over the interval of 80 steps. Additionally the movement
+  # is done with an easing in.
+  #
+  # @note The actor object must respond to setter methods that match
+  #   the specified attributes (e.g. x, y).
+  #
+  # The context provided is the context that the 'on_complete' block
+  # is executed. In this case, upon completition, transition the scene
+  # from the current one to the main scene.
+  #
+  class ImplicitAnimation < OnUpdateOperation
+
+    def animations
+      @animations ||= []
+    end
+
+    #
+    # @return the type of easing that the implicit animation should employ.
+    #   By default it uses linear but can be overridden when the easing is
+    #   configured.
+    #
+    attr_reader :easing
+
+    #
+    # Additional initializion is required to calculate the attributes
+    # that are going to be animated and to determine each of their deltas.
+    #
+    def after_initialize
+      to.each do |attribute,final|
+        start = actor.send(attribute)
+        animations.push build_animation_step(attribute,start,final)
+      end
+    end
+
+    def build_animation_step(attribute,start,final)
+      step = AnimationStep.new
+      step.actor = actor
+      step.attribute = attribute
+      step.deltas = easing_for(easing).calculate(start.to_f,final.to_f,interval.to_f)
+      step
+    end
+
+    class AnimationStep
+      attr_accessor :actor, :attribute, :deltas
+
+      def execute_step(step)
+        actor.set(attribute,deltas.at(step))
+      end
+    end
+
+    #
+    # @return the correct easing based on the specified name. When the name
+    #   provided does not match anything then default to linear easing.
+    #
+    def easing_for(name)
+      Metro::Easing.easing_for(name)
+    end
+
+    #
+    # The ImplicitAnimation overrides the {Animation#execute_step} and
+    # updates the attributes of the actor based upon the value of the
+    # current animation step.
+    #
+    def execute_step
+      animations.each {|step| step.execute_step(current_step) }
+    end
+
+    #
+    # @return the delta for the attribute for the given step
+    #
+    def delta_for_step(attribute)
+      deltas[attribute].at(current_step)
+    end
+
+  end
+end

data/lib/metro/animation/on_update_operation.rb

@@ -0,0 +1,96 @@
+module Metro
+
+  #
+  # OnUpdateOperation is an object that executes on the update cycle
+  # of the game. This usually take the form of an animation or some operation
+  # that needs to execute with each update of the game.
+  #
+  class OnUpdateOperation
+
+    def after_initialize ; end
+
+    def initialize(options)
+      @current_step = 0
+
+      options.each do |key,value|
+        send :instance_variable_set, "@#{key}".to_sym, value
+        self.class.send :define_method, key do
+          instance_variable_get("@#{key}")
+        end
+      end
+      after_initialize
+    end
+
+    #
+    # Sets the action that happens with each step of the animation.
+    #
+    def on_step(&block)
+      @step_block = block
+    end
+
+    #
+    # Sets the action that happens when the animation is completed.
+    #
+    def on_complete(&block)
+      @complete_block = block
+    end
+
+    #
+    # Perform a step of an animation, if it hasn't already been completed.
+    #
+    def update
+      return if update_completed?
+
+      execute_step
+      next_step
+
+      complete! if update_completed?
+    end
+
+    #
+    # @return the current step of the animation.
+    #
+    attr_reader :current_step
+
+    attr_reader :step_block, :complete_block
+
+    #
+    # Move to the next step in the animation.
+    #
+    def next_step
+      @current_step = current_step + step_interval
+    end
+
+    #
+    # @return the interval at which the animation take place.
+    #
+    def step_interval
+      1
+    end
+
+    #
+    # @return true if the animation has completed all the actions, false
+    #   if there are remaining actions.
+    #
+    def update_completed?
+      current_step >= interval
+    end
+
+    #
+    # Perform the action that happens with each step of the animation.
+    #
+    def execute_step
+      context.instance_eval(&@step_block) if step_block and context
+    end
+
+    #
+    # Perform the action that happens when the animation is completed.
+    #
+    def complete!
+      context.instance_eval(&@complete_block) if complete_block and context
+    end
+
+  end
+end
+
+require_relative 'implicit_animation'