Chapter 13 - Collision Detection and Input with Pygame

A very common behavior in most graphical games is collision detection. Collision detection is figuring when two things on the screen have touched (that is, collided with) each other. This is used very often in computer games. For example, if the player touches an enemy they may lose health or a game life. Or we may want to know when the player has touched a coin so that they automatically pick it up. Our next example program will cover this basic technique.

Type the following into a new file and save it as 3_CollisionDetection.py.

3_CollisionDetection.py

1. import pygame, sys, time, random
2. from pygame.locals import *
4. def doRectsOverlap(rect1, rect2):
5.     for a, b in [(rect1, rect2), (rect2, rect1)]:
6.         # Check if a's corners are inside b
7.         if ((isPointInsideRect(a.left, a.top, b)) or
8.             (isPointInsideRect(a.left, a.bottom, b)) or
9.             (isPointInsideRect(a.right, a.top, b)) or
10.             (isPointInsideRect(a.right, a.bottom, b))):
11.             return True
13.     return False
15. def isPointInsideRect(x, y, rect):
16.     if (x > rect.left) and (x < rect.right) and (y > rect.top) and (y < rect.bottom):
17.         return True
18.     else:
19.         return False
22. # set up pygame
23. pygame.init()
25. # set up the window
26. WINDOWWIDTH = 400
27. WINDOWHEIGHT = 400
28. windowSurface = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT), 0, 32)
29. pygame.display.set_caption('Collision Detection')
31. # set up direction variables
32. DOWNLEFT = 1
33. DOWNRIGHT = 3
34. UPLEFT = 7
35. UPRIGHT = 9
37. MOVESPEED = 4
39. # set up the colors
40. BLACK = (0, 0, 0)
41. GREEN = (0, 255, 0)
42. WHITE = (255, 255, 255)
44. # set up the bouncer and food data structures
45. foodCounter = 0
46. NEWFOOD = 40
47. FOODSIZE = 20
48. bouncer = {'rect':pygame.Rect(300, 100, 50, 50), 'dir':UPLEFT}
49. foods = []
50. for i in range(20):
51.     foods.append(pygame.Rect(random.randint(0, WINDOWWIDTH - FOODSIZE), random.randint(0, WINDOWHEIGHT - FOODSIZE), FOODSIZE, FOODSIZE))
53. # run the game loop
54. while True:
55.     # check for the QUIT event
56.     for event in pygame.event.get():
57.         if event.type == QUIT:
58.             pygame.quit()
59.             sys.exit()
61.     foodCounter += 1
62.     if foodCounter >= NEWFOOD:
63.         # add new food
64.         foodCounter = 0
65.         foods.append(pygame.Rect(random.randint(0, WINDOWWIDTH - FOODSIZE), random.randint(0, WINDOWHEIGHT - FOODSIZE), FOODSIZE, FOODSIZE))
67.     # draw the black background onto the surface
68.     windowSurface.fill(BLACK)
69.     
70.     # move the bouncer data structure
71.     if bouncer['dir'] == DOWNLEFT:
72.         bouncer['rect'].left -= MOVESPEED
73.         bouncer['rect'].top += MOVESPEED
74.     if bouncer['dir'] == DOWNRIGHT:
75.         bouncer['rect'].left += MOVESPEED
76.         bouncer['rect'].top += MOVESPEED
77.     if bouncer['dir'] == UPLEFT:
78.         bouncer['rect'].left -= MOVESPEED
79.         bouncer['rect'].top -= MOVESPEED
80.     if bouncer['dir'] == UPRIGHT:
81.         bouncer['rect'].left += MOVESPEED
82.         bouncer['rect'].top -= MOVESPEED
84.     # check if the bouncer has move out of the window
85.     if bouncer['rect'].top < 0:
86.         # bouncer has moved past the top
87.         if bouncer['dir'] == UPLEFT:
88.             bouncer['dir'] = DOWNLEFT
89.         if bouncer['dir'] == UPRIGHT:
90.             bouncer['dir'] = DOWNRIGHT
91.     if bouncer['rect'].bottom > WINDOWHEIGHT:
92.         # bouncer has moved past the bottom
93.         if bouncer['dir'] == DOWNLEFT:
94.             bouncer['dir'] = UPLEFT
95.         if bouncer['dir'] == DOWNRIGHT:
96.             bouncer['dir'] = UPRIGHT
97.     if bouncer['rect'].left < 0:
98.         # bouncer has moved past the left side
99.         if bouncer['dir'] == DOWNLEFT:
100.             bouncer['dir'] = DOWNRIGHT
101.         if bouncer['dir'] == UPLEFT:
102.             bouncer['dir'] = UPRIGHT
103.     if bouncer['rect'].right > WINDOWWIDTH:
104.         # bouncer has moved past the right side
105.         if bouncer['dir'] == DOWNRIGHT:
106.             bouncer['dir'] = DOWNLEFT
107.         if bouncer['dir'] == UPRIGHT:
108.             bouncer['dir'] = UPLEFT
110.     # draw the bouncer onto the surface
111.     pygame.draw.rect(windowSurface, WHITE, bouncer['rect'])
112.     
113.     # check if the bouncer has intersected with any food rectangles.
114.     for food in foods[:]:
115.         if doRectsOverlap(bouncer['rect'], food):
116.             foods.remove(food)
118.     # draw the food
119.     for i in range(len(foods)):
120.         pygame.draw.rect(windowSurface, GREEN, foods[i])
122.     # draw the window onto the screen
123.     pygame.display.update()
124.     time.sleep(0.02)

