Pie Game

<pre>
import math
import pygame
import sys
from pygame.locals import *

pygame.init()
screen = pygame.display.set_mode((600, 500))

pygame.display.set_caption("The Pie Game")

my_font = pygame.font.Font(None, 60)

color = 200, 80, 60
width = 4
x = 300
y = 250
radius = 200
position = x - radius, y - radius, radius * 2, radius * 2

piece1 = False
piece2 = False
piece3 = False
piece4 = False

while True:
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
elif event.type == KEYUP:
if event.key == pygame.K_ESCAPE:
sys.exit()
elif event.key == pygame.K_1:
piece1 = True
elif event.key == pygame.K_2:
piece2 = True
elif event.key == pygame.K_3:
piece3 = True
elif event.key == pygame.K_4:
piece4 = True

screen.fill((0, 0, 200))

# draw four numbers
textImg1 = my_font.render("1", True, color)
screen.blit(textImg1, (x + radius / 2, y - radius / 2))
textImg2 = my_font.render("2", True, color)
screen.blit(textImg2, (x - radius / 2, y - radius / 2))
textImg3 = my_font.render("3", True, color)
screen.blit(textImg3, (x - radius / 2, y + radius / 2))
textImg4 = my_font.render("4", True, color)
screen.blit(textImg4, (x + radius / 2, y + radius / 2))

if piece1:
    start_angle = math.radians(0)
    end_angle = math.radians(90)
    pygame.draw.arc(screen, color, position, start_angle,end_angle, width)
    pygame.draw.line(screen, color, (x, y), (x, y - radius), width)
    pygame.draw.line(screen, color, (x, y), (x + radius, y), width)
if piece2:
    start_angle = math.radians(90)
    end_angle = math.radians(180)
    pygame.draw.arc(screen, color, position, start_angle,end_angle, width)
    pygame.draw.line(screen, color, (x, y), (x, y - radius), width)
    pygame.draw.line(screen, color, (x, y), (x - radius, y), width)
if piece3:
    start_angle = math.radians(180)
    end_angle = math.radians(270)
    pygame.draw.arc(screen, color, position, start_angle,end_angle, width)
    pygame.draw.line(screen, color, (x, y), (x, y + radius), width)
    pygame.draw.line(screen, color, (x, y), (x - radius, y), width)
if piece4:
    start_angle = math.radians(270)
    end_angle = math.radians(360)
    pygame.draw.arc(screen, color, position, start_angle,end_angle, width)
    pygame.draw.line(screen, color, (x, y), (x, y + radius), width)
    pygame.draw.line(screen, color, (x, y), (x + radius, y), width)

if piece1 and piece2 and piece3 and piece4:
    color = 0, 255, 255


pygame.display.update()

</pre>

Palette:

<pre>import pygame
import sys
from pygame.locals import *

initialization

pygame.init()
screen = pygame.display.set_mode((640, 480), 0, 32)

def create_scales(height):
red_scale_surface = pygame.surface.Surface((640, height))
green_scale_surface = pygame.surface.Surface((640, height))
blue_scale_surface = pygame.surface.Surface((640, height))
for x in range(640):
c = int((x / 640) * 255)
red = (c, 0, 0)
green = (0, c, 0)
blue = (0, 0, c)
line_rect = Rect(x, 0, 1, height)
pygame.draw.rect(red_scale_surface, red, line_rect)
pygame.draw.rect(green_scale_surface, green, line_rect)
pygame.draw.rect(blue_scale_surface, blue, line_rect)
return red_scale_surface, green_scale_surface, blue_scale_surface

red_scale, green_scale, blue_scale = create_scales(80)

put the color index in the middle

color = [127, 127, 127]

while True:
for event in pygame.event.get():
if event.type == QUIT:
exit()
screen.fill((0, 0, 0))
screen.blit(red_scale, (0, 00))
screen.blit(green_scale, (0, 80))
screen.blit(blue_scale, (0, 160))
x, y = pygame.mouse.get_pos()

# 0: press left button 1:wheel button 2: right button
if pygame.mouse.get_pressed()[0]:
    for component in range(3):
        if y > component \* 80 and y < (component + 1) \* 80:
            color[component] = int((x / 639) \* 255)
    pygame.display.set_caption("PyGame Color Test - " + str(tuple(color)))

for component in range(3):
    pos = (int((color[component] / 255) \* 639), component \* 80 + 40)
    pygame.draw.circle(screen, (255, 255, 255), pos, 20)
pygame.draw.rect(screen, tuple(color), (0, 240, 640, 240))
pygame.display.update()

</pre>

Trivia:

<pre>

The Trivia Game

import sys, pygame
from pygame.locals import *

class Trivia(object):
def init(self, filename):
self.data = [] # store the question and answer
self.current = 0 # current question
self.total = 0 # total question
self.correct = 0 # correct answer you select
self.score = 0 # total score
self.scored = False # is right answer or not
self.failed = False # fail or not
self.wronganswer = 0 # wrong answer you select
self.colors = [white, white, white, white] # the color of the option

    # read trivia data from file
    f = open(filename, "r")
    trivia_data = f.readlines()
    f.close()

    # count and clean up trivia data
    for text_line in trivia_data:
        self.data.append(text_line.strip())
        self.total += 1

# show the question
def show_question(self):
    print_text(font1, 210, 5, "TRIVIA GAME")
    print_text(font2, 190, 500 - 20, "Press Keys (1-4) To Answer", purple)
    print_text(font2, 530, 5, "SCORE", purple)
    print_text(font2, 550, 25, str(self.score), purple)

    # get correct answer out of data (first)
    self.correct = int(self.data[self.current + 5])

    # display question
    question = self.current // 6 + 1
    print_text(font1, 5, 80, "QUESTION " + str(question))
    print_text(font2, 20, 120, self.data[self.current], yellow)

    # respond to correct answer
    if self.scored:
        self.colors = [white, white, white, white]
        self.colors[self.correct - 1] = green
        print_text(font1, 230, 380, "CORRECT!", green)
        print_text(font2, 170, 420, "Press Enter For Next Question", green)
    elif self.failed:
        self.colors = [white, white, white, white]
        self.colors[self.wronganswer - 1] = red
        self.colors[self.correct - 1] = green
        print_text(font1, 220, 380, "INCORRECT!", red)
        print_text(font2, 170, 420, "Press Enter For Next Question", red)

    # display answers
    print_text(font1, 5, 170, "ANSWERS")
    print_text(font2, 20, 210, "1 - " + self.data[self.current + 1], self.colors[0])
    print_text(font2, 20, 240, "2 - " + self.data[self.current + 2], self.colors[1])
    print_text(font2, 20, 270, "3 - " + self.data[self.current + 3], self.colors[2])
    print_text(font2, 20, 300, "4 - " + self.data[self.current + 4], self.colors[3])

