Mini-Game — Brick Breaker

By the end of this lesson you can:

• Build a list of Rect objects with a list comprehension to form a brick wall.
• Detect ball-to-brick collisions with colliderect, remove the brick, and add to the score.
• Combine the paddle, ball, brick wall, and score into a complete single-file game.

The brick wall is a list of Rect objects. Predict how many rects this comprehension produces and where the first and last ones are:

BW, BH = 60, 20
GAP = 4
bricks = [
    Rect((col * (BW + GAP) + 10, row * (BH + GAP) + 50), (BW, BH))
    for row in range(4)
    for col in range(8)
]
print(len(bricks))
print(bricks[0])
print(bricks[-1])

32
Rect(10, 50, 60, 20)
Rect(514, 122, 60, 20)

A brick wall is like a list of soap bubbles. When the ball touches any bubble, it pops (gets removed) and the ball bounces off. The collision check is one for loop with a colliderect inside it.

Checking all bricks each frame

ball_rect = Rect((int(bx) - BR, int(by) - BR), (BR * 2, BR * 2))

for brick in bricks[:]:              # copy so remove is safe
    if ball_rect.colliderect(brick):
        bricks.remove(brick)         # destroy
        score += 10                  # score
        vy = -vy                     # bounce vertically
        break                        # only one brick per frame

Why break?

Without break the ball could destroy several adjacent bricks in one frame and flip vy multiple times, making the bounce direction unpredictable. One brick per frame keeps the physics honest.

Ball-paddle collision

paddle_rect = Rect((paddle_x - PAD_W // 2, HEIGHT - 30), (PAD_W, 12))

if ball_rect.colliderect(paddle_rect):
    vy = -abs(vy)   # always move upward after paddle hit

Stage 1 · Paddle + ball (no bricks yet)

# brick_breaker.py — stage 1: paddle + ball

import pgzrun

WIDTH = 600
HEIGHT = 450
TITLE = "Brick Breaker"

PAD_W, PAD_H = 90, 12
BR = 9
bx, by = WIDTH // 2, HEIGHT // 2
vx, vy = 3, -4
paddle_x = WIDTH // 2
score = 0
lives = 3

def draw():
    screen.fill("black")
    screen.draw.filled_rect(
        Rect((paddle_x - PAD_W // 2, HEIGHT - 30), (PAD_W, PAD_H)), "deepskyblue")
    screen.draw.filled_circle((int(bx), int(by)), BR, "white")
    screen.draw.text(f"Score: {score}  Lives: {lives}",
                     topleft=(8, 8), fontsize=26, color="white")

def update():
    global bx, by, vx, vy, paddle_x, lives
    if keyboard.left and paddle_x > PAD_W // 2:
        paddle_x -= 6
    if keyboard.right and paddle_x < WIDTH - PAD_W // 2:
        paddle_x += 6
    bx += vx
    by += vy
    if bx <= BR or bx >= WIDTH - BR:
        vx = -vx
    if by <= BR:
        vy = abs(vy)
    pad_r = Rect((paddle_x - PAD_W // 2, HEIGHT - 30), (PAD_W, PAD_H))
    ball_r = Rect((int(bx) - BR, int(by) - BR), (BR * 2, BR * 2))
    if ball_r.colliderect(pad_r):
        vy = -abs(vy)
    if by > HEIGHT:
        lives -= 1
        bx, by = WIDTH // 2, HEIGHT // 2
        vx, vy = 3, -4

pgzrun.go()

Stage 2 · Add the brick wall

Add these lines near the top (after the lives variable), then extend update() with the brick loop, and add the brick drawing to draw().

BW, BH = 58, 18
GAP = 4
BRICK_COLOURS = ["tomato", "orange", "gold", "limegreen"]
bricks = [
    Rect((col * (BW + GAP) + 10, row * (BH + GAP) + 50), (BW, BH))
    for row in range(4)
    for col in range(8)
]

# inside draw(), after drawing the paddle:
for i, brick in enumerate(bricks):
    colour = BRICK_COLOURS[i % len(BRICK_COLOURS)]
    screen.draw.filled_rect(brick, colour)

# inside update(), after paddle collision:
ball_r = Rect((int(bx) - BR, int(by) - BR), (BR * 2, BR * 2))
for brick in bricks[:]:
    if ball_r.colliderect(brick):
        bricks.remove(brick)
        score += 10
        vy = -vy
        break

What you'll see

Brick Breaker combines everything learnt so far: a player-controlled paddle, a bouncing ball with vx/vy, and a list of Rect bricks that are destroyed and scored on collision. Iterating a copy of the list ([:]) and using break after the first hit keeps the physics clean.