ray 0.0.0.pre2 → 0.0.1

data/lib/ray/helper.rb

@@ -1,17 +1,55 @@
 module Ray
-  # This module includes the methods you may want to use in your code.
-  # It allows you to play with events (listen to them, raise them) and
-  # includes the matchers you described, which you may want to use when
-  # you want to listen to the events matching a condition.
+  # Module including many helpful modules and methods.
   module Helper
     include Ray::DSL::EventRaiser
-    include Ray::DSL::Listener
+    include Ray::DSL::EventListener
 
     include Ray::Matchers
 
+    # Sets the event runner for this object.
     def event_runner=(value)
       self.listener_runner = value
       self.raiser_runner   = value
     end
+
+    # @return [DSL::EventRunner] The event runner used to handle event.
+    def event_runner
+      listener_runner
+    end
+
+    # Creates an event runner for this object
+    def create_event_runner
+      self.event_runner = Ray::DSL::EventRunner.new
+    end
+
+    # @see Ray::ImageSet.[]
+    def image(name)
+      Ray::ImageSet[name]
+    end
+
+    # @see Ray::Sprite#initialize
+    def sprite(image, opts = {})
+      Ray::Sprite.new(image, opts)
+    end
+
+    # @see Ray::Channel#initialize
+    def channel(id)
+      Ray::Channel.new(id)
+    end
+    
+    # @see Ray::MusicSet.[]
+    def sound(file)
+      Ray::SoundSet[file]
+    end
+    
+    # @see Ray::MusicSet.[]
+    def music(file)
+      Ray::MusicSet[file]
+    end
+
+    # @see Ray::FontSet.[]
+    def font(name, size)
+      Ray::FontSet[name, size]
+    end
   end
 end

data/lib/ray/image.rb

@@ -1,11 +1,98 @@
 module Ray
   class Image
     def inspect
-      "#<#{self} w=#{w} h=#{h} bpp=#{bpp}>"
+      "#<#{self.class} w=#{w} h=#{h}>"
     end
 
     alias :bits_per_pixel :bpp
-    alias :width :w
-    alias :height :h
+    alias :w :width
+    alias :h :height
+
+    alias :draw :blit
+    alias :update :flip
+
+    extend Ray::ResourceSet
+    add_set(/^(.*)$/) { |filename| new(filename) }
+
+    # @yield [pixel]
+    # @yieldparam [Ray::Color] pixel Color of a point
+    def each
+      return Enumerator.new(self, :each) unless block_given?
+
+      (0...w).each do |x|
+        (0...h).each do |y|
+          yield self[x, y]
+        end
+      end
+
+      self
+    end
+
+    # Same as each, but also yields the position of each point.
+    # @yield [x, y, pixel]
+    def each_with_pos
+      return Enumerator.new(self, :each_with_pos) unless block_given?
+
+      (0...w).each do |x|
+        (0...h).each do |y|
+          yield x, y, self[x, y]
+        end
+      end
+
+      self
+    end
+
+    # @yield [pixel] Block returning the new color of this pixel.
+    def map!
+      return Enumerator.new(self, :map!) unless block_given?
+
+      lock do
+        (0...w).each do |x|
+          (0...h).each do |y|
+            self[x, y] = yield self[x, y]
+          end
+        end
+      end
+
+      self
+    end
+
+    # @yield [x, y, pixel] Block returning the new color of this pixel
+    def map_with_pos!
+      return Enumerator.new(self, :map_with_pos!) unless block_given?
+
+      lock do
+        (0...w).each do |x|
+          (0...h).each do |y|
+            self[x, y] = yield x, y, self[x, y]
+          end
+        end
+      end
+
+      self
+    end
+
+    # @return [Ray::Image] New image created according to a block.
+    def map(&block)
+      dup.map!(&block)
+    end
+
+    # @return [Ray::Image] New image created according to a block.
+    def map_with_pos(&block)
+      dup.map_with_pos!(&block)
+    end
+
+    def to_image
+      self
+    end
+
+    include Enumerable
+  end
+end
+
+class String
+  # Converts the string to an image using Ray::ImageSet.[]
+  def to_image
+    Ray::ImageSet[self]
   end
 end

data/lib/ray/image_set.rb

