ray 0.1.0.pre1 → 0.1.0

data/lib/ray/animation/vector_variation.rb

@@ -0,0 +1,111 @@
+module Ray
+  class Animation
+    # Animates the transition from a vector to another one.
+    # Registered as #vector_variation.
+    class VectorVariation < Animation
+      register_for :vector_variation
+
+      # @option opts [Ray::Vector2, Ray::Vector3] :of [r, g, b, a] Variation for
+      #   the vector. Required unless :from and :to are set.
+      # @option opts [Ray::Vector2, Ray::Vector3] :from Initial value of the vector.
+      # @option opts [Ray::Vector2, Ray::Vector3] :to Last value of the vector.
+      # @option opts [Symbol] :attribute 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]
+
+          if (@variation.is_a?(Array) && @variation.size == 3) ||
+              @variation.is_a?(Ray::Vector3)
+            @variation = @variation.to_vector3
+          else
+            @variation = @variation.to_vector2
+          end
+        else
+          if (opts[:from].is_a?(Array) && opts[:from].size == 2) ||
+              opts[:from].is_a?(Ray::Vector2)
+            @initial_value = opts[:from].to_vector2
+            @variation = opts[:to].to_vector2 - @initial_value
+          else
+            @initial_value = opts[:from].to_vector3
+            @variation = opts[:to].to_vector3 - @initial_value
+          end
+        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.dup
+        end
+
+        @animations = []
+        @animations << float_variation(:of => @variation.x, :attribute => :x,
+                                       :duration => duration)
+        @animations << float_variation(:of => @variation.y, :attribute => :y,
+                                       :duration => duration)
+
+        if @variation.is_a? Ray::Vector3
+          @animations << float_variation(:of => @variation.z, :attribute => :z,
+                                         :duration => duration)
+        end
+
+        @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 [VectorVariation] The opposite vector variation.
+      def -@
+        if @initial_value
+          vector_variation(:to   => @initial_value.dup,
+                           :from => @initial_value + @variation,
+                           :attribute => @attribute,
+                           :duration => duration)
+        else
+          vector_variation(:of => -@variation, :attribute => @attribute,
+                           :duration => duration)
+        end
+      end
+
+      attr_accessor :current_value
+
+      attr_reader :initial_value
+      attr_reader :variation
+      attr_reader :attribute
+
+      def last_value
+        @initial_value + @variation if @initial_value
+      end
+    end
+  end
+
+  module Helper
+    # Same as #vector_variation, but :attribute is set to :pos.
+    def translation(opts)
+      vector_variation(opts.merge(:attribute => :pos))
+    end
+
+    # Same as #vector_variation, but :attribute is set to :scale.
+    def scale_variation(opts)
+      vector_variation(opts.merge(:attribute => :scale))
+    end
+  end
+end

data/lib/ray/animation_list.rb

@@ -0,0 +1,50 @@
+module Ray
+  # Animations lists are collections of animations, updating them and
+  # removing all the animations that are done running. As this the only thing
+  # you'll need to do most of the time, you can just push an animation at the
+  # end of it and let {Scene} do the rest of the work.
+  #
+  # @example
+  #   animations << color_variation(:from => [255, 0, 0], :to => [0, 255, 0],
+  #                                 :duration => 3).start(sprite)
+  #
+  class AnimationList
+    include Enumerable
+
+    def initialize
+      @animations = []
+    end
+
+    # @return [true, false] True if the animation list is empty
+    def empty?
+      @animations.empty?
+    end
+
+    # @param [Ray::Animation] elem An animation to add to the animation list.
+    def <<(elem)
+      @animations << elem
+      self
+    end
+
+    # Updates all the animations, and removes those that are finished.
+    def update
+      @animations.reject! do |anim|
+        anim.update
+        !anim.running? && !anim.paused?
+      end
+
+      self
+    end
+
+    # @yield Iterates over all of the animations.
+    # @yieldparam [Ray::Animation] anim An animation.
+    def each(&block)
+      @animations.each(&block)
+      self
+    end
+
+    def inspect
+      "#{self.class}#{@animations.inspect}"
+    end
+  end
+end

data/lib/ray/audio.rb

@@ -1,11 +1,8 @@
 module Ray
-  class Sound
-    extend Ray::ResourceSet
-    add_set(/^(.*)$/) { |filename| new(filename) }
-  end
+  module Audio
+    alias position  pos
+    alias position= pos=
 
