Designing 3 Levels on Paper — the multi-level platformer design doc

Learning Goals 3 min

By the end of this lesson you will be able to:

1. Sketch a level layout on paper for each of three platformer levels, marking platform shapes, coin positions, enemy patrol paths, and the goal location.
2. Pick a theme (forest, cave, sky, beach, kampung) for each level and list the matching backdrop, music, and enemy types it implies.
3. Write a single shared variables list and backdrop list that covers all three levels, before opening Scratch even once.

Warm-Up — predict the rebuild 7 min

Back in L03-45 you planned a one-level game on paper. Worked beautifully. So in L04-01 Zara decided to skip planning for her multi-level project — she figured, "I already know how to make levels, I'll just code the first one and copy it for the rest."

Two weeks later her project looks like this:

• Level 1 has a Coin sprite, a Slime enemy, and a green Goal flag.
• Level 2 has a Coin sprite, a Bat enemy (different from Slime), and a yellow Goal flag.
• Level 3 has a Coin sprite (renamed Gem halfway through), a Bat and a Boss, and the goal is "reach x > 220".

Three goal mechanisms. Two coin sprite names. Random enemy assortment. Predict: how many separate "you won this level" scripts is Zara now maintaining, and what happens when she wants to add a Level 4?

Today is meta-week. No new blocks. Just a method. The method is the difference between a 3-level game that ships and one that ships at level 1.5.

New Concept — the 3-level design doc 15 min

One A4 sheet split into four panels. Top-left, top-right, and bottom-left are the three levels. Bottom-right is the shared sheet — variables, broadcasts, and the backdrop list that covers all three.

The per-level panel

Each level panel contains five fixed items. Same five items, every level. If a level is missing one, that's a hole — fill it before moving on.

1. Theme + name. One word ("Forest"), one short title ("The Kuala Selangor Trail").
2. Layout sketch. A small rectangle the shape of the Stage. Draw the platforms as horizontal lines, sloped where they slope. This is the world the player walks on.
3. Coin positions. Mark each coin as a small circle. Aim for 5 to 8 per level — enough to make collecting feel meaningful, few enough to fit on the screen at once.
4. Enemy patrol paths. Draw each enemy as a square and an arrow showing the patrol direction and distance. Label the enemy type ("Slime", "Bat").
5. Goal location. A single big star where the level-end trigger sits. Could be a door, a flag, a doorway in the wall.

The shared panel

The fourth panel lists what is the same across all three levels. This is the spine of the project — it must be decided once and never contradicted.