@@ -0,0 +1,35 @@
+module Ray
+  module ImageSet
+    extend Ray::ResourceSet
+
+    class << self
+      def missing_pattern(string)
+        Ray::Image[string]
+      end
+
+      def select!(&block)
+        super(&block)
+        Ray::Image.select!(&block)
+      end
+    end
+  end
+
+  # Creates a new image set.
+  #
+  # @param [Regexp] regex Regular expression used to match file
+  # @yield [*args] Block returning the image
+  # @yieldparam args Regex captures
+  def self.image_set(regex, &block)
+    Ray::ImageSet.add_set(regex, &block)
+  end
+end
+
+begin
+  require 'open-uri'
+
+  Ray.image_set(/^(http|ftp):\/\/(\S+)$/) do |protocol, address|
+    open("#{protocol}://#{address}") { |io| Ray::Image.new(io) }
+  end
+rescue LoadError
+  # that image set is not needed
+end

data/lib/ray/joystick.rb

@@ -0,0 +1,30 @@
+module Ray
+  class Joystick
+    @@joysticks = Hash.new { |h, k| h[k] = new(k) }
+
+    class << self
+      # @return [Ray::Joystick] an opened joystick
+      def [](id)
+        joy = @@joysticks[id]
+        joy.open if joy.closed?
+        joy
+      end
+
+      # Enumerates through all the joysitcks.
+      #
+      # @yield [joystick]
+      # @yieldparam [Ray::Joystick] joystick
+      def each
+        return Enumerator.new(self, :each) unless block_given?
+
+        (0...count).each do |i|
+          yield self[i]
+        end
+
+        self
+      end
+
+      include Enumerable
+    end
+  end
+end

data/lib/ray/music_set.rb

@@ -0,0 +1,35 @@
+module Ray
+  module MusicSet
+    extend Ray::ResourceSet
+    
+    class << self
+      def missing_pattern(string)
+        Ray::Music[string, size]
+      end
+
+      def select!(&block)
+        super(&block)
+        Ray::Music.select!(&block)
+      end
+    end
+  end
+
+  # Creates a new music set.
+  #
+  # @param [Regexp] regex Regular expression used to match file
+  # @yield [*args] Block returning the music
+  #
+  # @yieldparam args Regex captures
+  def self.music_set(regex, &block)
+    Ray::MusicSet.add_set(regex, &block)
+  end
+end
+
+begin
+  require 'open-uri'
+
+  Ray.music_set(/^(http|ftp):\/\/(\S+)$/) do |protocol, address|
+    open("#{protocol}://#{address}") { |io| Ray::Music.new(io) }
+  end
+rescue LoadError
+end

data/lib/ray/ray.rb

@@ -1,19 +1,27 @@
-unless defined? Ray
-  unless RUBY_PLATFORM =~ /darwin/
-    require 'ray_ext'
-  else
-    $stderr.puts "Please run this program using ray: ray #$0"
-    exit 1
-  end
-end
+require 'enumerator'
+
+# 'ray_ext' doesn't exist on the PSP.
+# We assume that Ray isn't defined in other cases.
+require 'ray_ext' unless defined? Ray
+
+require 'ray/resource_set'
 
 require 'ray/color'
 require 'ray/rect'
+require 'ray/image'
+require 'ray/joystick'
+require 'ray/font' if Ray.has_font_support?
+require 'ray/audio' if Ray.has_audio_support?
 
-require 'ray/config'
+require 'ray/image_set'
+require 'ray/font_set'  if Ray.has_font_support?
+require 'ray/sound_set' if Ray.has_audio_support?
+require 'ray/music_set' if Ray.has_audio_support?
 
 require 'ray/dsl'
 require 'ray/helper'
 
+require 'ray/sprite'
+
 require 'ray/scene'
 require 'ray/game'

data/lib/ray/rect.rb

@@ -4,6 +4,43 @@ module Ray
       "#<#{self.class} {{#{x}, #{y}}, {#{w}, #{h}}}>"
     end
 
