ray 0.1.0.pre1 → 0.1.0

data/lib/ray/animation/block_animation.rb

@@ -0,0 +1,36 @@
+module Ray
+  class Animation
+    # Animation occurring by running a block.
+    # Registered as #block_animation.
+    # @example
+    #   block_animation :duration => 10, :block => proc { |target, progression|
+    #     p target => progression
+    #   }
+    class BlockAnimation < Animation
+      register_for :block_animation
+
+      # @option opts [#call] :block Object which will be called with the target
+      #   and a progression between 0 and 1.
+      # @option opts [#call] :proc Same as :block.
+      # @option opts [true, false] :reversed (false) True to make the
+      #   progression decrease from 1 to 0.
+      # @option opts [Float] :duration Duration in seconds.
+      def setup(opts)
+        @block    = opts[:block] || opts[:proc]
+        @reversed = opts.key?(:reversed) ? opts[:reversed] : false
+
+        self.duration = opts[:duration]
+      end
+
+      def update_target
+        @block.call(target, @reversed ? 1 - progression : progression)
+      end
+
+      # @return [BlockAnimation] Reversed animation.
+      def -@
+        block_animation(:block => @block, :reversed => !@reversed,
+                        :duration => @duration)
+      end
+    end
+  end
+end

data/lib/ray/animation/circular_motion.rb

@@ -0,0 +1,57 @@
+module Ray
+  class Animation
+    # The target of this animation will move on a circular
+    # orbit.
+    #
+    # Registered as #circular_motion.
+    class CircularMotion < Animation
+      register_for :circular_motion
+
+      # @option opts [Ray::Vector2] :center Center of the orbit
+      # @option opts [Float] :radius Radius of the circle followed by the target.
+      # @option opts [Float] :angle Required unless :from and :to are set.
+      #   Last value for the angle.
+      # @option opts [Float] :from First value for the angle.
+      # @option opts [Float] :to Last value for the angle.
+      # @option opts [Float] :duration Duration in seconds.
+      def setup(opts)
+        @center = opts[:center].to_vector2
+        @radius = opts[:radius]
+
+        if opts[:angle]
+          @from_angle = 0
+          @to_angle   = (opts[:angle] / 180) * Math::PI
+        else
+          @from_angle = (opts[:from] / 180) * Math::PI
+          @to_angle   = (opts[:to]   / 180) * Math::PI
+        end
+
+        self.duration = opts[:duration]
+      end
+
+      def update_target
+        angle = @from_angle + progression * (@from_angle - @to_angle)
+
+        x = @center.x + (Math.cos(angle) * @radius)
+        y = @center.y - (Math.sin(angle) * @radius)
+
+        target.pos = [x, y]
+      end
+
+      def end_animation
+        x = @center.x + (Math.cos(@to_angle) * @radius)
+        y = @center.y - (Math.sin(@to_angle) * @radius)
+
+        target.pos = [x, y]
+      end
+
+      # @return [CircularMotion] An animation cancelling self.
+      def -@
+        circular_motion(:from => (@to_angle / Math::PI) * 180,
+                        :to => (@from_angle / Math::PI) * 180,
+                        :duration => duration, :center => @center,
+                        :radius => @radius)
+      end
+    end
+  end
+end

data/lib/ray/animation/color_variation.rb

