The question or thesis
This route turns the wiki from a reference collection into a practice sequence. It is designed for students who need to learn by doing: read a small page, build or explain something, check the answer, then move to a slightly larger task.
The learning-science reason is simple. Retrieval practice, spaced review and varied problem types build stronger memory than rereading alone. The wiki now has enough practice tasks, self-tests and answer keys to support that pattern across programming, Unity, 3D, production and business topics (Brown, Roediger and McDaniel, Make It Stick, see source-make-it-stick).
How to use this route
For each stage:
- Read the linked page only far enough to attempt the practice task.
- Do the task in Unity, C#, Blender, a document or a notebook.
- Answer the self-test without looking.
- Check the answer key.
- Save one artefact: screenshot, script, table, pitch paragraph, diagram or commit.
- Write one sentence about what you would change next.
The artefact matters. A finished tiny thing is better evidence of learning than a large page half-read.
Practice route
Stage 1: C# thinking
Goal: trace code before writing larger scripts.
Use:
Do:
- trace an
if,whileandforexample by hand - build a tiny inventory using
List<T> - explain when a dictionary is better than a list
Exit signal:
- you can predict the output of a short C# snippet before running it
Stage 2: Unity lifecycle and input
Goal: understand when code runs and how player action enters the game.
Use:
Do:
- make one object move from input
- separate input reading from movement
- explain why frame-rate independence matters
Exit signal:
- you can say which code belongs in
Start(),Update()andFixedUpdate()
Stage 3: Collision, triggers and communication
Goal: make small game objects talk to each other without turning one script into the whole game.
Use:
- unity-collider2d-and-triggers
- unity-object-communication
- unity-getcomponent
- unity-gamemanager-pattern
Do:
- make three collectibles disappear on trigger
- update score through a manager or UI script
- debug one trigger that does not fire
Exit signal:
- you can explain which object owns the event, which object receives it and which object stores the state
Stage 4: Code walkthroughs and creative systems
Goal: read an existing example, change one parameter safely and explain the behaviour change.
Use:
- overview-unity-nature-of-code-examples
- cellular-automata
- steering-behaviours
- particle-systems-design
- genetic-algorithms
Do:
- run one simulation scene
- change one safe variable such as grid size, steering force, spawn rate or mutation rate
- describe the visible result in plain English
Exit signal:
- you can connect a visible behaviour to the rule or parameter that produced it
Stage 5: Beginner 3D scene building
Goal: build a playable 3D space before trying to make final art.
Use:
- overview-beginner-3d-game-development-route
- 3d-blocking-and-greyboxing
- unity-3d-import-pipeline
- 3d-materials-and-uvs
- unity-lighting-for-3d-scenes
Do:
- greybox one room
- import one Blender prop
- add one material and one guiding light
- test the scene from the game camera
Exit signal:
- a new player can understand the goal within 10 seconds
Stage 6: Production and business judgement
Goal: explain whether a project is feasible, communicable and worth continuing.
Use:
- business-model-canvas-for-games
- game-design-documentation
- game-industry-realities
- publishing-and-funding
- game-marketing-fundamentals
- investment-pitches-for-games
Do:
- fill one Business Model Canvas for a small student game
- calculate a break-even point
- write a pitch goal for one audience
- score the project with the funding readiness rubric
- draft a store-page pitch check
Exit signal:
- you can distinguish “I like this idea” from “this project has evidence”
Weekly study pattern
Use this pattern for a 6-week independent catch-up block:
| Week | Focus | Output |
|---|---|---|
| 1 | C# basics | traced code and one collection exercise |
| 2 | Unity lifecycle and input | moving object with short explanation |
| 3 | triggers and object communication | collectible loop with score update |
| 4 | code walkthrough | changed simulation with before and after notes |
| 5 | 3D room | greybox, imported prop and lighting check |
| 6 | production judgement | canvas, pitch paragraph and break-even calculation |
What the evidence suggests
CRE132 lab material supports the route’s early focus on C#, Unity scripting, physics, prefabs, animation, audio and particles as practical skill-building rather than abstract reading (CRE132 Labs, see source-cre132-labs).
Miles’ C# material supports putting types, control flow, methods, classes and collections before larger Unity architecture. Students need the language machinery before they can reason about Unity scripts confidently (Miles, C# Yellow Book, see source-csharp-yellow-book).
Unity’s official pathway supports a project route where students build small playable games, then extend them through materials, lighting, UI, audio, animation and personal projects (Unity Technologies, Game Development Pathway, see source-unity-learn-game-development-pathway).
Brown, Roediger and McDaniel support the route’s study rhythm: retrieval, varied practice and self-testing should be built into the learning process rather than added after reading (Brown, Roediger and McDaniel, Make It Stick, see source-make-it-stick).
What to investigate next
- Add more practice tasks to pages that are still reference-heavy.
- Decide whether lecturer-only lab maps should stay in
docs/rather than the public wiki. - Build a short checklist for students to track which practice artefacts they have completed.
Related
overview-unity-csharp-cpp-programming | overview-unity-nature-of-code-examples | overview-beginner-3d-game-development-route | overview-full-game-development-pipeline | overview-final-year-game-project-route | evidence-based-learning