Wrap-Around ⭐

🎯 Learning Objectives

• Use the modulo operator % to implement wrap-around (toroidal) movement
• Explain what happens with negative numbers in modulo
• Refactor direction handling using a dictionary
• Identify and reason about edge cases in game logic

💡 The Big Idea — Annotated Code

# ── Direction dictionary (replaces the if/elif chain) ──
DIRECTIONS = {
    pygame.K_UP:    (0, -1),
    pygame.K_DOWN:  (0,  1),
    pygame.K_LEFT:  (-1, 0),
    pygame.K_RIGHT: (1,  0),
}

# In the event loop:
if event.type == pygame.KEYDOWN and event.key in DIRECTIONS:
    ndx, ndy = DIRECTIONS[event.key]
    # Reverse guard: don't allow 180° turn
    if (ndx, ndy) != (-dx, -dy):
        dx, dy = ndx, ndy

# ── Wrap-around movement ──
# OLD (collision):
# head_x += dx
# head_y += dy

# NEW (wrap):
head_x = (head_x + dx) % GRID_COLS
head_y = (head_y + dy) % GRID_ROWS

Modulo %

a % b gives the remainder when a is divided by b. Key property: the result is always 0 to b−1. When head_x = 20 and GRID_COLS = 20, 20 % 20 = 0 — the snake appears at column 0.

Negative numbers

When head_x = -1 and GRID_COLS = 20, -1 % 20 = 19 in Python. Python modulo always returns non-negative — the snake appears at the right edge. This is intentional and makes wrap-around work naturally from any direction.

Direction dictionary

Maps each key constant to its (dx, dy) vector. Replaces four elif branches with a single DIRECTIONS[event.key] lookup. Adding a new direction means adding one line to the dictionary.

New reverse guard

(ndx, ndy) != (-dx, -dy) checks if the new direction is exactly opposite to the current — cleaner than the four separate dx != 1 checks used in earlier steps.

🔢 Activity Answers

Tier 1 — Check Understanding

Tier 2 — Fix the Bug

Fix: head_x = (head_x + dx) % GRID_COLS — parentheses ensure the addition happens first.

Tier 3 — Extend: Add diagonal movement

DIRECTIONS[pygame.K_q] = (-1, -1)   # up-left diagonal
DIRECTIONS[pygame.K_e] = (1, -1)    # up-right diagonal

The reverse guard (ndx, ndy) != (-dx, -dy) handles diagonal directions automatically.

Tier 4 — New Task: "Ghost mode" — pressing G toggles wrap-around on/off

wrap = True

if event.type == pygame.KEYDOWN:
    if event.key == pygame.K_g:
        wrap = not wrap

# In update:
if wrap:
    head_x = (head_x + dx) % GRID_COLS
    head_y = (head_y + dy) % GRID_ROWS
else:
    head_x += dx
    head_y += dy
    if head_x < 0 or head_x >= GRID_COLS or head_y < 0 or head_y >= GRID_ROWS:
        running = False

Reflective Journal — Suggested Strong Answers

⚠️ Mistakes Students Actually Make

🗣️ Teaching & Facilitation Notes

Opening hook — The clock analogy

"What time is it 3 hours after 11pm? Not 14:00 — it's 2am. That's modulo: 11 + 3 = 14, 14 % 12 = 2." Clocks, Pac-Man mazes, and wrap-around grids all use the same idea.

Key pedagogical moment — negative modulo

Most students expect -1 % 20 = -1 (from their mental model of remainders). Show Python's actual behaviour: -1 % 20 = 19. Explain this is intentional — Python's modulo is defined to make wrap-around work, not just as a remainder.

The dictionary refactor

Some students will resist changing code that "already works." Frame it as: "Which is easier to add a new key to — 4 elif branches or 1 dictionary?" This surfaces the maintainability argument for data structures.

CT connection — Edge case thinking

Ask: "What are all the ways a snake's head can leave the grid? Left, right, top, bottom — four edge cases. Does our solution handle all four? Test each one."