def test_collide_mask__opaque(self):
        # make some fully opaque sprites that will collide with masks.
        self.s1.image.fill((255,255,255,255))
        self.s2.image.fill((255,255,255,255))
        self.s3.image.fill((255,255,255,255))

        # masks should be autogenerated from image if they don't exist.
        self.assertEqual (
            sprite.spritecollide (
                self.s1, self.ag2, dokill = False,
                collided = sprite.collide_mask
            ),
            [self.s2]
        )

        self.s1.mask = pygame.mask.from_surface(self.s1.image)
        self.s2.mask = pygame.mask.from_surface(self.s2.image)
        self.s3.mask = pygame.mask.from_surface(self.s3.image)

        # with set masks.
        self.assertEqual (
            sprite.spritecollide (
                self.s1, self.ag2, dokill = False,
                collided = sprite.collide_mask
            ),
            [self.s2]
        )

    def update(self, dt):
        self.player.update(dt)
        self.coins.update(dt)

        # lock player in bounds
        self.player.rect.clamp_ip(self.bounds)

        spritecollide(self.player, self.coins, True)

    def update(self, dt):
        self.player.update(dt)
        self.cookies.update(dt)

        # lock player in bounds
        self.player.rect.clamp_ip(self.bounds)

        # collide player with coins
        spritecollide(self.player, self.cookies, True)

    def update(self, time, player_group, platform_group):
        if self.KILL:
            self.explode()
        hit_players = PS.spritecollide(self, player_group, False)
        hit_platforms = PS.spritecollide(self, platform_group, False)

        if hit_players:
            for this_player in hit_players:
                self.react(this_player)

        if hit_platforms:
            for this_platform in hit_platforms:
                self.rect.centery = (this_platform.get_top() - self.rect.height/4)

    def update(self):
        dt = self.clock.tick(FPS)

        # basic update
        self.player.update(dt)
        self.coins.update(dt)

        # check if the player is on the path
        onpath = spritecollide(self.player, self.level.path, False)
        self.player.on_path(onpath)

        # collide coins
        for coin in spritecollide(self.player, self.coins, True):
            self.score += 1

        self.cam.update(self.player.rect)

	def kill_people(self, scene):
		hitted_players = sprite.spritecollide(self, scene.enemyGroup, False)
		# scene.bulletGroup.remove(self)
		for player in hitted_players:
			player.hit_by_bullet(self.atk)
			# A bullet should not be capable of going through an infinite amount of bodies
			scene.bulletGroup.remove(self)

    def detect_collision(self):
        collisions = spritecollide(self.player, self.obstacle_group, True)

        for c in collisions:
            self.collision_strategy_factory.get_strategy(c).on_collision()
            self.obstacles.remove(c)
            c.kill()

 def useportal(self):
     # check for portals
     portalbox = spritecollide(self,self.level.portal_list,False)
     if portalbox != []:
         return portalbox[0].destination
     else:
         return 0

 def handle_collision(self, bg, m_back=False):
     if m_back:
         face_copy = self.face
         self.face = self.move_face
     collisions = PS.spritecollide(self, bg, False)
     if 'r' in self.face:
         for collision in collisions:
             if(self.rect.x +
                self.rect.width) >= collision.rect.left:
                 self.rect.x = collision.rect.left - self.rect.width
     elif 'l' in self.face:
         for collision in collisions:
             if (self.rect.x) <= (collision.rect.left +
                                  collision.rect.width):
                 self.rect.x = collision.rect.left + \
                     collision.rect.width
     elif 'd' in self.face:
         for collision in collisions:
             if(self.rect.y +
                self.rect.height) >= collision.rect.top:
                 self.rect.y = collision.rect.top - self.rect.height
     elif 'u' in self.face:
         for collision in collisions:
             if (self.rect.y <= (collision.rect.top +
                                 collision.rect.height)):
                 self.rect.y = collision.rect.top + \
                     collision.rect.height
     if m_back:
         self.face = face_copy
     return (collisions is None)

 def handle_player(self, player):
     player.sprites()[0].set_attacking_rect()
     collisions = PS.spritecollide(self, player, False)
     if(len(collisions) == 1 and isinstance(collisions[0], Player)):
         if(Globals.INVINCIBILITY_COUNT == 0):
             self.attacked_player = True
     player.sprites()[0].reset_attacking_rect()

 def update(self):
     BouncySprite.update(self)
     if sprite.spritecollide(self, self.game.monsters, True):
         self.kill()
     self.life -= 1
     if self.life <= 0:
         self.kill()

    def execute(self):
        '''Controls the actor movement as a regular object under Newton's laws. Checks collisions with grounds'''
        actor=self.__parent
        self.velocity=self.velocity+(actor.steering_acceleration+PS_freefall.GRAVITY)*self.time_step
        
        self.position=self.position+self.velocity*self.time_step
        if self.i==4:
            for floor in spritecollide(actor, actor.get_level().floors, False):
                if not actor.crect.colliderect(floor.crect):
                    continue
                if -16<floor.crect.top-actor.crect.bottom<3 and self.velocity[1]>=0:
                    self.velocity[1]=0
                    actor.standing_on=floor
                    self.position[1]=floor.crect.top-actor.rect.height/2
                    self.__parent_PM.set_state(PS_walking)
                    continue
                
                elif -16<floor.crect.left-actor.crect.right<3 and self.velocity[0]>0:
                    self.velocity[0]=-self.velocity[0]
                elif -3<floor.crect.right-actor.crect.left<16 and self.velocity[0]<0:
                    self.velocity[0]=-self.velocity[0]
                elif -3<floor.crect.bottom-actor.crect.top<16 and self.velocity[1]<0:
                    self.velocity[1]=-self.velocity[1]
            self.i=0
        else: self.i+=1

        actor.set_position([self.position[0], self.position[1]])

	def update(self, time, scene):
		self.floatX += self.speedX * time * GRENADE_SPEED
		self.floatY += self.speedY * time * GRENADE_SPEED
		self.rect.x = roundToInt(self.floatX)
		self.rect.y = roundToInt(self.floatY)

		self.timeToBoom -= time

		if self.timeToBoom <= 0:
			scene.bulletGroup.remove(self)
			scene.bulletGroup.add(Explosion(self.rect.x, self.rect.y))

			# Kill people!
			originalRect = self.rect.copy()
			self.rect.inflate_ip(80, 80)  # 80x80 area damage
			
			enemies_hit = sprite.spritecollide(self, scene.enemyGroup, False)

			for enemy in enemies_hit:
				# Friendly fire
				if self.creator.__class__.__name__ == enemy.__class__.__name__:
					continue
				enemy.receive_attack(self.atk)

			if sprite.collide_rect(self, scene.player):
				scene.player.receive_attack(self.atk)

			self.rect = originalRect  # Restore the real rect

		self.timeToStop -= time

		if self.timeToStop <= 0:
			self.speedX = 0
			self.speedY = 0

 def test_collide_circle__no_radius_set(self):
     # collide_circle with no radius set.
     self.assertEqual (
         sprite.spritecollide (
             self.s1, self.ag2, dokill = False, collided = sprite.collide_circle
         ),
         [self.s2]
     )

 def test_spritecollide__works_if_collided_cb_is_None(self):
     # Test that sprites collide without collided function.
     self.assertEqual (
         sprite.spritecollide (
             self.s1, self.ag2, dokill = False, collided = None
         ),
         [self.s2]
     )

 def test_spritecollide__collided_defaults_to_collide_rect(self):
     # collide_rect should behave the same as default.
     self.assertEqual (
         sprite.spritecollide (
             self.s1, self.ag2, dokill = False, collided = sprite.collide_rect
         ),
         [self.s2]
     )

 def grounded(self):
     "Check for ground underneath players feet, if not found switch to falling state"
     tmp = self.player.rect
     self.player.rect = self.player.rect.move(0, 1)
     collides = spritecollide(self.player, level.tile_group, False)
     if not collides:
         self.fall()
         
     self.player.rect = tmp

    def detect_collision(self):
        if self.elements['ship'].sprite:
            self.ship_collides = spritecollideany(self.elements['ship'].sprite, self.elements['asteroids'])
            self.ship_catches = spritecollide(self.elements['ship'].sprite, self.elements['power-ups'], True)

        if groupcollide(self.elements['lasers'], self.elements['asteroids'], True, True):
            if randint(1, 20) == 1:
                self.newPU = True
            self.score_add(50)

 def test_collide_circle_ratio__no_radius_and_ratio_of_one(self):
     # collide_circle_ratio with no radius set, at a 1.0 ratio.
     self.assertEqual (
         sprite.spritecollide (
             self.s1, self.ag2, dokill = False,
             collided = sprite.collide_circle_ratio(1.0)
         ),
         [self.s2]
     )

 def test_collide_rect_ratio__ratio_of_one_like_default(self):
     # collide_rect_ratio should behave the same as default at a 1.0 ratio.
     self.assertEqual (
         sprite.spritecollide (
             self.s1, self.ag2, dokill = False,
             collided = sprite.collide_rect_ratio(1.0)
         ),
         [self.s2]
     )