-  class Music
-    extend Ray::ResourceSet
-    add_set(/^(.*)$/) { |filename| new(filename) }
+    module_function :position, :position=
   end
 end

data/lib/ray/buffer_renderer.rb

@@ -0,0 +1,9 @@
+module Ray
+  class BufferRenderer
+    alias << push
+
+    def drawables
+      @drawables.dup # don't let evil users touch this!
+    end
+  end
+end

data/lib/ray/color.rb

@@ -11,15 +11,46 @@ module Ray
       def cyan;    new(0, 255, 255);   end
       def yellow;  new(255, 255, 0);   end
       def fuschia; new(255, 0, 255);   end
+
+      # @param [Float] hue Hue, between 0 and 360
+      # @param [Float] sat Saturation, between 0 and 1
+      # @param [Float] val Value, between 0 and 1
+      #
+      # @return [Ray::Color] Color created from those parameters
+      def from_hsv(hue, sat, val)
+        hue, sat, val = hue.to_f, sat.to_f, val.to_f
+
+        if sat == 0
+          new(val * 255, val * 255, val * 255)
+        else
+          i = (hue / 60).floor % 6
+          f = (hue / 60) - i
+          l = val * (1 - sat)
+          m = val * (1 - f * sat)
+          n = val * (1 - (1 - f) * sat)
+
+          case i
+          when 0 then new(val * 255, n * 255, l * 255)
+          when 1 then new(m * 255, val * 255, l * 255)
+          when 2 then new(l * 255, val * 255, n * 255)
+          when 3 then new(l * 255, m * 255, val * 255)
+          when 4 then new(n * 255, l * 255, val * 255)
+          when 5 then new(val * 255, l * 255, m * 255)
+          end
+        end
+      end
+    end
+
+    def to_color
+      self
     end
 
     def to_s
       "RGBA(#{r}, #{g}, #{b}, #{a})"
     end
 
-    # @param [Ray::Color] color Another color
-    # @return [Ray::Color] Sum of two colors, each components
-    #   are added.
+    # @param [Ray::Color] color Another color.
+    # @return [Ray::Color] Sum of two colors, adding component pairs.
     def +(color)
       r = red   + color.red
       g = green + color.green
@@ -32,9 +63,9 @@ module Ray
                      a > 255 ? 255 : a)
     end
 
