ray 0.0.0.pre2 → 0.0.1

data/lib/ray/scene.rb

@@ -1,102 +1,271 @@
 module Ray
+  # Scenes contain the main logic of a game.
+  #
+  # You can define a new scene using a block, which will be called every time
+  # your scene is about to be used. However, you may also want to subclass
+  # Ray::Scene. When doing this, you'll probably want to override the register
+  # method:
+  #   def register
+  #     on :some_event do some_stuff end
+  #   end
+  #
+  # Another method is called before register: setup. Putting code in register or
+  # in setup doesn't matter, but setting the scene up inside register method
+  # seems (and, indeed, is) inappropriate. You can override it:
+  #   def setup
+  #     @sprite = sprite("image.png")
+  #   end
+  #
+  # You can indicate how your scene should be rendered there:
+  #    render do |win|
+  #      # Do drawing here
+  #    end
+  #
+  # Or you can override render:
+  #   def render(win)
+  #     # Do drawing here
+  #   end
+  #
+  # Notice win is not filled with an empty color when render is called, i.e.
+  # it still contains the frame which appears to the user.
+  #
+  # Also, scenes are rendered lazily: only once when the scene is created,
+  # and then every time need_render! is called.
+  #
+  # Once your scene is loaded, you'll probably want to clean it up (set some
+  # instance variables to nil so they can be garbaged collected for instance).
+  # You can do that by passing a block to clean_up:
+  #   clean_up do
+  #     @some_big_resource = nil
+  #   end
+  #
+  # Or by overriding it:
+  #   def clean_up
+  #     @some_big_resource = nil
+  #   end
+  #
+  # == Managing the stack of scenes
+  # exit is called when you want to stop running the scene, but not to remove
+  # the last scene from the stack. It is useful if you want to push a new
+  # scene. Hence Ray::Scene#push_scene will call exit.
+  #
+  # exit! (or pop_scene), on the other hand, is used to go back to the previous
+  # scene in the hierarchy
+  #
+  # == Sending informations to a scene
+  # Scenes may need some arguments to work. You can pass those in push_scene:
+  #   push_scene(:polygon, 6, Ray::Color.red)
+  # Then you can use them with scene_arguments:
+  #   scene :polygon do
+  #     sides, color = scene_arguments
+  #     # ...
+  #   end
+  #
+  # They are also passed to #setup:
+  #   def setup(sides, color)
+  #     # ...
+  #   end
+  #
+  # == Limiting the loop rate
+  # You can prevent a scene from always running by using #loops_per_second=:
+  #   self.loops_per_second = 30 # will sleep some time after each loop
+  #
+  # @see Ray::DSL::EventTranslator
   class Scene
     include Ray::Helper
 
     class << self
-      # If you want to subclass Scene, this is the method you need to call.
-      # It will return a subclass, responding to bind, which allows you to
-      # register it.
-      #
-      # @example
-      #   Klass = Scene.create(:foo) do ... end
-      #   Klass.bind(game)
-      #   game.push_scene(:foo)
-      def create(scene_name, &block)
-        klass = Class.new(self)
-        klass.instance_variable_set("@block", block)
-
-        (class << klass; self; end).class_eval do
-          define_method(:bind) do |game|
-            game.scene(scene_name, self, &@block)
-          end
-
-          define_method(:inspect) { "Scene:#{scene_name}" }
-          define_method(:block) { @block }
-        end
-
-        klass.class_eval do
-          define_method(:initialize) do
-            super(&self.class.block)
-          end
-        end
+      # Registers a scene to a game object, used for subclasses.
+      def bind(game)
+        game.scene(scene_name, self)
+      end
 
-        return klass
+      # @overload scene_name
+      #   @return [Symbol] the name of the scene
+      # @overload scene_name(value)
+      #   Sets the name of the scene
+      def scene_name(val = nil)
+        @scene_name = val || @scene_name
       end
     end
 
-    # Creates a new scene. block will be instance evaluated
-    # every time the current scene changes.
+    scene_name :scene
+
+    # Creates a new scene. block will be instance evaluated when
+    # this scene becomes the current one.
     def initialize(&block)
-      @exit = false
-      @block = block
+      @scene_register_block = block
     end
 
     def register_events
-      instance_eval(&@block)
+      @scene_held_keys = []
+
+      on :key_press do |key, mod|
+        @scene_held_keys << key
+      end
+
+      on :key_release do |key, mod|
+        @scene_held_keys.reject! { |i| i == key }
+      end
+
+      if @scene_register_block
+        instance_eval(&@scene_register_block)
+      else
+        register
+      end
+
+      @scene_exit = false
+    end
+
+    # Override this method in subclasses to setup the initial state
+    # of your scene.
+    def setup(*args)
+    end
+
+    # Override this method in subclasses to register your own events
+    def register
+    end
+
+    # @param [Symbol, Integer] val A symbol to find the key (its name)
+    #                              or an integer (Ray::Event::KEY_*)
+    #
+    # @return [true, false] True if the user is holding key.
+    def holding?(val)
+      if val.is_a? Symbol
+        val = key(val)
+        @scene_held_keys.any? { |o| val === o }
+      elsif val.is_a? DSL::Matcher
+        @scene_held_keys.any? { |o| val === o }
+      else
+        @scene_held_keys.include? val
+      end
     end
 
     # Runs until you exit the scene.
     # This will also raise events if the mouse moves, ... allowing you
     # to directly listen to a such event.
     def run
