This document discusses building a simple game in Python using Pygame where circular sprites called "creeps" move randomly around the screen. It outlines goals of having configurable creeps that bounce off walls and exhibit semi-random behavior. Key aspects covered include using the Pygame sprite and vector capabilities, implementing a creep class with movement logic in its update method, rotating and drawing the creep sprites, computing displacement of creeps over time, and detecting wall collisions to bounce creeps off boundaries. The main game loop calls the creep update method each frame to animate the creep movements.

1. Python & Perl
Lecture 09
Department of Computer Science
Utah State University

2. Outline
●
PyGame
●
Sprite Movements
●
Build a simple game

3. Games
●
●
●
Games are one of the most applicative areas of
programming.
To write even the simplest games, you have to get into
graphics, math, physics and even AI.
It’s a great and fun way to practice programming.

4. Creeps
A complete simulation of creeps, round creatures that
move around the screen, bouncing off walls and
changing their direction from time to time.

5. Goals
●
●
●
●
We want to have creeps moving around the screen
The amount of creeps and their appearance should be
easily configurable
The creeps will bounce off walls correctly
To make things more interesting, the creeps will exhibit
semi-random behavior

6. So what is a creep ?
●
●
●
A creep is a small image that will be moved around the
screen and rotated using Pygame’s capabilities
In gaming terminology they are known as sprites
We limit the rotations to quantas of 45 degrees
(meaning that creeps will move up, down, left, right or in
4 diagonals)

7. How do creeps "move" ?
●
●
●
Movement is an illusion. Nothing really moves on a
computer screen.
Rather, the program displays a sequence of images with
small displacements fast enough for the human eye to
perceive movement.
The rule of thumb is that anything with 30 updates per
second or faster is good enough and looks smooth to
the average person.

8. Game Loop

9. The game loop

10. How often does this loop run ?
●
This is decided by the call to clock.tick.
●
clock is a pygame.time.Clock object.
●
The call to tick basically says this: sleep until the next
1/50 second boundary, at most. This limits the game
speed to 50 FPS, which is a good thing, because we
want the game to be smooth on one hand, and not eat
up most of the CPU on the other hand.

11. What comes before the loop

12. Creep class

13. Creep constructor
●
●
●
●
The Creep is provided with a random image from the list
of images (choice is a function from Python’s standard
random module)
It is set in a random position on the screen (randint is
also from random)
A random direction (more about the direction later)
The speed is set to 0.1 px/ms (0.1 pixels per
millisecond), or 100 pixels per second

14. Vectors and directions
●
●
Vectors are the chief mathematical tool for making
computations related to movement on the screen
We’ll use vectors for two things:

Position

Velocity

15. Vectors and directions

16. Vectors and directions
●
●
●
A point on the XY plane can be represented by a 2D
vector.
The difference between two vectors is the velocity
(displacement) vector.
In other words, adding the velocity vector to the original
position vector yields the new position.

17. Normalized Vectors
●
In almost all graphical drawing interfaces, the top-left
corner is (0, 0), X increases to the right, and Y increases
to downwards. In other words, the screen drawing XY
plane is:

18. Implementing vectors
●
●
●
Surprisingly, Pygame doesn’t have a "standard" vector
implementation shipping with it.
So game writers have to either roll their own or find
vector modules online.
We will use the vec2d.py file, a 2D vector
implementation the Pygame Wiki.

19. Updating the creep
●
The most interesting function of this demo is the update
method of Creep
def update(self, time_passed)
●
This method is called periodically by the main loop and
is passed the amount of time passed (in milliseconds)
since the previous call.

20. Updating the creep

21. Rotating the creeps
●
transform.rotate rotates a given surface
counterclockwise by the provided angle.
self.image = pygame.transform.rotate
(self.base_image, -self.direction.angle)
●
We give it a negation of the angle because of the
inverted "screen XY plane"

22. Rotating the creeps
●
●
Suppose our rotation direction is 45 degrees (that is,
south-east in our screen coordinates)
If we give 45 degrees to rotate, it will make the creep
point north-east (as its rotation is counterclockwise). So
to perform the correct rotation, we have to negate the
angle.

23. Update continued
●
Next in update method we have

24. Displacement
displacement = vec2d(self.direction.x * self.speed *
time_passed,self.direction.y * self.speed * time_passed)
●
●
self.direction is a normalized vector that tells us where
the creep points to
The displacement is computed from the basic rule of
motion that distance equals speed multiplied by time

25. Blitting
●
Blitting is the game programmers’ jargon for transferring
an image (or a pattern) onto a drawable surface. In
Pygame this is implemented with the blit function

26. Blitting
●
●
●
Blitting, like many other things in Pygame, uses the
versatile pygame.Rect class
The call to blit accepts an image (a surface, actually)
and a rectangle that specifies where this image will be
blitted to the surface on which blit is invoked
We provide the drawing position as the creep’s current
position (self.pos) but with a small adjustment

27. Blitting
●
●
●
When images are rotated in Pygame, their size
increases.
Since the image is square, Pygame has to include all of
its information in the rotated image, so the rotated image
has to grow in size. This only happens for rotations that
are not multiples of 90 degrees
Whenever a creep turns, its image size changes.
Without a special adjustment, the creep will shift with
each turn and the animation won’t be smooth and pretty.

28. Blit adjustment
●
●
We center the creep when we draw it
The draw position is computed to be the center of the
creep’s image. Even when the image rotates and grows,
its center stays in the same place, so there will be no
noticeable shift in the creep this way.

29. Bouncing off walls

30. Bouncing off walls
●
●
First, the screen boundary itself is computed, by taking
the rectangle representing the screen and adjusting it to
the image size
Then, for each of the 4 walls we compute whether the
creep collides with it, and if it does, the creep’s direction
is inverted in the axis perpendicular to the wall

31. Change directions
●
if self.pos.x < bounds_rect.left:
self.pos.x = bounds_rect.left
self.direction.x *= -1
This is for the bounce off the left wall. The creeps always arrives to
it from the right, so when we negate the X component of its
direction vector while keeping the Y component intact, it will start
moving to the right but with the same vertical direction.

32. Reading & References
●
●
http://www.pygame.org/
http://eli.thegreenplace.net/2008/12/13/writing-a-game-inpython-with-pygame-part-i/