pygame documentation | || Pygame Home || Help Contents || Reference Index || Camera || Cdrom || Color || Cursors || Display || Draw || Event || Examples || Font || Gfxdraw || Image || Joystick || Key || Locals || Mask || Midi || Mixer || Mouse || Movie || Music || Overlay || Pixelarray || Pygame || Rect || Scrap || Sndarray || Sprite || Surface || Surfarray || Tests || Time || Transform

pygame.examples

module of example programs

pygame.examples.aliens.main - play the full aliens example | play the full aliens example
pygame.examples.oldalien.main - play the original aliens example | play the original aliens example
pygame.examples.stars.main - run a simple starfield example | run a simple starfield example
pygame.examples.chimp.main - hit the moving chimp | hit the moving chimp
pygame.examples.moveit.main - display animated objects on the screen | display animated objects on the screen
pygame.examples.fonty.main - run a font rendering example | run a font rendering example
pygame.examples.vgrade.main - display a vertical gradient | display a vertical gradient
pygame.examples.eventlist.main - display pygame events | display pygame events
pygame.examples.arraydemo.main - show various surfarray effects | show various surfarray effects
pygame.examples.sound.main - load and play a sound | load and play a sound
pygame.examples.sound_array_demos.main - play various sndarray effects | play various sndarray effects
pygame.examples.liquid.main - display an animated liquid effect | display an animated liquid effect
pygame.examples.glcube.main - display an animated 3D cube using OpenGL | display an animated 3D cube using OpenGL
pygame.examples.scrap_clipboard.main - access the clipboard | access the clipboard
pygame.examples.mask.main - display multiple images bounce off each other using collision detection | display multiple images bounce off each other using collision detection
pygame.examples.testsprite.main - show lots of sprites moving around | show lots of sprites moving around
pygame.examples.headless_no_windows_needed.main - write an image file that is smoothscaled copy of an input file | write an image file that is smoothscaled copy of an input file
pygame.examples.fastevents.main - stress test the fastevents module | stress test the fastevents module
pygame.examples.overlay.main - play a .pgm video using overlays | play a .pgm video using overlays
pygame.examples.blend_fill.main - demonstrate the various surface.fill method blend options | demonstrate the various surface.fill method blend options
pygame.examples.cursors.main - display two different custom cursors | display two different custom cursors
pygame.examples.pixelarray.main - display various pixelarray generated effects | display various pixelarray generated effects
pygame.examples.scaletest.main - interactively scale an image using smoothscale | interactively scale an image using smoothscale
pygame.examples.midi.main - run a midi example | run a midi example
pygame.examples.scroll.main - run a Surface.scroll example that shows a magnified image | run a Surface.scroll example that shows a magnified image
pygame.examples.movieplayer.main - play an MPEG movie | play an MPEG movie

These examples should help get you started with pygame. Here is a brief rundown of what you get. The source code for these examples is in the public domain. Feel free to use for your own projects.

There are several ways to run the examples. First they can be run as stand-alone programs. Second they can be imported and their main() methods called (see below). Finally, the easiest way is to use the python -m option:

       python -m pygame.examples.<example name> <example arguments>

eg:

       python -m pygame.examples.scaletest someimage.png

Resources for the examples are found in the pygame/examples/data subdirectory.

We're always on the lookout for more examples and/or example requests. Code like this is probably the best way to start getting involved with python gaming.

This page is adapted from the original examples `readme.txt` by:

        Pete Shinners
        shredwheat@mediaone.net

Further references

      pySDL    : http://pysdl.sourceforge.net
      SDL      : http://www.libsdl.org
      aliens.c : http://www.libsdl.org/projects/aliens

examples as a package is new to pygame `1.9.0`.

pygame.examples.aliens.main

play the full aliens example
`pygame.aliens.main(): return None`

This started off as a port of the `SDL` demonstration, Aliens. Now it has evolved into something sort of resembling fun. This demonstrates a lot of different uses of sprites and optimized blitting. Also transparency, colorkeys, fonts, sound, music, joystick, and more. `(PS`, my high score is 117! goodluck)

pygame.examples.oldalien.main

play the original aliens example
`pygame.examples.oldalien.main(): return None`

This more closely resembles a port of the `SDL` Aliens demo. The code is a lot simpler, so it makes a better starting point for people looking at code for the first times. These blitting routines are not as optimized as they should/could be, but the code is easier to follow, and it plays quick enough.

pygame.examples.stars.main

run a simple starfield example
`pygame.examples.stars.main(): return None`