-      until @exit
-        ev = DSL::EventTranslator.translate_event(Ray::Event.new)
-        raise_event(*ev) if ev
+      until @scene_exit
+        loop_start = Time.now
 
-        @always.call if @always
+        DSL::EventTranslator.translate_event(Ray::Event.new).each do |args|
+          raise_event(*args)
+        end
+
+        @scene_always_block.call if @scene_always_block
 
         listener_runner.run
 
-        if @need_render
-          @need_render = false
+        if @scene_need_render
+          @scene_need_render = false
+
+          render(@scene_window)
+          @scene_window.flip
+        end
+
+        if @scene_loops_per_second
+          ellapsed_time = Time.now - loop_start
+          time_per_loop = 1.0 / @scene_loops_per_second
 
-          @render.call(@window)
-          @window.flip
+          sleep(time_per_loop - ellapsed_time) if ellapsed_time < time_per_loop
         end
       end
+
+      clean_up
     end
 
-    # Exits the scene, but does not pops the scene (the next scene
-    # will be the same one)
+    # Exits the scene, but does not pop the scene.
+    #
+    # You may want to call this if you pushed a new scene, to switch to
+    # the new scene.
     def exit
-      @exit = true
+      @scene_exit = true
     end
 
-    # Exits the scene and pops it.
+    # Exits the scene and pops it (may not work as expected if the current
+    # scene is not the last one)
     def exit!
       exit
       game.pop_scene
     end
 
-    # Register a block to be excuted as often as possible.
+    # Registers a block to be excuted as often as possible.
     def always(&block)
-      @always = block
+      @scene_always_block = block
     end
 
     # Marks the scene should be redrawn.
     def need_render!
-      @need_render = true
+      @scene_need_render = true
     end
 
     # Registers the block to draw the scene.
     #
+    # Does nothing if no block is given, this method being called if you
+    # didn't register any render block. You can thus override it in subclasses
+    # instead of providing a block to it.
+    #
     # @yield [window] Block to render this scene.
     # @yieldparam [Ray::Image] window The window you should draw on
-    def render(&block)
-      @render = block
+    def render(win = nil, &block)
+      if block_given?
+        @scene_render_block = block
+      else
+        @scene_render_block.call(win) if @scene_render_block
+      end
+    end
+
+    # Pushes a scene in the stack, and exits that one
+    def push_scene(scene, *args)
+      game.push_scene(scene, *args)
+      exit
+    end
+     
+    # @see Ray::Game#resize_window
+    def resize_window(w, h)
+      game.resize_window(w, h)
+    end
+
+    # Cleans the scene or registers a block to clean it.
+    def clean_up(&block)
+      if block_given?
+        @scene_clean_block = block
+      else
+        @scene_clean_block.call if @scene_clean_block
+      end
+    end
+
+    def inspect
+      "#<#{self.class} game=#{self.game.inspect}>"
+    end
+
+    alias :pop_scene :exit!
+
+    def game
+      @scene_game
+    end
+
+    def game=(val)
+      @scene_game = val
+    end
+
+    def window
+      @scene_window
+    end
+
+    def window=(val)
+      @scene_window = val
+    end
+
+    def loops_per_second
+      @scene_loops_per_second
+    end
+
+    def loops_per_second=(val)
+      @scene_loops_per_second = val
     end
 
-    attr_accessor :game
-    attr_accessor :window
+    # The arguments passed to the scene with push_scene
+    attr_accessor :scene_arguments
   end
 end

data/lib/ray/sound_set.rb

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

data/lib/ray/sprite.rb