@@ -0,0 +1,102 @@
+module Ray
+  class Animation
+    # This animates the transition from a color to another one.
+    # Registered as #color_variation.
+    class ColorVariation < Animation
+      register_for :color_variation
+
+      # @option opts [Array] :of [r, g, b, a] Variation for the color.
+      #   Required unless :from and :to are set.
+      # @option opts [Ray::Color] :from Initial value for the color.
+      # @option opts [Ray::Color] :to Last value of the color.
+      # @option opts [Symbol] :attribute (:color) Attribute of the target to change.
+      # @option opts [Float] :duration Duration in seconds.
+      def setup(opts)
+        if opts[:of]
+          @current_value = @initial_value = nil
+          @variation = opts[:of].to_a
+        else
+          @initial_value = opts[:from].to_color
+
+          value_array = @initial_value.to_a
+
+          @variation = opts[:to].to_a.each_with_index.map do |o, i|
+            o - value_array[i]
+          end
+        end
+
+        @attribute = opts[:attribute] || :color
+
+        self.duration = opts[:duration]
+      end
+
+      def setup_target
+        unless @initial_value
+          @current_value = target.send(@attribute)
+        else
+          @current_value = @initial_value.dup
+        end
+
+        @animations = []
+        @animations << float_variation(:of => @variation[0], :attribute => :r,
+                                       :duration => duration)
+        @animations << float_variation(:of => @variation[1], :attribute => :g,
+                                       :duration => duration)
+        @animations << float_variation(:of => @variation[2], :attribute => :b,
+                                       :duration => duration)
+        @animations << float_variation(:of => @variation[3], :attribute => :a,
+                                       :duration => duration)
+
+        @animations.each { |anim| anim.start(@current_value) }
+      end
+
+      def pause_animation
+        @animations.each { |anim| anim.pause }
+      end
+
+      def resume_animation
+        @animations.each { |anim| anim.resume }
+      end
+
+      def update_target
+        @animations.each { |anim| anim.update }
+        target.send("#{@attribute}=", @current_value)
+      end
+
+      # @return [ColorVariation] Opposite color variation.
+      def -@
+        if @initial_value
+          color_variation(:from => last_value, :to => @initial_value,
+                          :attribute => @attribute, :duration => duration)
+        else
+          rev_variation = @variation.map { |o| -o }
+          color_variation(:of => rev_variation, :attribute => @attribute,
+                          :duration => duration)
+        end
+      end
+
+      # @return [Ray::Color] Current color.
+      attr_accessor :current_value
+
+      # @return [Ray::Color] Initial color.
+      attr_reader :initial_value
+
+      # @return [Array<Integer>] Variation between initial and last value.
+      attr_reader :variation
+
+      # @return [Symbol] Attribut modified by the animation.
+      attr_reader :attribute
+
+      # @return [Ray::Color] Last color.
+      def last_value
+        if @initial_value
+          initial_array = @initial_value.to_a
+
+          Ray::Color.new(*initial_array.each_with_index.map { |o, i|
+                           o + @variation[i]
+                         })
+        end
+      end
+    end
+  end
+end

data/lib/ray/animation/combination.rb

@@ -0,0 +1,71 @@
+module Ray
+  class Animation
+    # This class allows to use a single object to apply several kind of
+    # animations to a same target.
+    #
+    # Note combining two animations affecting the same attribute usually won't
+    # work.
+    #
+    # Thus:
+    #   translation(:of => [10, 10], :duration => 2) +
+    #     translation(:of => [10, 10], :duration => 2)
+    # Is not the same as:
+    #   translation(:of => [20, 20], :duration => 2)
+    #
+    #
+    class Combination < Animation
+      register_for :animation_combination
+
+      def setup(*args)
+        @animations = args
+        self.duration = @animations.map(&:duration).max || 0
+      end
+
+      def setup_target
+        @animations.each { |anim| anim.start(target) }
+      end
+
+      def update_target
+        @animations.each { |anim| anim.update }
+      end
+
+      def pause_animation
+        @animations.each { |anim| anim.pause }
+      end
+
+      def resume_animation
+        @animations.each { |anim| anim.resume }
+      end
+
+      # Adds several animations to this combination.
+      def push(*animations)
+        @animations.concat(animations)
+        max_duration = animations.map(&:duration).max || 0
+        self.duration = max_duration if max_duration > duration
+
+        self
+      end
+
+      alias :<< :push
+
+      # (see Ray::Animation#+)
+      def +(animation)
+        animation_combination(*(@animations + [animation]))
+      end
+
+      # (see Ray::Animation#-)
+      def -(animation)
+        animation_combination(*(@animations + [-animation]))
+      end
+
+      # @return [Ray::Animation::Combination] Combination of the opposite of
+      #   each animation stored in this object.
+      def -@
+        animation_combination(*@animations.map { |anim| -anim })
+      end
+
+      # @return [Array<Ray::Animation>]
+      attr_reader :animations
+    end
+  end
+end

data/lib/ray/animation/float_variation.rb

@@ -0,0 +1,76 @@
+module Ray
+  class Animation
+    # Animates the transition of a float to another one.
+    # Registered as #float_variation.
+    class FloatVariation < Animation
+      register_for :float_variation
+
+      # @option opts [Float] :of Variation of the value. May be negative.
+      #   Required unless :to and :from are set.
+      # @option opts [Float] :from Initial value of attribute.
+      # @option opts [Float] :to Last value of attribute.
+      # @option opts [Symbol] :attribute Attribute of the target to change.
+      # @option opts [Float] :duration Duration in seconds.
+      def setup(opts)
+        if opts[:of]
+          @initial_value = nil
+          @variation = opts[:of]
+        else
+          @initial_value = opts[:from]
+          @variation = opts[:to] - @initial_value
+        end
+
+        @attribute = opts[:attribute]
+
+        self.duration = opts[:duration]
+      end
+
+      def setup_target
+        unless @initial_value
+          @current_value = target.send(@attribute)
+        else
+          @current_value = @initial_value
+        end
+      end
+
+      def update_target
+        increase = progression * @variation
+        target.send("#{@attribute}=", @current_value + increase)
+      end
+
+      def end_animation
+        target.send("#{@attribute}=", @current_value + @variation)
+      end
+
+      # @return [FloatVariation] The opposite variation.
+      def -@
+        if @initial_value
+          float_variation(:from => @initial_value + @variation,
+                          :to => @initial_value,
+                          :attribute => @attribute,
+                          :duration => duration)
+        else
+          float_variation(:of => -@variation, :attribute => @attribute,
+                          :duration => duration)
+        end
+      end
+
+      # @return [Symbol] Attribute modified by the animation.
+      attr_reader :attribute
+
+      # @return [Float] Initial value.
+      attr_reader :initial_value
+
+      # @return [Float] Variation between the initial value and the last value.
+      attr_reader :variation
+    end
+  end
+
+  module Helper
+    # @return [Ray::Animation::FloatVariation] Same as #float_variation, but
+    #   attribute is set to angle.
+    def rotation(opts)
+      float_variation(opts.merge(:attribute => :angle))
+    end
+  end
+end

