My First Python Game Ep 5: Breakout

🧩

Need the game setup? Each episode builds a new game on the same "usual template", import pygameimport pygame, pygame.init()pygame.init(), the window and the while runningwhile running game loop. If you're starting here or need that template, grab it in one click: Episode 1 full template → · Python Cheatsheet →

🏓

Setup & Paddle

Template plus a clamped paddle

Active

🎯

Goal for this step

Fresh project with a smooth, clamped paddle at the bottom.

1New game.py, 700×520 window, the usual template.
2Paddle Rect: 110×14 at the bottom, arrows move ±8, clamped.
3This is the third time you have built "move a thing with arrows", notice it now takes you two minutes. That is skill.

game.py

paddle = pygame.Rect(295, 480, 110, 14)

keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
    paddle.x -= 8
if keys[pygame.K_RIGHT]:
    paddle.x += 8
paddle.x = max(0, min(700 - paddle.width, paddle.x))paddle = pygame.Rect(295, 480, 110, 14)

keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
    paddle.x -= 8
if keys[pygame.K_RIGHT]:
    paddle.x += 8
paddle.x = max(0, min(700 - paddle.width, paddle.x))

📦 Full starter file , the Episode 1 pygame template (700×520)

The standard pygame window, the clock and the while runningwhile running game loop, sized 700×520 for Breakout. Save it as game.pygame.py and run it. Every step below adds to this same file.

game.py

import pygame
pygame.init()
screen = pygame.display.set_mode((700, 520))
pygame.display.set_caption("My Python Game")
clock = pygame.time.Clock()

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    screen.fill((25, 30, 60))      # everything you build below is drawn here
    pygame.display.flip()
    clock.tick(60)                 # 60 frames per second

pygame.quit()import pygame
pygame.init()
screen = pygame.display.set_mode((700, 520))
pygame.display.set_caption("My Python Game")
clock = pygame.time.Clock()

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    screen.fill((25, 30, 60))      # everything you build below is drawn here
    pygame.display.flip()
    clock.tick(60)                 # 60 frames per second

pygame.quit()

✏️

Fill in the Blanks

+15 XP

The paddle is clamped between 0 and 700 minus its . Held-key movement uses pygame.key.().

🧠

Knowledge Check

+15 XP

You have now written the arrow-move-and-clamp pattern three times. What is the lesson?

AProgramming is repetitive and boring

BCore patterns repeat across games, mastering a few building blocks unlocks many games

CPygame has no better way

⚪

The Ball

Velocity vector, wall bounces

Locked

🎯

Goal for this step

A ball that moves diagonally and bounces off three walls.

1Ball Rect (14×14) plus velocity bvx, bvy = 4, -4.
2Each frame add velocity; left/right walls flip bvx, ceiling flips bvy.
3The floor does NOT bounce, falling past it will cost a life later.
4Draw it white with draw.ellipse.

game.py

ball = pygame.Rect(340, 300, 14, 14)
bvx, bvy = 4, -4

ball.x += bvx
ball.y += bvy
if ball.left <= 0 or ball.right >= 700:
    bvx = -bvx
if ball.top <= 0:
    bvy = -bvyball = pygame.Rect(340, 300, 14, 14)
bvx, bvy = 4, -4

ball.x += bvx
ball.y += bvy
if ball.left <= 0 or ball.right >= 700:
    bvx = -bvx
if ball.top <= 0:
    bvy = -bvy

⌨️

Code Challenge

+20 XP

Bounce off the three solid walls:

game.py

if ball.left <= 0 or ball.right >= if ball.left <= 0 or ball.right >= :
    bvx = :
    bvx = 
if ball.top <= 0:
    bvy = 
if ball.top <= 0:
    bvy =

💡 Hint: The right wall is the window width. Bouncing negates the matching velocity component.

🧠

Knowledge Check

+15 XP

Why does the bottom edge NOT bounce the ball?

APygame cannot detect it

BLosing the ball past the paddle is the core challenge, bounce it and the game has no stakes

CThe paddle blocks the check

🎯

Paddle Spin

Where the ball lands on the paddle steers the rebound

Locked

🎯

Goal for this step

Rebound off the paddle with player-controlled angle.

