pygame.examples
module of example programs

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    : <a href="http://pysdl.sourceforge.net">http://pysdl.sourceforge.net<a/>
  SDL      : <a href="http://www.libsdl.org">http://www.libsdl.org<a/>
  aliens.c : <a href="http://www.libsdl.org/projects/aliens">http://www.libsdl.org/projects/aliens<a/>

examples as a package is new to pygame 1.9.0.
<SECTION>



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



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



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



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




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




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
<END>



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 :]
<END>



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




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



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
<END>



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



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



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



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

A simple demonstration example for the clipboard support.
<END>




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




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




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
<END>




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




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



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


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

Display an arrow or circle with crossbar cursor.
<END>



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

Display various pixelarray generated effects.
<END>




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



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
<END>



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



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