Tilt Game Design

Overview

Students build and refine a simple “tilt-to-move” game using a micro:bit accelerometer. They connect real-world motion to positive and negative values and use coordinate thinking to understand direction and zero.

Learning intentions

• Students will use positive and negative numbers to describe tilt direction and explain what 0 means in the game context.
• Students will interpret and create ordered pairs that represent locations/actions in a simple coordinate plane view of game movement.
• Students will explain how changing signs affects where a point lands (reflection across axes).
• Students will troubleshoot so their game is playable and responds reliably to tilting.

Success criteria

• I can describe my game controls using positive/negative numbers (e.g., “tilting right gives positive X, tilting left gives negative X”).
• I can explain what 0 means in my game (e.g., “when the micro:bit is level, X or Y is 0 and the sprite stops drifting”).
• I can use ordered pairs to describe my game’s movement and direction.
• My game is playable and reliably responds to tilting.

Curriculum links

• The Number System — understand positive and negative numbers together and explain the meaning of 0 in real-world contexts.
• The Number System — signs of numbers in ordered pairs indicate locations in quadrants and are related by reflections across axes.
• The Number System — graph points in all four quadrants of the coordinate plane using coordinates.
• The Number System — interpret inequalities as relative position on a number line (used for thresholds like “tilt beyond this value”).

Lesson structure (45 minutes)

1. 0–5 min · Hook + problem question. Teacher demonstrates a prototype: tilting the micro:bit moves a dot or sprite; “level” keeps it still. Students quickly answer: “What numbers could represent left vs right, and what number represents level?”

2. 5–12 min · Mini-lesson: sign + zero in a tilt context. Teacher shows a simple table on the board: Tilt left / Level / Tilt right with example values (negative / 0 / positive). Students copy one sentence starter: “When I tilt ___, my sensor value is ___, and 0 means ___.”

3. 12–18 min · Coordinate reflection quick demo. Teacher draws a small coordinate plane on the board and places points like (2, 1) and (-2, 1), pointing out that only the sign of x changed. Students do a 30-second think: “What changes when x changes sign? Where does the point move?”

4. 18–30 min · Build: Creating a tilt game loop. Teacher models the game plan:

• Use accelerometer readings to change a sprite’s position.
• Define a “dead zone” around 0 so small jitters don’t move the sprite. Students work in pairs to implement:
• Choose one axis for movement (X or Y) and map it to screen movement.
• Add threshold logic so motion only happens when values pass a limit (inequalities like “if tilt > threshold, move right”).
• Test repeatedly while physically tilting and leveling the micro:bit.

5. 30–37 min · Playtest + evidence check. Teacher circulates with a checklist: “Is it playable? Does tilting change the action? What happens at level?” Students swap devices with another pair and run their game for 30–45 seconds each, noting one claim they can prove with observations (for example, “at level it stays still because value is 0”).

6. 37–44 min · Reflection: ordered pairs for movement direction. Teacher provides two sample ordered pairs for students to interpret (one with both positives, one with a negative x or y). Students write two short explanations in their notebooks:

• “Point A is in quadrant __ because the signs are __.”
• “Point B is a reflection of Point A across the __ axis because the sign changed.”

7. 44–45 min · Exit ticket. Students answer on a half-page:

• “In my tilt game, tilting left corresponds to ___ and tilting right corresponds to ___.”
• “My dead zone uses 0; when the micro:bit is level, the value is ___ and the sprite does ___.”

Resources

• micro:bit devices (one per student or pair)
• micro:bit batteries or power supplies
• computers with the micro:bit coding environment installed
• printed coordinate plane handout (small quadrant diagram)
• printed “tilt values vs directions” worksheet
• pairing roles cards (Coder / Tester)
• student notebooks or graph paper
• small display area for whole-class demonstration
• optional: accelerometer readout blocks view for debugging

Assessment

• Teacher observation during build: students correctly use thresholds and can describe why 0 matters.
• Playtest evidence notes: students can state whether the game responds to tilting and what level does.
• Exit ticket checks: accurate positive/negative mapping and correct explanation of 0 behavior.
• Notebook reflection: ordered pair quadrant explanation using signs.

Differentiation

• Support: Provide sentence starters for explanations (“If the value is negative, the sprite moves ___.” “0 means the micro:bit is level, so ___.”) and a word bank (left/right, up/down, negative/positive, quadrant).
• Support: Give a “dead zone” template (students fill in axis choice and threshold number).
• Extension (within today’s lesson): Challenge students to use both x and y (diagonal movement) and explain reflections if one sign changes.
• EAL/SEN: Offer visuals—arrow diagrams linked to sign and quadrant; allow students to write brief answers or draw the coordinate plane responses.
• Technical pacing: If some pairs finish early, assign them as “debug partners” to check another group’s threshold and dead zone settings.