self,*sprites:Union[_TSprite,AbstractGroup[_TSprite],Iterable[_TSprite]]

)->bool: ...

defupdate(self,*args:Any,**kwargs:Any)->None: ...

defdraw(self,surface:Surface)->List[Rect]: ...

defdraw(

self,surface:Surface,bgsurf:Optional[Surface]=None,special_flags:int=0

)->List[Rect]: ...

defclear(

self,surface:Surface,bgd:Union[Surface,Callable[[Surface,Rect],Any]]

)->None: ...

classLayeredDirty(LayeredUpdates[_TDirtySprite]):

def__init__(self,*sprites:_TDirtySprite,**kwargs:Any)->None: ...

defdraw(self,surface:Surface,bgd:Optional[Surface]=None)->List[Rect]: ...

defdraw(

self,surface:Surface,bgsurf:Optional[Surface]=None,special_flags:int=None

)->List[Rect]: ...

defclear(self,surface:Surface,bgd:Surface)->None: ...# type: ignore[override]

defrepaint_rect(self,screen_rect:RectValue)->None: ...

..method::draw

Draws the contained Sprites to the Surface argument. This uses the

``Sprite.image`` attribute for the source surface, and ``Sprite.rect``

for the position.

for the position. ``special_flags`` is passed to ``Surface.blit()``.

``bgsurf`` is unused in this method but ``LayeredDirty.draw()`` uses

it.

The Group does not keep sprites in any order, so the draw order is

arbitrary.

..method::draw

Draws all the Sprites to the surface, the same as ``Group.draw()``. This

method also returns a list of Rectangular areas on the screen that have

been changed. The returned changes include areas of the screen that have

been affected by previous ``Group.clear()`` calls.

been affected by previous ``Group.clear()`` calls. ``special_flags`` is

passed to ``Surface.blit()``.

The returned Rect list should be passed to ``pygame.display.update()``.

This will help performance on software driven display modes. This type of

..method::draw

..method::draw

You can pass the background too. If a background is already set, then the

bgd argument has no effect.

bgsurf argument has no effect. If present, the ``special_flags`` argument is

always passed to ``Surface.blit()``, overriding ``DirtySprite.blendmode``.

If ``special_flags`` is not present, ``DirtySprite.blendmode`` is passed

to the ``Surface.blit()`` instead.

#defineDOC_GROUPREMOVE "remove(*sprites) -> None\nremove Sprites from the Group"

#defineDOC_GROUPHAS "has(*sprites) -> bool\ntest if a Group contains Sprites"

#defineDOC_GROUPUPDATE "update(*args, **kwargs) -> None\ncall the update method on contained Sprites"

#defineDOC_GROUPDRAW "draw(Surface) -> List[Rect]\nblit the Sprite images"

#defineDOC_GROUPDRAW "draw(Surface, bgsurf=None, special_flags=0) -> List[Rect]\nblit the Sprite images"

#defineDOC_GROUPCLEAR "clear(Surface_dest, background) -> None\ndraw a background over the Sprites"

#defineDOC_GROUPEMPTY "empty() -> None\nremove all Sprites"

#defineDOC_PYGAMESPRITERENDERPLAIN "Same as pygame.sprite.Group"

#defineDOC_PYGAMESPRITERENDERCLEAR "Same as pygame.sprite.Group"

#defineDOC_PYGAMESPRITERENDERUPDATES "RenderUpdates(*sprites) -> RenderUpdates\nGroup sub-class that tracks dirty updates."

#defineDOC_RENDERUPDATESDRAW "draw(surface) -> Rect_list\nblit the Sprite images and track changed areas"

#defineDOC_RENDERUPDATESDRAW "draw(surface, bgsurf=None, special_flags=0) -> Rect_list\nblit the Sprite images and track changed areas"

#defineDOC_PYGAMESPRITEORDEREDUPDATES "OrderedUpdates(*sprites) -> OrderedUpdates\nRenderUpdates sub-class that draws Sprites in order of addition."

#defineDOC_PYGAMESPRITELAYEREDUPDATES "LayeredUpdates(*sprites, **kwargs) -> LayeredUpdates\nLayeredUpdates is a sprite group that handles layers and draws like OrderedUpdates."

#defineDOC_LAYEREDUPDATESADD "add(*sprites, **kwargs) -> None\nadd a sprite or sequence of sprites to a group"

#defineDOC_LAYEREDUPDATESSPRITES "sprites() -> sprites\nreturns a ordered list of sprites (first back, last top)."

#defineDOC_LAYEREDUPDATESDRAW "draw(surface) -> Rect_list\ndraw all sprites in the right order onto the passed surface."

#defineDOC_LAYEREDUPDATESDRAW "draw(surface, bgsurf=None, special_flags=0) -> Rect_list\ndraw all sprites in the right order onto the passed surface."

#defineDOC_LAYEREDUPDATESGETSPRITESAT "get_sprites_at(pos) -> colliding_sprites\nreturns a list with all sprites at that position."

#defineDOC_LAYEREDUPDATESGETSPRITE "get_sprite(idx) -> sprite\nreturns the sprite at the index idx from the groups sprites"

#defineDOC_LAYEREDUPDATESREMOVESPRITESOFLAYER "remove_sprites_of_layer(layer_nr) -> sprites\nremoves all sprites from a layer and returns them as a list."