`A` simple starfield example. You can change the center of perspective by leftclicking the mouse on the screen.

pygame.examples.chimp.main

hit the moving chimp
`pygame.examples.chimp.main(): return None`

This simple example is derived from the line-by-line tutorial that comes with pygame. It is based on a 'popular' web banner. Note there are comments here, but for the full explanation, follow along in the tutorial.

pygame.examples.moveit.main

display animated objects on the screen
`pygame.examples.moveit.main(): return None`

This is the full and final example from the Pygame Tutorial, "How Do `I` Make It Move". It creates 10 objects and animates them on the screen.

Note it's a bit scant on error checking, but it's easy to read. :] Fortunately, this is python, and we needn't wrestle with a pile of error codes.

pygame.examples.fonty.main

run a font rendering example
`pygame.examples.fonty.main(): return None`

Super quick, super simple application demonstrating the different ways to render fonts with the font module

pygame.examples.vgrade.main

display a vertical gradient
`pygame.examples.vgrade.main(): return None`

Demonstrates creating a vertical gradient with NumPy python. The app will create a new gradient every half second and report the time needed to create and display the image. If you're not prepared to start working with the NumPy arrays, don't worry about the source for this one :]

pygame.examples.eventlist.main

display pygame events
`pygame.examples.eventlist.main(): return None`

Eventlist is a sloppy style of pygame, but is a handy tool for learning about pygame events and input. At the top of the screen are the state of several device values, and a scrolling list of events are displayed on the bottom.

This is not quality 'ui' code at all, but you can see how to implement very non-interactive status displays, or even a crude text output control.

pygame.examples.arraydemo.main

show various surfarray effects
`pygame.examples.arraydemo.main(arraytype=None): return None`

Another example filled with various surfarray effects. It requires the surfarray and image modules to be installed. This little demo can also make a good starting point for any of your own tests with surfarray

