ray 0.0.1 → 0.1.0.pre1

data/lib/ray/audio.rb

@@ -1,45 +1,4 @@
 module Ray
-  # Represents an audio channel, where sounds are played.
-  class Channel
-    # Creates a channel.
-    # @param [Integer] id Identifer of the channel.
-    def initialize(id)
-      @id = id
-    end
-
-    # Plays a sound on the channel.
-    # @param [Ray::Sound] sound The sound to be played
-    # @param [Integer, :forever] times How many times the sound should be played.
-    def play(sound, times = 1)
-      sound.play(@id, times)
-    end
-
-    # Stops playing on the channel, without being able to resume.
-    def stop
-      Ray::Audio.stop(@id)
-    end
-
-    # Pauses the channel.
-    def pause
-      Ray::Audio.pause(@id)
-    end
-
-    # Resumes from pause.
-    def resume
-      Ray::Audio.resume(@id)
-    end
-
-    # @return [true, false] True if the channel is paused.
-    def paused?
-      Ray::Audio.paused?(@id)
-    end
-
-    # @return [true, false] True if a sound is being played.
-    def playing?
-      Ray::Audio.playing?(@id)
-    end
-  end
-
   class Sound
     extend Ray::ResourceSet
     add_set(/^(.*)$/) { |filename| new(filename) }

data/lib/ray/color.rb

@@ -13,17 +13,46 @@ module Ray
       def fuschia; new(255, 0, 255);   end
     end
 
-    def inspect
+    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.
+    def +(color)
+      r = red   + color.red
+      g = green + color.green
+      b = blue  + color.blue
+      a = alpha + color.alpha
+
+      Ray::Color.new(r > 255 ? 255 : r,
+                     g > 255 ? 255 : g,
+                     b > 255 ? 255 : b,
+                     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.
+    def *(color)
+      Ray::Color.new(r * color.r / 255.0,
+                     g * color.g / 255.0,
+                     b * color.b / 255.0,
+                     a * color.a / 255.0)
+    end
+
     def ==(obj)
       return false unless obj.is_a? Color
       r == obj.r && g == obj.g && b == obj.b && a == obj.a
     end
 
-    def to_color
-      self
+    def eql?(obj)
+      self.class == obj.class && self == obj
+    end
+
+    def hash
+      [r, g, b, a].hash
     end
 
     alias :red :r
@@ -37,10 +66,3 @@ module Ray
     alias :alpha= :a=
   end
 end
-
-class Array
-  # Converts an Array to a color
-  def to_color
-    Ray::Color.new(*self)
-  end
-end

data/lib/ray/drawable.rb

@@ -0,0 +1,16 @@
+module Ray
+  class Drawable
+    # Draws the drawable on an image.
+    def draw_on(image)
+      image.draw_drawable self
+    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)
+    end
+  end
+end

data/lib/ray/dsl/event_listener.rb

@@ -13,7 +13,7 @@ module Ray
       #                                            the block will be called anyway)
       def on(event, *args, &block)
         return unless listener_runner
-        listener_runner.add_handler(event, args, block)
+        listener_runner.add_handler(event, current_event_group, args, block)
       end
 
       # @overload add_hook(event, ..., callable)
@@ -23,7 +23,30 @@ module Ray
       #   @example
       #     add_hook :quit, method(:exit!)
       def add_hook(event, *args)
-        on(event, *args[0...-1], &args.last)
+        return 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.
+      def event_group(name)
+        old_group = current_event_group
+        self.current_event_group = name
+
+        begin
+          yield name
+        ensure
+          self.current_event_group = old_group
+        end
+      end
+
+      def current_event_group
+        @__listener_event_group ||= :default
+      end
+
+      def current_event_group=(val)
+        @__listener_event_group = val
       end
 
       def listener_runner

data/lib/ray/dsl/event_runner.rb

@@ -12,6 +12,9 @@ module Ray
         @event_list  = []
         @next_events = []
 
+        @event_groups = Hash.new { |h, k| h[k] = true }
+        @event_groups[:default] = true
+
         @mutex = Mutex.new
       end
 
@@ -22,20 +25,45 @@ module Ray
           @next_events = []
         end
 