data/lib/ray/animation/sequence.rb

@@ -0,0 +1,65 @@
+module Ray
+  class Animation
+    # Stores an array of animations that will be executed sequentially.
+    #
+    # Registered as animation_sequence.
+    class Sequence < Animation
+      register_for :animation_sequence
+
+      # @param [Array<Animation>] animations Animation to execute
+      def setup(*animations)
+        @animations   = animations
+        @current_anim = nil
+
+        self.duration = @animations.inject(0) { |sum, a| sum + a.duration }
+      end
+
+      def setup_target
+        @animations.each { |anim| anim.event_runner = event_runner }
+
+        @animations.each_cons(2) do |prev, succ|
+          on :animation_end, prev do
+            @current_anim = succ
+            succ.start target
+          end
+        end
+
+        @current_anim = @animations.first
+
+        @current_anim.start target
+      end
+
+      def update_target
+        @current_anim.update
+      end
+
+      def pause_animation
+        @current_anim.pause
+      end
+
+      def resume_animation
+        @current_anim.resume
+      end
+
+      # Adds several animations to the sequence.
+      def push(*animations)
+        @animations.concat(animations)
+        self.duration += animations.inject(0) { |sum, a| sum + a.duration }
+
+        self
+      end
+
+      alias :<< :push
+
+      # @return [Ray::Animation::Sequence] Animation sequence, calling reversed
+      #   animations in reversed order.
+      def -@
+        anims = @animations.reverse.map { |anim| -anim }
+        animation_sequence(*anims)
+      end
+
+      # @return [Array<Ray::Animation>]
+      attr_reader :animations
+    end
+  end
+end

data/lib/ray/animation/sprite_animation.rb

@@ -0,0 +1,68 @@
+module Ray
+  class Animation
+    # Sprite animations are used to animate a position change in a sprite
+    # sheet.
+    #
+    # It is written so that each step of the animation (including the latest
+    # one) has the same duration.
+    class SpriteAnimation < Ray::Animation
+      register_for :sprite_animation
+
+      # @option opts [Ray::Vector2] :from First sprite position
+      # @option opts [Ray::Vector2] :to   Last sprite position
+      # @option opts [true, false]  :loop Whether to reset to the first step at
+      #   the end of the animation.
+      # @option opts [Float] :duration Duration of the animation, in seconds.
+      def setup(opts)
+        self.duration = opts[:duration]
+
+        @initial_value = opts[:from].to_vector2.dup
+
+        delta = opts[:to].to_vector2 - opts[:from].to_vector2
+
+        @x_steps = delta.x.to_i.abs + 1
+        @y_steps = delta.y.to_i.abs + 1
+
+        @negative_x = delta.x < 0
+        @negative_y = delta.y < 0
+
+        @loop = opts[:loop]
+      end
+
+      def update_target
+        progress = progression
+
+        x_prog = (progress * @x_steps).floor
+        y_prog = (progress * @y_steps).floor
+
+        x_prog = @x_steps - 1 if x_prog == @x_steps
+        y_prog = @y_steps - 1 if y_prog == @y_steps
+
+        target.sheet_pos = @initial_value + variation(x_prog, y_prog)
+      end
+
+      def end_animation
+        target.sheet_pos = @initial_value if @loop
+      end
+
+      def variation(x, y)
+        Ray::Vector2[@negative_x ? -x : x, @negative_y ? -y : y]
+      end
+
+      def -@
+        last_value = @initial_value + variation(@x_steps - 1, @y_steps - 1)
+
+        sprite_animation(:from     => @initial_value,
+                         :to       => last_value,
+                         :loop     => @loop,
+                         :duration => @duration)
+      end
+
+      attr_reader :current_value
+
+      attr_reader :initial_value
+      attr_reader :x_steps, :y_steps
+      attr_reader :negative_x, :negative_y
+    end
+  end
+end