minigl 2.2.2 → 2.2.3

data/lib/minigl/game_object.rb

@@ -1,379 +1,379 @@
-require_relative 'movement'
-
-module MiniGL
-  # This class represents an (optionally animated) image inside the game screen.
-  class Sprite
-    # The index of the current sprite in the spritesheet being drawn.
-    attr_reader :img_index
-
-    # The x-coordinate of the image in the screen.
-    attr_accessor :x
-
-    # The y-coordinate of the image in the screen.
-    attr_accessor :y
-
-    # Creates a new sprite.
-    #
-    # Parameters:
-    # [x] The x-coordinate in the screen (or map) where the sprite will be
-    #     drawn. This can be modified later via the +x+ attribute.
-    # [y] The y-coordinate in the screen (or map) where the sprite will be
-    #     drawn. This can be modified later via the +y+ attribute.
-    # [img] The path to a PNG image or spritesheet, following the MiniGL
-    #       convention: images must be inside a 'data/img' directory, relative
-    #       to the code file, and you must only provide the file name, without
-    #       extension, in this case. If the image is inside a subdirectory of
-    #       'data/img', you must prefix the file name with each subdirectory
-    #       name, followed by an underscore (so the file and directories names
-    #       must not contain underscores). For example, if your image is
-    #       'data/img/sprite/1.png', you must provide <code>"sprite_1"</code>
-    #       or +:sprite_1+.
-    # [sprite_cols] The number of columns in the spritesheet. Use +nil+ if the
-    #               image is not a spritesheet.
-    # [sprite_rows] The number of rows in the spritesheet. Use +nil+ if the
-    #               image is not a spritesheet.
-    def initialize(x, y, img, sprite_cols = nil, sprite_rows = nil, retro = nil)
-      @x = x; @y = y
-      retro = Res.retro_images if retro.nil?
-      @img =
-        if sprite_cols.nil?
-          [Res.img(img, false, false, '.png', retro)]
-        else
-          Res.imgs img, sprite_cols, sprite_rows, false, '.png', retro
-        end
-      @anim_counter = 0
-      @img_index = 0
-      @index_index = 0
-      @animate_once_control = 0
-    end
-
-    # Performs time checking to update the image index according to the
-    # sequence of indices and the interval.
-    #
-    # Parameters:
-    # [indices] The sequence of image indices used in the animation. The
-    #           indices are determined from left to right, and from top to
-    #           bottom, inside the spritesheet. All indices must be in the
-    #           interval <code>0..(sprite_cols * sprite_rows)</code>.
-    # [interval] The amount of frames between each change in the image index.
-    #            A frame will usually represent 1/60 second (roughly 17
-    #            milliseconds).
-    def animate(indices, interval)
-      @animate_once_control = 0 if @animate_once_control != 0
-
-      @anim_counter += 1
-      if @anim_counter >= interval
-        @index_index += 1
-        @index_index = 0 if @index_index >= indices.length
-        @img_index = indices[@index_index]
-        @anim_counter = 0
-      end
-    end
-
-    # Causes the sprite to animate through the +indices+ array exactly once,
-    # so that the animation stops once it reaches the last index in the array.
-    # Subsequent calls with the same parameters will have no effect, but if
-    # the index or interval changes, or if +set_animation+ is called, then a
-    # new animation cycle will begin.
-    #
-    # Parameters:
-    # [indices] The sequence of image indices used in the animation. See
-    #           +animate+ for details.
-    # [interval] The amount of frames between each change in the image index.
-    #            See +animate+ for details.
-    def animate_once(indices, interval)
-      if @animate_once_control == 2
-        return if indices == @animate_once_indices && interval == @animate_once_interval
-        @animate_once_control = 0
-      end
-
-      unless @animate_once_control == 1
-        @anim_counter = 0
-        @img_index = indices[0]
-        @index_index = 0
-        @animate_once_indices = indices
-        @animate_once_interval = interval
-        @animate_once_control = 1
-        return
-      end
-
-      @anim_counter += 1
-      return unless @anim_counter >= interval
-
-      @index_index += 1
-      @img_index = indices[@index_index]
-      @anim_counter = 0
-      @animate_once_control = 2 if @index_index == indices.length - 1
-    end
-
-    # Resets the animation timer and immediately changes the image index to
-    # the specified value.
-    #
-    # Parameters:
-    # [index] The image index to be set.
-    def set_animation(index)
-      @anim_counter = 0
-      @img_index = index
-      @index_index = 0
-      @animate_once_control = 0
-    end
-
-    # Draws the sprite in the screen
-    #
-    # Parameters:
-    # [map] A Map object, relative to which the sprite will be drawn (the x
-    #       and y coordinates of the sprite will be changed according to the
-    #       position of the camera).
-    # [scale_x] A scale factor to be applied horizontally to the image.
-    # [scale_y] A scale factor to be applied vertically to the image.
-    # [alpha] The opacity with which the image will be drawn. Valid values
-    #         vary from 0 (fully transparent) to 255 (fully opaque).
-    # [color] A color filter to apply to the image. A white (0xffffff) filter
-    #         will keep all colors unchanged, while a black (0x000000) filter
-    #         will turn all colors to black. A red (0xff0000) filter will keep
-    #         reddish colors with slight or no change, whereas bluish colors
-    #         will be darkened, for example.
-    # [angle] A rotation, in degrees, to be applied to the image, relative to
-    #         its center.
-    # [flip] Specify +:horiz+ to draw the image horizontally flipped or +:vert+
-    #        to draw it vertically flipped.
-    # [z_index] The z-order to draw the object. Objects with larger z-orders
-    #           will be drawn on top of the ones with smaller z-orders.
-    # [round] Specify whether the drawing coordinates should be rounded to an
-    #         integer before drawing, to avoid little distortions of the image.
-    #         Only applies when the image is not rotated.
-    #
-    # *Obs.:* This method accepts named parameters.
-    def draw(map = nil, scale_x = 1, scale_y = 1, alpha = 0xff, color = 0xffffff, angle = nil, flip = nil, z_index = 0, round = false)
-      if map.is_a? Hash
-        scale_x = map.fetch(:scale_x, 1)
-        scale_y = map.fetch(:scale_y, 1)
-        alpha = map.fetch(:alpha, 0xff)
-        color = map.fetch(:color, 0xffffff)
-        angle = map.fetch(:angle, nil)
-        flip = map.fetch(:flip, nil)
-        z_index = map.fetch(:z_index, 0)
-        round = map.fetch(:round, false)
-        map = map.fetch(:map, nil)
-      end
-
-      color = (alpha << 24) | color
-      if angle
-        @img[@img_index].draw_rot @x - (map ? map.cam.x : 0) + @img[0].width * scale_x * 0.5,
-                                  @y - (map ? map.cam.y : 0) + @img[0].height * scale_y * 0.5,
-                                  z_index, angle, 0.5, 0.5, (flip == :horiz ? -scale_x : scale_x),
-                                  (flip == :vert ? -scale_y : scale_y), color
-      else
-        x = @x - (map ? map.cam.x : 0) + (flip == :horiz ? scale_x * @img[0].width : 0)
-        y = @y - (map ? map.cam.y : 0) + (flip == :vert ? scale_y * @img[0].height : 0)
-        @img[@img_index].draw (round ? x.round : x), (round ? y.round : y),
-                              z_index, (flip == :horiz ? -scale_x : scale_x),
-                              (flip == :vert ? -scale_y : scale_y), color
-      end
-    end
-
-    # Returns whether this sprite is visible in the given map (i.e., in the
-    # viewport determined by the camera of the given map). If no map is given,
-    # returns whether the sprite is visible on the screen.
-    def visible?(map = nil)
-      r = Rectangle.new @x, @y, @img[0].width, @img[0].height
-      return Rectangle.new(0, 0, G.window.width, G.window.height).intersect? r if map.nil?
-      map.cam.intersect? r
-    end
-  end
-
-  # This class represents an object with a set of properties and methods
-  # commonly used in games. It defines an object with a rectangular bounding
-  # box, and having all the attributes required for using the Movement module.
-  class GameObject < Sprite
-    include Movement
-
-    # Creates a new game object.
-    #
-    # Parameters:
-    # [x] The x-coordinate of the object's bounding box. This can be modified
-    #     later via the +x+ attribute.
-    # [y] The y-coordinate of the object's bounding box. This can be modified
-    #     later via the +y+ attribute.
-    # [w] The width of the object's bounding box.
-    # [h] The height of the object's bounding box.
-    # [img] The image or spritesheet for the object.
-    # [img_gap] A Vector object representing the difference between the top
-    #           left corner of the bounding box and the coordinates of the
-    #           image. For example, an object with <code>x = 100</code>,
-    #           <code>y = 50</code> and <code>img_gap = Vector.new(-5, -5)</code>
-    #           will be drawn at position (95, 45) of the screen.
-    # [sprite_cols] The number of columns in the spritesheet. Use +nil+ if the
-    #               image is not a spritesheet.
-    # [sprite_rows] The number of rows in the spritesheet. Use +nil+ if the
-    #               image is not a spritesheet.
-    # [mass] The mass of the object. Details on how it is used can be found
-    #        in the Movement module.
-    def initialize(x, y, w, h, img, img_gap = nil, sprite_cols = nil, sprite_rows = nil, mass = 1.0, retro = nil)
-      super x, y, img, sprite_cols, sprite_rows, retro
-      @w = w; @h = h
-      @img_gap =
-        if img_gap.nil?
-          Vector.new 0, 0
-        else
-          img_gap
-        end
-      @mass = mass
-      @speed = Vector.new 0, 0
-      @max_speed = Vector.new 15, 15
-      @stored_forces = Vector.new 0, 0
-    end
-
-    # Draws the game object in the screen.
-    #
-    # Parameters:
-    # [map] A Map object, relative to which the object will be drawn (the x
-    #       and y coordinates of the image will be changed according to the
-    #       position of the camera).
-    # [scale_x] A scale factor to be applied horizontally to the image.
-    # [scale_y] A scale factor to be applied vertically to the image.
-    # [alpha] The opacity with which the image will be drawn. Valid values
-    #         vary from 0 (fully transparent) to 255 (fully opaque).
-    # [color] A color filter to apply to the image. A white (0xffffff) filter
-    #         will keep all colors unchanged, while a black (0x000000) filter
-    #         will turn all colors to black. A red (0xff0000) filter will keep
-    #         reddish colors with slight or no change, whereas bluish colors
-    #         will be darkened, for example.
-    # [angle] A rotation, in degrees, to be applied to the image, relative to
-    #         its center.
-    # [flip] Specify +:horiz+ to draw the image horizontally flipped or +:vert+
-    #        to draw it vertically flipped.
-    # [z_index] The z-order to draw the object. Objects with larger z-orders
-    #           will be drawn on top of the ones with smaller z-orders.
-    # [round] Specify whether the drawing coordinates should be rounded to an
-    #         integer before drawing, to avoid little distortions of the image.
-    #         Only applies when the image is not rotated.
-    #
-    # *Obs.:* This method accepts named parameters.
-    def draw(map = nil, scale_x = 1, scale_y = 1, alpha = 0xff, color = 0xffffff, angle = nil, flip = nil, z_index = 0, round = false)
-      if map.is_a? Hash
-        scale_x = map.fetch(:scale_x, 1)
-        scale_y = map.fetch(:scale_y, 1)
-        alpha = map.fetch(:alpha, 0xff)
-        color = map.fetch(:color, 0xffffff)
-        angle = map.fetch(:angle, nil)
-        flip = map.fetch(:flip, nil)
-        z_index = map.fetch(:z_index, 0)
-        round = map.fetch(:round, false)
-        map = map.fetch(:map, nil)
-      end
-
-      color = (alpha << 24) | color
-      if angle
-        center_x = @x + @w * 0.5
-        center_y = @y + @h * 0.5
-        o_x = center_x - @x - @img_gap.x
-        o_y = center_y - @y - @img_gap.y
-        @img[@img_index].draw_rot @x + (flip == :horiz ? -1 : 1) * (@img_gap.x + o_x) - (map ? map.cam.x : 0),
-                                  @y + (flip == :vert ? -1 : 1) * (@img_gap.y + o_y) - (map ? map.cam.y : 0),
-                                  z_index, angle, o_x.to_f / (@img[0].width * scale_x), o_y.to_f / (@img[0].height * scale_y),
-                                  (flip == :horiz ? -scale_x : scale_x), (flip == :vert ? -scale_y : scale_y), color
-      else
-        x = @x + (flip == :horiz ? -1 : 1) * @img_gap.x - (map ? map.cam.x : 0) + (flip == :horiz ? @w : 0)
-        y = @y + (flip == :vert ? -1 : 1) * @img_gap.y - (map ? map.cam.y : 0) + (flip == :vert ? @h : 0)
-        @img[@img_index].draw (round ? x.round : x), (round ? y.round : y),
-                              z_index, (flip == :horiz ? -scale_x : scale_x),
-                              (flip == :vert ? -scale_y : scale_y), color
-      end
-    end
-
-    # Returns whether this object is visible in the given map (i.e., in the
-    # viewport determined by the camera of the given map). If no map is given,
-    # returns whether the object is visible on the screen.
-    def visible?(map = nil)
-      r = Rectangle.new @x.round + @img_gap.x, @y.round + @img_gap.y, @img[0].width, @img[0].height
-      return Rectangle.new(0, 0, G.window.width, G.window.height).intersect? r if map.nil?
-      map.cam.intersect? r
-    end
-  end
-
-  # Represents a visual effect, i.e., a graphic - usually animated - that shows
-  # up in the screen, lasts for a given time and "disappears". You should
-  # explicitly dispose of references to effects whose attribute +dead+ is set
-  # to +true+.
-  class Effect < Sprite
-    # This is +true+ when the effect's lifetime has already passed.
-    attr_reader :dead
-
-    # Creates a new Effect.
-    #
-    # Parameters:
-    # [x] The x-coordinate in the screen (or map) where the effect will be
-    #     drawn. This can be modified later via the +x+ attribute.
-    # [y] The y-coordinate in the screen (or map) where the effect will be
-    #     drawn. This can be modified later via the +y+ attribute.
-    # [img] The image or spritesheet to use for this effect (see Sprite for
-    #       details on spritesheets).
-    # [sprite_cols] (see Sprite)
-    # [sprite_rows] (see Sprite)
-    # [interval] The interval between steps of the animation, in updates.
-    # [indices] The indices to use in the animation. See Sprite#animate for
-    #           details. If +nil+, it will be the sequence from 0 to
-    #           <code>sprite_cols * sprite_rows - 1</code>.
-    # [lifetime] The lifetime of the effect, in updates. After +update+ is
-    #            called this number of times, the effect will no longer
-    #            be visible, even when +draw+ is called, and the +dead+ flag
-    #            will be set to +true+, so you get to know when to dispose
-    #            of the Effect object. If +nil+, it will be set to
-    #            <code>@indices.length * interval</code>, i.e., the exact time
-    #            needed for one animation cycle to complete.
-    # [sound] The id of a sound to be played when the effect is created (id must
-    #         be given in the format specified for the +Res.sound+ method).
-    # [sound_ext] Extension of the sound file, if a sound is given. Default is
-    #             '.wav'.
-    # [sound_volume] The volume (from 0 to 1) to play the sound, if any. Default
-    #                is 1.
-    #
-    # *Obs.:* This method accepts named parameters, but +x+, +y+ and +img+ are
-    # mandatory.
-    def initialize(x, y = nil, img = nil, sprite_cols = nil, sprite_rows = nil, interval = 10, indices = nil, lifetime = nil,
-                   sound = nil, sound_ext = '.wav', sound_volume = 1)
-      if x.is_a? Hash
-        y = x[:y]
-        img = x[:img]
-        sprite_cols = x.fetch(:sprite_cols, nil)
-        sprite_rows = x.fetch(:sprite_rows, nil)
-        interval = x.fetch(:interval, 10)
-        indices = x.fetch(:indices, nil)
-        lifetime = x.fetch(:lifetime, nil)
-        sound = x.fetch(:sound, nil)
-        sound_ext = x.fetch(:sound_ext, '.wav')
-        sound_volume = x.fetch(:sound_volume, 1)
-        x = x[:x]
-      end
-
-      super x, y, img, sprite_cols, sprite_rows
-      @timer = 0
-      if indices
-        @indices = indices
-      else
-        @indices = *(0..(@img.length - 1))
-      end
-      @interval = interval
-      if lifetime
-        @lifetime = lifetime
-      else
-        @lifetime = @indices.length * interval
-      end
-      Res.sound(sound, false, sound_ext).play(sound_volume) if sound
-    end
-
-    # Updates the effect, animating and counting its remaining lifetime.
-    def update
-      unless @dead
-        animate @indices, @interval
-        @timer += 1
-        @dead = true if @timer == @lifetime
-      end
-    end
-
-    def draw(map = nil, scale_x = 1, scale_y = 1, alpha = 0xff, color = 0xffffff, angle = nil, z_index = 0)
-      super unless @dead
-    end
-  end
-end
+require_relative 'movement'
+
+module MiniGL
+  # This class represents an (optionally animated) image inside the game screen.
+  class Sprite
+    # The index of the current sprite in the spritesheet being drawn.
+    attr_reader :img_index
+
+    # The x-coordinate of the image in the screen.
+    attr_accessor :x
+
+    # The y-coordinate of the image in the screen.
+    attr_accessor :y
+
+    # Creates a new sprite.
+    #
+    # Parameters:
+    # [x] The x-coordinate in the screen (or map) where the sprite will be
+    #     drawn. This can be modified later via the +x+ attribute.
+    # [y] The y-coordinate in the screen (or map) where the sprite will be
+    #     drawn. This can be modified later via the +y+ attribute.
+    # [img] The path to a PNG image or spritesheet, following the MiniGL
+    #       convention: images must be inside a 'data/img' directory, relative
+    #       to the code file, and you must only provide the file name, without
+    #       extension, in this case. If the image is inside a subdirectory of
+    #       'data/img', you must prefix the file name with each subdirectory
+    #       name, followed by an underscore (so the file and directories names
+    #       must not contain underscores). For example, if your image is
+    #       'data/img/sprite/1.png', you must provide <code>"sprite_1"</code>
+    #       or +:sprite_1+.
+    # [sprite_cols] The number of columns in the spritesheet. Use +nil+ if the
+    #               image is not a spritesheet.
+    # [sprite_rows] The number of rows in the spritesheet. Use +nil+ if the
+    #               image is not a spritesheet.
+    def initialize(x, y, img, sprite_cols = nil, sprite_rows = nil, retro = nil)
+      @x = x; @y = y
+      retro = Res.retro_images if retro.nil?
+      @img =
+        if sprite_cols.nil?
+          [Res.img(img, false, false, '.png', retro)]
+        else
+          Res.imgs img, sprite_cols, sprite_rows, false, '.png', retro
+        end
+      @anim_counter = 0
+      @img_index = 0
+      @index_index = 0
+      @animate_once_control = 0
+    end
+
+    # Performs time checking to update the image index according to the
+    # sequence of indices and the interval.
+    #
+    # Parameters:
+    # [indices] The sequence of image indices used in the animation. The
+    #           indices are determined from left to right, and from top to
+    #           bottom, inside the spritesheet. All indices must be in the
+    #           interval <code>0..(sprite_cols * sprite_rows)</code>.
+    # [interval] The amount of frames between each change in the image index.
+    #            A frame will usually represent 1/60 second (roughly 17
+    #            milliseconds).
+    def animate(indices, interval)
+      @animate_once_control = 0 if @animate_once_control != 0
+
+      @anim_counter += 1
+      if @anim_counter >= interval
+        @index_index += 1
+        @index_index = 0 if @index_index >= indices.length
+        @img_index = indices[@index_index]
+        @anim_counter = 0
+      end
+    end
+
+    # Causes the sprite to animate through the +indices+ array exactly once,
+    # so that the animation stops once it reaches the last index in the array.
+    # Subsequent calls with the same parameters will have no effect, but if
+    # the index or interval changes, or if +set_animation+ is called, then a
+    # new animation cycle will begin.
+    #
+    # Parameters:
+    # [indices] The sequence of image indices used in the animation. See
+    #           +animate+ for details.
+    # [interval] The amount of frames between each change in the image index.
+    #            See +animate+ for details.
+    def animate_once(indices, interval)
+      if @animate_once_control == 2
+        return if indices == @animate_once_indices && interval == @animate_once_interval
+        @animate_once_control = 0
+      end
+
+      unless @animate_once_control == 1
+        @anim_counter = 0
+        @img_index = indices[0]
+        @index_index = 0
+        @animate_once_indices = indices
+        @animate_once_interval = interval
+        @animate_once_control = 1
+        return
+      end
+
+      @anim_counter += 1
+      return unless @anim_counter >= interval
+
+      @index_index += 1
+      @img_index = indices[@index_index]
+      @anim_counter = 0
+      @animate_once_control = 2 if @index_index == indices.length - 1
+    end
+
+    # Resets the animation timer and immediately changes the image index to
+    # the specified value.
+    #
+    # Parameters:
+    # [index] The image index to be set.
+    def set_animation(index)
+      @anim_counter = 0
+      @img_index = index
+      @index_index = 0
+      @animate_once_control = 0
+    end
+
+    # Draws the sprite in the screen
+    #
+    # Parameters:
+    # [map] A Map object, relative to which the sprite will be drawn (the x
+    #       and y coordinates of the sprite will be changed according to the
+    #       position of the camera).
+    # [scale_x] A scale factor to be applied horizontally to the image.
+    # [scale_y] A scale factor to be applied vertically to the image.
+    # [alpha] The opacity with which the image will be drawn. Valid values
+    #         vary from 0 (fully transparent) to 255 (fully opaque).
+    # [color] A color filter to apply to the image. A white (0xffffff) filter
+    #         will keep all colors unchanged, while a black (0x000000) filter
+    #         will turn all colors to black. A red (0xff0000) filter will keep
+    #         reddish colors with slight or no change, whereas bluish colors
+    #         will be darkened, for example.
+    # [angle] A rotation, in degrees, to be applied to the image, relative to
+    #         its center.
+    # [flip] Specify +:horiz+ to draw the image horizontally flipped or +:vert+
+    #        to draw it vertically flipped.
+    # [z_index] The z-order to draw the object. Objects with larger z-orders
+    #           will be drawn on top of the ones with smaller z-orders.
+    # [round] Specify whether the drawing coordinates should be rounded to an
+    #         integer before drawing, to avoid little distortions of the image.
+    #         Only applies when the image is not rotated.
+    #
+    # *Obs.:* This method accepts named parameters.
+    def draw(map = nil, scale_x = 1, scale_y = 1, alpha = 0xff, color = 0xffffff, angle = nil, flip = nil, z_index = 0, round = false)
+      if map.is_a? Hash
+        scale_x = map.fetch(:scale_x, 1)
+        scale_y = map.fetch(:scale_y, 1)
+        alpha = map.fetch(:alpha, 0xff)
+        color = map.fetch(:color, 0xffffff)
+        angle = map.fetch(:angle, nil)
+        flip = map.fetch(:flip, nil)
+        z_index = map.fetch(:z_index, 0)
+        round = map.fetch(:round, false)
+        map = map.fetch(:map, nil)
+      end
+
+      color = (alpha << 24) | color
+      if angle
+        @img[@img_index].draw_rot @x - (map ? map.cam.x : 0) + @img[0].width * scale_x * 0.5,
+                                  @y - (map ? map.cam.y : 0) + @img[0].height * scale_y * 0.5,
+                                  z_index, angle, 0.5, 0.5, (flip == :horiz ? -scale_x : scale_x),
+                                  (flip == :vert ? -scale_y : scale_y), color
+      else
+        x = @x - (map ? map.cam.x : 0) + (flip == :horiz ? scale_x * @img[0].width : 0)
+        y = @y - (map ? map.cam.y : 0) + (flip == :vert ? scale_y * @img[0].height : 0)
+        @img[@img_index].draw (round ? x.round : x), (round ? y.round : y),
+                              z_index, (flip == :horiz ? -scale_x : scale_x),
+                              (flip == :vert ? -scale_y : scale_y), color
+      end
+    end
+
+    # Returns whether this sprite is visible in the given map (i.e., in the
+    # viewport determined by the camera of the given map). If no map is given,
+    # returns whether the sprite is visible on the screen.
+    def visible?(map = nil)
+      r = Rectangle.new @x, @y, @img[0].width, @img[0].height
+      return Rectangle.new(0, 0, G.window.width, G.window.height).intersect? r if map.nil?
+      map.cam.intersect? r
+    end
+  end
+
+  # This class represents an object with a set of properties and methods
+  # commonly used in games. It defines an object with a rectangular bounding
+  # box, and having all the attributes required for using the Movement module.
+  class GameObject < Sprite
+    include Movement
+
+    # Creates a new game object.
+    #
+    # Parameters:
+    # [x] The x-coordinate of the object's bounding box. This can be modified
+    #     later via the +x+ attribute.
+    # [y] The y-coordinate of the object's bounding box. This can be modified
+    #     later via the +y+ attribute.
+    # [w] The width of the object's bounding box.
+    # [h] The height of the object's bounding box.
+    # [img] The image or spritesheet for the object.
+    # [img_gap] A Vector object representing the difference between the top
+    #           left corner of the bounding box and the coordinates of the
+    #           image. For example, an object with <code>x = 100</code>,
+    #           <code>y = 50</code> and <code>img_gap = Vector.new(-5, -5)</code>
+    #           will be drawn at position (95, 45) of the screen.
+    # [sprite_cols] The number of columns in the spritesheet. Use +nil+ if the
+    #               image is not a spritesheet.
+    # [sprite_rows] The number of rows in the spritesheet. Use +nil+ if the
+    #               image is not a spritesheet.
+    # [mass] The mass of the object. Details on how it is used can be found
+    #        in the Movement module.
+    def initialize(x, y, w, h, img, img_gap = nil, sprite_cols = nil, sprite_rows = nil, mass = 1.0, retro = nil)
+      super x, y, img, sprite_cols, sprite_rows, retro
+      @w = w; @h = h
+      @img_gap =
+        if img_gap.nil?
+          Vector.new 0, 0
+        else
+          img_gap
+        end
+      @mass = mass
+      @speed = Vector.new 0, 0
+      @max_speed = Vector.new 15, 15
+      @stored_forces = Vector.new 0, 0
+    end
+
+    # Draws the game object in the screen.
+    #
+    # Parameters:
+    # [map] A Map object, relative to which the object will be drawn (the x
+    #       and y coordinates of the image will be changed according to the
+    #       position of the camera).
+    # [scale_x] A scale factor to be applied horizontally to the image.
+    # [scale_y] A scale factor to be applied vertically to the image.
+    # [alpha] The opacity with which the image will be drawn. Valid values
+    #         vary from 0 (fully transparent) to 255 (fully opaque).
+    # [color] A color filter to apply to the image. A white (0xffffff) filter
+    #         will keep all colors unchanged, while a black (0x000000) filter
+    #         will turn all colors to black. A red (0xff0000) filter will keep
+    #         reddish colors with slight or no change, whereas bluish colors
+    #         will be darkened, for example.
+    # [angle] A rotation, in degrees, to be applied to the image, relative to
+    #         its center.
+    # [flip] Specify +:horiz+ to draw the image horizontally flipped or +:vert+
+    #        to draw it vertically flipped.
+    # [z_index] The z-order to draw the object. Objects with larger z-orders
+    #           will be drawn on top of the ones with smaller z-orders.
+    # [round] Specify whether the drawing coordinates should be rounded to an
+    #         integer before drawing, to avoid little distortions of the image.
+    #         Only applies when the image is not rotated.
+    #
+    # *Obs.:* This method accepts named parameters.
+    def draw(map = nil, scale_x = 1, scale_y = 1, alpha = 0xff, color = 0xffffff, angle = nil, flip = nil, z_index = 0, round = false)
+      if map.is_a? Hash
+        scale_x = map.fetch(:scale_x, 1)
+        scale_y = map.fetch(:scale_y, 1)
+        alpha = map.fetch(:alpha, 0xff)
+        color = map.fetch(:color, 0xffffff)
+        angle = map.fetch(:angle, nil)
+        flip = map.fetch(:flip, nil)
+        z_index = map.fetch(:z_index, 0)
+        round = map.fetch(:round, false)
+        map = map.fetch(:map, nil)
+      end
+
+      color = (alpha << 24) | color
+      if angle
+        center_x = @x + @w * 0.5
+        center_y = @y + @h * 0.5
+        o_x = center_x - @x - @img_gap.x
+        o_y = center_y - @y - @img_gap.y
+        @img[@img_index].draw_rot @x + (flip == :horiz ? -1 : 1) * (@img_gap.x + o_x) - (map ? map.cam.x : 0),
+                                  @y + (flip == :vert ? -1 : 1) * (@img_gap.y + o_y) - (map ? map.cam.y : 0),
+                                  z_index, angle, o_x.to_f / (@img[0].width * scale_x), o_y.to_f / (@img[0].height * scale_y),
+                                  (flip == :horiz ? -scale_x : scale_x), (flip == :vert ? -scale_y : scale_y), color
+      else
+        x = @x + (flip == :horiz ? -1 : 1) * @img_gap.x - (map ? map.cam.x : 0) + (flip == :horiz ? @w : 0)
+        y = @y + (flip == :vert ? -1 : 1) * @img_gap.y - (map ? map.cam.y : 0) + (flip == :vert ? @h : 0)
+        @img[@img_index].draw (round ? x.round : x), (round ? y.round : y),
+                              z_index, (flip == :horiz ? -scale_x : scale_x),
+                              (flip == :vert ? -scale_y : scale_y), color
+      end
+    end
+
+    # Returns whether this object is visible in the given map (i.e., in the
+    # viewport determined by the camera of the given map). If no map is given,
+    # returns whether the object is visible on the screen.
+    def visible?(map = nil)
+      r = Rectangle.new @x.round + @img_gap.x, @y.round + @img_gap.y, @img[0].width, @img[0].height
+      return Rectangle.new(0, 0, G.window.width, G.window.height).intersect? r if map.nil?
+      map.cam.intersect? r
+    end
+  end
+
+  # Represents a visual effect, i.e., a graphic - usually animated - that shows
+  # up in the screen, lasts for a given time and "disappears". You should
+  # explicitly dispose of references to effects whose attribute +dead+ is set
+  # to +true+.
+  class Effect < Sprite
+    # This is +true+ when the effect's lifetime has already passed.
+    attr_reader :dead
+
+    # Creates a new Effect.
+    #
+    # Parameters:
+    # [x] The x-coordinate in the screen (or map) where the effect will be
+    #     drawn. This can be modified later via the +x+ attribute.
+    # [y] The y-coordinate in the screen (or map) where the effect will be
+    #     drawn. This can be modified later via the +y+ attribute.
+    # [img] The image or spritesheet to use for this effect (see Sprite for
+    #       details on spritesheets).
+    # [sprite_cols] (see Sprite)
+    # [sprite_rows] (see Sprite)
+    # [interval] The interval between steps of the animation, in updates.
+    # [indices] The indices to use in the animation. See Sprite#animate for
+    #           details. If +nil+, it will be the sequence from 0 to
+    #           <code>sprite_cols * sprite_rows - 1</code>.
+    # [lifetime] The lifetime of the effect, in updates. After +update+ is
+    #            called this number of times, the effect will no longer
+    #            be visible, even when +draw+ is called, and the +dead+ flag
+    #            will be set to +true+, so you get to know when to dispose
+    #            of the Effect object. If +nil+, it will be set to
+    #            <code>@indices.length * interval</code>, i.e., the exact time
+    #            needed for one animation cycle to complete.
+    # [sound] The id of a sound to be played when the effect is created (id must
+    #         be given in the format specified for the +Res.sound+ method).
+    # [sound_ext] Extension of the sound file, if a sound is given. Default is
+    #             '.wav'.
+    # [sound_volume] The volume (from 0 to 1) to play the sound, if any. Default
+    #                is 1.
+    #
+    # *Obs.:* This method accepts named parameters, but +x+, +y+ and +img+ are
+    # mandatory.
+    def initialize(x, y = nil, img = nil, sprite_cols = nil, sprite_rows = nil, interval = 10, indices = nil, lifetime = nil,
+                   sound = nil, sound_ext = '.wav', sound_volume = 1)
+      if x.is_a? Hash
+        y = x[:y]
+        img = x[:img]
+        sprite_cols = x.fetch(:sprite_cols, nil)
+        sprite_rows = x.fetch(:sprite_rows, nil)
+        interval = x.fetch(:interval, 10)
+        indices = x.fetch(:indices, nil)
+        lifetime = x.fetch(:lifetime, nil)
+        sound = x.fetch(:sound, nil)
+        sound_ext = x.fetch(:sound_ext, '.wav')
+        sound_volume = x.fetch(:sound_volume, 1)
+        x = x[:x]
+      end
+
+      super x, y, img, sprite_cols, sprite_rows
+      @timer = 0
+      if indices
+        @indices = indices
+      else
+        @indices = *(0..(@img.length - 1))
+      end
+      @interval = interval
+      if lifetime
+        @lifetime = lifetime
+      else
+        @lifetime = @indices.length * interval
+      end
+      Res.sound(sound, false, sound_ext).play(sound_volume) if sound
+    end
+
+    # Updates the effect, animating and counting its remaining lifetime.
+    def update
+      unless @dead
+        animate @indices, @interval
+        @timer += 1
+        @dead = true if @timer == @lifetime
+      end
+    end
+
+    def draw(map = nil, scale_x = 1, scale_y = 1, alpha = 0xff, color = 0xffffff, angle = nil, z_index = 0)
+      super unless @dead
+    end
+  end
+end