def handle_input(self, number):
    if not self.scored and not self.failed:
        if number == self.correct:
            self.scored = True
            self.score += 1
        else:
            self.failed = True
            self.wronganswer = number

def next_question(self):
    if self.scored or self.failed:
        self.scored = False
        self.failed = False
        self.correct = 0
        self.colors = [white, white, white, white]
        self.current += 6
        if self.current >= self.total:
            self.current = 0

def print_text(font, x, y, text, color=(255, 255, 255), shadow=True):
if shadow:
imgText = font.render(text, True, (0, 0, 0))
screen.blit(imgText, (x - 2, y - 2))
imgText = font.render(text, True, color)
screen.blit(imgText, (x, y))

main program begins

pygame.init()
screen = pygame.display.set_mode((600, 500))
pygame.display.set_caption("The Trivia Game")
font1 = pygame.font.Font(None, 40)
font2 = pygame.font.Font(None, 24)
white = 255, 255, 255
cyan = 0, 255, 255
yellow = 255, 255, 0
purple = 255, 0, 255
green = 0, 255, 0
red = 255, 0, 0

load the trivia data file

trivia = Trivia("trivia_data.txt")

repeating loop

while True:
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
elif event.type == KEYUP:
if event.key == pygame.K_ESCAPE:
sys.exit()
elif event.key == pygame.K_1:
trivia.handle_input(1)
elif event.key == pygame.K_2:
trivia.handle_input(2)
elif event.key == pygame.K_3:
trivia.handle_input(3)
elif event.key == pygame.K_4:
trivia.handle_input(4)
elif event.key == pygame.K_RETURN:
trivia.next_question()

# clear the screen
screen.fill((0, 0, 200))

# display trivia data
trivia.show_question()

# update the display
pygame.display.update()

</pre>

<pre>
trivia_data.txt

What is the name of the 4th planet from the Sun?
Saturn
Mars
Earth
Venus
2
Which planet has the most moons in the solar system?
Uranus
Saturn
Neptune
Jupiter
4
Approximately how large is the Sun's diameter (width)?
65 thousand miles
45 million miles
1 million miles
825 thousand miles
3
How far is the Earth from the Sun in its orbit (on average)?
13 million miles
93 million miles
250 thousand miles
800 thousand miles
2
What causes the Earth's oceans to have tides?
The Moon
The Sun
Earth's molten core
Oxygen
1
</pre>

Mouse Demo:

<pre>

Mouse Demo

Chapter 4

import sys, pygame
from pygame.locals import *

def print_text(font, x, y, text, color=(255, 255, 255)):
imgText = font.render(text, True, color)
screen.blit(imgText, (x, y))

main program begins

pygame.init()
screen = pygame.display.set_mode((600, 500))
pygame.display.set_caption("Mouse Demo")
font1 = pygame.font.Font(None, 24)
white = 255, 255, 255

seconds = 10
score = 0
clock_start = 0
game_over = True
mouse_x = mouse_y = 0
move_x = move_y = 0
mouse_down = mouse_up = 0
mouse_down_x = mouse_down_y = 0
mouse_up_x = mouse_up_y = 0

repeating loop

while True:
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
elif event.type == MOUSEMOTION:
mouse_x, mouse_y = event.pos
move_x, move_y = event.rel
elif event.type == MOUSEBUTTONDOWN:
mouse_down = event.button
mouse_down_x, mouse_down_y = event.pos
elif event.type == MOUSEBUTTONUP:
mouse_up = event.button
mouse_up_x, mouse_up_y = event.pos

keys = pygame.key.get_pressed()
if keys[K_ESCAPE]:
    sys.exit()

screen.fill((0, 100, 0))

print_text(font1, 0, 0, "Mouse Events")
print_text(font1, 0, 20, "Mouse position: " + str(mouse_x) +
           "," + str(mouse_y))
print_text(font1, 0, 40, "Mouse relative: " + str(move_x) +
           "," + str(move_y))

print_text(font1, 0, 60, "Mouse button down: " + str(mouse_down) +
           " at " + str(mouse_down_x) + "," + str(mouse_down_y))

print_text(font1, 0, 80, "Mouse button up: " + str(mouse_up) +
           " at " + str(mouse_up_x) + "," + str(mouse_up_y))

print_text(font1, 0, 160, "Mouse Polling")

x, y = pygame.mouse.get_pos()
print_text(font1, 0, 180, "Mouse position: " + str(x) + "," + str(y))

b1, b2, b3 = pygame.mouse.get_pressed()
print_text(font1, 0, 200, "Mouse buttons: " +
           str(b1) + "," + str(b2) + "," + str(b3))

pygame.display.update()

</pre>

Keyboard Demo:

<pre>
import sys, random, time, pygame
from pygame.locals import *

def print_text(font, x, y, text, color = (255, 255, 255)):
imgText = font.render(text, True, color)
screen.blit(imgText, (x, y))

pygame.init()
screen = pygame.display.set_mode((600, 500))
pygame.display.set_caption("Keyboard Demo")
font1 = pygame.font.Font(None, 24)
font2 = pygame.font.Font(None, 200)
white = 255, 255, 255
yellow = 255, 255, 0

key_flag = False
correct_answer = 97
seconds = 10
score = 0
clock_start = 0
game_over = True
speed = 0
while True:
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
elif event.type == KEYDOWN:
key_flag = True
elif event.type == KEYUP:
key_flag = False

keys = pygame.key.get_pressed()


if keys[K_ESCAPE]:
    sys.exit()
if keys[K_RETURN]:
    if game_over:
        game_over = False
        score = 0
        seconds = 11
        clock_start = time.clock()

screen.fill((0, 100, 0))

if not game_over:
    current = time.clock() - clock_start
    print_text(font1, 0, 80, "Time: " + str(int(seconds - current)))

    if keys[correct_answer]:
        score += 1
        correct_answer = random.randint(97, 122)
        speed = score \* 6

    if seconds - current < 0:
        game_over = True
else:
    print_text(font1, 0, 160, "Press Enter to start")

print_text(font1, 0, 0, "Let's see how fast you can type")
print_text(font1, 0, 20, "Try to keep up for 10 seconds...")

if key_flag:
    print_text(font1, 500, 0, "<key>")

print_text(font1, 0, 100, "Speed: " + str(speed) + " letters/min")

print_text(font2, 0, 240, chr(correct_answer - 32), yellow)

pygame.display.update()

</pre>

Bomb Catcher:

<pre>

Bomb Catcher Game

Chapter 4

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

def print_text(font, x, y, text, color=(255, 255, 255)):
imgText = font.render(text, True, color)
screen.blit(imgText, (x, y))

main program begins

pygame.init()
screen = pygame.display.set_mode((600, 500))
pygame.display.set_caption("Bomb Catching Game")
font1 = pygame.font.Font(None, 24)
pygame.mouse.set_visible(False)
white = 255, 255, 255
red = 220, 50, 50
yellow = 230, 230, 50
black = 0, 0, 0

