Mizipzor's Weblog

My latest little pet project, a game, has progressed far enough to have some rendering put in. I’ve always used Pygame for my games in Python. This started out as no exception.

Pygame uses SDL, in which rendering is simple but slow. You can get some quite significant speed boosts if you only redraw the pixels on the screen that actually change. So you keep track of where the sprite was and if it moved, you redraw the background there and then draw the sprite at the new location. DR0ID has a great article (scroll down to “Dirty Rects”) explaining this!

Anyway, I made a snippet to show how its done, the code is at the bottom of the post. Notice the use of Pygame’s sprite group LayeredDirty, it handles dirty sprites and keeps track of sprites moving across each other. In that snippet the Below class would be a background tile, Above would be the player’s avatar moving across it.

So theres two things I don’t like here. First, when implementing the rendering in my game, all of the drawing bugs were related to me forgetting to set the dirty attribute when I should have. Rendering code is boring to write, so I want it to be as simple as possible. In a perfect world, the sprite would keep track of its dirty status itself. This is also the reason for the title of this post, since its a cumbersome part of Pygame, its dirty. Get it?

Jokes aside, the second thing is that I go through all this trouble to gain some speed. But how much extra speed? How many sprites do I need to put into it before it starts to slow down? I plan to do some benchmarking on this (anyone know about any Pygame benchmarks by the way?).

The norm in systems like OpenGL or DirectX, more commonly used in games, is to redraw the entire screen each frame. That way you don’t have to care about dirty attributes. Those systems are also, at least as far as I know, faster than SDL. There are OpenGL libs for Python. I recently found the project Pyglet, which seems to be written as an alternative to Pygame. I’ll look into that, if it both easier to code in (no manual dirty tracking) and faster, there’s no reason not to switch.

Now for the code:

import pygame
from pygame.locals import *

pygame.init()
screen = pygame.display.set_mode((100,100))
background = pygame.surface.Surface(screen.get_size()).convert()
background.fill((0,0,255))

group = pygame.sprite.LayeredDirty()

class Below(pygame.sprite.DirtySprite):
    def __init__(self):
        pygame.sprite.DirtySprite.__init__(self, group)
        self.dirty = 1
        self.layer = 10
        self.image = pygame.surface.Surface((25,25)).convert()
        self.image.fill((255,0,0))
        self.rect = self.image.get_rect()
        self.rect.center = (50,50)

    def update(self):
        pass

class Above(pygame.sprite.DirtySprite):
    def __init__(self):
        pygame.sprite.DirtySprite.__init__(self, group)
        self.dirty = 1
        self.layer = 20
        self.image = pygame.surface.Surface((10,10)).convert()
        self.image.fill((0,255,0))
        self.rect = self.image.get_rect()
        self.rect.center = (25,50)
        self.going_right = True

    def update(self):
        if self.going_right:
            self.rect.centerx += 1
            if self.rect.centerx > 75:
                self.going_right = False
        else:
            self.rect.centerx -= 1
            if self.rect.centerx < 25:
                self.going_right = True
        self.dirty = 1

def main():
    Below()
    Above()
    while 1:
        for e in pygame.event.get():
            if e.type in (KEYDOWN, QUIT): return
        group.clear(screen, background)
        group.update()
        group.draw(screen)
        pygame.display.flip()

if __name__=="__main__":
    main()