Code Explanation

In this demo, we have one white square (which we will call the bouner) bouncing off the edges of the walls just like in the animation program in the last chapter. However, we also have green squares (which we will call food) randomly appearing on the screen. Whenever the bouncer touches any of the food, we have the food disappear from the screen.

Much of this code is similar to the animation program, so we will skip over explaining how to make the bouncer move and bounce off of the walls.

1. import pygame, sys, time, random
2. from pygame.locals import *

The collision detection program also makes use of the random module, so we import it along with everything else.

4. def doRectsOverlap(rect1, rect2):

In order to do collision detection, we need to determine if two rectangles intersect each other or not. Here is a picture of two intersecting rectangles (on the left) and rectangles that do not intersect (on the right):

We will make a single function that is passed two pygame.Rect objects. The function, doRectsOverlap(), will return True if they do and False if they don't.

There is a very simple rule we can follow to determine if rectangles intersect (that is, collide). Look at each of the four corners on both rectangles. If at least one of these eight corners is inside the other rectangle, then we know that the two rectangles have collided. We will use this fact to determine if doRectsOverlap() returns True or False

5.     for a, b in [(rect1, rect2), (rect2, rect1)]:
6.         # Check if a's corners are inside b
7.         if ((isPointInsideRect(a.left, a.top, b)) or
8.             (isPointInsideRect(a.left, a.bottom, b)) or
9.             (isPointInsideRect(a.right, a.top, b)) or
10.             (isPointInsideRect(a.right, a.bottom, b))):
11.             return True

Above is the code that checks if one rectangle's corners are inside another. Later we will create a function called isPointInsideRect() that returns True if the x- and y-coordinates of the point are inside the rectangle. We call this function four times for each of the four corners, and if any of these calls return True, the or operators will make the entire condition True.

The parameters for doRectsOverlap() are rect1 and rect2. We first want to check if rect1's corners are inside rect2 and then check if rect2's corners are in rect1.

We don't want to repeat the code that checks all four corners for both rect1 and rect2, so instead we use a and b on lines 7, 8, 9, and 10. The for loop on line 5 uses the multiple assignment trick so that on the first iteration, a is set to rect1 and b is set to rect2. On the second iteration through the loop, it is the opposite. a is set to rect2 and b is set to rect1.

We do this because then we only have to type the code for the if statement on line 7 once. This is good, because this is a very long if statement. The less code we have to type for our program, the better.

13.     return False

If we never return True from the previous if statements, then none of the eight corners we checked are in the other rectangle. In that case, the rectangles do not collide and we return False.

15. def isPointInsideRect(x, y, rect):
16.     if (x > rect.left) and (x < rect.right) and (y > rect.top) and (y < rect.bottom):
17.         return True

The isPointInsideRect function is used by the doRectsOverlap() function. isPointInsideRect() will return True if the x- and y-coordinates passed to it as the first and second parameters are located "inside" the pygame.Rect object that is passed as the third parameter. Otherwise, this function returns False.

Here is an example picture of a rectangle and several dots. The dots and the corners of the rectangle are labeled with coordinates:

