Class: Rubygame::Sprites::Group

Inherits:
Array
  • Object
show all
Defined in:
lib/rubygame/sprite.rb

Overview

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).

Instance Method Summary collapse

Instance Method Details

#<<(sprite) ⇒ Object

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



240
241
242
243
244
245
246
 
# File 'lib/rubygame/sprite.rb', line 240

def <<(sprite)
	unless self.include? sprite
		super(sprite)
		sprite.add(self)
	end
	return self
end

#call(symbol, *args) ⇒ Object

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.



252
253
254
255
256
 
# File 'lib/rubygame/sprite.rb', line 252

def call(symbol,*args)
	self.each { |sprite|
		sprite.send(symbol,*args)
	}
end

#clear ⇒ Object

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.



261
262
263
 
# File 'lib/rubygame/sprite.rb', line 261

def clear
	self.dup.each { |sprite| sprite.remove(self) }
end

#collide_group(group, killa = false, killb = false, &block) ⇒ Object

call-seq:

collide_group(group, &block)  ->  Hash
collide_group(group, killa=false, killb=false) -> Hash # deprecated

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.



305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
 
# 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

#collide_sprite(sprite) ⇒ Object

call-seq: collide_sprite(sprite) -> Array

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.



270
271
272
 
# File 'lib/rubygame/sprite.rb', line 270

def collide_sprite(sprite)
	sprite.collide_group(self)
end

#delete(*sprites) ⇒ Object

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)



335
336
337
338
339
340
341
342
343
 
# 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(dest) ⇒ Object

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



347
348
349
 
# File 'lib/rubygame/sprite.rb', line 347

def draw(dest)
	self.each { |sprite| sprite.draw(dest) }
end

#push(*sprites) ⇒ Object

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 #<<.



353
354
355
356
357
358
 
# File 'lib/rubygame/sprite.rb', line 353

def push(*sprites)
	sprites.each { |sprite|
		self << sprite
	}
	return self
end

#update(*args) ⇒ Object

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



362
363
364
365
366
 
# File 'lib/rubygame/sprite.rb', line 362

def update(*args)
	self.each { |sprite|
		sprite.update(*args)
	}
end