If arraytype is provided then use that array package. Valid values are 'numeric' or 'numpy'. Otherwise default to NumPy, or fall back on Numeric if NumPy is not installed. As a program `surfarray.py` accepts an optional --numeric or --numpy flag. (New pygame `1.9.0)`

pygame.examples.sound.main

load and play a sound
`pygame.examples.sound.main(file_path=None): return None`

Extremely basic testing of the mixer module. Load a sound and play it. All from the command shell, no graphics.

If provided, use the audio file 'file_path', otherwise use a default file.

`sound.py` optional command line argument: an audio file

pygame.examples.sound_array_demos.main

play various sndarray effects
`pygame.examples.sound_array_demos.main(arraytype=None): return None`

If arraytype is provided then use that array package. Valid values are 'numeric' or 'numpy'. Otherwise default to NumPy, or fall back on Numeric if NumPy is not installed.

Uses sndarray and NumPy ( or Numeric) to create offset faded copies of the original sound. Currently it just uses hardcoded values for the number of echos and the delay. Easy for you to recreate as needed. Run as a program `sound_array_demos.py` takes an optional command line option, --numpy or --numeric, specifying which array package to use.

pygame.examples.liquid.main

display an animated liquid effect
`pygame.examples.liquid.main(): return None`

This example was created in a quick comparison with the BlitzBasic gaming language. Nonetheless, it demonstrates a quick 8-bit setup (with colormap).

pygame.examples.glcube.main

display an animated 3D cube using OpenGL
`pygame.examples.glcube.main(): return None`

Using PyOpenGL and pygame, this creates a spinning `3D` multicolored cube.

pygame.examples.scrap_clipboard.main

access the clipboard
`pygame.examples.scrap_clipboard.main(): return None`

`A` simple demonstration example for the clipboard support.

pygame.examples.mask.main

display multiple images bounce off each other using collision detection
`pygame.examples.mask.main(*args): return None`

Positional arguments:

        one or more image file names.

This `pygame.masks` demo will display multiple moving sprites bouncing off each other. More than one sprite image can be provided.

If run as a program then `mask.py` takes one or more image files as command line arguments.

pygame.examples.testsprite.main

show lots of sprites moving around
`pygame.examples.testsprite.main(update_rects = True, use_static = False, use_FastRenderGroup = False, screen_dims = [640, 480], use_alpha = False, flags = 0): return None`

Optional keyword arguments:

        update_rects - use the RenderUpdate sprite group class
        use_static - include non-moving images
        use_FastRenderGroup - Use the FastRenderGroup sprite group
        screen_dims - pygame window dimensions
        use_alpha - use alpha blending
        flags - additional display mode flags

Like the `testsprite.c` that comes with sdl, this pygame version shows lots of sprites moving around.

If run as a stand-alone program then no command line arguments are taken.

pygame.examples.headless_no_windows_needed.main

write an image file that is smoothscaled copy of an input file
`pygame.examples.headless_no_windows_needed.main(fin, fout, w, h): return None`

arguments:

        fin - name of an input image file
        fout - name of the output file to create/overwrite
        w, h - size of the rescaled image, as integer width and height

How to use pygame with no windowing system, like on headless servers.

Thumbnail generation with scaling is an example of what you can do with pygame.

`NOTE:` the pygame scale function uses mmx/sse if available, and can be run in multiple threads.

If `headless_no_windows_needed.py` is run as a program it takes the following command line arguments:

        -scale inputimage outputimage new_width new_height
        eg. -scale in.png outpng 50 50

pygame.examples.fastevents.main

stress test the fastevents module
`pygame.examples.fastevents.main(): return None`

This is a stress test for the fastevents module.

- Fast events does not appear faster!

So far it looks like normal `pygame.event` is faster by up to two times. So maybe fastevent isn't fast at all.

Tested on windowsXP sp2 athlon, and freebsd.

`However..`. on my debian duron 850 machine fastevents is faster.

pygame.examples.overlay.main

play a .pgm video using overlays
`pygame.examples.overlay.main(fname): return None`

Play the .pgm video fila a path fname.

If run as a program `overlay.py` takes the file name as a command line argument.

pygame.examples.blend_fill.main

demonstrate the various surface.fill method blend options
`pygame.examples.blend_fill.main(): return None`

`A` interactive demo that lets one choose which BLEND_xxx option to apply to a surface.

pygame.examples.cursors.main

display two different custom cursors
`pygame.examples.cursors.main(): return None`

Display an arrow or circle with crossbar cursor.

pygame.examples.pixelarray.main

display various pixelarray generated effects
`pygame.examples.pixelarray.main(): return None`

Display various pixelarray generated effects.

pygame.examples.scaletest.main

interactively scale an image using smoothscale
`pygame.examples.scaletest.main(imagefile, convert_alpha=False, run_speed_test=True): return None`

arguments:

        imagefile - file name of source image (required)
        convert_alpha - use convert_alpha() on the surf (default False)
        run_speed_test - (default False)

`A` smoothscale example that resized an image on the screen. Vertical and horizontal arrow keys are used to change the width and height of the displayed image. If the convert_alpha option is True then the source image is forced to have source alpha, whether or not the original images does. If run_speed_test is True then a background timing test is performed instead of the interactive scaler.

If `scaletest.py` is run as a program then the command line options are:

        ImageFile [-t] [-convert_alpha]
        [-t] = Run Speed Test
        [-convert_alpha] = Use convert_alpha() on the surf.

pygame.examples.midi.main

run a midi example
`pygame.examples.midi.main(mode='output', device_id=None): return None`

Arguments:

        mode - if 'output' run a midi keyboard output example
                  'input' run a midi event logger input example
                  'list' list available midi devices
               (default 'output')
        device_id - midi device number; if None then use the default midi input or
                    output device for the system

The output example shows how to translate mouse clicks or computer keyboard events into midi notes. It implements a rudimentary button widget and state machine.

The input example shows how to translate midi input to pygame events.

With the use of a virtual midi patch cord the output and input examples can be run as separate processes and connected so the keyboard output is displayed on a console.

new to pygame `1.9.0`

pygame.examples.scroll.main

run a Surface.scroll example that shows a magnified image
`pygame.examples.scroll.main(image_file=None): return None`

This example shows a scrollable image that has a zoom factor of eight. It uses the `Surface.scroll` function to shift the image on the display surface. `A` clip rectangle protects a margin area. If called as a function, the example accepts an optional image file path. If run as a program it takes an optional file path command line argument. If no file is provided a default image file is used.

When running click on a black triangle to move one pixel in the direction the triangle points. Or use the arrow keys. Close the window or press `ESC` to quit.

pygame.examples.movieplayer.main

play an MPEG movie
`pygame.examples.moveplayer.main(filepath): return None`

`A` simple movie player that plays an `MPEG` movie in a Pygame window. It showcases the `pygame.movie` module. The window adjusts to the size of the movie image. It is given a boarder to demonstrate that a movie can play autonomously in a sub- window. Also, the file is copied to a file like object to show that not just Python files can be used as a movie source.

The `pygame.movie` module is problematic and may not work on all systems. It is intended to replace it with an ffmpeg based version.