Class Rubygame::Sprites::Group
In: lib/rubygame/sprite.rb
Parent: Array

The Group class is a special container, based on Array, with supplemental methods for handling multiple Sprite objects. Group can draw, update, and check collision for all its member sprites with one call.

All members of a Group must be unique (duplicates will be refused), and should be a Sprite (or functionally equivalent).

Methods

<<   call   clear   collide_group   collide_sprite   delete   draw   push   update  

Public Instance methods

Add sprite to the Group. sprite is notified so that it can add this Group to its list of parent Groups. See also push.

[Source]

# File lib/rubygame/sprite.rb, line 240
                        def <<(sprite)
                                unless self.include? sprite
                                        super(sprite)
                                        sprite.add(self)
                                end
                                return self
                        end

Call the method represented by symbol for every member sprite, giving args as the arguments to the method. This method uses Object#send, which does not hesitate to call private methods, so use this wisely! See also draw and update.

[Source]

# File lib/rubygame/sprite.rb, line 252
                        def call(symbol,*args)
                                self.each { |sprite|
                                        sprite.send(symbol,*args)
                                }
                        end

Remove every member sprite from the Group. Each sprite is notified so that it can remove this Group from its list of parent Groups. See also delete.

[Source]

# File lib/rubygame/sprite.rb, line 261
                        def clear
                                self.dup.each { |sprite| sprite.remove(self) }
                        end

Check collision between each member of the calling Group and each member of group. Returns a Hash table with each member of the calling Group as a key, and as a value an Array of all members of group that it collided with.

If a block is given, that block is executed for every pair of colliding sprites. For example, if a1 collides with b1 and b2, the block will be called twice: once with [ a1, b1 ] and once with [ a1, b2 ].

Example:

    # 'kills' both sprites when they collide

    groupA,collide_group(groupB) do |a, b|
      a.kill
      b.kill
    end

NOTE: killa and killb are deprecated and will be removed in the future. It is highly recommended that you use the block argument instead.

IMPORTANT: killa and killb will be ignored if a block is given!

If killa is true and a sprite in group A collides with a sprite in group B, the sprite in group A will have its kill method called; the same goes for killb and group B.

[Source]

# File lib/rubygame/sprite.rb, line 305
                        def collide_group(group, killa=false, killb=false, &block)
                                sprites = {}
                                self.each { |sprite|
                                        col = sprite.collide_group(group)
                                        sprites[sprite] = col if col.length > 0
                                }
                                
                                if block_given?
                                        sprites.each_pair do |a, bs|
                                                bs.each { |b| yield(a, b) }
                                        end
                                else
                                        # killa and killb only work if no block is given
                                        if killa
                                                sprites.each_key { |sprite| sprite.kill }
                                        end
                                        if killb
                                                sprites.each_value do |array|
                                                        array.each { |sprite| sprite.kill }
                                                end
                                        end
                                end
                                
                                return sprites
                        end

Check collision between each member of the Group and sprite. Returns an Array of all member sprites that collided with sprite. If none collided, returns an empty Array.

[Source]

# File lib/rubygame/sprite.rb, line 270
                        def collide_sprite(sprite)
                                sprite.collide_group(self)
                        end

Remove each sprite in sprites from the Group. Each sprite is notified so that it can remove this Group from its list of parent Groups. Note that this will not work correctly if fed a list of its own sprites (use Array.dup if you want correct behavior)

[Source]

# File lib/rubygame/sprite.rb, line 335
                        def delete(*sprites)
                                sprites.each { |sprite|
                                        if self.include? sprite
                                                super(sprite)
                                                sprite.remove(self)
                                        end
                                }
                                return self
                        end

Draw every sprite on Surface dest. Calls Sprite#draw for every member sprite, passing dest as the argument. See also call and update.

[Source]

# File lib/rubygame/sprite.rb, line 347
                        def draw(dest)
                                self.each { |sprite| sprite.draw(dest) }
                        end

Add each sprite in sprites to the Group. Each sprite is notified so that it can add this Group to its list of parent Groups. See also #<<.

[Source]

# File lib/rubygame/sprite.rb, line 353
                        def push(*sprites)
                                sprites.each { |sprite|
                                        self << sprite
                                }
                                return self
                        end

Update every member sprite. Calls Sprite#update for every member sprite, passing on all arguments. See also call and draw.

[Source]

# File lib/rubygame/sprite.rb, line 362
                        def update(*args)
                                self.each { |sprite|
                                        sprite.update(*args)
                                }
                        end

[Validate]