lives = 3
score = 0
clock_start = 0
game_over = True
mouse_x = mouse_y = 0

pos_x = 300
pos_y = 460

bomb_x = random.randint(0, 500)
bomb_y = -50
vel_y = 15

repeating loop

while True:
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
elif event.type == MOUSEMOTION:
mouse_x, mouse_y = event.pos
move_x, move_y = event.rel
elif event.type == MOUSEBUTTONUP:
if game_over:
game_over = False
lives = 3
score = 0

keys = pygame.key.get_pressed()
if keys[K_ESCAPE]:
    sys.exit()

screen.fill((0, 0, 100))

if game_over:
    print_text(font1, 100, 200, "<CLICK TO PLAY>")
else:
    # move the bomb
    bomb_y += vel_y

    # has the player missed the bomb?
    if bomb_y > 500:
        # reset
        bomb_x = random.randint(0, 500)
        bomb_y = -50
        lives -= 1
        if lives == 0:
            game_over = True

    # see if player has caught the bomb
    elif bomb_y > pos_y:
        if bomb_x > pos_x and bomb_x < pos_x + 120:
            score += 10
            bomb_x = random.randint(0, 500)
            bomb_y = -50

    # draw the bomb
    pygame.draw.circle(screen, black, (bomb_x - 4, int(bomb_y) - 4), 30, 0)
    pygame.draw.circle(screen, yellow, (bomb_x, int(bomb_y)), 30, 0)

    # set basket position
    pos_x = mouse_x
    if pos_x < 0:
        pos_x = 0
    elif pos_x > 500:
        pos_x = 500
    # draw basket
    pygame.draw.rect(screen, black, (pos_x - 4, pos_y - 4, 120, 40), 0)
    pygame.draw.rect(screen, red, (pos_x, pos_y, 120, 40), 0)

# print # of lives
print_text(font1, 0, 0, "LIVES: " + str(lives))

# print score
print_text(font1, 500, 0, "SCORE: " + str(score))

pygame.display.update()

</pre>

Circle Demo:

<pre>

Circle Demo

Chapter 5

import random, math, pygame
from pygame.locals import *

main program begins

pygame.init()
screen = pygame.display.set_mode((600, 500))
pygame.display.set_caption("Circle Demo")
screen.fill((0, 0, 100))

pos_x = 300
pos_y = 250
radius = 200
angle = 360

repeating loop

while True:
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
keys = pygame.key.get_pressed()
if keys[K_ESCAPE]:
sys.exit()

# increment angle
angle += 1
if angle >= 360:
    angle = 0
    r = random.randint(0, 255)
    g = random.randint(0, 255)
    b = random.randint(0, 255)
    color = r, g, b

# calculate coordinates
x = math.cos(math.radians(angle)) \* radius
y = math.sin(math.radians(angle)) \* radius

# draw one step around the circle
pos = (int(pos_x + x), int(pos_y + y))
pygame.draw.circle(screen, color, pos, 1, 0)

pygame.display.update()

</pre>

Clock:

<pre>

Analog Clock Demo

Chapter 5

import sys, random, math, pygame
from pygame.locals import *
from datetime import datetime, date, time

def print_text(font, x, y, text, color=(255, 255, 255)):
imgText = font.render(text, True, color)
screen.blit(imgText, (x, y))

def wrap_angle(angle):
return angle % 360

main program begins

pygame.init()
screen = pygame.display.set_mode((600, 500))
pygame.display.set_caption("Analog Clock Demo")
font = pygame.font.Font(None, 36)
orange = 220, 180, 0
white = 255, 255, 255
yellow = 255, 255, 0
pink = 255, 100, 100

pos_x = 300
pos_y = 250
radius = 250
angle = 360

repeating loop

while True:
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
keys = pygame.key.get_pressed()
if keys[K_ESCAPE]:
sys.exit()

screen.fill((0, 0, 100))

# draw one step around the circle
pygame.draw.circle(screen, white, (pos_x, pos_y), radius, 6)

# draw the clock numbers 1-12
for n in range(1, 13):
    angle = math.radians(n \* (360 / 12) - 90)
    x = math.cos(angle) \* (radius - 20) - 10
    y = math.sin(angle) \* (radius - 20) - 10
    print_text(font, pos_x + x, pos_y + y, str(n))

# get the time of day
today = datetime.today()
hours = today.hour % 12
minutes = today.minute
seconds = today.second

# draw the hours hand
hour_angle = wrap_angle(hours \* (360 / 12) - 90 + 30 \* minutes / 60)
hour_angle = math.radians(hour_angle)
hour_x = math.cos(hour_angle) \* (radius - 80)
hour_y = math.sin(hour_angle) \* (radius - 80)
target = (pos_x + hour_x, pos_y + hour_y)
pygame.draw.line(screen, pink, (pos_x, pos_y), target, 25)

# draw the minutes hand
min_angle = wrap_angle(minutes \* (360 / 60) - 90)
min_angle = math.radians(min_angle)
min_x = math.cos(min_angle) \* (radius - 60)
min_y = math.sin(min_angle) \* (radius - 60)
target = (pos_x + min_x, pos_y + min_y)
pygame.draw.line(screen, orange, (pos_x, pos_y), target, 12)

# draw the seconds hand
sec_angle = wrap_angle(seconds \* (360 / 60) - 90)
sec_angle = math.radians(sec_angle)
sec_x = math.cos(sec_angle) \* (radius - 40)
sec_y = math.sin(sec_angle) \* (radius - 40)
target = (pos_x + sec_x, pos_y + sec_y)
pygame.draw.line(screen, yellow, (pos_x, pos_y), target, 6)

# cover the center
pygame.draw.circle(screen, white, (pos_x, pos_y), 20)

print_text(font, 0, 0, str(hours) + ":" + str(minutes) + ":" + str(seconds))

pygame.display.update()

</pre>

OrbitDemo:

<pre>

Orbit Demo

Chapter 5

import sys, random, math, pygame
from pygame.locals import *

Point class

class Point(object):
def init(self, x, y):
self.__x = x
self.__y = y

# X property
def getx(self): return self.__x

def setx(self, x): self.__x = x

x = property(getx, setx)

# Y property
def gety(self): return self.__y

def sety(self, y): self.__y = y

y = property(gety, sety)

def __str__(self):
    return "{X:" + "{:.0f}".format(self.__x) + \
           ",Y:" + "{:.0f}".format(self.__y) + "}"

print_text function

def print_text(font, x, y, text, color=(255, 255, 255)):
imgText = font.render(text, True, color)
screen.blit(imgText, (x, y))

wrap_angle function

def wrap_angle(angle):
return angle % 360

main program begins

pygame.init()
screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption("Orbit Demo")
font = pygame.font.Font(None, 18)