+        handlers = @handlers.select { |o| group_enabled?(o.group) }
+
         @event_list.each do |ev|
-          @handlers.select { |i| i.match? ev }.each do |handler|
-            handler.call(ev)
-          end
+          handlers.select { |o| o.call(ev) if o.match?(ev) }
         end
       end
 
-      def add_handler(type, args, block)
-        @handlers << Ray::DSL::Handler.new(type, args, block)
+      def add_handler(type, group, args, block)
+        @handlers << Ray::DSL::Handler.new(type, group, args, block)
       end
 
       def add_event(type, args)
         @mutex.synchronize { @next_events << Ray::DSL::Event.new(type, args) }
       end
+
+      # Disables an event group
+      def disable_group(group)
+        @event_groups[group] = false
+      end
+
+      # Enables an event group
+      def enable_group(group)
+        @event_groups[group] = true
+      end
+
+      # Removes all the handlers belonging to a given group
+      def remove_group(name)
+        @handlers.delete_if { |o| o.group == name }
+      end
+
+      # Removes all the registred handlers
+      def clear
+        @handlers.clear
+      end
+
+      # @return Whether an event group is enabled
+      def group_enabled?(group)
+        @event_groups[group]
+      end
     end
   end
 end

data/lib/ray/dsl/event_translator.rb

@@ -3,31 +3,32 @@ module Ray
     # Module charged to translate an instance of Ray::Event into the arguments
     # you pass to raise_event. It is for instance used in Ray::Scene.
     #
+    # Unless otherwise mentionned, points and sizes are Ray::Vector2 and
+    # rects Ray::Rect.
+    #
     # == Raised events
-    # 1. quit
-    # 2. focus_gain(focus_type)
-    # 3. mouse_motion(rect), where [rect.x, rect.y] is where the user clicked.
-    # 4. mouse_press(button, rect)
-    # 5. mouse_release(button, rect)
-    # 6. key_press(key, mod_keys)
-    # 7. key_release(key, mod_keys)
-    # 8. window_resize(rect), where [rect.w, rect.h] is the size of the window.
-    # 9. joy_motion(joystick_id, axis_id, axis_value)
-    # 10. joy_press(joystick_id, button_id)
-    # 11. joy_release(joystick_id, button_id)
+    # - quit
+    # - focus_gain
+    # - focus_loss
+    # - mouse_entered
+    # - mouse_left
+    # - mouse_motion(pos)
+    # - wheel_motion(pos, delta)
+    # - mouse_press(button, pos)
+    # - mouse_release(button, pos)
+    # - key_press(key, mod_keys)
+    # - key_release(key, mod_keys)
+    # - window_resize(size)
+    # - joy_motion(joystick_id, axis_id, axis_value)
+    # - joy_press(joystick_id, button_id)
+    # - joy_release(joystick_id, button_id)
     module EventTranslator
-      FOCUS_TYPES = {
-        Ray::Event::APPMOUSEFOCUS => :mouse_focus,
-        Ray::Event::APPINPUTFOCUS => :input_focus,
-        Ray::Event::APPACTIVE     => :app_activity
-      }
-
       MOUSE_BUTTONS = {
-        Ray::Event::BUTTON_LEFT      => :left,
-        Ray::Event::BUTTON_MIDDLE    => :middle,
-        Ray::Event::BUTTON_RIGHT     => :right,
-        Ray::Event::BUTTON_WHEELUP   => :wheel_up,
-        Ray::Event::BUTTON_WHEELDOWN => :wheel_down
+        Ray::Event::BUTTON_LEFT   => :left,
+        Ray::Event::BUTTON_MIDDLE => :middle,
+        Ray::Event::BUTTON_RIGHT  => :right,
+        Ray::Event::BUTTON_EXTRA1 => :extra1,
+        Ray::Event::BUTTON_EXTRA2 => :extra2
       }
 
       class << self
@@ -36,8 +37,12 @@ module Ray
           case ev.type
           when Ray::Event::TYPE_NOEVENT then []
           when Ray::Event::TYPE_QUIT then quit(ev)
