Chapter 17 — Exercises

These exercises move you from analysis to building. Some are pencil-and-paper sketches; others are full Godot implementations. Allocate roughly 2-4 hours per exercise. Do them in order — later exercises assume the artifacts produced earlier.

Exercise 17.1 — Measure Your Jump Arc

Type: Implementation (Godot) Time: 45 minutes

Create a scene with your player character and a simple flat ground. Run the game and jump in place. Without using a stopwatch, estimate (in tiles) the maximum height of your character's jump and the maximum horizontal distance from a running jump.

Now, measure precisely. Add a single line of debug code that prints the player's vertical velocity and Y position every frame. Jump and read the peak height from the console. Run, jump, and read the maximum horizontal distance traveled before landing.

Deliverables: - The two measured numbers in tile units - A screenshot of your debug output - A one-paragraph reflection: how close was your estimate to reality? Why did you over- or under-estimate?

📝 Note: This number is your fundamental constant. Write it on a sticky note and put it on your monitor. Every gap you ever design will reference it.

Exercise 17.2 — Coyote Time A/B Test

Type: Implementation + Playtest Time: 60 minutes

Take your platformer prototype and create two builds: one with coyote time disabled (set coyote_time = 0.0) and one with coyote time at 0.1 seconds (about 6 frames at 60 FPS).

Recruit 2-3 playtesters. Have each one play a section of your level on Build A, then Build B (alternate the order between testers to avoid bias). Don't tell them what's different.

Ask: - Which build felt more responsive? - Which build felt fairer? - Did either build feel "wrong" or "off"? - Could they articulate a specific moment that felt different?

Most testers will prefer Build B without being able to say why. Some experienced platformer players may notice "input grace" specifically.

Deliverables: - A short report (one page) of playtester reactions - Your conclusion: what coyote time value will you ship with, and why?

Exercise 17.3 — Build a 3-Screen Tilemap Level

Type: Implementation (Godot) Time: 2-3 hours

Build the Section A / B / C structure described in the chapter's progressive project. Use the tilemap setup script as your starting point.

Constraints: - Three screens of content (where one screen = the visible area at default zoom) - Section A: introduce walking and one jump - Section B: introduce three gaps and one enemy - Section C: introduce a vertical element (one-way platforms or a climbable wall)

Deliverables: - The Godot scene file (level1.tscn) - A screenshot showing the entire level - A 30-second video of you completing the level

Exercise 17.4 — Implement Camera2DController With Room Boundaries

Type: Implementation (Godot) Time: 90 minutes

Take the Camera2DController.gd from the chapter and integrate it with your Level 1. Configure it for your player. Then add three Area2D "room boundary" nodes that, on entry, update room_min and room_max to constrain the camera to the current room.

Test the transitions. Are they smooth? Jarring? Tune the lerp speed (follow_speed) and the lookahead.

Deliverables: - The updated camera script (with any modifications you made) - Your scene file showing the room boundary nodes - Tuning notes: what values did you settle on for follow_speed, lookahead_distance, and lookahead_smoothing? Why?

Exercise 17.5 — Analyze Celeste's First Chapter

Type: Analysis Time: 90 minutes

Play (or replay, or watch a longplay of) Celeste Chapter 1: "Forsaken City." Take notes on each screen.

For each of the first 15 screens, document: - What new mechanic or twist (if any) is introduced? - How is it introduced (in safe context, or under pressure)? - Is it tested (required to progress)? - Is it twisted (combined with another mechanic)? - Is it mastered (required under pressure or with multiple complications)?

You will find that nearly every screen does at least one of these things — and the ITTM cycle for each mechanic plays out across multiple screens, sometimes spanning the whole chapter.

Deliverables: - A table of 15 screens × ITTM categorization - A short analysis (one page): which mechanics get the full ITTM cycle in Chapter 1? Which get cut short?

Exercise 17.6 — Sketch a Metroidvania Map

Type: Pencil-and-paper sketch Time: 60-90 minutes

Design (on paper or digitally) a small Metroidvania map: 12-16 interconnected rooms. Mark: - Starting room - 2 ability-gated locks (e.g., requires double jump, requires wall climb) - 1 boss room - 3 collectible rooms (optional but rewarding) - 2 save points

The constraint: the player must be unable to reach the boss without first finding both abilities. Design a critical path that wanders, doubles back, and eventually unlocks the boss arena.