• Variables list. Usually four: level (1, 2, or 3 — drives everything), score (total coins all levels), lives (3 to start), coins-left (decrements as the level's coins are collected; reaching 0 unlocks the goal).
• Backdrop list. Three backdrops, named after the themes: forest, cave, sky. Plus optional title, game-over, victory. Six total.
• Broadcasts list. The shared signals: start-level, level-up, coin-collected, player-hit, game-over. Five broadcasts cover the whole game.
• Sprite roster. Player, Coin (clones), Enemy (clones with costumes per type), Goal, plus the optional title/end screens. The same Coin sprite is reused on every level — clones spawn at the positions you marked on each layout.

The shared rule: levels are data, not code

The whole reason this method works is that you spend the planning time finding what's the same. The differences (where the platforms are, which enemy patrols where) become per-level data — set by the (level) variable inside each sprite. The shared logic — collecting, dying, advancing — is written once.

If your three panels look totally different from each other (different sprite names, different goal triggers, different variable purposes), you have three games, not three levels of one game. Pull them back into the shared panel.

Worked Example — planning "Kampung Quest" 20 min

We'll plan a three-level platformer set in a Malaysian kampung. The player is a kid named Adi who has lost his cat. He searches forest, then cave, then up into the sky on a kite. Each level: find coins (chicken-feed bags), avoid enemies, reach the cat-shaped goal.

Shared panel — fill this in first

Pitch: "Adi runs, jumps and collects feed-bags across three levels — forest, cave, sky — to find his cat. Touching an enemy costs a life; three lives down means game over."

Variables list:

• level — current level number (1, 2, 3) — starts at 1 on flag.
• score — total feed-bags collected across the game — starts at 0.
• lives — misses remaining — starts at 3.
• coins-left — feed-bags still on this level — set to 5/6/7 at the start of each level.

Backdrop list: title, forest, cave, sky, victory, game-over. Six backdrops; backdrop name == theme name where it matches the level.

Broadcasts list:

• start-game — Stage on flag — every sprite (reset).
• start-level — Stage when level changes — Coin spawner, Enemy spawner, Player (reposition).
• coin-collected — Coin clone on player touch — Score (+1) and coins-left (−1).
• player-hit — Enemy clone on player touch — Lives (−1), Player (knockback).
• level-up — Player on goal touch (only when coins-left = 0) — Stage (next backdrop), level (+1).

Sprite roster:

• Adi — player. One sprite, one set of scripts, present on every level.
• Coin — feed-bag clones. Spawns 5/6/7 clones depending on level, at positions from the layout sketch.
• Enemy — patrolling clones. Different costume per level (boar in forest, bat in cave, hawk in sky), same patrol script.
• Goal — the cat-shaped end-of-level marker. Hidden until coins-left = 0.

Level 1 panel — Forest (the tutorial level)

• Theme: Forest. Daytime, green platforms, soft canopy backdrop.
• Layout: Three platforms in a staircase from bottom-left to top-right. Wide ground floor. No tricky jumps.
• Coins (5): One on each platform, plus two on the ground. Player can collect all five with simple left-to-right walking and three jumps.
• Enemies (1): One boar patrolling the bottom floor left-to-right, distance ~150 px. Easy to time a jump over.
• Goal: Cat sprite on the top-right platform. Player has to climb the staircase, which forces them through all five coins on the way.

Design rule: Level 1 teaches the controls. No surprises, no traps, no tricky jumps. The player should reach the cat on their first or second try.

Level 2 panel — Cave (the challenge level)

• Theme: Cave. Dim, brown rock platforms, dripping stalactites in the backdrop.
• Layout: Floating platforms with bigger gaps. A dead-drop pit in the middle that costs a life if touched.
• Coins (6): Three on a "safe" left path, three on a "risky" right path with bigger jumps. Player chooses.
• Enemies (2): Two bats. One patrols a high platform horizontally; one patrols vertically in a narrow shaft, blocking a coin.
• Goal: Cat sprite at the bottom-right, past the vertical bat shaft. Forces the player to time the vertical bat.

Design rule: Level 2 introduces challenge. Gaps you can fall through. Enemies in inconvenient places. Two paths so skilled players can show off and cautious players can survive.

Level 3 panel — Sky (the finale)

• Theme: Sky. Bright blue, white cloud platforms, sun in the backdrop. Adi is on a kite.
• Layout: Cloud platforms that drift slowly. Some are small (you'll need to be precise). One huge cloud at the top.
• Coins (7): Spread vertically — bottom cloud has 2, middle has 3, top has 2. Player must climb cloud-by-cloud.
• Enemies (3): Three hawks. One per cloud level, all patrolling horizontally with different speeds (slow, medium, fast).
• Goal: Cat sprite on the highest cloud, top-centre. The cat is sitting on the very last platform — climactic, framed against the sun.

Design rule: Level 3 is the finale. Every mechanic from Levels 1 and 2 is needed, plus one new wrinkle (drifting platforms). The goal is visually obvious from the start of the level so the player feels the climb.

From plan to code — a glimpse

You are not coding today. But the magic of having all three plans done is that the per-level setup script writes itself. Here's roughly what each spawner looks like once you do start building (next lesson):

when I receive (start-level v)
delete this clone
if <(level) = (1)> then
  set [coins-left v] to (5)
  switch backdrop to (forest v)
end
if <(level) = (2)> then
  set [coins-left v] to (6)
  switch backdrop to (cave v)
end
if <(level) = (3)> then
  set [coins-left v] to (7)
  switch backdrop to (sky v)
end
        

What you just did: turned a vague "I want a 3-level platformer" into a complete, buildable spec on one sheet of A4. Every sprite is named. Every variable has a starting value. Every level has a layout, coins, enemies, and a goal. When you open Scratch next lesson, you won't be designing — you'll be transcribing.

Try It Yourself — three planning drills 12 min

Mini-Challenge — "Mei Lin's mismatched levels" 5 min

Three levels that don't talk to each other

Mei Lin shows you her plan. It looks beautiful — every panel is full, every level has coins and enemies and a goal. But when you read it carefully, something is off:

• Level 1 — Forest: Player is Kitty, collects fish, avoids dog, goal is to reach x > 200.
• Level 2 — Castle: Player is Knight, collects coins, avoids spider, goal is to touch the door sprite.
• Level 3 — Space: Player is Astronaut, collects stars, avoids alien, goal is to collect all stars (no goal sprite).

Mei Lin says, "I have three full levels — I'm ready to build!" What's wrong, and what should she fix before she opens Scratch?

Recap 3 min

You designed a three-level platformer on a single sheet of paper. Each level got a panel: theme, layout sketch, coins, enemies, goal. A fourth panel listed what every level shares: a level variable, a score, lives, coins-left, three to six backdrops, a small set of broadcasts, and one player + one coin sprite + one enemy sprite + one goal sprite. Themes vary; machinery doesn't. When you start building next lesson, you'll find that almost every script is already written in your head — the plan turns into code with one-line changes per level. Most importantly, you spotted invisible problems (mismatched goal mechanisms, runaway sprite counts) in the cheapest medium there is: pencil on paper.

Design doc

A short written-and-sketched plan that describes a game before it's built. For a multi-level project, the design doc is one sheet with one panel per level plus a shared panel.

Per-level data

Numbers, positions, and costume names that change between levels — driven by the level variable in your code. Coin counts, enemy types, backdrop names are all per-level data.

Shared logic

The scripts that run identically on every level — player movement, collect-a-coin, lose-a-life, level-up. Shared logic is written once; per-level data feeds it.

Theme

The visual flavour of a level — forest, cave, sky, kampung. Theme drives backdrop choice, costume choice, and music choice. Themes vary to keep the player engaged; mechanics stay constant to keep the game buildable.

Difficulty curve

The graph of how hard the game gets over time. Good curves climb steadily with a small dip before the finale; bad curves spike or flatline. Designers sketch this before coding.

Sprite roster

The complete list of sprites your game needs. For a 3-level platformer, the roster is usually under 6 sprites — most variety comes from costumes, not new sprites.

Homework 2 min

The 3-Level Design Doc. Plan your own three-level platformer on one sheet of A4. No Scratch. Pencil only.

1. Divide your A4 into four panels: top-left Level 1, top-right Level 2, bottom-left Level 3, bottom-right Shared.
2. Fill the shared panel first: pitch, variables list, backdrop list, broadcasts list, sprite roster. Lock these down before drawing levels.
3. For each level, sketch the layout, mark 5–8 coins, draw 1–3 enemies with patrol arrows, and place the goal. Write the theme name on top.
4. Photograph the sheet (or scan it) for next lesson — we'll start building from this exact plan.

Bring back next class:

• The paper plan itself (or a clear photo).
• Your one-sentence pitch.
• Your answer to: "Which two levels are most different from each other in theme, and most similar in mechanics? Why is that a good thing?"

Heads up for next class: SCR-L04-18 introduces the (level) variable — the single number that drives which level the player is on. Every sprite reads it; one block changes it; the whole world reshapes around it. Bring your design doc — we'll wire it up.