@@ -0,0 +1,184 @@
+module Ray
+  class Sprite
+    # Creates a sprite.
+    #
+    # @param [String, Ray::Image] The image this object will wrap;
+    # @option opts [Ray::Rect, Array<Integer>] :at Position of the sprite
+    #                                              (defaults to 0,0)
+    # @option opts [Ray::Rect, Array<Integer>] :rect Rect of the image which will
+    #                                                be drawn (defaults to the
+    #                                                whole image)
+    # @option opts [Float] :angle The angle which will be used to draw the image
+    #                              in degrees. Defaults to 0.
+    # @option opts [Float] :zoom The zoom level which will be used to draw the image.
+    #                              Defaults to 1.
+    def initialize(image, opts = {})
+      opts = {
+        :rect  => Ray::Rect.new(0, 0, 0, 0),
+        :at    => [0, 0],
+        :angle => 0.0,
+        :zoom  => 1
+      }.merge(opts)
+
+      @from_rect = opts[:rect].to_rect
+
+      rect = opts[:at].to_rect
+      @x, @y = rect.x, rect.y
+
+      self.angle = opts[:angle]
+      self.zoom  = opts[:zoom]
+
+      @image = image.to_image
+    end
+    
+    # Sets the size of the sprite sheet. For instance,
+    #   sprite.sheet_size = [3, 4]
+    # would mean there are 4 rows and 3 columns in the sprite (and each cell
+    # has the same size).
+    def sheet_size=(ary)
+      w, h = ary
+      
+      @uses_sprite_sheet = true
+      
+      @sprite_sheet_w = w
+      @sprite_sheet_h = h
+      
+      self.sheet_pos = [0, 0]
+    end
+    
+    # Sets which cell of the sprite sheet should be displayed.
+    #   sprite.sheet_pos = [0, 1] # Uses the first cell of the second line.
+    def sheet_pos=(ary)
+      x, y = ary
+      
+      self.from_rect = Ray::Rect.new(x * sprite_width, y * sprite_height,
+                                     sprite_width, sprite_height)
+      
+      @sheet_pos_x = x
+      @sheet_pos_y = y
+    end
+    
+    # Returns the position of the cell which is being used.
+    def sheet_pos
+      [@sheet_pos_x, @sheet_pos_y]
+    end
+    
+    # @return [Integer, nil] The width of each cell in the sprite sheet
+    def sprite_width
+      if uses_sprite_sheet?
+        @image.w / @sprite_sheet_w
+      end
+    end
+    
+    # @return [Integer, nil] The height of each cell in the sprite sheet
+    def sprite_height
+      if uses_sprite_sheet?
+        @image.h / @sprite_sheet_h
+      end
+    end
+    
+    # Disables the sprite sheet
+    def disable_sprite_sheet
+      self.from_rect = Ray::Rect.new(0, 0, @image.w, @image.h)
+      
+      @sprite_sheet_w = nil
+      @sprite_sheet_h = nil
+      
+      @uses_sprite_sheet = false
+    end
+    
+    def uses_sprite_sheet?
+      @uses_sprite_sheet
+    end
+
+    # Draws the sprite on an image.
+    # @param [Ray::Image] screen The image on which the sprite will be drawn
+    def draw_on(screen)
+      @image.blit(:rect => @from_rect, :on => screen, :at => [@x, @y],
+                  :angle => @angle, :zoom => @zoom)
+    end
+
+    # Draws the sprite on the screen or on another image
+    # @option opts [Ray::Image] :on The image we should draw on. Defaults to
+    #                               Ray.screen.
+    def draw(opts = {})
+      draw_on(opts[:on] || Ray.screen)
+    end
+
+    # @return [true, false] True if the sprite is located at (x, y)
+    def is_at?(x, y)
+      @x == x && @y == y
+    end
+
+    # @return [Ray::Rect] The rect where this sprite will be drawn.
+    def rect
+      Ray::Rect.new(@x, @y, @from_rect.w == 0 ? @image.w : @from_rect.w,
+                    @from_rect.h == 0 ? @image.h : @from_rect.h)
+    end
+
+    # @param [Ray::Rect, #rect] An object with which the receiver may collide
+    # @return [true, false]
+    def collide?(obj)
+      rect.collide?(obj.to_rect)
+    end
+
+    # @param [Ray::Rect, #rect] (See #collide?)
+    # @return [true, false]
+    def inside?(obj)
+      rect.inside?(obj.to_rect)
+    end
+
+    # @param [Ray::Rect, #rect] (See #collide?)
+    # @return [true, false]
+    def outside?(obj)
+      rect.outside?(obj.to_rect)
+    end
+
+    def to_rect
+      rect
+    end
+
+    # @return [Ray::Image]
+    attr_reader :image
+
+    # @return [Integer] position of the sprite
+    attr_accessor :x, :y
+
+    # @return [Ray::Rect] the part of the image which will be drawn. An empty
+    #                     rect means the whole image.
+    attr_accessor :from_rect
+    
+    # @return [Ray::Rect] the position of the sprite
+    def pos
+      [x, y]
+    end
+    
+    # Sets the position of the sprite
+    def pos=(ary)
+      rect = ary.to_rect
+      
+      self.x = rect.x
+      self.y = rect.y
+    end
+
+    # @return [Float] The angle used when the image is drawn.
+    def angle
+      @angle ? @angle : 0
+    end
+
+    # Sets the angle.
+    def angle=(val)
+      @angle = (val % 360).zero? ? nil : val
+    end
+
+    # @return [Float] the zoom applied to the image when it is drawn.
+    def zoom
+      @zoom ? @zoom : 1
+    end
+
+    # Sets the zoom level.
+    def zoom=(val)
+      @zoom = val == 1 ? nil : val
+    end
+  end
+end