The pattern that you need to notice is that the points that are inside the rectangles have an x-coordinate that is greater than the x-coordinate of the left side and less than the x-coordinate of the right side, and have a y-coordinate that is greater than the y-coordinate of the top side and less than the y-coordinate of the bottom side. We combine all four of these conditions into the if statement's condition with and operators because all four of the conditions must be True.

18.     else:
19.         return False

If just one of the four expressions in the condition on line 16 is False, then we should have isPointInsideRect return the value False.

This function will be called from the doRectsOverlap() function to see if any of the corners in the two pygame.Rect objects are inside each other. These two functions give us the power to do collision detection between two rectangles.

29. pygame.display.set_caption('Collision Detection')

Lines 22 to 42 are things we've already covered in the animation Pygame program in the last chapter, so we won't cover it again.

44. # set up the bouncer and food data structures
45. foodCounter = 0
46. NEWFOOD = 40
47. FOODSIZE = 20

We are going to set up a few variables for the food blocks that appear on the screen. foodCounter will start at the value

48. bouncer = {'rect':pygame.Rect(300, 100, 50, 50), 'dir':UPLEFT}

We are going to set up a new data structure called bouncer. bouncer is a dictionary with two keys. The value stored in the 'rect' key will be a pygame.Rect object that represents the bouncer's size and position. The value stored in the 'dir' key will be a direction that the bouncer is currently moving. The bouncer will move the same way the blocks did in our previous animation program: moving in diagonal directions and bouncing off of the sides of the window.

49. foods = []
50. for i in range(20):
51.     foods.append(pygame.Rect(random.randint(0, WINDOWWIDTH - FOODSIZE), random.randint(0, WINDOWHEIGHT - FOODSIZE), FOODSIZE, FOODSIZE))

Our program will keep track of every food square with a list of pygame.Rect objects called foods. At the start of the program, we want to create twenty food squares randomly placed around the screen. We can use the random.randint() function to come up with random xy coordinates.

On line 51, we will call the pygame.Rect() constructor function to return a new pygame.Rect object that will represent the position and size of the food square. The first two parameters for pygame.Rect() are the xy coordinates of the top left corner. We want the random coordinate to be between 0 and the size of the window minus the size of the food square. If we had the random coordinate between 0 and the size of the window, then the food square might be pushed outside of the window altogether. Look at the diagram below.

The square on the left has an x-coordinate of its top left corner at 380. Because the food square is 20 pixels wide, the right edge of the food square is at 400. (This is because 380 + 20 = 400.) The square on the right has an x-coordinate of its top left corner at 400. Because the food square is 20 pixels wide, the right edge of the food square is at 420, which puts the entire square outside of the window (and not viewable to the user).

Lines 70 to 108 cause the bouncer to move around the window and bounce off of the edges of the window. This code is very similar to lines 45 to 83 of our animation program in the last chapter, so we will not go over them again here.

110.     # draw the bouncer onto the surface
111.     pygame.draw.rect(windowSurface, WHITE, bouncer['rect'])

After moving the bouncer, we now want to draw it on the window in its new position. We call the pygame.draw.rect() function to draw a rectangle. The windowSurface passed for the first parameter tells the computer which pygame.Surface object to draw the rectangle on. The WHITE variable, which has (255, 255, 255) stored in it, will tell the computer to draw a white rectangle. The pygame.Rect object stored in the bouncer dictionary at the 'rect' key tells the position and size of the rectangle to draw. This is all the information needed to draw a white rectangle on windowSurface.

Remember, we are not done drawing things on the windowSurface object yet. We still need to draw a green square for each food square in the foods list. And we are just "drawing" rectangles on the windowSurface object. This pygame.Surface object is only inside the computer's memory, which is much faster to modify than the screen. The window on the screen will not be updated until we call the pygame.display.update() function.

113.     # check if the bouncer has intersected with any food rectangles.
114.     for food in foods[:]:

Before we draw the food squares, we want to see if the bouncer has overlapped any of the food squares. If it has, we will remove that food square from the foods list. This way, the computer won't draw any food squares that the bouncer has "eaten".

On each iteration through the for loop, the current food square from the foods (plural) list will be stored inside a variable called food (singular).

Don't Add to or Delete from a List while Iterating Over It

Notice that there is something slightly different with this for loop. If you look carefully at line 114, we are not iterating over foods but actually over foods[:]. Just as foods[:2] would return a copy of the list with the items from the start and up to (but not including) the item at index 2, and just as foods[3:] would return a copy of the list with the items from index 3 to the end of the list, foods[:] will give you a copy of the list with the items from the start to the end. Basically, foods[:] creates a new list with a copy of all the items in foods.