-    # @param [Ray::Color] color Another color
-    # @return [Ray::Color] Product of two colors, each components
-    #   are multiplied and then divided by 255.
+    # @param [Ray::Color] color Another color.
+    # @return [Ray::Color] Product of two colors, multiplying component pairs
+    #   before dividing everything by 255.
     def *(color)
       Ray::Color.new(r * color.r / 255.0,
                      g * color.g / 255.0,
@@ -55,6 +86,10 @@ module Ray
       [r, g, b, a].hash
     end
 
+    def to_a
+      [r, g, b, a]
+    end
+
     alias :red :r
     alias :green :g
     alias :blue :b

data/lib/ray/drawable.rb

@@ -1,16 +1,41 @@
 module Ray
   class Drawable
-    # Draws the drawable on an image.
-    def draw_on(image)
-      image.draw_drawable self
+    def y
+      pos.y
     end
 
-    # Draws the drawable.
-    #
-    # @option opts [Ray::Image] :on (Ray.screen) The image to draw the drawable
-    #   on.
-    def draw(opts = {})
-      draw_on(opts[:on] || Ray.screen)
+    def x
+      pos.x
     end
+
+    def y=(val)
+      self.pos = [x, val]
+    end
+
+    def x=(val)
+      self.pos = [val, y]
+    end
+
+    def scale_x
+      scale.x
+    end
+
+    def scale_y
+      scale.y
+    end
+
+    def scale_x=(val)
+      self.scale = [val, scale_y]
+    end
+
+    def scale_y=(val)
+      self.scale = [scale_x, val]
+    end
+
+    alias zoom  scale
+    alias zoom= scale=
+
+    alias position  pos
+    alias position= pos=
   end
 end

data/lib/ray/dsl.rb

@@ -3,6 +3,12 @@ module Ray
   # need to, the other classes and methods written with them being what
   # you should use instead.
   module DSL; end
+
+  class NoRunnerError < StandardError
+    def initialize(o)
+      super "#{o.inspect} has no runner object"
+    end
+  end
 end
 
 require 'ray/dsl/matcher'

data/lib/ray/dsl/event.rb

@@ -1,6 +1,6 @@
 module Ray
   module DSL
-    # Used internally to store event when raise_event is caled.
+    # Used internally to store event when raise_event is called.
     class Event
       def initialize(type, args)
         @type = type

data/lib/ray/dsl/event_listener.rb

@@ -7,29 +7,30 @@ module Ray
       # Arguments are compared with the ones of the regex using === and,
       # if it failed, ==.
       #
-      # @param [Symbol] event Name of the event to listen to
+      # @param [Symbol] event Name of the event to listen to.
       # @param [DSL::Matcher, Regexp, Object] args List of arguments that should
-      #                                            match the event's (if empty,
-      #                                            the block will be called anyway)
+      #   match the event's (if empty, the block will be called anyway).
       def on(event, *args, &block)
-        return unless listener_runner
+        raise NoRunnerError, self unless listener_runner
         listener_runner.add_handler(event, current_event_group, args, block)
       end
 
       # @overload add_hook(event, ..., callable)
-      #   Same as on, but the last argument is an object which responds to
-      #   to_proc.
+      #   Same as #on, but the last argument is an object which responds to
+      #   #to_proc.
       #
       #   @example
       #     add_hook :quit, method(:exit!)
       def add_hook(event, *args)
-        return unless listener_runner
+        raise NoRunnerError, self unless listener_runner
         listener_runner.add_handler(event, current_event_group, args[0...-1],
                                     args.last)
       end
 
-      # Sets the current event group to name and runs a block to register
-      # events. The current event group is reset to its old value afterwards.
+      # Sets the current event group temporarily.
+      # @param name Name of the event group.
+      # @yield Runs a block where registered event will be registred to the
+      #   event group.
       def event_group(name)
         old_group = current_event_group
         self.current_event_group = name
@@ -49,10 +50,13 @@ module Ray
         @__listener_event_group = val
       end
 
+      # @return [Ray::DSL::EventRunner] Object where matchers will be registred.
       def listener_runner
-        @__listener_runner
+        @__listener_runner if defined?(@__listener_runner)
       end
 
+      # Sets the event runner which will be used for listening.
+      # @param [Ray::DSL::EventRunner] arg The new even runner.
       def listener_runner=(arg)
         @__listener_runner = arg
       end

data/lib/ray/dsl/event_raiser.rb

@@ -1,18 +1,21 @@
 module Ray
   module DSL
     # The module charged to raise your events, asking to an event runner to send
-    # this event to the objects who said they were interested in it.
+    # this event to the objects which registered to it.
     module EventRaiser
       # Raises a new event, with the given type and arguments.
       def raise_event(type, *args)
-        return unless raiser_runner
+        raise NoRunnerError, self unless raiser_runner
         raiser_runner.add_event(type, args)
       end
 
+      # @return [Ray::DSL::EventRunner] Event runner used to raise events.
       def raiser_runner
         @__raiser_runner
       end
 
+      # Sets the event runner used to raise events.
+      # @param [Ray::DSL::EventRunner] arg The new event runner.
       def raiser_runner=(arg)
         @__raiser_runner = arg
       end

data/lib/ray/dsl/event_runner.rb

@@ -1,5 +1,3 @@
-require 'thread'
-
 module Ray
   module DSL
     # This class is the one that dispatches events in your program, the one that
@@ -14,16 +12,12 @@ module Ray
 
         @event_groups = Hash.new { |h, k| h[k] = true }
         @event_groups[:default] = true
-
-        @mutex = Mutex.new
       end
 
       # Sends all the known events to our listeners.
       def run
-        @mutex.synchronize do
-          @event_list  = @next_events
-          @next_events = []
-        end
+        @event_list  = @next_events
+        @next_events = []
 
         handlers = @handlers.select { |o| group_enabled?(o.group) }
 
@@ -37,7 +31,7 @@ module Ray
       end
 
       def add_event(type, args)
-        @mutex.synchronize { @next_events << Ray::DSL::Event.new(type, args) }
+        @next_events << Ray::DSL::Event.new(type, args)
       end
 
       # Disables an event group
@@ -55,7 +49,7 @@ module Ray
         @handlers.delete_if { |o| o.group == name }
       end
 
-      # Removes all the registred handlers
+      # Removes all the registered handlers
       def clear
         @handlers.clear
       end