-          when Ray::Event::TYPE_ACTIVEEVENT then active_event(ev)
+          when Ray::Event::TYPE_FOCUS_GAIN then focus_gain(ev)
+          when Ray::Event::TYPE_FOCUS_LOSS then focus_loss(ev)
+          when Ray::Event::TYPE_MOUSE_ENTERED then mouse_entered(ev)
+          when Ray::Event::TYPE_MOUSE_LEFT then mouse_left(ev)
           when Ray::Event::TYPE_MOUSEMOTION then mouse_motion(ev)
+          when Ray::Event::TYPE_MOUSEWHEELMOVED then wheel_motion(ev)
           when Ray::Event::TYPE_MOUSEBUTTONDOWN then mouse_press(ev)
           when Ray::Event::TYPE_MOUSEBUTTONUP then mouse_release(ev)
           when Ray::Event::TYPE_KEYDOWN then key_press(ev)
@@ -46,6 +51,7 @@ module Ray
           when Ray::Event::TYPE_JOYAXISMOTION then joy_motion(ev)
           when Ray::Event::TYPE_JOYBUTTONDOWN then joy_press(ev)
           when Ray::Event::TYPE_JOYBUTTONUP then joy_release(ev)
+          when Ray::Event::TYPE_TEXT_ENTERED then text_entered(ev)
           else []
           end
         end
@@ -54,25 +60,40 @@ module Ray
           [[:quit]]
         end
 
-        def active_event(ev)
-          [[ev.is_gain? ? :focus_gain : :focus_loss,
-            FOCUS_TYPES[ev.focus_state]]]
+        def focus_gain(ev)
+          [[:focus_gain]]
+        end
+
+        def focus_loss(ev)
+          [[:focus_loss]]
+        end
+
+        def mouse_entered(ev)
+          [[:mouse_entered]]
+        end
+
+        def mouse_left(ev)
+          [[:mouse_left]]
         end
 
         def mouse_motion(ev)
-          [[:mouse_motion, Ray::Rect.new(ev.mouse_x, ev.mouse_y)]]
+          [[:mouse_motion, Vector2[ev.mouse_x, ev.mouse_y]]]
+        end
+
+        def wheel_motion(ev)
+          [[:wheel_motion, Vector2[ev.mouse_x, ev.mouse_y], ev.wheel_delta]]
         end
 
         def mouse_press(ev)
           [[:mouse_press,
             MOUSE_BUTTONS[ev.mouse_button],
-            Ray::Rect.new(ev.mouse_x, ev.mouse_y)]]
+            Vector2[ev.mouse_x, ev.mouse_y]]]
         end
 
         def mouse_release(ev)
           [[:mouse_release,
             MOUSE_BUTTONS[ev.mouse_button],
-            Ray::Rect.new(ev.mouse_x, ev.mouse_y)]]
+            Vector2[ev.mouse_x, ev.mouse_y]]]
         end
 
         def key_press(ev)
@@ -84,7 +105,7 @@ module Ray
         end
 
         def resize(ev)
-          [[:window_resize, Ray::Rect.new(0, 0, ev.window_w, ev.window_h)]]
+          [[:window_resize, Vector2[ev.window_w, ev.window_h]]]
         end
 
         def joy_motion(ev)
@@ -98,6 +119,21 @@ module Ray
         def joy_release(ev)
           [[:joy_release, ev.joystick_id, ev.joystick_button]]
         end
+
+        def text_entered(ev)
+          text = ev.entered_text
+
+          # Set the right encoding, whcih depends on the native endianness.
+          if text.respond_to? :encoding
+            if BIG_ENDIAN
+              text.force_encoding "UTF-32BE"
+            else
+              text.force_encoding "UTF-32LE"
+            end
+          end
+
+          [[:text_entered, text]]
+        end
       end
     end
   end

data/lib/ray/dsl/handler.rb

@@ -2,8 +2,8 @@ module Ray
   module DSL
     # Used internally to call blocks registred with Ray::DSL::EventListener#on.
     class Handler
-      def initialize(type, args, block)
-        @type, @args, @block = type, args, block
+      def initialize(type, group, args, block)
+        @type, @group, @args, @block = type, group, args, block
       end
 
       def match?(event)