Why would we want to iterate over a copy of the list instead of the list itself? It is because we cannot add or remove items from a list while we are iterating over it. Python can lose track of what the next value of food should be if the size of the foods list is always changing. Think of how difficult it would be for you if you tried to count the number of jelly beans in a jar while someone was adding or removing jelly beans. But if we iterate over a copy of the list (and the copy never changes), then adding or removing items from the original list won't be a problem.

TODO - earlier, describe how objects in a variable are really references. Also, are lists also considered objects themselves?

Code Explanation continued...

115.         if doRectsOverlap(bouncer['rect'], food):
116.             foods.remove(food)

Line 115 is where our doRectsOverlap() function that we defined earlier comes in handy. We pass two pygame.Rect objects to doRectsOverlap(): the bouncer and the current food square. If these two rectangles overlap, then doRectsOverlap() will return True and we will remove the overlapping food squares from foods list.

118.     # draw the food
119.     for food in foods:
120.         pygame.draw.rect(windowSurface, GREEN, food)

The code on lines 119 and 120 are very similiar to how we drew the white square for the player. We will loop through each food square in the foods list, and then draw the rectangle onto the windowSurface surface.

These past few programs are interesting to watch, but the user does not get to actually control anything. In this next program, we will learn how to get input from the keyboard. Keyboard input is handled in Pygame by using events.

Start a new file and type in the following code, then save it as 4_Input.py.

4_Input.py

1. import pygame, sys, time, random
2. from pygame.locals import *
4. # set up pygame
5. pygame.init()
7. # set up the window
8. WINDOWWIDTH = 400
9. WINDOWHEIGHT = 400
10. windowSurface = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT), 0, 32)
11. pygame.display.set_caption('Mouse')
13. # set up the colors
14. BLACK = (0, 0, 0)
15. GREEN = (0, 255, 0)
16. WHITE = (255, 255, 255)
18. # set up the player and food data structure
19. foodCounter = 0
20. NEWFOOD = 40
21. FOODSIZE = 20
22. player = pygame.Rect(300, 100, 50, 50)
23. foods = []
24. for i in range(20):
25.     foods.append(pygame.Rect(random.randint(0, WINDOWWIDTH - FOODSIZE), random.randint(0, WINDOWHEIGHT - FOODSIZE), FOODSIZE, FOODSIZE))
27. # set up keyboard variables
28. moveLeft = False
29. moveRight = False
30. moveUp = False
31. moveDown = False
33. MOVESPEED = 6
36. # run the game loop
37. while True:
38.     # check for events
39.     for event in pygame.event.get():
40.         if event.type == QUIT:
41.             pygame.quit()
42.             sys.exit()
43.         if event.type == KEYDOWN:
44.             # change the keyboard variables
45.             if event.key == K_LEFT or event.key == ord('a'):
46.                 moveRight = False
47.                 moveLeft = True
48.             if event.key == K_RIGHT or event.key == ord('d'):
49.                 moveLeft = False
50.                 moveRight = True
51.             if event.key == K_UP or event.key == ord('w'):
52.                 moveDown = False
53.                 moveUp = True
54.             if event.key == K_DOWN or event.key == ord('s'):
55.                 moveUp = False
56.                 moveDown = True
57.         if event.type == KEYUP:
58.             if event.key == K_ESCAPE:
59.                 pygame.quit()
60.                 sys.exit()
61.             if event.key == K_LEFT or event.key == ord('a'):
62.                 moveLeft = False
63.             if event.key == K_RIGHT or event.key == ord('d'):
64.                 moveRight = False
65.             if event.key == K_UP or event.key == ord('w'):
66.                 moveUp = False
67.             if event.key == K_DOWN or event.key == ord('s'):
68.                 moveDown = False
69.             if event.key == ord('x'):
70.                 player.top = random.randint(0, WINDOWHEIGHT - player.height)
71.                 player.left = random.randint(0, WINDOWWIDTH - player.width)
72.         
73.         if event.type == MOUSEBUTTONUP:
74.             foods.append(pygame.Rect(event.pos[0], event.pos[1], FOODSIZE, FOODSIZE))
76.     foodCounter += 1
77.     if foodCounter >= NEWFOOD:
78.         # add new food
79.         foodCounter = 0
80.         foods.append(pygame.Rect(random.randint(0, WINDOWWIDTH - FOODSIZE), random.randint(0, WINDOWHEIGHT - FOODSIZE), FOODSIZE, FOODSIZE))
81.         
82.     # draw the black background onto the surface
83.     windowSurface.fill(BLACK)
85.     # move the player
86.     if moveDown and player.bottom < WINDOWHEIGHT:
87.         player.top += MOVESPEED
88.     if moveUp and player.top > 0:
89.         player.top -= MOVESPEED
90.     if moveLeft and player.left > 0:
91.         player.left -= MOVESPEED
92.     if moveRight and player.right < WINDOWWIDTH:
93.         player.right += MOVESPEED
95.     # draw the player onto the surface
96.     pygame.draw.rect(windowSurface, WHITE, player)
97.     
98.     # check if the player has intersected with any food rectangles.
99.     for food in foods[:]:
100.         if player.colliderect(food):
101.             foods.remove(food)
103.     # draw the food
104.     for i in range(len(foods)):
105.         pygame.draw.rect(windowSurface, GREEN, foods[i])
107.     # draw the window onto the screen
108.     pygame.display.update()
109.     time.sleep(0.02)