1On paddle collision (while moving down), flip bvy.
2Then the spin: offset = ball centre − paddle centre; bvx = offset // 12.
3Catch on the left edge → sharp left shot; centre → straight up. YOU aim every rebound.
4Never allow bvx = 0 (a perfectly vertical ball is a softlock), nudge it to 1.

game.py

if ball.colliderect(paddle) and bvy > 0:
    bvy = -bvy
    offset = ball.centerx - paddle.centerx
    bvx = offset // 12
    if bvx == 0:
        bvx = 1if ball.colliderect(paddle) and bvy > 0:
    bvy = -bvy
    offset = ball.centerx - paddle.centerx
    bvx = offset // 12
    if bvx == 0:
        bvx = 1

✏️

Fill in the Blanks

+15 XP

The rebound angle comes from the offset between the two values divided by 12. A bvx of exactly must be avoided or the ball bounces straight up forever.

🧠

Knowledge Check

+15 XP

Paddle spin turns Breakout from luck into skill because…

AThe ball moves faster

BThe player chooses each rebound angle by where they catch the ball, aiming becomes the core skill

CBricks become softer

🧱

The Brick Wall

Nested loops build a colour-banded wall of Rects

Locked

🎯

Goal for this step

Generate 5 rows × 10 columns of bricks with row colours.

1Bricks are a list of dicts: {"rect": Rect, "row": r} built by nested loops before the game loop.
2Each brick 64×22 with small gaps: x = col*68 + 12, y = row*26 + 50.
3Colour by row from a list of 5 colours.
4Run it, a proper arcade wall.

game.py

colours = [(248,113,113),(251,146,60),(250,204,21),(74,222,128),(96,165,250)]
bricks = []
for row in range(5):
    for col in range(10):
        bricks.append({
            "rect": pygame.Rect(col*68 + 12, row*26 + 50, 64, 22),
            "row": row
        })

for b in bricks:
    pygame.draw.rect(screen, colours[b["row"]], b["rect"])colours = [(248,113,113),(251,146,60),(250,204,21),(74,222,128),(96,165,250)]
bricks = []
for row in range(5):
    for col in range(10):
        bricks.append({
            "rect": pygame.Rect(col*68 + 12, row*26 + 50, 64, 22),
            "row": row
        })

for b in bricks:
    pygame.draw.rect(screen, colours[b["row"]], b["rect"])

⌨️

Code Challenge

+20 XP

Build the full wall with nested loops:

game.py

for row in range(for row in range():
    for col in range():
    for col in range():
        bricks.append({"rect": pygame.Rect(col*):
        bricks.append({"rect": pygame.Rect(col* + 12, row*26 + 50, 64, 22), "row": row}) + 12, row*26 + 50, 64, 22), "row": row})

💡 Hint: 5 rows, 10 columns; each column steps 68 px across (64 brick + 4 gap).

🧠

Knowledge Check

+15 XP

Why 68 in col*68 when bricks are 64 wide?

AA typo

BThe extra 4 px is the gap between bricks, spacing is part of the step

CPygame adds borders

💥

Smashing & Scoring

Ball destroys bricks; higher rows pay more

Locked

🎯

Goal for this step

Destroy bricks on contact with a satisfying bounce and scaled score.

1Loop bricks (copy!), on colliderect: remove, bounce (bvy = -bvy), score, and break.
2The break means one brick per frame, no laser-drilling a whole column.
3Score by depth: score += (5 - b["row"]) * 10, top rows are worth 50.
4Draw the score.

game.py

score = 0

for b in bricks[:]:
    if ball.colliderect(b["rect"]):
        bricks.remove(b)
        score += (5 - b["row"]) * 10
        bvy = -bvy
        breakscore = 0

for b in bricks[:]:
    if ball.colliderect(b["rect"]):
        bricks.remove(b)
        score += (5 - b["row"]) * 10
        bvy = -bvy
        break

✏️

Fill in the Blanks

+15 XP

After removing a hit brick we flip and use so only one brick dies per frame. Row 0 bricks are worth points.

🧠

Knowledge Check

+15 XP

What goes wrong WITHOUT the break?

ANothing, it is just faster

BOne pass can delete several overlapping bricks and double-flip bvy, so the ball drills through the wall

CPython raises an error

❤️

Lives, Loss & Victory

Three lives, serve after a drop, win when the wall is gone

Locked

🎯

Goal for this step

Finish the game: lives, game over, and the you-cleared-it screen.

