Level 3 Recap & Vocabulary — the closing lesson

Learning Goals 3 min

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

1. Name all eight clusters of Level 3 and give the single highest-leverage idea from each — operators, lists, my blocks, clones, state machines, top-down maze, scrolling platformer, and build & polish.
2. Define 18 vocabulary terms drawn from across Level 3 without peeking at notes — the L3 cold-memory list you'll be tested on in the assessment.
3. Read the L3 cert-style mini-challenge stack and identify which cluster each section belongs to, so you can see Level 3 working as one connected toolbox instead of 48 separate lessons.

Warm-Up — quick-fire without re-reading 7 min

The L3 assessment is next class. Today you stop looking things up and start knowing them. Here are three puzzles. Predict the answer in your head without scrolling back through your notes. Then peek.

Puzzle 1 — the list

when flag clicked
delete all of [scores v]
add (10) to [scores v]
add (20) to [scores v]
add (30) to [scores v]
say (item (2) of [scores v]) for (2) seconds
        

Puzzle 2 — the my-block

when flag clicked
draw star (5) (50)

define draw star (points) (size)
pen down
repeat (points)
  move (size) steps
  turn cw ((360) / (points)) degrees
end
pen up
        

Puzzle 3 — the state machine

when flag clicked
set [state v] to [title]

when [s v] key pressed
if <(state) = [title]> then
  set [state v] to [play]
end

when flag clicked
forever
  if <(state) = [play]> then
    change x by (5)
  end
end
        

Three puzzles, three different clusters. If you got all three without notes — you're ready for the assessment. If not, the cluster you missed is the one to revise tonight.

New Concept — the eight clusters of Level 3 15 min

Level 3 had 48 lessons. Like L2, nobody remembers 48 separate things. The lessons clumped into eight clusters, each one teaching a single big idea. Today's job is to name them, link them, and see the level as one map instead of a long list.

The eight L3 clusters at a glance

How the clusters chain together

The clusters aren't independent. Each one uses the ones before it. A scrolling platformer (G) needs clones (D) for collectibles, my blocks (C) for the jump recipe, and a state machine (E) for the pause menu. The maze (F) needs operators (A) for grid math, lists (B) for tracking visited squares, and clones (D) for enemies.

The big picture: L1 taught blocks. L2 taught patterns. L3 taught how to combine patterns into a real game. Every cluster is a tool. The skill is picking the right tool from the right cluster for the job in front of you.

One question per cluster — answer without notes

1. A: What does (7) mod (3) report? (1 — the remainder after dividing.)
2. B: What's the first index in a Scratch list — 0 or 1? (1.)
3. C: Where does the define ( ) hat go — on every sprite, or just the one that calls it? (Just the sprite that calls it. My blocks are per-sprite.)
4. D: The when I start as a clone hat — when does it fire? (Every time a clone is created. The original sprite does not run it.)
5. E: What does a gated game script look like? (A forever with an if <(state) = [play]> then wrapping the actual action blocks.)
6. F: What block reads a single pixel colour at the sprite's position? (touching color [...] ? — used to detect walls drawn in the backdrop.)
7. G: In a scroll, who moves — the player or the background? (The background. The player stays roughly centred on the Stage; the world slides under them.)
8. H: The first debugging tool you should reach for? (The on-Stage variable watcher, in large mode.)

What you can build now

This is your L3 capability card. Anything from this list, you can build from scratch in under an hour:

• A catch-the-falling-objects game with a score, lives, title screen, pause menu, and game over screen.
• A top-down maze where the player navigates from start to goal, with wall collision and a treasure list.
• A side-scrolling platformer with gravity, jumping, a moving background, and collectible coins.
• A drawing tool with custom brush-shape my blocks (stars, polygons, spirals) and a saved list of designs.
• A simple quiz game that reads questions and answers from two parallel lists.

Worked Example — the L3 cert-style mini-challenge 12 min

Below is a project that touches four clusters at once. Read it top to bottom and, after each script, name which cluster it belongs to. This is the kind of multi-cluster reading the L3 assessment expects.

Step 1 — the setup