Code Explanation

In this program, we can still control the bouncer by using the keyboard. However, we can also click anywhere in the GUI window and create new food objects at the coordinates where we clicked.

11. pygame.display.set_caption('Mouse')

First, we set the caption of the window's title bar to the string to 'Mouse'.

27. # set up keyboard variables
28. moveLeft = False
29. moveRight = False
30. moveUp = False
31. moveDown = False

We are going to use four different boolean variables to keep track of which of the arrow keys are being held down. For example, when the user pushes the left arrow key on her keyboard, we will set the moveLeft variable to True. When she lets go of the key, we will set the moveLeft variable back to False.

The code to handle the key press and key release events is below. But at the start of the program, we will set all of these variables to False.

43.         if event.type == KEYDOWN:

Pygame has another event type called KEYDOWN. On line 40, we check if the event.type attribute is equal to the QUIT value to check if we should exit the program. But there are other events that Pygame can generate. Here is a brief list of the events that could be returned by pygame.event.get():

• QUIT - Generated when the user closes with window.
• KEYDOWN - Generated when the user pressed down a key. Has a key attribute that tells which key was pressed. Also has a mod attribute that tells if the Shift, Ctrl, Alt, or other keys were held down when this key was pressed.
• KEYUP - Generated when the user releases a key. Has a key and mod attribute that are similar to those for KEYDOWN.
• MOUSEMOTION - Generated whenever the mouse moves over the window. Has a pos attribute that returns tuple (x, y) for the coordinates of where the mouse is in the window. The rel attribute also returns a (x, y) tuple, but it gives coordinates relative since the last MOUSEMOTION event. For example, if the mouse moves left by four pixels from (200, 200) to (196, 200), then rel will be (-4, 0). The buttons attribute returns a tuple of three integers. The first integer in the tuple is for the left mouse button, the second integer for the middle mouse button (if there is a middle mouse button), and the third integer is for the right mouse button. These integers will be 0 if they are not being pressed down when the mouse moved and 1 if they are pressed down.
• MOUSEBUTTONDOWN - Generated when a mouse button is pressed down in the window. This event has a pos attribute which is an (x, y) tuple for the coordinates of where the mouse was when the button was pressed. There is also a button attribute which is an integer from 1 to 5 that tells which mouse button was pressed:

Value of button	Mouse Button
1	Left button
2	Middle button
3	Right button
4	Scroll wheel moved up
5	Scroll wheel moved down

• MOUSEBUTTONUP - Generated when the mouse button is released. This has the same attributes as MOUSEBUTTONDOWN

44.             # change the keyboard variables
45.             if event.key == K_LEFT or event.key == ord('a'):
46.                 moveRight = False
47.                 moveLeft = True
48.             if event.key == K_RIGHT or event.key == ord('d'):
49.                 moveLeft = False
50.                 moveRight = True
51.             if event.key == K_UP or event.key == ord('w'):
52.                 moveDown = False
53.                 moveUp = True
54.             if event.key == K_DOWN or event.key == ord('s'):
55.                 moveUp = False
56.                 moveDown = True

If the event type is !KEYDOWN, then the !event object will have a !key attribute that will tell us which key was pressed down. On line 45, we can compare this value to !K_LEFT, which represents the left arrow key on the keyboard. We will do this for each of the arrow keys: !K_LEFT, !K_RIGHT, !K_UP, !K_DOWN.