1Ball past the bottom: lives -= 1, recentre the ball and serve again; at 0 → game over.
2Victory when len(bricks) == 0.
3Freeze updates in either end state, draw the message, R to fully reset (rebuild the brick list with the same nested loops, make it a function!).
4SAVE THIS FILE, Episode 6 builds power-ups directly on top of it.

game.py

lives = 3
state = "PLAY"

if ball.top > 520:
    lives -= 1
    ball.center = (350, 300)
    bvx, bvy = 4, -4
    if lives == 0:
        state = "LOSE"

if len(bricks) == 0:
    state = "WIN"lives = 3
state = "PLAY"

if ball.top > 520:
    lives -= 1
    ball.center = (350, 300)
    bvx, bvy = 4, -4
    if lives == 0:
        state = "LOSE"

if len(bricks) == 0:
    state = "WIN"

⌨️

Code Challenge

+20 XP

Handle the dropped ball:

game.py

if ball.top > 520:
    lives -= 1
    ball.if ball.top > 520:
    lives -= 1
    ball. = (350, 300)
    if lives ==  = (350, 300)
    if lives == :
        state = :
        state =

💡 Hint: Rects can be repositioned by their centre point. Zero lives ends the game with the losing state.

🧠

Knowledge Check

+15 XP

The win check is len(bricks) == 0. Why does this work?

Abricks is a boolean

BDestroyed bricks are removed from the list, so an empty list literally means the wall is gone

Clen counts the ball too

✅ See the complete finished Breakout , all 6 steps assembled

A clamped paddle, a bouncing ball, paddle-spin steering, a colour-banded brick wall, break-and-score, three lives and win/lose screens , one file. Save it as game.pygame.py, run python game.pypython game.py, and play. This is also the base Episode 6 builds power-ups on. Stuck? Compare your file against this.

game.py

import pygame
pygame.init()
screen = pygame.display.set_mode((700, 520))
pygame.display.set_caption("Brick Breaker")
clock = pygame.time.Clock()
font = pygame.font.SysFont(None, 32)
big_font = pygame.font.SysFont(None, 64)

colours = [(248, 113, 113), (251, 146, 60), (250, 204, 21), (74, 222, 128), (96, 165, 250)]

def build_bricks():
    b = []
    for row in range(5):
        for col in range(10):
            b.append({"rect": pygame.Rect(col*68 + 12, row*26 + 50, 64, 22), "row": row})
    return b

paddle = pygame.Rect(295, 480, 110, 14)
ball = pygame.Rect(340, 300, 14, 14)
bvx, bvy = 4, -4
bricks = build_bricks()
score = 0
lives = 3
state = "PLAY"

def reset():
    global paddle, ball, bvx, bvy, bricks, score, lives, state
    paddle = pygame.Rect(295, 480, 110, 14)
    ball = pygame.Rect(340, 300, 14, 14)
    bvx, bvy = 4, -4
    bricks = build_bricks()
    score = 0
    lives = 3
    state = "PLAY"

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN and event.key == pygame.K_r and state != "PLAY":
            reset()

    if state == "PLAY":
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:
            paddle.x -= 8
        if keys[pygame.K_RIGHT]:
            paddle.x += 8
        paddle.x = max(0, min(700 - paddle.width, paddle.x))

        ball.x += bvx
        ball.y += bvy
        if ball.left <= 0 or ball.right >= 700:
            bvx = -bvx
        if ball.top <= 0:
            bvy = -bvy

        if ball.colliderect(paddle) and bvy > 0:
            bvy = -bvy
            offset = ball.centerx - paddle.centerx
            bvx = offset // 12
            if bvx == 0:
                bvx = 1

        for b in bricks[:]:
            if ball.colliderect(b["rect"]):
                bricks.remove(b)
                score += (5 - b["row"]) * 10
                bvy = -bvy
                break

        if ball.top > 520:
            lives -= 1
            ball.center = (350, 300)
            bvx, bvy = 4, -4
            if lives == 0:
                state = "LOSE"

        if len(bricks) == 0:
            state = "WIN"

    # draw
    screen.fill((25, 30, 60))
    for b in bricks:
        pygame.draw.rect(screen, colours[b["row"]], b["rect"])
    pygame.draw.rect(screen, (255, 119, 0), paddle)
    pygame.draw.ellipse(screen, (255, 255, 255), ball)
    screen.blit(font.render("Score: " + str(score), True, (255, 255, 255)), (12, 8))
    screen.blit(font.render("Lives: " + str(max(0, lives)), True, (255, 255, 255)), (560, 8))
    if state != "PLAY":
        text = "YOU WIN!" if state == "WIN" else "GAME OVER"
        msg = big_font.render(text, True, (255, 209, 102))
        screen.blit(msg, msg.get_rect(center=(350, 235)))
        sub = font.render("Press R to play again", True, (255, 255, 255))
        screen.blit(sub, sub.get_rect(center=(350, 290)))

    pygame.display.flip()
    clock.tick(60)