Deliverables: - The hand-drawn or digital map - A one-paragraph "designer's commentary" explaining the intended player journey: which room first, what they discover, what they backtrack to, where they get stuck and what unsticks them

Exercise 17.7 — Place Enemies for Pacing

Type: Implementation (Godot) + Reflection Time: 60 minutes

Take your Level 1 from Exercise 17.3. Currently it has a few enemies you placed in Section B. Now intentionally redesign enemy placement to create a specific pacing curve:

  • Section A: 0 enemies (calm, learning)
  • Section B: 2 enemies, both at jump landing points (tension at decisions)
  • Section C: 4 enemies, with 2 placed at vertical climb pinch points (peak intensity)

Walk through the level. Does the pacing escalate? Does Section A still feel useful as warmup? Does Section C feel climactic?

Deliverables: - Updated scene file - A short pacing chart (X = level position, Y = perceived intensity 1-10) showing the intended emotional curve

Exercise 17.8 — Apply Variable Gravity for Apex Hang

Type: Implementation (Godot) Time: 45 minutes

If your character controller doesn't yet have variable gravity (rise/apex/fall phases), implement it now. Use the code pattern from the chapter:

  • Rising velocity (going up): normal gravity
  • Near apex (slow upward velocity): reduced gravity (multiplier ~0.5-0.6)
  • Falling: increased gravity (multiplier ~1.5-2.0)

Test by jumping. Does the apex feel "right"? Compare to Mario or Celeste — does your character hang at the top?

Deliverables: - The updated character controller - A reflection: which multipliers did you settle on? How would they differ for a "floaty" game vs. a "snappy" game?

Exercise 17.9 — Design a Single-Screen Puzzle (VVVVVV-Style)

Type: Implementation or Sketch Time: 60 minutes

Design a single-screen room that: - Fits entirely on one screen (no scrolling) - Has one mechanical idea (e.g., a moving spike, a gravity flip, a one-way bounce pad) - Can be solved in under 30 seconds when you know the solution - Takes 5-10 attempts when you don't

If you have time, build it in Godot. Otherwise, sketch it on graph paper with annotations explaining the intended player journey.

Deliverables: - The room (built or sketched) - A name for the room (in the VVVVVV tradition — give it a personality) - A paragraph explaining the intended "aha" moment

Exercise 17.10 — Procedural vs. Hand-Built Comparison

Type: Analysis Time: 60 minutes

Play 30 minutes of Spelunky 2 (procedural). Then play 30 minutes of Celeste (hand-built). Both are precision platformers. Both have death-and-restart loops.

Compare: - Memorability of specific moments (which game has more "I remember THAT moment"?) - Re-experience (when you replay, are you replaying the same level or a new one?) - Surprise (which game surprises you more often after 10 hours?) - Difficulty curves (does difficulty escalate consistently in either?)

Deliverables: - A two-column comparison table - Your conclusion: for your own game, would you choose hand-built, procedural, or hybrid? Why?

Exercise 17.11 — Implement Parallax Scrolling

Type: Implementation (Godot) Time: 60 minutes

Add three parallax layers to your Level 1: a far background (motion_scale 0.1), a mid background (motion_scale 0.5), and a near foreground accent (motion_scale 0.95). Use any art you have, even simple shapes.

Walk through the level. Do you feel depth? Adjust the motion scales until the depth illusion is strongest.

Deliverables: - The Godot scene with parallax configured - A short note: which layer was most important to selling depth? Which felt redundant?

Exercise 17.12 — Capstone: Iterate Level 1 Based on Playtest Feedback

Type: Implementation + Playtest Time: 2-3 hours

Recruit 3 playtesters. Have them play Level 1. Watch them silently — do not intervene unless they get truly stuck. Take notes on:

  • Where did they pause to think?
  • Where did they die or fail?
  • Where did they smile, lean in, or react?
  • Where did they look bored?

After all 3 testers, compile feedback. Identify the top 3 problem areas. Redesign those areas in Godot. Have one of the testers play again.

Deliverables: - Original playtest notes (3 sessions × notes) - A list of the 3 problems you identified - The updated level - A reflection on whether the iteration improved the experience

🪞 Learning Check-In: This exercise simulates the actual development loop. Real games iterate dozens of times. The skill is not "design well the first time" — it is "see the problems clearly and respond with empathy for the player."