You’ll learn far more building one game across the whole tutorial than doing disconnected exercises. So from here on, everything contributes to a single project you take from an empty editor to a packaged, playable vertical slice. The per-part exercises you’ll see are this game’s milestones — this section is the spine that connects them. Read it now; refer back to the milestone map as you go.
The pitch (one sentence)
You are a wisp — a fragile spark of light — relighting the beacons of a world that has gone dark, while shades try to snuff you out.
Why this design (chosen to teach, not just to be cute)
Every choice here exists to exercise an engine system while keeping the art burden low enough for one developer:
- The hero is a glowing orb with a particle trail — no character rigging required. You can ship the whole slice without a single skeletal animation, which removes the #1 thing that stalls solo devs. (Part 7 shows how to upgrade to a rigged/MetaHuman character once you want to.)
- “Light vs. dark” turns the engine’s marquee features into gameplay, not decoration. Lumen (global illumination), MegaLights (many dynamic lights), and Niagara (VFX) become the point of the game, so you have a real reason to learn them.
- The core loop scales from a one-screen 2D level to a streamed 3D open zone without changing the design — which is exactly the 2D→3D arc this tutorial follows.
Core loop
explore -> collect light motes -> reach a dark beacon -> relight it
^ (it lights the area via Lumen) |
+---------- defend against shades drawn to the new light <----------------+
all beacons in the zone lit -> the Hollow is restored -> slice completeScope discipline (read this twice)
The single most important habit in game dev is cutting scope. WISP’s shippable slice is deliberately tiny:
- One zone. ~5 beacons. One enemy type (the Shade). One collectible (the Mote). ~5–10 minutes of play.
- Everything else — multiple zones, bosses, upgrades, story — goes on a “later” list and stays there until the slice is done and fun. A finished tiny game beats a half-built big one every time.
The entity plan (your class diagram, mapped to Part 1’s framework)
| Entity | Base class | Role | Built in |
|---|---|---|---|
| BP_Wisp | PaperCharacter (2D) → Character (3D) | The player. Has a Glow value (= health). | Parts 3, 5 |
| BP_Mote | Actor (sprite/mesh + overlap) | Collectible. Restores a little Glow / adds score. | Parts 3, 5 |
| BP_Beacon | Actor (mesh + light + trigger) | Interact to relight; switches its light on (Lumen). | Parts 5, 7 |
| BP_Shade | Character + AIController | Enemy. Drains Glow on contact; flees bright areas. | Parts 5, 6 |
| BP_Keeper | Character (MetaHuman, optional) | NPC guide who explains the goal. | Part 7 |
| WBP_HUD / menus | UserWidget | Glow meter, mote count, main/pause/win screens. | Part 6 |
| BP_HollowGameMode | GameMode | Rules: beacons-lit count, win/lose, what to spawn. | Parts 5, 6 |
| BP_WispSave | SaveGame | Persists lit beacons + best time/score. | Part 6 |
Naming note: in the single Wisp project the throwaway 2D prototype (Part 3) uses 2D-suffixed assets — BP_Wisp2D, BP_Mote2D, BP_Beacon2D, BP_Hollow2DGameMode — so they never collide with the canonical 3D Blueprints above (built in Part 5). Same entity, two implementations; the 3D ones are what ship.
Milestone map — what each part delivers for WISP
| Part | WISP milestone |
|---|---|
| 0 | Create the project; set up the Content/_Wisp/ folder; put it under git. |
| 1 | Decide which framework class each WISP entity uses (the table above). No building yet — just the plan. |
| 2 | Add the Wisp’s first variable (Glow = 100); optionally a C++ base class for it. |
| 3 | Playable 2D prototype: Wisp runs/jumps through a one-screen level, collects 5 motes, reaches a beacon = “Zone Lit.” Package & share. |
| 4 | Rebuild the Wisp’s look in 3D space; make a Mote mesh + material; place a light and watch Lumen react. |
| 5 | First 3D zone: third-person Wisp that moves/dashes, motes that restore Glow, beacons you interact to relight, 3–5 Shades that chase and drain Glow, win when all beacons are lit. |
| 6 | Main menu + pause + win/lose screens; Glow meter HUD; collect/relight sounds + ambient hum (MetaSounds); Shades on Behavior Trees (chase in dark, flee from lit beacons); save the lit-beacon progress. |
| 7 | Niagara trail + mote sparkle + beacon flame; MegaLights for many lit beacons; (optional) a MetaHuman Keeper NPC; Lumen makes relighting visibly transform the world. Optionally turn the zone into a small World Partition open area — worth it only once the zone is large; otherwise the non-partitioned L_Hollow_3D stays your shipping map. |
| 8 | Use Claude Code + Unreal MCP to bulk-build the zone: scatter motes, place the beacon ring, rough-in lighting — then hand-tune. (Do it on a committed branch.) |
| 9 | Profile the lit open zone (stat unit, Insights); fix the worst Game- or GPU-bound offender. |
| 10 | Package a Shipping build of the slice; finalize git + LFS; tidy Content/_Wisp/ to the naming convention. |
| 11 | Write WISP’s “after the slice” roadmap and decide whether to keep going. |
Project setup (do this once, in Part 0)
Content/
_Wisp/ # leading underscore keeps the project's content at the top
Maps/ # L_Hollow_2D, L_Hollow_3D
Blueprints/ # BP_Wisp, BP_Mote, BP_Beacon, BP_Shade, BP_HollowGameMode
Characters/ # sprites/flipbooks (2D), mesh + materials (3D)
UI/ # WBP_HUD, WBP_MainMenu, WBP_Pause
Audio/ VFX/ Data/ # MetaSounds, Niagara systems, DataTables, SaveGameCommit the empty project to git before you build anything (Part 10 has the .gitignore). Every milestone becomes a commit — that’s your safety net, and it’s required before you let an AI agent touch the project in Part 8.
Definition of done (the vertical slice)
The slice is finished when, in a packaged Shipping build, a new player can: start from a menu, move and collect motes, relight every beacon while surviving the Shades, see the zone visibly brighten, reach a win screen, and have their progress saved — all holding a stable frame rate. Hit that and you’ve done what most aspiring devs never do: shipped a complete, self-contained game loop.