+    # @return [true, false] True if the receiver is inside the rect.
+    #                       (false if they just collide)
+    def inside?(rect)
+      (x >= rect.x) && (y >= rect.y) &&
+        (x + w) <= (rect.x + rect.w) &&
+        (y + h) <= (rect.y + rect.h)
+    end
+
+    # @return [true, false] True if the receiver is outside the rect.
+    def outside?(rect)
+      !rect.contain?(x, y) &&
+        !rect.contain?(x, y + h) &&
+        !rect.contain?(x + w, y) &&
+        !rect.contain?(x + w, y + h)
+    end
+
+    # @return [true, false] True if the receiver collides with the rect.
+    def collide?(rect)
+      !outside?(rect)
+    end
+
+    # @return [true, false] True if the receiver contians this point
+    def contain?(p_x, p_y)
+      (p_x >= x) && (p_y >= y) &&
+        (p_x < x + w) && (p_y < y + h)
+    end
+
+    # @return [true, false] True if the two rects are equal
+    def ==(rect)
+      return false unless rect.is_a? Rect
+      x == rect.x && y == rect.y && w == rect.w && h == rect.h
+    end
+
+    def to_rect
+      self
+    end
+
     alias :w :width
     alias :h :height
 
@@ -11,3 +48,17 @@ module Ray
     alias :h= :height=
   end
 end
+
+class Array
+  # Converts an Array to a rect
+  def to_rect
+    Ray::Rect.new(*self)
+  end
+end
+
+class Hash
+  # Converts a Hash to a rect
+  def to_rect
+    Ray::Rect.new(self)
+  end
+end

data/lib/ray/resource_set.rb

@@ -0,0 +1,92 @@
+module Ray
+  # Exception raised when a pattern isn't found in ResourceSet
+  class NoPatternError < StandardError; end
+
+  # Mixin used to cache resources. It allows to register different block
+  # to create the resources using a regexp:
+  #   add_set(/^http://(.+)$/) do |url| # captures are passed to the block
+  #     ...
+  #   end
+  #
+  # Custom arguments can also be specified:
+  #   add_set(/^http://(.+)/) do |url, priority| # arguments are passed at the end
+  #     ...
+  #   end
+  #
+  # Notice you would usually use extend instead of include to use this module.
+  #
+  module ResourceSet
+    # Registers a block for handling some resources.
+    def add_set(regexp, &block)
+      set_hash[regexp] = Hash.new do |hash, args|
+        regexp =~ args.first
+
+        block_args = $~.captures + args[1..-1]
+        hash[args] = block.call(*block_args)
+      end
+    end
+
+    def set_hash
+      (@set_hash ||= {})
+    end
+
+    # @return The object corresponding to a given list of parameters.
+    def [](value, *params)
+      if params.size != required_argument_count
+        raise(ArgumentError, "wrong number of arguments (%d for %d)" %
+              [params.size, required_argument_count])
+      end
+
+      set_hash.each do |regexp, hash|
+        return hash[([value] + params)] if regexp =~ value
+      end
+
+      missing_pattern(value, *params)
+    end
+
+    # Selects objects matching a condition.
+    #
+    # @yield *arguments, object
+    # @yieldparam *arguments All the arguments used to access that object
+    # @yieldparam object the actual resource
+    def select!(&block)
+      return Enumerator.new(self, :select!) unless block_given?
+
+      set_hash.each do |regexp, hash|
+        hash.delete_if do |key, val|
+          !block.call(*(key + [val]))
+        end
+      end
+    end
+
+    # Removes all the objects from the array but those for which
+    # block returned true.
+    #
+    # @yield *arguments, object (See #select!)
+    def reject!(&block)
+      return Enumerator.new(self, :reject!) unless block_given?
+      select! { |*args| !block.call(*args) }
+    end
+
+    alias :delete_if :reject!
+
+    # Sets the required argument count. The number of arguments passed to []
+    # must be equal to this + 1 (the first argument isn't counted and is required)
+    #
+    # Defaulted to 0.
+    def need_argument_count(n)
+      @set_argument_count = n
+    end
+
+    # Returns the required argument count.
+    def required_argument_count
+      @set_argument_count ||= 0
+    end
+
+    # Method called when a string isn't matched by any pattern.
+    # Raises a NoPatternError excpetion by default.
+    def missing_pattern(string, *args)
+      raise NoPatternError, "#{string.inspect} not macthed by any pattern"
+    end
+  end
+end