load bitmaps

space = pygame.image.load("space.png").convert_alpha()
planet = pygame.image.load("planet2.png").convert_alpha()
ship = pygame.image.load("freelance.png").convert_alpha()
width, height = ship.get_size()
ship = pygame.transform.smoothscale(ship, (width // 2, height // 2))

radius = 250
angle = 0.0
pos = Point(0, 0)
old_pos = Point(0, 0)

repeating loop

while True:
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
keys = pygame.key.get_pressed()
if keys[K_ESCAPE]:
sys.exit()

# draw background
screen.blit(space, (0, 0))

# draw planet
width, height = planet.get_size()
screen.blit(planet, (400 - width / 2, 300 - height / 2))

# move the ship
angle = wrap_angle(angle - 1)
pos.x = math.sin(math.radians(angle)) \* radius
pos.y = math.cos(math.radians(angle)) \* radius

# rotate the ship

scratch_ship = pygame.transform.rotate(ship, angle)
# draw the ship
width, height = scratch_ship.get_size()
x = 400 + pos.x - width // 2
y = 300 + pos.y - height // 2
screen.blit(scratch_ship, (x, y))

print_text(font, 0, 0, "Orbit: " + "{:.0f}".format(angle))
print_text(font, 0, 20, "Rotation: " + "{:.2f}".format(rangle))
print_text(font, 0, 40, "Position: " + str(pos))
print_text(font, 0, 60, "Old Pos: " + str(old_pos))

pygame.display.update()

# remember position
old_pos.x = pos.x
old_pos.y = pos.y

</pre>

Escape the dragon:

<pre>

Escape The Dragon Game

Chapter 7

import sys, time, random, math, pygame
from pygame.locals import *

class MySprite(pygame.sprite.Sprite):
def init(self, target):
pygame.sprite.Sprite.init(self) # extend the base Sprite class
self.master_image = None
self.frame = 0
self.old_frame = -1
self.frame_width = 1
self.frame_height = 1
self.first_frame = 0
self.last_frame = 0
self.columns = 1
self.last_time = 0

# X property
def _getx(self):
    return self.rect.x

def _setx(self, value):
    self.rect.x = value

X = property(_getx, _setx)

# Y property
def _gety(self):
    return self.rect.y

def _sety(self, value):
    self.rect.y = value

Y = property(_gety, _sety)

# position property
def _getpos(self):
    return self.rect.topleft

def _setpos(self, pos):
    self.rect.topleft = pos

position = property(_getpos, _setpos)

def load(self, filename, width, height, columns):
    self.master_image = pygame.image.load(filename).convert_alpha()
    self.frame_width = width
    self.frame_height = height
    self.rect = Rect(0, 0, width, height)
    self.columns = columns
    # try to auto-calculate total frames
    rect = self.master_image.get_rect()
    self.last_frame = (rect.width // width) \* (rect.height // height) - 1

def update(self, current_time, rate=30):
    # update animation frame number
    if current_time > self.last_time + rate:
        self.frame += 1
        if self.frame > self.last_frame:
            self.frame = self.first_frame
        self.last_time = current_time

    # build current frame only if it changed
    if self.frame != self.old_frame:
        frame_x = (self.frame % self.columns) \* self.frame_width
        frame_y = (self.frame // self.columns) \* self.frame_height
        rect = Rect(frame_x, frame_y, self.frame_width, self.frame_height)
        self.image = self.master_image.subsurface(rect)
        self.old_frame = self.frame

def __str__(self):
    return str(self.frame) + "," + str(self.first_frame) + \
           "," + str(self.last_frame) + "," + str(self.frame_width) + \
           "," + str(self.frame_height) + "," + str(self.columns) + \
           "," + str(self.rect)

def print_text(font, x, y, text, color=(255, 255, 255)):
imgText = font.render(text, True, color)
screen.blit(imgText, (x, y))

def reset_arrow():
y = random.randint(250, 350)
arrow.position = 800, y

main program begins

pygame.init()
screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption("Escape The Dragon Game")
font = pygame.font.Font(None, 18)
framerate = pygame.time.Clock()

load bitmaps

bg = pygame.image.load("background.png").convert_alpha()

create a sprite group

group = pygame.sprite.Group()

create the dragon sprite

dragon = MySprite(screen)
dragon.load("dragon.png", 260, 150, 3)
dragon.position = 100, 230
group.add(dragon)

create the player sprite

player = MySprite(screen)
player.load("caveman.png", 50, 64, 8)
player.first_frame = 1
player.last_frame = 7
player.position = 400, 303
group.add(player)

create the arrow sprite

arrow = MySprite(screen)
arrow.load("flame.png", 40, 16, 1)
arrow.position = 800, 320
group.add(arrow)

arrow_vel = 8.0
game_over = False
you_win = False
player_jumping = False
jump_vel = 0.0
player_start_y = player.Y
lives = 3
score = 0
font1 = pygame.font.Font(None, 24)
start_time = 0

repeating loop

while True:
framerate.tick(30)
# total time
ticks = pygame.time.get_ticks()

for event in pygame.event.get():
    if event.type == QUIT: sys.exit()
keys = pygame.key.get_pressed()
if keys[K_ESCAPE]:
    sys.exit()
elif keys[K_SPACE]:
    if not player_jumping:
        player_jumping = True
        jump_vel = -11.0

# update the arrow
if not game_over:
    arrow.X -= arrow_vel
    if arrow.X < -40: reset_arrow()

    # did arrow hit player?
    if pygame.sprite.collide_rect(arrow, player):
        reset_arrow()
        player.X -= 10

    # did arrow hit dragon?
    if pygame.sprite.collide_rect(arrow, dragon):
        reset_arrow()
        dragon.X -= 10

    # did dragon eat the player?
    if pygame.sprite.collide_rect(player, dragon):
        game_over = True

    # did the dragon get defeated?
    if dragon.X < -100:
        you_win = True
        game_over = True

        # is the player jumping?
    if player_jumping:
        player.Y += jump_vel
        jump_vel += 0.5
        if player.Y > player_start_y:
            player_jumping = False
            player.Y = player_start_y
            jump_vel = 0.0

# draw the background
screen.blit(bg, (0, 0))

# update sprites
if not game_over:
    group.update(ticks, 50)
    score += 1

# draw sprites
group.draw(screen)

print_text(font, 350, 560, "Press SPACE to jump!")

if game_over:
    print_text(font, 360, 100, "G A M E   O V E R")
    if you_win:
        print_text(font, 330, 130, "YOU BEAT THE DRAGON!")
    else:
        print_text(font, 330, 130, "THE DRAGON GOT YOU!")

        # print # of lives
print_text(font1, 0, 0, "LIVES: " + str(lives))

# print score
print_text(font1, 500, 0, "SCORE: " + str(score))

pygame.display.update()

</pre>

Zombie Mob:

<pre>

Zombie Mob Game

Chapter 8

import itertools, sys, time, random, math, pygame
from pygame.locals import *
from MyLibrary import *

def calc_velocity(direction, vel=1.0):
velocity = Point(0,0)
if direction == 0: #north
velocity.y = -vel
elif direction == 2: #east
velocity.x = vel
elif direction == 4: #south
velocity.y = vel
elif direction == 6: #west
velocity.x = -vel
return velocity

def reverse_direction(sprite):
if sprite.direction == 0:
sprite.direction = 4
elif sprite.direction == 2:
sprite.direction = 6
elif sprite.direction == 4:
sprite.direction = 0
elif sprite.direction == 6:
sprite.direction = 2

main program begins

pygame.init()
screen = pygame.display.set_mode((800,600))
pygame.display.set_caption("Collision Demo")
font = pygame.font.Font(None, 36)
timer = pygame.time.Clock()

create sprite groups

player_group = pygame.sprite.Group()
zombie_group = pygame.sprite.Group()
health_group = pygame.sprite.Group()

create the player sprite

player = MySprite()
player.load("farmer walk.png", 96, 96, 8)
player.position = 80, 80
player.direction = 4
player_group.add(player)

create the zombie sprite

zombie_image = pygame.image.load("zombie walk.png").convert_alpha()
for n in range(0, 10):
zombie = MySprite()
zombie.load("zombie walk.png", 96, 96, 8)
zombie.position = random.randint(0, 700), random.randint(0, 500)
zombie.direction = random.randint(0, 3) * 2
zombie_group.add(zombie)

create heath sprite

health = MySprite()
health.load("health.png", 32, 32, 1)
health.position = 400, 300
health_group.add(health)

game_over = False
player_moving = False
player_health = 100

start_time = 0

repeating loop

while True:
timer.tick(30)
ticks = pygame.time.get_ticks()

# add zombie every 10 seconds
if ticks - start_time > 10000:
    zombie = MySprite()
    zombie.load("zombie walk.png", 96, 96, 8)
    zombie.position = random.randint(0, 700), random.randint(0, 500)
    zombie.direction = random.randint(0, 3) \* 2
    zombie_group.add(zombie)
    start_time = ticks

for event in pygame.event.get():
    if event.type == QUIT: sys.exit()
keys = pygame.key.get_pressed()

if keys[K_ESCAPE]: sys.exit()
elif keys[K_UP] or keys[K_w]:
    player.direction = 0
    player_moving = True
elif keys[K_RIGHT] or keys[K_d]:
    player.direction = 2
    player_moving = True
elif keys[K_DOWN] or keys[K_s]:
    player.direction = 4
    player_moving = True
elif keys[K_LEFT] or keys[K_a]:
    player.direction = 6
    player_moving = True
else:
    player_moving = False

if not game_over:
    # set animation frames based on player's direction
    player.first_frame = player.direction \* player.columns
    player.last_frame = player.first_frame + player.columns-1
    if player.frame < player.first_frame:
        player.frame = player.first_frame

    if not player_moving:
        #stop animating when player is not pressing a key
        player.frame = player.first_frame = player.last_frame
    else:
        #move player in direction 
        player.velocity = calc_velocity(player.direction, 1.5)
        player.velocity.x \*= 1.5
        player.velocity.y \*= 1.5

    #update player sprite
    player_group.update(ticks, 50)

    #manually move the player
    if player_moving:
        player.X += player.velocity.x
        player.Y += player.velocity.y
        if player.X < 0: player.X = 0
        elif player.X > 700: player.X = 700
        if player.Y < 0: player.Y = 0
        elif player.Y > 500: player.Y = 500

    #update zombie sprites
    zombie_group.update(ticks, 50)

    #manually iterate through all the zombies
    for z in zombie_group:
        #set the zombie's animation range
        z.first_frame = z.direction \* z.columns
        z.last_frame = z.first_frame + z.columns-1
        if z.frame < z.first_frame:
            z.frame = z.first_frame
        z.velocity = calc_velocity(z.direction)

        #keep the zombie on the screen        
        z.X += z.velocity.x
        z.Y += z.velocity.y
        if z.X < 0 or z.X > 700 or z.Y < 0 or z.Y > 500:
            reverse_direction(z)
        

    #check for collision with zombies
    attacker = None
    attacker = pygame.sprite.spritecollideany(player, zombie_group)
    if attacker != None:
        #we got a hit, now do a more precise check
        if pygame.sprite.collide_rect_ratio(0.5)(player,attacker):
            player_health -= 10
            if attacker.X < player.X:   attacker.X -= 10
            elif attacker.X > player.X: attacker.X += 10
        else:
            attacker = None

    #update the health drop
    health_group.update(ticks, 50)

    #check for collision with health
    if pygame.sprite.collide_rect_ratio(0.5)(player,health):
        player_health += 30
        if player_health > 100: player_health = 100
        health.X = random.randint(0,700)
        health.Y = random.randint(0,500)
    

#is player dead?
if player_health <= 0:
    game_over = True


#clear the screen
screen.fill((50,50,100))

#draw sprites
health_group.draw(screen)
zombie_group.draw(screen)
player_group.draw(screen)

#draw energy bar
pygame.draw.rect(screen, (50,150,50,180), Rect(300,570,player_health \* 2,25))
pygame.draw.rect(screen, (100,200,100,180), Rect(300,570,200,25), 2)

if game_over:
    print_text(font, 300, 100, "G A M E   O V E R")

pygame.display.update()

</pre>

BlockBreaker:

<pre>

Block Breaker Game

Chapter 9

import sys, time, random, math, pygame
from pygame.locals import *
from MyLibrary import *

levels = (
(1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,0,0,1,1,1,1,1,
1,1,1,1,1,0,0,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1),

(2,2,2,2,2,2,2,2,2,2,2,2,
2,0,0,2,2,2,2,2,2,0,0,2,
2,0,0,2,2,2,2,2,2,0,0,2,
2,2,2,2,2,2,2,2,2,2,2,2,
2,2,2,2,2,2,2,2,2,2,2,2,
2,2,2,2,2,2,2,2,2,2,2,2,
2,2,2,2,2,2,2,2,2,2,2,2,
2,0,0,2,2,2,2,2,2,0,0,2,
2,0,0,2,2,2,2,2,2,0,0,2,
2,2,2,2,2,2,2,2,2,2,2,2),

(3,3,3,3,3,3,3,3,3,3,3,3,
3,3,0,0,0,3,3,0,0,0,3,3,
3,3,0,0,0,3,3,0,0,0,3,3,
3,3,0,0,0,3,3,0,0,0,3,3,
3,3,3,3,3,3,3,3,3,3,3,3,
3,3,3,3,3,3,3,3,3,3,3,3,
3,3,0,0,0,3,3,0,0,0,3,3,
3,3,0,0,0,3,3,0,0,0,3,3,
3,3,0,0,0,3,3,0,0,0,3,3,
3,3,3,3,3,3,3,3,3,3,3,3),
)

this function increments the level

def goto_next_level():
global level, levels
level += 1
if level > len(levels)-1:
level = 0
load_level()

this function updates the blocks in play

def update_blocks():
global block_group, waiting
if len(block_group) == 0: #all blocks gone?
goto_next_level()
waiting = True
block_group.update(ticks, 50)

this function sets up the blocks for the level

def load_level():
global level, block, block_image, block_group, levels

block_image = pygame.image.load("blocks.png").convert_alpha()

block_group.empty() #reset block group

for bx in range(0, 12):
    for by in range(0,10):
        block = MySprite()
        block.set_image(block_image, 58, 28, 4)
        x = 40 + bx \* (block.frame_width+1)
        y = 60 + by \* (block.frame_height+1)
        block.position = x, y

        #read blocks from level data
        num = levels[level][by \* 12+bx]
        block.first_frame = num-1
        block.last_frame = num-1
        if num > 0: #0 is blank
            block_group.add(block)

print(len(block_group))

this function initializes the game

def game_init():
global screen, font, timer
global paddle_group, block_group, ball_group
global paddle, block_image, block, ball

pygame.init()
screen = pygame.display.set_mode((800,600))
pygame.display.set_caption("Block Breaker Game")
font = pygame.font.Font(None, 36)
pygame.mouse.set_visible(False)
timer = pygame.time.Clock()

#create sprite groups
paddle_group = pygame.sprite.Group()
block_group = pygame.sprite.Group()
ball_group = pygame.sprite.Group()

#create the paddle sprite
paddle = MySprite()
paddle.load("paddle.png")
paddle.position = 400, 540
paddle_group.add(paddle)

#create ball sprite
ball = MySprite()
ball.load("ball.png")
ball.position = 400,300
ball_group.add(ball)

this function moves the paddle

def move_paddle():
global movex,movey,keys,waiting

paddle_group.update(ticks, 50)


if keys[K_LEFT]: paddle.velocity.x = -10.0
elif keys[K_RIGHT]: paddle.velocity.x = 10.0
elif movex < -2:
    paddle.velocity.x = movex
elif movex > 2:
    paddle.velocity.x = movex
else:
   paddle.velocity.x = 0

paddle.X += paddle.velocity.x
if paddle.X < 0: paddle.X = 0
elif paddle.X > 710: paddle.X = 710

this function resets the ball's velocity

def reset_ball():
ball.velocity = Point(4.5, -7.0)

this function moves the ball

def move_ball():
global waiting, ball, game_over, lives

#move the ball            
ball_group.update(ticks, 50)
if waiting:
    ball.X = paddle.X + 40
    ball.Y = paddle.Y - 20
ball.X += ball.velocity.x
ball.Y += ball.velocity.y
if ball.X < 0:
    ball.X = 0
    ball.velocity.x \*= -1
elif ball.X > 780:
    ball.X = 780
    ball.velocity.x \*= -1
if ball.Y < 0:
    ball.Y = 0
    ball.velocity.y \*= -1
elif ball.Y > 580: #missed paddle
    waiting = True
    lives -= 1
    if lives < 1: game_over = True

this function test for collision between ball and paddle

def collision_ball_paddle():
if pygame.sprite.collide_rect(ball, paddle):
ball.velocity.y = -abs(ball.velocity.y)
bx = ball.X + 8
by = ball.Y + 8
px = paddle.X + paddle.frame_width/2
py = paddle.Y + paddle.frame_height/2
if bx < px: #left side of paddle?
ball.velocity.x = -abs(ball.velocity.x)
else: #right side of paddle?
ball.velocity.x = abs(ball.velocity.x)

this function tests for collision between ball and blocks

def collision_ball_blocks():
global score, block_group, ball

hit_block = pygame.sprite.spritecollideany(ball, block_group)
if hit_block != None:
    score += 10
    block_group.remove(hit_block)
    bx = ball.X + 8
    by = ball.Y + 8

    #hit middle of block from above or below?
    if bx > hit_block.X+5 and bx < hit_block.X + hit_block.frame_width-5:
        if by < hit_block.Y + hit_block.frame_height/2: #above?
            ball.velocity.y = -abs(ball.velocity.y)
        else: #below?
            ball.velocity.y = abs(ball.velocity.y)

    #hit left side of block?
    elif bx < hit_block.X + 5:
        ball.velocity.x = -abs(ball.velocity.x)
    #hit right side of block?
    elif bx > hit_block.X + hit_block.frame_width - 5:
        ball.velocity.x = abs(ball.velocity.x)

    #handle any other situation
    else:
        ball.velocity.y \*= -1

main program begins

game_init()
game_over = False
waiting = True
score = 0
lives = 3
level = 0
load_level()

repeating loop

while True:
timer.tick(30)
ticks = pygame.time.get_ticks()

#handle events
for event in pygame.event.get():
    if event.type == QUIT: sys.exit()
    elif event.type == MOUSEMOTION:
        movex,movey = event.rel
    elif event.type == MOUSEBUTTONUP:
        if waiting:
            waiting = False
            reset_ball()
    elif event.type == KEYUP:
        if event.key == K_RETURN: goto_next_level()

#handle key presses
keys = pygame.key.get_pressed()
if keys[K_ESCAPE]: sys.exit()


#do updates
if not game_over:

    if keys[K_SPACE]:
        if waiting:
            waiting = False
            reset_ball()
            
    update_blocks()
    move_paddle()
    move_ball()
    collision_ball_paddle()
    collision_ball_blocks()

#do drawing
screen.fill((50,50,100))
block_group.draw(screen)
ball_group.draw(screen)
paddle_group.draw(screen)
print_text(font, 0, 0, "SCORE " + str(score))
print_text(font, 200, 0, "LEVEL " + str(level+1))
print_text(font, 400, 0, "BLOCKS " + str(len(block_group)))
print_text(font, 670, 0, "BALLS " + str(lives))
if game_over:
    print_text(font, 300, 380, "G A M E   O V E R")
pygame.display.update()

</pre>

Oil Spill:

<pre>

Oil Spill Game

Chapter 10

import sys, time, random, math, pygame
from pygame.locals import *
from MyLibrary import *

darktan = 190,190,110,255
tan = 210,210,130,255

class OilSprite(MySprite):
def init(self):
MySprite.init(self)
self.radius = random.randint(0,60) + 30 #radius 30 to 90
play_sound(new_oil)

def update(self, timing, rate=30):
    MySprite.update(self, timing, rate)

def fade(self):
    r2 = self.radius//2
    color = self.image.get_at((r2,r2))
    if color.a > 5:
        color.a -= 5
        pygame.draw.circle(self.image, color, (r2, r2), r2, 0)
    else:
        oil_group.remove(self)
        play_sound(clean_oil)

this function initializes the game

def game_init():
global screen, backbuffer, font, timer, oil_group, cursor, cursor_group

pygame.init()
screen = pygame.display.set_mode((800,600))
pygame.display.set_caption("Oil Spill Game")
font = pygame.font.Font(None, 36)
pygame.mouse.set_visible(False)
timer = pygame.time.Clock()

#create a drawing surface
backbuffer = pygame.Surface((800,600))
backbuffer.fill(darktan)

#create oil list
oil_group = pygame.sprite.Group()

#create cursor sprite
cursor = MySprite()
cursor.radius = 60
image = pygame.Surface((60,60)).convert_alpha()
image.fill((255,255,255,0))
pygame.draw.circle(image, (80,80,220,70), (30,30), 30, 0)
pygame.draw.circle(image, (80,80,250,255), (30,30), 30, 4)
cursor.set_image(image)
cursor_group = pygame.sprite.GroupSingle()
cursor_group.add(cursor)

this function initializes the audio system

def audio_init():
global new_oil, clean_oil

#initialize the audio mixer
pygame.mixer.init() #not always called by pygame.init()

#load sound files
new_oil = pygame.mixer.Sound("new_oil.wav")
clean_oil = pygame.mixer.Sound("clean_oil.wav")

def play_sound(sound):
channel = pygame.mixer.find_channel(True)
channel.set_volume(0.5)
channel.play(sound)

def add_oil():
global oil_group, new_oil

oil = OilSprite()
image = pygame.Surface((oil.radius,oil.radius)).convert_alpha()
image.fill((255,255,255,0))
oil.fadelevel = random.randint(50,150)
oil_color = 10,10,20,oil.fadelevel
r2 = oil.radius//2
pygame.draw.circle(image, oil_color, (r2,r2), r2, 0)
oil.set_image(image)
oil.X = random.randint(0,760)
oil.Y = random.randint(0,560)
oil_group.add(oil)

play_sound(new_oil)

main program begins

game_init()
audio_init()
game_over = False
last_time = 0

repeating loop

while True:
timer.tick(30)
ticks = pygame.time.get_ticks()

for event in pygame.event.get():
    if event.type == QUIT: sys.exit()
keys = pygame.key.get_pressed()
if keys[K_ESCAPE]: sys.exit()


#get mouse input
b1,b2,b3 = pygame.mouse.get_pressed()
mx,my = pygame.mouse.get_pos()
pos = (mx+30,my+30)
if b1 > 0:
    pygame.draw.circle(backbuffer, tan, pos, 30, 0)

#collision test
oil_hit = None
for oil in oil_group:
    if pygame.sprite.collide_circle_ratio(0.5)(cursor, oil):
        oil_hit = oil
        if b1 > 0: oil_hit.fade()
        break

#add new oil sprite once per second
if ticks > last_time + 1000:
    add_oil()
    last_time = ticks


#draw backbuffer
screen.blit(backbuffer, (0,0))

#draw oil
oil_group.update(ticks)
oil_group.draw(screen)

#draw cursor
cursor.position = (mx,my)
cursor_group.update(ticks)
cursor_group.draw(screen)

if oil_hit: print_text(font, 0, 0, "OIL SPLOTCH - CLEAN IT!")
else: print_text(font, 0, 0, "CLEAN")
pygame.display.update()

</pre>

Snake:

<pre>

Snake Game

Chapter 11

import sys, time, random, math, pygame
from pygame.locals import *
from MyLibrary import *

class Food(MySprite):
def init(self):
MySprite.init(self)
image = pygame.Surface((32,32)).convert_alpha()
image.fill((255,255,255,0))
pygame.draw.circle(image, (250,250,50), (16,16), 16, 0)
self.set_image(image)
MySprite.update(self, 0, 30) #create frame image
self.X = random.randint(0,23) * 32
self.Y = random.randint(0,17) * 32

class SnakeSegment(MySprite):
def init(self,color=(20,200,20)):
MySprite.init(self)
image = pygame.Surface((32,32)).convert_alpha()
image.fill((255,255,255,0))
pygame.draw.circle(image, color, (16,16), 16, 0)
self.set_image(image)
MySprite.update(self, 0, 30) #create frame image

class Snake():
def init(self):
self.velocity = Point(-1,0)
self.old_time = 0
head = SnakeSegment((50,250,50))
head.X = 12 * 32
head.Y = 9* 32
self.segments = list()
self.segments.append(head)
self.add_segment()
self.add_segment()

def update(self,ticks):
    global step_time #additional code
    if ticks > self.old_time + step_time: #modified code
        self.old_time = ticks
        #move body segments
        for n in range(len(self.segments)-1, 0, -1):
            self.segments[n].X = self.segments[n-1].X
            self.segments[n].Y = self.segments[n-1].Y
        #move snake head
        self.segments[0].X += self.velocity.x \* 32
        self.segments[0].Y += self.velocity.y \* 32

def draw(self,surface):
    for segment in self.segments: 
        surface.blit(segment.image, (segment.X, segment.Y))

def add_segment(self):
    last = len(self.segments)-1
    segment = SnakeSegment()
    start = Point(0,0)
    if self.velocity.x < 0: start.x = 32
    elif self.velocity.x > 0: start.x = -32
    if self.velocity.y < 0: start.y = 32
    elif self.velocity.y > 0: start.y = -32
    segment.X = self.segments[last].X + start.x
    segment.Y = self.segments[last].Y + start.y
    self.segments.append(segment)

this function gets the snake's current direction

def get_current_direction():
global head_x,head_y
first_segment_x = snake.segments[1].X//32
first_segment_y = snake.segments[1].Y//32
if head_x-1 == first_segment_x: return "right"
elif head_x+1 == first_segment_x: return "left"
elif head_y-1 == first_segment_y: return "down"
elif head_y+1 == first_segment_y: return "up"

this function gets the direction to the food

def get_food_direction():
global head_x,head_y
food = Point(0,0)
for obj in food_group:
food = Point(obj.X//32,obj.Y//32)
direction = get_current_direction()

if direction == "up" or direction == "down":
    if head_x < food.x:
        return "right"
    elif head_x > food.x:
        return "left"
    else:
        return direction

if direction == "left" or direction == "right":
    if head_y < food.y:
        return "down"
    elif head_y > food.y:
        return "up"
    else:
        return direction

this function causes snake to move automatically

def auto_move():
global head_x, head_y
direction = get_current_direction()
food_dir = get_food_direction()

print(direction + ":" + food_dir+":" + str(head_x) + ":" + str(head_y))
if direction == "up":
    if food_dir == "left":
        direction = "left"
        for segment in snake.segments:
            if segment.X // 32 == head_x - 1:
                direction == "up"
                break
        for segment in snake.segments:
            if segment.Y // 32 == head_y - 1:
                direction == "right"
                break

    if food_dir == "right":
        direction = "right"
        for segment in snake.segments:
            if segment.X // 32 == head_x + 1:
                direction == "up"
                break
        for segment in snake.segments:
            if segment.Y // 32 == head_y - 1:
                direction == "left"
                break

    if food_dir == "up":
        for segment in snake.segments:
            if segment.Y // 32 == head_y - 1:
                direction == "left"
                break
        for segment in snake.segments:
            if segment.X // 32 == head_x - 1:
                direction == "right"
                break

    if head_y - 1 < 0:
        direction == "left"
        for segment in snake.segments:
            if segment.X // 32 == head_x - 1:
                direction == "right"
                break

if direction == "down":
    if food_dir == "left":
        direction = "left"
        for segment in snake.segments:
            if segment.X // 32 == head_x - 1:
                direction == "down"
                break
        for segment in snake.segments:
            if segment.Y // 32 == head_y + 1:
                direction == "right"
                break

    if food_dir == "right":
        direction = "right"
        for segment in snake.segments:
            if segment.X // 32 == head_x + 1:
                direction == "down"
                break
        for segment in snake.segments:
            if segment.Y // 32 == head_y + 1:
                direction == "left"
                break

    if food_dir == "down":
        for segment in snake.segments:
            if segment.Y // 32 == head_y + 1:
                direction == "left"
                break
        for segment in snake.segments:
            if segment.X // 32 == head_x - 1:
                direction == "right"
                break

    if head_y + 1 >= 18:
        direction == "left"
        for segment in snake.segments:
            if segment.X // 32 == head_x - 1:
                direction == "right"
                break

if direction == "left":
    print("llllll")
    if food_dir == "up":
        direction = "up"
        for segment in snake.segments:
            if segment.Y // 32 == head_y - 1:
                direction == "left"
                break
        for segment in snake.segments:
            if segment.X // 32 == head_x - 1:
                direction == "down"
                break

    if food_dir == "down":
        direction = "down"
        for segment in snake.segments:
            if segment.Y // 32 == head_y + 1:
                direction == "left"
                break
        for segment in snake.segments:
            if segment.X // 32 == head_x - 1:
                direction == "up"
                break

    if food_dir == "left":
        for segment in snake.segments:
            if segment.X // 32 == head_x - 1:
                direction == "up"
                break
        for segment in snake.segments:
            if segment.Y // 32 == head_y - 1:
                direction == "down"
                break

    if head_x - 1 < 0:
        direction == "up"
        for segment in snake.segments:
            if segment.Y // 32 == head_y - 1:
                direction == "down"
                break

if direction == "right":
    if food_dir == "up":
        direction = "up"
        for segment in snake.segments:
            if segment.Y // 32 == head_y - 1:
                direction == "right"
                break
        for segment in snake.segments:
            if segment.X // 32 == head_x + 1:
                direction == "down"
                break

    if food_dir == "down":
        direction = "down"
        for segment in snake.segments:
            if segment.Y // 32 == head_y + 1:
                direction == "right"
                break
        for segment in snake.segments:
            if segment.X // 32 == head_x + 1:
                direction == "up"
                break

    if food_dir == "right":
        for segment in snake.segments:
            if segment.X // 32 == head_x + 1:
                direction == "up"
                break
        for segment in snake.segments:
            if segment.Y // 32 == head_y - 1:
                direction == "down"
                break

    if head_x + 1 >= 24:
        direction == "up"
        for segment in snake.segments:
            if segment.Y // 32 == head_y - 1:
                direction == "down"
                break

#set velocity based on direction
if direction == "up": snake.velocity = Point(0,-1)
elif direction == "down": snake.velocity = Point(0,1)
elif direction == "left": snake.velocity = Point(-1,0)
elif direction == "right": snake.velocity = Point(1,0)

this function initializes the game

def game_init():
global screen, backbuffer, font, timer, snake, food_group

pygame.init()
screen = pygame.display.set_mode((24 \* 32,18 \* 32))
pygame.display.set_caption("Snake Game")
font = pygame.font.Font(None, 30)
timer = pygame.time.Clock()

#create a drawing surface
backbuffer = pygame.Surface((screen.get_rect().width,screen.get_rect().height))

#create snake
snake = Snake()
image = pygame.Surface((60,60)).convert_alpha()
image.fill((255,255,255,0))
pygame.draw.circle(image, (80,80,220,70), (30,30), 30, 0)
pygame.draw.circle(image, (80,80,250,255), (30,30), 30, 4)

#create food
food_group = pygame.sprite.Group()
food = Food()
food_group.add(food)

main program begins

game_init()
game_over = False
last_time = 0

auto_play = False #additional code added
step_time = 400

main loop

while True:
timer.tick(30)
ticks = pygame.time.get_ticks()

#event section
for event in pygame.event.get():
    if event.type == QUIT: sys.exit()
keys = pygame.key.get_pressed()
if keys[K_ESCAPE]: sys.exit()
elif keys[K_UP] or keys[K_w]:
    snake.velocity = Point(0,-1)
elif keys[K_DOWN] or keys[K_s]:
    snake.velocity = Point(0,1)
elif keys[K_LEFT] or keys[K_a]:
    snake.velocity = Point(-1,0)
elif keys[K_RIGHT] or keys[K_d]:
    snake.velocity = Point(1,0)
elif keys[K_SPACE]: #additional code added
    if auto_play:
        auto_play = False
        step_time = 400
    else:
        auto_play = True
        step_time = 50

#update section
if not game_over:
    snake.update(ticks)
    food_group.update(ticks)
    
    #try to pick up food
    hit_list = pygame.sprite.groupcollide(snake.segments, \
        food_group, False, True)
    if len(hit_list) > 0:
        food_group.add(Food())
        snake.add_segment()

    #see if head collides with body
    for n in range(1, len(snake.segments)):
        if pygame.sprite.collide_rect(snake.segments[0], snake.segments[n]):
            game_over = True

    #check screen boundary
    head_x = snake.segments[0].X//32
    head_y = snake.segments[0].Y//32
    if head_x < 0 or head_x > 24 or head_y < 0 or head_y > 18:
        game_over = True

    #additional code added
    if auto_play: auto_move()


#drawing section
backbuffer.fill((20,50,20)) 
snake.draw(backbuffer)
food_group.draw(backbuffer)
screen.blit(backbuffer, (0,0))

if not game_over:
    print_text(font, 0, 0, "Length " + str(len(snake.segments)))
    print_text(font, 0, 20, "Position " + str(snake.segments[0].X//32) + \
               "," + str(snake.segments[0].Y//32))
else:
    print_text(font, 0, 0, "GAME OVER")

#additional code added
if auto_play: 
    print_text(font, 700, 0, "AUTO")
    

pygame.display.update() 

</pre>