University of Michigan - Ann Arbor

Pygame is a Python library for game development, including multiple independent modules to help create games. It's written on top of SDL, which is a library for interacting with hardware peripherals and graphical displays. Pygame's modules can be installed separately and swapped out, making it a modular package. Pygame is not a game engine or framework.

Pygame

Pygame Documentation

Time is represented in milliseconds. The time module is used for retrieving the time and creating clocks.
To get the time that has passed since pygame.init() was called, use the following command:
```python
pygame.time.get_ticks()
```
Both the wait and delay methods will pause the program for a period of time, with wait sleeping the program and using less processor time, but being less accurate as a result. Delay is more accurate but uses the processor to pause the program. You just pass in the amount of time (in ms) you want to pause the program.
```python
pygame.time.wait(milliseconds)

pygame.time.delay(milliseconds)
```
You can also set an event to appear every certain number of ms on the event queue using the set_timer method. Once is an optional parameter that, when set to True, will only call the event once.
```python
pygame.time.set_timer(eventid, time, once)
```
Clocks can also be created to help track time, and have a number of methods that can be used with them.

Time in Pygame

You can think of a Surface as a blank piece of paper. There are plenty of methods you can call to draw on the Surface using graphics manipulation. This means altering pixel color values and their alphas. In order to actually make a game, you will have to decide which Surface you want to be your screen by calling a method on the Display (which handles the main game screen). You can only have one Surface as your screen. Additionally, all images must be displayed on a Surface.

Surfaces in Pygame

There a multitude of shapes you can draw with pygame. You specify attributes of the shape like color, size, coordinates for the position, and which surface to draw the shape on. All the drawing functions will take in a color parameter that can be a pygame.Color object, an RGB tuple/list, RGBA tuple/list, or an integer value that has been mapped to the surface's pixel format.

Drawing in Pygame

The image module contains functions for loading and saving image files. Images will be loaded as Surface objects. Images can be saved by passing in the Surface you want to make an Image file out of. The module will then generate an image file from the Surface. 
Note that there are no image objects in Pygame--images are stored on Surfaces. The Surface class will allow you to manipulate the image on the Surface by 
selecting and modifying regions of it, along with drawing over it with lines and other shapes (see Drawing in Pygame). By default only uncompressed BMP images can be loaded.
When built with full image support, the pygame.image.load() function can support the following formats:
- JPG
- PNG
- GIF (non-animated)
- BMP
- PCX
- TGA (uncompressed)
- TIF
- LBM (and PBM)
- PBM (and PGM, PPM)
- XPM

Saving images only supports a limited set of formats. You can save to the following formats:
- BMP
- TGA
- PNG
- JPEG

Images in Pygame

Pygame registers a lot of different interactions from peripherals, such as mouse and keyboard, through events. It also registers certain actions, such as attempting to
close the program, as an event. Events are objects which store a type (an int), describing what type of event it is, and potential additional attributes. Pygame stores the events in a queue--henceforth this will be referred to as the event queue. You can receive the queue yourself using a get method, and then decide what to do based on what the event was. For example, if the user pressed an arrow key on the keyboard, you could execute some method to move their character on the screen. Note that you can also do this by directly accessing the keyboard and mouse modules themselves, ignoring the event queue entirely.

Events in Pygame

The font module offers functionality for rendering fonts into Surface objects. You can create a font object by passing in the font name or ttf file name depending on how the font is stored, and then use a render() function to create a Surface object for the font.

Fonts in Pygame

Sounds can be stored and played using the mixer module. The module is initialized by default, thuogh you can reinitialize it to change certain settings. A Sound object, when played, will immediately return while the sound continues to play on a certain channel. The channels are usually selected automatically, and the default is 8 simultaneous channels. However, more intensive programs may modify/control how many
channels are available. There is also a submodule called music which is used for music playback and provides a special channel for it.

Learn Before

Related