Loop & Events

🎯 Learning Objectives

What students will be able to do after Step 2:

• Explain what a while loop is and when it exits
• Trace through the event queue and identify the QUIT event
• Understand how pygame.time.Clock.tick(fps) limits frame rate
• Describe the game loop as: Process → Update → Draw

💡 The Big Idea — Annotated Code

Key code block: the game loop.

clock = pygame.time.Clock()
running = True            # Boolean flag — controls the loop

while running:            # "Keep going while running is True"
    # 1. PROCESS — read all events from the queue
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False   # set flag → loop exits next iteration

    # 2. UPDATE — move the game state (nothing yet in Step 2)

    # 3. DRAW — render to screen
    screen.fill(BG)
    pygame.display.flip()   # swap buffers: make the new frame visible

    clock.tick(8)           # wait until 1/8 second has elapsed → 8 FPS

Boolean flag pattern

running = True at start; running = False to stop. Better than break because it is visible and testable — you can inspect running in any frame to know the loop state.

Event queue

pygame collects every keyboard, mouse, and window event in a queue each frame. pygame.event.get() drains the entire queue. If you never drain it, the queue fills and pygame's event system stalls — the window becomes unresponsive.

pygame.QUIT

Fired when the user clicks the red × button. Without this check the window appears "frozen" (unresponsive) but the loop keeps running in the background.

pygame.display.flip()

Swaps the back buffer to the screen — required every frame. pygame draws to a hidden back buffer; flip() is the "reveal." Without it, every frame is drawn but never shown, so students see a blank/black window.

clock.tick(8)

Sleeps until 1/8 second has elapsed since the last call; returns the actual milliseconds since last call. Essential for consistent speed across fast and slow machines.

🔢 Activity Answers — step-2-activity.html

Tier 1 — Fill in the Blanks (9 blanks)

Students complete 9 blanks inside a game-loop code snippet. Answers must match exactly (case-insensitive trimming applied). Up to 2 attempts; scores recorded per attempt in t1_b1_1…t1_b9_2.

Tier 2 — Debug the Code (3 bugs, up to 2 attempts)

Three separate buggy lines are shown. Students type corrections. Answers must match exactly (trimmed). Each bug+attempt is recorded.

Tier 3 — Extend the Code (max 3 attempts, code recorded)

Students write code to add a frame counter that increments every loop iteration. A sample correct answer:

# Before the while loop:
frame_count = 0

# Inside the while loop (after clock.tick):
frame_count += 1
if frame_count % 60 == 0:
    print(f"Frame: {frame_count}")

Accept variations: any working counter that increments per frame. Look for: variable initialised before the loop, incremented inside, += 1 or equivalent. The exact print format is flexible.

Tier 4 — Create Your Own (max 3 attempts, code recorded)

Students write code to add a second boolean flag (e.g. paused) that toggles on/off when the spacebar is pressed, and only runs game updates when not paused. A sample correct answer:

# Before loop:
paused = False

# Inside event loop:
if event.type == pygame.KEYDOWN:
    if event.key == pygame.K_SPACE:
        paused = not paused   # toggle

# Wrap updates in:
if not paused:
    # ... game update logic here ...

Accept variations: any working pause mechanic using a boolean flag. Key concepts to look for: toggle with not, guarded update block, KEYDOWN event detection. Students who use running = not running miss the point — that would exit the loop.

Reflective Journal — Suggested Answers

⚠️ Mistakes Students Actually Make

🗣️ Teaching & Facilitation Notes

Opening hook

"How does Netflix keep video playing smoothly? How does your mouse pointer follow your hand in real time?" Both use an event loop — a program that loops rapidly, checking what happened and updating what to show. A game loop is the same idea.

Key pedagogical moment — the 3-phase structure

Write Process → Update → Draw on the board. Every frame follows this pattern. Step 2 has no Update yet (the snake doesn't move) — that's intentional so students can observe the loop structure in isolation before adding complexity.

CT connection — Algorithm Design

The game loop IS an algorithm. Ask: "What is the input? What is the output? What are the steps?" This surfaces computational thinking through a real artifact students have written themselves.

Pacing tip

If students ask "why is 8 FPS so slow?" — that's the perfect moment to explain that Steps 2–4 run slowly on purpose so we can observe each frame. The snake will speed up in later steps.