@@ -23,6 +23,7 @@ module Ray
       end
 
       attr_reader :type
+      attr_reader :group
       attr_reader :args
 
       private

data/lib/ray/dsl/matcher.rb

@@ -2,6 +2,8 @@ module Ray
   # This is the module including all of your matchers as private methods,
   # allowing you to use them when you call on.
   module Matchers
+    module_function
+
     # @return [DSL::Matcher] An anonymous matcher, using your block to
     #                        know if the argument matches.
     #
@@ -12,6 +14,17 @@ module Ray
     def where(&block)
       DSL::Matcher.new { |o| block.call(o) }
     end
+
+    # @return [Ray::Key] A key object representing the key of that name
+    def key(name)
+      Key.new(name)
+    end
+
+    # @return [Ray::KeyMod] A key_mod object representing the mod combination
+    #   of that name
+    def key_mod(name)
+      KeyMod.new(name)
+    end
   end
 
   module DSL
@@ -40,14 +53,18 @@ module Ray
   #   Ray.describe_matcher(:match, :string) do |regex|
   #     lambda { |str| str =~ regex }
   #   end
-  def self.describe_matcher(name, &create_block)
+  def describe_matcher(name, &create_block)
     Matchers.module_eval do
       define_method(name) do |*args|
         DSL::Matcher.new(&create_block.call(*args))
       end
+
+      module_function name
     end
   end
 
+  module_function :describe_matcher
+
   # @return [DSL::Matcher] A matcher matching anything (always true)
   describe_matcher(:anything) do
     lambda { |o| true }
@@ -110,8 +127,6 @@ module Ray
   KEYS = Ray::Event.constants.inject({}) do |hash, const|
     if const =~ /^KEY_(.+)$/
       hash[$1.downcase.to_sym] = [Ray::Event.const_get(const)]
-    elsif const =~ /^PSP_BUTTON_(.+)$/
-      hash["psp_#{$1.downcase.to_sym}".to_sym] = [Ray::Event.const_get(const)]
     end
 
     hash
@@ -136,7 +151,6 @@ module Ray
   KEYS[:mod] = [Ray::Event::KEY_RSHIFT, Ray::Event::KEY_LSHIFT,
                 Ray::Event::KEY_RCTRL, Ray::Event::KEY_LCTRL,
                 Ray::Event::KEY_RALT, Ray::Event::KEY_LALT,
-                Ray::Event::KEY_RMETA, Ray::Event::KEY_LMETA,
                 Ray::Event::KEY_RSUPER, Ray::Event::KEY_LSUPER]
 
   KEYS[:arrow] = [Ray::Event::KEY_UP, Ray::Event::KEY_DOWN,
@@ -150,17 +164,47 @@ module Ray
     hash
   end
 
-  # @return [DSL::Matcher] A matcher matching the given key, which is a symbol
-  #                        like :space, :a, :b, :number, :letter, :arrow, ...
-  describe_matcher(:key) do |sym|
-    ary = KEYS[sym.to_sym]
-    lambda { |o| ary.include? o }
+  class Key
+    def initialize(name)
+      @symbol = name.to_sym
+    end
+
+    def to_a
+      KEYS[@symbol]
+    end
+
+    def to_sym
+      @symbol
+    end
+
+    def ===(other)
+      to_a.include? other
+    end
+
+    def inspect
+      "key(#{to_sym})"
+    end
   end
 
-  # @return [DSL::Matcher] A matcher matching the given modifier key
-  #                        (:rctrl, :lctrl, :rmeta, :lmeta, ...)
-  describe_matcher(:key_mod) do |sym|
-    ary = MOD[sym.to_sym]
-    lambda { |o| ary.detect { |const| o & const } }
+  class KeyMod
+    def initialize(name)
+      @symbol = name.to_sym
+    end
+
+    def to_a
+      MOD[@symbol]
+    end
+
+    def to_sym
+      @symbol
+    end
+
+    def ===(other)
+      other.is_a?(Integer) && to_a.any? { |const| (o & const) != 0 }
+    end
+
+    def inspect
+      "key_mod(#{to_sym})"
+    end
   end
 end