Project: "Random Kuih Catcher". Three sprites — a Basket, a Kuih, and a Score sprite. Two variables — state and score. One list — high-scores.

Step 2 — the title-screen state machine (cluster E)

when flag clicked
set [state v] to [title]

when [s v] key pressed
if <(state) = [title]> then
  set [state v] to [play]
  set [score v] to (0)
end
        

Cluster E — game state machines. The state variable holds the title/play/game-over value; every other script gates on it.

Step 3 — the kuih spawner with clones (cluster D)

when flag clicked
hide
forever
  if <(state) = [play]> then
    create clone of [myself v]
    wait (1) seconds
  end
end
        

Cluster D — cloning, nested inside cluster E gating. Two clusters working together in eight blocks.

Step 4 — the kuih's fall recipe as a my-block (cluster C)

when I start as a clone
show
go to x: (pick random (-200) to (200)) y: (180)
fall and check

define fall and check
repeat until <<touching [Basket v] ?> or <(y position) < (-170)>>
  change y by (-5)
end
if <touching [Basket v] ?> then
  change [score v] by (1)
end
delete this clone
        

Cluster C — my blocks. Naming a chunk of logic fall and check makes the clone script readable. Anyone reading it can tell what the clone does without reading the recipe.

Step 5 — the high-score list (cluster B)

when [g v] key pressed
if <(state) = [play]> then
  add (score) to [high-scores v]
  set [state v] to [game over]
end
        

Cluster B — lists. Combined with cluster E gating again. Every run of the game appends one score to the persistent list.

Step 6 — read the list with operators (cluster A)

when [h v] key pressed
say (join [Last score: ] (item (length of [high-scores v]) of [high-scores v])) for (3) seconds
        

Cluster A — operators, meeting cluster B — lists. The length of [list v] reporter is the index of the most recent entry, because lists are 1-indexed.

Step 7 — recognise the pattern

One small project, four clusters visible in under 25 blocks: E (state machine), D (clones), C (my blocks), B (lists), and operators (A) along the way. This is what an L3 project looks like. Not one feature, not one cluster — several clusters cooperating in a single design.

Step 8 — the full assembled mini-game

when flag clicked
set [state v] to [title]
hide
forever
  if <(state) = [play]> then
    create clone of [myself v]
    wait (1) seconds
  end
end

when I start as a clone
show
go to x: (pick random (-200) to (200)) y: (180)
fall and check

define fall and check
repeat until <<touching [Basket v] ?> or <(y position) < (-170)>>
  change y by (-5)
end
if <touching [Basket v] ?> then
  change [score v] by (1)
end
delete this clone
        

What you just proved: you can read a multi-cluster L3 project and name where each piece comes from. That's the assessment skill. Reading first, then writing.

Try It Yourself — fill in your own L3 credentials card 15 min

Three difficulty tiers. Pick the one that matches your honest confidence. (No marks for picking the hardest one and freezing.)

when flag clicked
delete all of [hits v]
set [state v] to [play]

when [space v] key pressed
if <(state) = [play]> then
  add (timer) to [hits v]
end
          

when flag clicked
set [state v] to [play]
delete all of [spawn-x v]

when I start as a clone
go to x: (item (1) of [spawn-x v]) y: (180)
fall

define fall
repeat until <(y position) < (-180)>
  if <(state) = [play]> then
    change y by (-4)
  end
end
delete this clone
          

Mini-Challenge — "Which cluster is this?" 5 min

Aisyah's mystery stack

Aisyah hands you this stack and says, "Tell me which L3 clusters I used." Read it cold.

when flag clicked
set [count v] to (0)
delete all of [names v]
add [Aisha] to [names v]
add [Daniel] to [names v]
add [Priya] to [names v]

forever
  if <(count) > ((length of [names v]) - (1))> then
    stop [this script v]
  end
  greet (item ((count) + (1)) of [names v])
  change [count v] by (1)
  wait (1) seconds
end

define greet (name)
say (join [Hello, ] (name)) for (1) seconds
        

List the L3 clusters in play. Bonus: explain why she used ((count) + (1)) instead of just (count) as the list index.