#defineDOC_LAYEREDUPDATESGETSPRITESFROMLAYER "get_sprites_from_layer(layer) -> sprites\nreturns all sprites from a layer, ordered by how they where added"

#defineDOC_LAYEREDUPDATESSWITCHLAYER "switch_layer(layer1_nr, layer2_nr) -> None\nswitches the sprites from layer1 to layer2"

#defineDOC_PYGAMESPRITELAYEREDDIRTY "LayeredDirty(*sprites, **kwargs) -> LayeredDirty\nLayeredDirty group is for DirtySprite objects. Subclasses LayeredUpdates."

#defineDOC_LAYEREDDIRTYDRAW "draw(surface,bgd=None) -> Rect_list\ndraw all sprites in the right order onto the passed surface."

#defineDOC_LAYEREDDIRTYDRAW "draw(surface,bgsurf=None, special_flags=None) -> Rect_list\ndraw all sprites in the right order onto the passed surface."

#defineDOC_LAYEREDDIRTYCLEAR "clear(surface, bgd) -> None\nused to set background"

#defineDOC_LAYEREDDIRTYREPAINTRECT "repaint_rect(screen_rect) -> None\nrepaints the given area"

#defineDOC_LAYEREDDIRTYSETCLIP "set_clip(screen_rect=None) -> None\nclip the area where to draw. Just pass None (default) to reset the clip"

forspriteinself.sprites():

sprite.update(*args,**kwargs)

defdraw(self,surface):

defdraw(

self,surface,bgsurf=None,special_flags=0

):# noqa pylint: disable=unused-argument; bgsurf arg used in LayeredDirty

sprites=self.sprites()

ifhasattr(surface,"blits"):

self.spritedict.update(

zip(sprites,surface.blits((spr.image,spr.rect)forsprinsprites))

zip(

sprites,

surface.blits(

(spr.image,spr.rect,None,special_flags)forsprinsprites

),

)

)

else:

forsprinsprites:

self.spritedict[spr]=surface.blit(spr.image,spr.rect)

self.spritedict[spr]=surface.blit(

spr.image,spr.rect,None,special_flags

)

self.lostsprites= []

dirty=self.lostsprites

defdraw(self,surface):

defdraw(self,surface,bgsurf=None,special_flags=0):

surface_blit=surface.blit

dirty=self.lostsprites

self.lostsprites= []

dirty_append=dirty.append

forspriteinself.sprites():

old_rect=self.spritedict[sprite]

new_rect=surface_blit(sprite.image,sprite.rect)

new_rect=surface_blit(sprite.image,sprite.rect,None,special_flags)

ifold_rect:

ifnew_rect.colliderect(old_rect):

dirty_append(new_rect.union(old_rect))

returnself._spritelist.copy()

defdraw(self,surface):

defdraw(self,surface,bgsurf=None,special_flags=0):

spritedict=self.spritedict

init_rect=self._init_rect

forsprinself.sprites():

rec=spritedict[spr]

newrect=surface_blit(spr.image,spr.rect)

newrect=surface_blit(spr.image,spr.rect,None,special_flags)

ifrecisinit_rect:

dirty_append(newrect)

else:

LayeredUpdates.add_internal(self,sprite,layer)

defdraw(

self,surface,bgd=None

):# noqa pylint: disable=arguments-differ; unable to change public interface

defdraw(self,surface,bgsurf=None,special_flags=None):

surf_blit_func=surface.blit

ifbgdisnotNone:

self._bgd=bgd

ifbgsurfisnotNone:

self._bgd=bgsurf

local_bgd=self._bgd

surface.set_clip(latest_clip)

iflocal_bgdisnotNone:

forrecinlocal_update:

surf_blit_func(local_bgd,rec,rec)

surf_blit_func(local_bgd,rec,rec,flags)

self._draw_dirty_internal(

local_old_rect,rect_type,local_sprites,surf_blit_func,local_update

local_old_rect,

rect_type,

local_sprites,

surf_blit_func,

local_update,

special_flags,

)

local_ret=list(local_update)

else:# flip, full screen mode

iflocal_bgdisnotNone:

surf_blit_func(local_bgd, (0,0))

surf_blit_func(local_bgd, (0,0),None,flags)

forsprinlocal_sprites:

ifspr.visible:

flags=spr.blendmodeifspecial_flagsisNoneelsespecial_flags

local_old_rect[spr]=surf_blit_func(

spr.image,spr.rect,spr.source_rect,spr.blendmode

spr.image,spr.rect,spr.source_rect,flags

)

local_ret= [rect_type(latest_clip)]

def_draw_dirty_internal(_old_rect,_rect,_sprites,_surf_blit,_update):

def_draw_dirty_internal(

_old_rect,_rect,_sprites,_surf_blit,_update,_special_flags

):

forsprin_sprites:

flags=spr.blendmodeif_special_flagsisNoneelse_special_flags

ifspr.dirty<1andspr.visible:

ifspr.source_rectisnotNone:

clip[2],

clip[3],

),

spr.blendmode,

flags,

)

else:# dirty sprite

ifspr.visible:

_old_rect[spr]=_surf_blit(

spr.image,spr.rect,spr.source_rect,spr.blendmode

spr.image,spr.rect,spr.source_rect,flags

)

ifspr.dirty==1:

spr.dirty=0