pygame.quit()import pygame
pygame.init()
screen = pygame.display.set_mode((700, 520))
pygame.display.set_caption("Brick Breaker")
clock = pygame.time.Clock()
font = pygame.font.SysFont(None, 32)
big_font = pygame.font.SysFont(None, 64)

colours = [(248, 113, 113), (251, 146, 60), (250, 204, 21), (74, 222, 128), (96, 165, 250)]

def build_bricks():
    b = []
    for row in range(5):
        for col in range(10):
            b.append({"rect": pygame.Rect(col*68 + 12, row*26 + 50, 64, 22), "row": row})
    return b

paddle = pygame.Rect(295, 480, 110, 14)
ball = pygame.Rect(340, 300, 14, 14)
bvx, bvy = 4, -4
bricks = build_bricks()
score = 0
lives = 3
state = "PLAY"

def reset():
    global paddle, ball, bvx, bvy, bricks, score, lives, state
    paddle = pygame.Rect(295, 480, 110, 14)
    ball = pygame.Rect(340, 300, 14, 14)
    bvx, bvy = 4, -4
    bricks = build_bricks()
    score = 0
    lives = 3
    state = "PLAY"

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN and event.key == pygame.K_r and state != "PLAY":
            reset()

    if state == "PLAY":
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:
            paddle.x -= 8
        if keys[pygame.K_RIGHT]:
            paddle.x += 8
        paddle.x = max(0, min(700 - paddle.width, paddle.x))

        ball.x += bvx
        ball.y += bvy
        if ball.left <= 0 or ball.right >= 700:
            bvx = -bvx
        if ball.top <= 0:
            bvy = -bvy

        if ball.colliderect(paddle) and bvy > 0:
            bvy = -bvy
            offset = ball.centerx - paddle.centerx
            bvx = offset // 12
            if bvx == 0:
                bvx = 1

        for b in bricks[:]:
            if ball.colliderect(b["rect"]):
                bricks.remove(b)
                score += (5 - b["row"]) * 10
                bvy = -bvy
                break

        if ball.top > 520:
            lives -= 1
            ball.center = (350, 300)
            bvx, bvy = 4, -4
            if lives == 0:
                state = "LOSE"

        if len(bricks) == 0:
            state = "WIN"

    # draw
    screen.fill((25, 30, 60))
    for b in bricks:
        pygame.draw.rect(screen, colours[b["row"]], b["rect"])
    pygame.draw.rect(screen, (255, 119, 0), paddle)
    pygame.draw.ellipse(screen, (255, 255, 255), ball)
    screen.blit(font.render("Score: " + str(score), True, (255, 255, 255)), (12, 8))
    screen.blit(font.render("Lives: " + str(max(0, lives)), True, (255, 255, 255)), (560, 8))
    if state != "PLAY":
        text = "YOU WIN!" if state == "WIN" else "GAME OVER"
        msg = big_font.render(text, True, (255, 209, 102))
        screen.blit(msg, msg.get_rect(center=(350, 235)))
        sub = font.render("Press R to play again", True, (255, 255, 255))
        screen.blit(sub, sub.get_rect(center=(350, 290)))

    pygame.display.flip()
    clock.tick(60)

pygame.quit()

🎉🏆🎮✨🎉

Workshop Complete!

The arcade classic rebuilt in Python. Keep your code safe, Episode 6 upgrades THIS game with power-ups, multi-ball and levels!

Total XP

Level

Best Streak

Accuracy

▶ Episode 6: Breakout Part 2 →
⭐ View My Progress & Certificates

This workshop was free and took many hours to build. If it helped you learn something new, consider supporting the project.

☕ Support on Ko-fi

Brick Storm!Breakout

Brick Storm!
Breakout