When one of these keys is pressed down, we will set the corresponding movement variable to !True. We will also set the movement variable of the opposite direction to !False. For example, the program executes lines 46 and 47 when the left arrow key has been pressed. In this case, we will set !moveLeft to !True and !moveRight to !False (even though !moveRight might already be !False, we set it to !False just to be sure).

You may notice that on line 45, in !event.key can either be equal to !K_LEFT or !ord('a'). The value in !event.key is set to the integer ASCII value of the key that was pressed on the keyboard. (There is no ASCII value for the arrow keys, which is why we use the constant variable !K_LEFT.) You can use the !ord() function to get the ASCII value of any single character to compare it with !event.key.

By executing the code on lines 46 and 47 if the keystroke was either !K_LEFT or !ord('a'), we make the left arrow key and the A key do the same thing. You may notice that the W, A, S, and D keys are all used as alternates for changing the movement variables. This is because some people may want to use their left hand to press the WASD keys instead of their right hand to press the arrow keys. Our program offers them both!

57.         if event.type == KEYUP:

When the user releases the key that they are holding down, a !KEYUP event is generated.

58.             if event.key == K_ESCAPE:
59.                 pygame.quit()
60.                 sys.exit()

If the key that the user released was the Esc key, then we want to terminate the program. Remember, in Pygame you must call the !pygame.quit() function before calling the !sys.exit() function. We want to do this when the user releases the Esc key, not when they first Esc key down.

61.             if event.key == K_LEFT or event.key == ord('a'):
62.                 moveLeft = False
63.             if event.key == K_RIGHT or event.key == ord('d'):
64.                 moveRight = False
65.             if event.key == K_UP or event.key == ord('w'):
66.                 moveUp = False
67.             if event.key == K_DOWN or event.key == ord('s'):
68.                 moveDown = False

If the user released one of the keys that moves the player, then we want to set the movement variable that corresponds with the key to !False. This will tell the later parts of our program to no longer move the player's square on the screen.

69.             if event.key == ord('x'):
70.                 player.top = random.randint(0, WINDOWHEIGHT - player.height)
71.                 player.left = random.randint(0, WINDOWWIDTH - player.width)

We will also add teleportation to our game. If the user presses the X key, then we will set the position of the user's square to a random place on the window. This will give the user the ability to teleport around the window by pushing the X key (though they can't control where they will teleport: it's completely random).

73.         if event.type == MOUSEBUTTONUP:
74.             foods.append(pygame.Rect(event.pos[0], event.pos[1], FOODSIZE, FOODSIZE))

Mouse input is handled by events just like keyboard input is. The !MOUSEBUTTONUP event occurs when the user clicks a mouse button somewhere in our window, and releases the mouse button. The !pos attribute in the !Event object is set to a tuple of two integers for the xy coordinates. On line 74, the x coordinate is stored in !event.pos[0] and the y coordinate is stored in !event.pos[1]. We will create a new !Rect object to represent a new food and place it where the !MOUSEBUTTONUP event occurred. By adding a new !Rect object to the !foods list, a new food square will be displayed on the screen.

85.     # move the player
86.     if moveDown and player.bottom < WINDOWHEIGHT:
87.         player.top += MOVESPEED
88.     if moveUp and player.top > 0:
89.         player.top -= MOVESPEED
90.     if moveLeft and player.left > 0:
91.         player.left -= MOVESPEED
92.     if moveRight and player.right < WINDOWWIDTH:
93.         player.right += MOVESPEED

We have set the movement variables (!moveDown, !moveUp, !moveLeft, and !moveRight) to !True or !False depending on what keys the user has pressed. Now we will actually move the player's square (which is represented by the around by adjusting the xy coordinates of. If !moveDown is set to !True (and the bottom of the player's square is not below the bottom edge of the window), then we move the player's square down by adding !MOVESPEED to the player's current !top attribute.

The rest of the code is similar to the code in the Collision Detection program: draw the food squares and the player squares to the !windowSurface surface, occasionally add a new food square at a random location to the !foods list, check if the player square has collided with any of the food squares, and call !time.sleep(0.02) to slow down the program a little.

TODO - talk about how eerything is really just a representation based on what we store in our data. There is no actual player's square.

TODO - try messing around with the values of the constant variables in our program.

TODO - have I introduced the colliderect() function?