Mini-Game — Gravity Catcher

By the end of this lesson you can:

• Spawn falling objects as a list of dicts, each with its own position and velocity, and apply gravity each frame.
• Detect a catch using colliderect between the falling object's Rect and the basket Actor, updating score and lives correctly.
• Build a complete game loop with score, lives, and game-over state that resets cleanly when the player presses a key.

Two quick questions before we build. Predict the output of each snippet:

# Snippet A
vy = 2.0
GRAVITY = 0.5
for _ in range(3):
    vy += GRAVITY
print(round(vy, 1))

# Snippet B
import pgzrun
basket = Actor("basket", center=(300, 350))
fruit_rect = Rect((290, 340), (20, 20))
print(basket.colliderect(fruit_rect))

3.5

True

Think of each falling kuih as a sticky note: it has a position, a vertical speed, and a size. We keep all of them in a list and loop through every frame to update and draw each one.

Spawning a falling object

import random

ITEM_W = 28
ITEM_H = 28
ITEM_GRAVITY = 0.3

def make_item():
    return {
        "x": float(random.randint(ITEM_W, WIDTH - ITEM_W)),
        "y": 0.0,
        "vy": random.uniform(1.5, 3.5),
    }

Updating all falling objects

Apply gravity, move, then check if the item fell off the bottom (missed):

def update_items():
    global lives
    for item in list(items):
        item["vy"] += ITEM_GRAVITY
        item["y"] += item["vy"]
        if item["y"] > HEIGHT + ITEM_H:
            items.remove(item)
            lives -= 1

Catching with colliderect

colliderect needs a Rect. Build one from the item's position and size, then test against the basket Actor:

def check_catches():
    global score
    for item in list(items):
        item_rect = Rect(
            (int(item["x"] - ITEM_W // 2), int(item["y"] - ITEM_H // 2)),
            (ITEM_W, ITEM_H),
        )
        if basket.colliderect(item_rect):
            items.remove(item)
            score += 10

Nurul builds the full game. The basket is a wide rectangle Actor (save a wide basket PNG as images/basket.png, or any suitable image). Use clock.schedule_interval to spawn a new item every 1.5 seconds. Save as gravity_catcher.py:

# gravity_catcher.py — catch falling kuih with a basket

import pgzrun
import random

WIDTH = 480
HEIGHT = 500
TITLE = "Gravity Catcher"
BASKET_SPEED = 6
ITEM_W = 28
ITEM_H = 28
ITEM_GRAVITY = 0.25
MAX_LIVES = 3
SPAWN_INTERVAL = 1.4
COLOURS = ["gold", "orange", "crimson", "limegreen", "violet"]

basket = Actor("basket", center=(240, 450))
items = []
score = 0
lives = MAX_LIVES
STATE = "play"

def make_item():
    return {
        "x": float(random.randint(ITEM_W, WIDTH - ITEM_W)),
        "y": 0.0,
        "vy": random.uniform(1.8, 3.5),
        "colour": random.choice(COLOURS),
    }

def spawn_item():
    if STATE == "play":
        items.append(make_item())

clock.schedule_interval(spawn_item, SPAWN_INTERVAL)

def check_catches():
    global score
    for item in list(items):
        item_rect = Rect(
            (int(item["x"] - ITEM_W // 2), int(item["y"] - ITEM_H // 2)),
            (ITEM_W, ITEM_H),
        )
        if basket.colliderect(item_rect):
            items.remove(item)
            score += 10

def update_items():
    global lives, STATE
    for item in list(items):
        item["vy"] += ITEM_GRAVITY
        item["y"] += item["vy"]
        if item["y"] > HEIGHT + ITEM_H:
            items.remove(item)
            lives -= 1
            if lives <= 0:
                STATE = "over"
                clock.unschedule(spawn_item)

def update():
    if STATE != "play":
        return
    if keyboard.left:
        basket.x = max(basket.width // 2, basket.x - BASKET_SPEED)
    if keyboard.right:
        basket.x = min(WIDTH - basket.width // 2, basket.x + BASKET_SPEED)
    update_items()
    check_catches()

def draw():
    screen.fill("darkblue")
    if STATE == "play":
        basket.draw()
        for item in items:
            screen.draw.filled_rect(
                Rect(
                    (int(item["x"] - ITEM_W // 2), int(item["y"] - ITEM_H // 2)),
                    (ITEM_W, ITEM_H),
                ),
                item["colour"],
            )
        screen.draw.text(f"Score: {score}", topleft=(10, 10), fontsize=26, color="white")
        for i in range(lives):
            screen.draw.filled_circle((WIDTH - 20 - i * 30, 22), 10, "red")
    elif STATE == "over":
        screen.draw.text("GAME OVER", center=(240, 200), fontsize=52, color="red")
        screen.draw.text(f"Score: {score}", center=(240, 270), fontsize=36, color="white")
        screen.draw.text("SPACE to play again", center=(240, 330), fontsize=24, color="grey")

def on_key_down(key):
    global STATE, score, lives, items
    if key == keys.SPACE and STATE == "over":
        score = 0
        lives = MAX_LIVES
        items.clear()
        basket.center = (240, 450)
        STATE = "play"
        clock.schedule_interval(spawn_item, SPAWN_INTERVAL)

pgzrun.go()

Gravity Catcher brings together everything from the physics lessons. Falling objects use the same vy += GRAVITY recipe from PZ-35. Collision uses colliderect with a Rect built from the object's position. Score and lives update on catch or miss. clock.schedule_interval handles spawning without cluttering update(). Each subsystem was already tested alone — combining them is straightforward.