Recap 3 min

This is the end of Level 3. You walked through all eight clusters — operators (A), lists (B), my blocks (C), cloning (D), state machines (E), top-down maze (F), scrolling platformer (G), and build & polish (H). Each cluster is a single big idea with a signature block. Real L3 projects always combine several clusters at once — the assessment will too. The 18 terms below are the cold-memory vocabulary list for the level: if you can define each one without looking, you're ready.

Modulo (mod)

The () mod () operator. Reports the remainder after division. 7 mod 3 = 1. Used for "every Nth step" patterns. (Cluster A.)

Round / floor / abs

Three options inside the [round v] of () dropdown. Round snaps to nearest integer, floor always rounds down, abs strips the sign. (Cluster A.)

List

A named variable that holds many values in order. Made in the Variables palette via "Make a List". (Cluster B.)

1-indexed

The first item in a Scratch list is item 1, not item 0. Different from most other programming languages. (Cluster B.)

item ( ) of [list v]

The list reader. Returns the value at the given index. item 1 of [scores] is the first score. (Cluster B.)

length of [list v]

Reports how many items are currently in the list. Useful as the last index, or as a loop count. (Cluster B.)

My block

A custom block you make in the My Blocks palette. Defined once with define, called by name from anywhere on the same sprite. (Cluster C.)

Parameter / input

A value you pass into a my-block. Defined as a "number or text" or "boolean" slot. (Cluster C.)

Run without screen refresh

A checkbox on the my-block definition that makes the entire recipe run in one frame — used for instant drawing without animation. (Cluster C.)

Clone

A live copy of a sprite, made with create clone of [myself v]. Each clone runs its own copy of any when I start as a clone script. (Cluster D.)

when I start as a clone

The hat that fires once per clone, never on the original. The most important block in the cloning cluster. (Cluster D.)

delete this clone

Removes a clone permanently. Forgetting this is the #1 cause of L3 lag. (Cluster D.)

State machine

A pattern where one state variable holds one of several named values (title, play, paused, game over) and every game script gates on it. (Cluster E.)

Gated script

A script wrapped in if <(state) = [...]> then inside a forever loop. Only does work when the state matches. (Cluster E.)

touching color

Sensing block that returns true when the sprite overlaps a specific pixel colour. The basis of maze-wall collision. (Cluster F.)

Gravity / velocity-y

A variable that holds vertical speed. Decreased by 1 every frame to fall, set to a positive number to jump. The heart of the platformer. (Cluster G.)

Scrolling background

A backdrop that moves while the player stays roughly centred on the Stage. The player feels like they're moving but really the world slides past them. (Cluster G.)

Divide and conquer

A debugging technique: drag half a stack aside, run, and use whether the bug remains to halve the search space. The bug is found in log-2-of-N steps. (Cluster H.)

Homework — prepare for the L3 assessment 2 min

The Cluster Re-Play. No new building this week. Your homework is re-opening old work.

1. For each of the eight clusters, open your favourite project from that cluster — the one you remember most fondly, or the one that took the most effort.
2. Hit the flag. Play it for at least one minute.
3. Write one sentence per project: "This project lives in cluster X because it uses the signature pattern Y." Eight sentences total.
4. For any cluster where you can't find a project of yours, replay one of the worked-example demos from the lesson notes instead.
5. Re-read the 18 vocabulary terms above. Cover the definitions with your hand. Try to say each one out loud.

Bring back next class:

• Your eight sentences (paper or digital — your choice).
• Your answer to: "Which cluster do you feel weakest in?" — so the assessment can be paced to give you the most help where you need it.
• A clear head. The L3 assessment is built from the eight clusters above, in cert-style multi-cluster combinations like today's worked example. Nothing on it will be new.

Heads up for next class: SCR-L03 Assessment. 90 minutes. Three sections — a reading section (predict-before-click on three multi-cluster stacks), a debug section (find the bug in a sabotaged project using the five tools from L03-46), and a build section (a small cert-style project combining at least three clusters, just like today's stretch task). Bring everything you've built across L3 — you may reference your own projects during the build section. Selamat berjaya!