Levels & avatars: building out the game Project 2 launch

Mon 2:00 · Brief One room becomes a game

A single level is a diorama. A game is a sequence of spaces with rules about how you move through them. Today is about building spaces fast from a template, and the glue between them.

What a level is, and what a template level is

In Unreal a level is a .umap asset: a world with its own actors, lighting and Player Start. A project can hold as many as you like, and only one is loaded and played at a time unless you ask for more. A template level is a map you build once with everything every level needs — sky, light, fog, post-process, a floor, a Player Start, a Game Mode override — and then duplicate for each new space. Unreal's own New Level dialog offers Basic and Open World templates; yours is better because it carries your lighting and your kit already loaded.

Level Instances: rooms as reusable templates

A Level Instance is a small level — a room, a corridor — that you place inside another level like an actor, as many times as you like, and edit in place. Build the room once from your kit, save it as a Level Instance, and stamp it into every map. Change the room and every instance updates. This is how studios build large worlds from a small set of hand-made spaces, and it is the fastest way to get three levels out of one kit.

The transition catalogue

There is more than one way to move a player between spaces, and a finished game usually uses several. Know them all, then pick per situation:

1. Trigger box → Open Level. A volume in the doorway; cross it and the next map loads. The simplest, in the Level Blueprint.
2. Reusable portal actor. An Actor Blueprint with a Target Level variable you set per placement. Works in any map; the Level Blueprint stays empty.
3. Interact-key door. Overlap shows a prompt; the player presses a key to go. The player chooses, instead of being pulled.
4. Level streaming. A persistent level loads and unloads sub-levels while you walk — no load screen, one continuous world.
5. Fade, then load. Any of the above wrapped in a camera fade so the cut is not a hard pop.
6. Menu button. A UMG widget — main menu or level select — that calls Open Level.
7. Teleport within a level. Move the player to a target point in the same map. Same feel, no load.

Two more exist that you will not build today: World Partition, which chunks one huge map automatically, and seamless travel for multiplayer. Name them correctly in crit; use the simplest tool that works.

Where interactivity lives

Two places. The Level Blueprint belongs to one map — good for "when the player crosses this line, load the next map." An Actor Blueprint is a reusable thing — a portal, a door, a pickup — that works in any level you drop it into. The rule of thumb: if it only ever happens in this one map, Level Blueprint; if you will want it twice, make it an Actor. Both are driven by the same events: OnActorBeginOverlap from a trigger, Event BeginPlay, a Timeline to animate a door, Open Level (by Name) to change maps.

Mon 2:40 · Guided lab · task set A The template level, and three levels from it

Build the template once, stamp it three times, give each stamp a reason to exist.

1. Five minutes first: install Claude Code and Codex

   The agent lab starts Week 09, and its first minutes should go to directing the agent, not installing it. Install both CLIs now — they are small — and sign in once from your project directory. Install only: no agents touch this week’s work.

   Exact steps

   1. Install Claude Code: follow code.claude.com/docs — one install command for your OS — then cd into your project root, run claude, and sign in.
   2. Install the Codex CLI from github.com/openai/codex, then run codex from the project root and sign in.
   3. Always launch an agent from inside the project folder — that is how it sees your files.

   Done when both claude and codex start from your project root without errors.

2. Build the template level

   File → New Level → Basic, save it as T00_Template in a Maps folder. It already has a Directional Light, Sky Atmosphere, Sky Light, Exponential Height Fog and a floor. Add a Post Process Volume (set Infinite Extent), a Player Start, and a Kill Z safety net (World Settings → Kill Z to about −1000 so a fall respawns instead of falling forever). Set World Settings → Game Mode Override to the Third Person game mode. Light it the way you lit Project 1. This is now every level's starting point.

   Why the Game Mode goes in the template

   The Game Mode decides which character spawns and where. If it is set in the template, every stamp inherits it and you never get the "I pressed Play and nothing spawned" moment in a new map.

3. Make a room template as a Level Instance

   In T00_Template (or your Project 1 map), build one room from your kit — walls, floor, a doorway. Select all its pieces, right-click → Level → Create Level Instance, save it as LI_Room_A. It becomes one placeable actor. Drag a second copy from the Content Browser and rotate it: two rooms, one source. Right-click an instance → Edit to change the room; every copy updates.

4. Stamp the three levels

   Right-click T00_Template → Duplicate three times: L01_Start, L02_Middle, L03_Goal. Open each and lay out a different space from Level Instances and loose kit pieces: a corridor, a courtyard, a vertical climb, the goal room. Keep one Player Start per map, placed where the player should arrive. Three spaces that read as different is the bar; polish is not.

5. Set the starting map

   Edit → Project Settings → Maps & Modes: set Editor Startup Map and Game Default Map to L01_Start. Now Play always begins at the start, whichever map is open.

Mon 3:05 · Guided lab · task set B Transitions, every method

Build each kind once. By the end you can walk from the first room to the last without touching the editor, and you have met every transition you will use for the rest of the course.

1. Method 1 · Trigger box → Open Level (Level Blueprint)

   In L01_Start, drag a Trigger Box from Place Actors and scale it across the exit doorway at player height. With it selected, open the Level Blueprint (Blueprints menu → Open Level Blueprint), right-click → Add Event for Trigger Box → Collision → On Actor Begin Overlap. From that event drag out Open Level (by Name) and type L02_Middle exactly (no path, no extension). Play, walk into the box: the next map loads and you arrive at its Player Start.

   If nothing happens

   1. Check the map name is spelled exactly, including the prefix.
   2. Make sure the Trigger Box's Collision Presets is Trigger and it actually spans the doorway at player height.
   3. Put a Print String on the event first to prove it fires, then add Open Level.

   Done when walking through the doorway loads the next map every time.

2. Method 2 · Reusable portal actor

   Right-click → Blueprint Class → Actor, name it BP_Portal. Add a Box Collision and a Static Mesh (a doorframe from your kit, or a plane with an emissive material). Add a variable TargetLevel, type Name, and tick Instance Editable (the eye icon). On the Box's OnComponentBeginOverlap, check Other Actor is the player (Cast To BP_ThirdPersonCharacter, or == Get Player Pawn), then Open Level (by Name) with TargetLevel. Place one in L02_Middle and set its Target Level to L03_Goal in the Details panel. Same actor, any map, no Level Blueprint.

   The player check matters

   Without it, any physics prop or NPC that drifts into the portal changes the level. Every transition below uses the same check.

3. Method 3 · Interact-key door with a prompt

   Duplicate BP_Portal as BP_Door. Instead of loading on overlap, set a boolean PlayerInside true on begin overlap and false on end overlap, and show a small Widget Component ("Press E") while inside. In the Third Person character (or via Enable Input on the door), bind the E key (an Input Action in Enhanced Input, or the key event directly today): if PlayerInside, play a Timeline that swings the door mesh open over one second, then Open Level. The player chooses to go.

4. Method 4 · Level streaming, no load screen

   Open L01_Start and Window → Levels. Click Levels → Add Existing and add L02_Middle as a sub-level (it becomes a streaming level under the persistent one; set its streaming method to Blueprint). Place a Level Streaming Volume across the corridor between the two spaces, select the sub-level in the Levels window, and in its details add the volume under Streaming Volumes. Walk toward the corridor: the second space appears before you reach it, and unloads behind you. For control from Blueprint instead, use Load Stream Level / Unload Stream Level with the sub-level's name.

   Streaming vs Open Level

   Open Level throws away the whole world and builds the next one — simple, and a visible cut. Streaming keeps the persistent level (your player, your score) and swaps spaces around it. Use streaming when the world should feel continuous; use Open Level when a clean reset is fine or wanted. Offset the sub-level in the Levels window so the two spaces do not overlap.

5. Method 5 · Fade, then load

   Back in BP_Portal: before Open Level, call Get Player Camera Manager → Start Camera Fade (From 0, To 1, Duration 0.5, Hold When Finished ticked), then a Delay of 0.5, then Open Level. In the template level's Level Blueprint, on Event BeginPlay fade back in (From 1, To 0). Now every portal cuts to black and the new level fades up. A half-second of black reads as intentional; a hard pop reads as a bug.

6. Method 6 · Menu button

   Create a Widget Blueprint WBP_LevelSelect with three buttons named for your levels. On each button's OnClicked, Open Level (by Name). In L03_Goal's Level Blueprint (or on a trigger at the goal), Create Widget → Add to Viewport, Set Input Mode UI Only, Show Mouse Cursor. Reaching the goal shows a menu; the menu goes anywhere. This is also your main menu and your "play again" screen.

7. Method 7 · Teleport inside a level

   Place a Target Point somewhere in L02_Middle. Duplicate BP_Portal as BP_Teleporter, replace the TargetLevel variable with a Target actor reference (Instance Editable), and on overlap call Set Actor Location on the player with the target's location (optionally Set Actor Rotation too). Drop one in, point it at the Target Point in Details. No load, same map — the right tool when the "transition" is just a jump across the room.

8. Walk the whole route

   Play from L01_Start. Cross the trigger box, stream into the second space, take the teleporter, press E at the door, fade through the portal, reach the goal, use the menu to go back to the start. Fix every place you got stuck or fell through. That full walk is Monday's deliverable.

Wed 2:00 · Brief Avatar generation: a character you did not model by hand

You have a world. Now you need someone to be in it. This session is about getting a rigged, game-ready avatar into Unreal quickly, so the next three weeks of animation have a body to animate.

Three doors to an avatar

MetaHuman. Epic's character system builds a fully rigged, Unreal-ready human from sliders or from a photo, with the full facial rig. The fastest route to a believable human; the least yours. Auto-rigged mesh. Any humanoid mesh — bought, found, or built in Blender — uploaded to Mixamo comes back rigged on a standard skeleton with a library of motion. Generated character. Image-to-3D and text-to-3D tools (Meshy, Tripo and their peers) produce a stylized character mesh from a drawing or a sentence; it then goes through the auto-rigger like any other mesh, or through the Rigify lab below if you want the rig to be yours. Pick the door that fits the game you are building, not the one that is easiest.

What "game-ready" means for a character

One mesh, one material set, a clean T- or A-pose, a skeleton whose root is at the origin, deform bones only, and a bone set that retargets: Unreal's IK Retargeter maps one humanoid skeleton onto another, which is how the Third Person template's walk, run and jump end up on your avatar without you animating a frame. Whatever door you take, that is the contract the import has to meet.

On the hands-only rule

Weeks 1–8 keep agents and generative tools out of your submitted work. Avatar generation is the one written exception (AI policy, amended Oct 19): the skill this week is everything after generation — cleanup, rig check, import, retarget — and that stays in your hands. Name which door you used in your Project 2 submission.

Wed 2:25 · Guided lab Generate, check, retarget, walk

By the end of the hour your avatar walks the levels you built Monday.

1. Generate the avatar

   Take one door. MetaHuman: open MetaHuman Creator (the plugin in UE 5.6+, or the web version), build the character, export to your project. Mixamo: upload a humanoid FBX in T-pose, place the markers, download the rigged character (FBX for Unreal, T-pose). Generated: feed a reference image or a sentence to Meshy or Tripo, download the FBX or GLB, then send that through Mixamo for the rig — or rig it yourself with Rigify, below. Fluid Avatar Studio: open the class studio, tune a body, press Export for Unreal, unzip, and run the bundled import_fluid_avatar.py from Unreal’s Python console (or follow its README by hand).

2. Check it in Blender before Unreal

   Import the FBX into Blender. Confirm scale (a human is about 1.8 m), apply transforms, confirm the root bone sits at the origin, delete any control or helper bones that are not deform bones. If the mesh is a mess of separate parts, join them. Re-export: FBX, apply transforms, +Z up / -Y forward.

   MetaHuman skips this

   MetaHumans arrive already correct for Unreal; go straight to the retarget step. The Blender check is for Mixamo and generated meshes.

3. Import as a Skeletal Mesh

   Drag the FBX into the Content Browser with Skeletal Mesh checked. Unreal creates a Skeletal Mesh, a Skeleton and a Physics Asset. Open the Skeletal Mesh and look: no missing bones, no exploded parts, materials assigned.

4. Retarget the mannequin's animations

   Create an IK Rig for your avatar's skeleton (right-click the Skeletal Mesh → Create → IK Rig) and let auto-generate find the chains. Create an IK Retargeter from the Third Person mannequin's IK Rig to yours, check the chain mapping, then Export Selected Animations for Idle, Walk, Run and Jump. You now have the template's motion on your body.

   Retarget looks wrong

   1. Both characters must be in the same rest pose — set your avatar's retarget pose to A- or T-pose to match the mannequin.
   2. Check the chain mapping: spine to spine, left arm to left arm. Auto-mapping gets one side backwards surprisingly often.
   3. Scale: if the avatar is ten times too big or small, fix it in Blender and re-import rather than fighting it here.

   Done when the walk cycle plays on your avatar without sliding feet or a twisted spine.

5. Swap it into the Third Person character

   Open BP_ThirdPersonCharacter, select the Mesh component, set Skeletal Mesh to your avatar. Duplicate the template's Animation Blueprint, retarget it to your skeleton (right-click → Retarget Animation Assets), and assign it to the Mesh. Play.

6. Walk your levels as yourself

   Play from L01_Start. Walk the whole route from Monday as your avatar: through the trigger, the stream, the teleporter, the door, the portal, into the goal room. Record a short screen capture of that walk — it is the proof for both halves of the week.

Wed 3:05 · Guided lab Rigging: skeletons & skinning — the hand-built path

If your avatar is a mesh you modeled yourself, or a generated mesh you want to own all the way down, this is how you build the puppet. Get the skeleton and the skinning right and animation is a joy; get them wrong and every pose fights you. Even if you took the MetaHuman or Mixamo door, do this once on the provided base mesh — it is what lets you fix an auto-rig when it goes wrong.

Joints and hierarchies

A rig is a tree of bones (Blender calls them bones; Maya calls them joints — same idea). Each bone is the child of another, so rotating the shoulder carries the elbow, wrist, and fingers with it. That parent-child hierarchy is the whole trick: you pose a few high-level controls and the chain follows. Build the hierarchy wrong — a bone parented to the skip-a-generation ancestor — and limbs detach in ways that are maddening to debug.

The humanoid skeleton

Humanoid rigs share a standard skeleton: a spine chain, a head, two arm chains (shoulder, upper arm, forearm, hand), two leg chains (thigh, shin, foot, toe). This standardization is what lets you retarget animation from one humanoid to another — the IK Retargeter step above. The bones sit at the anatomical joints — the elbow bone pivot goes exactly where your elbow bends, not an inch off, or the deformation lies.

Rigify, and Maya as the alternative

Blender's Rigify add-on generates a full, production-grade control rig from a metarig — a simplified skeleton you position to match your character. It gives you IK/FK limbs, foot rolls, and clean controls without hand-building hundreds of constraints. Maya's HumanIK and rigging tools do the equivalent job; we teach Rigify because it's free and in our default DCC, but the concepts port directly. Either way, you'll export the deform skeleton — the bones that actually skin the mesh — for Unreal.

Skinning and weight painting

Binding the mesh assigns each vertex a set of weights — how much each nearby bone influences it. Automatic weights gives a fast, usually-decent guess based on proximity. But automatic weights always struggle at high-deformation zones: shoulders, elbows, hips. Weight painting is you correcting that guess by hand — literally painting influence onto vertices — until the mesh creases and stretches like flesh over bone instead of shrink-wrap.

1. Add the metarig

   With your mesh in a T/A-pose, Add → Armature → Human (Meta-Rig) from Rigify. If your character isn't humanoid, block a simple joint chain by hand instead and follow the same skinning steps.

2. Position the metarig

   In edit mode, move each metarig bone to sit exactly at your character's joints — shoulders, elbows, wrists, hips, knees, ankles. Use front and side views. This alignment is the single biggest determinant of deformation quality.

3. Generate the control rig

   In the Rigify panel, click Generate Rig. This builds the full control rig with IK/FK switches and posing widgets from your metarig. The metarig is now just the blueprint; you animate the generated rig.

4. Parent with automatic weights

   Select the mesh, shift-select the rig, and Ctrl+P → With Automatic Weights. Blender binds every vertex to nearby bones. Grab a control and pose an arm — it moves, imperfectly. That's expected.

5. Enter weight paint mode

   Select the mesh, switch to Weight Paint mode, and pick a bone to inspect its influence. Red is full influence, blue is none. Now you can see exactly where the automatic guess went wrong.

6. Fix shoulders and hips

   Pose the arm up and the leg out, then paint weights until the shoulder and hip crease instead of collapsing or spiking. Smooth harsh transitions with the Blur brush. These are the two zones that make or break a humanoid.

7. Test-pose the whole rig

   Run the character through extreme poses — arms overhead, deep crouch, head turned. Watch for pinching, volume loss, and candy-wrapper twists at the forearm and shin. Fix each as you find it.

8. Export and import as a Skeletal Mesh

   Export the mesh with its deform skeleton to FBX (apply transforms, +Z up / -Y forward for Unreal), then import into Unreal with Skeletal Mesh checked. Unreal creates a Skeletal Mesh, a Skeleton asset, and a Physics Asset. Keep the bone set clean so the IK Retargeter step above works on it, then join the avatar lab at the retarget step.

Wed 3:35 · Crit / share Project 2 launch & avatar walk

Project 2 — the Rigged & Animated Character — launches today, and your avatar is its starting point; read the full brief on the course hub. Bring your project to the front and play the walk: your levels, your avatar, the transitions. We are not judging animation yet — only whether the structure holds and the body is trustworthy enough to animate. Say which avatar door you took, which transitions you used where, and what you would fix first.

Homework — due before Week 09

Resources

• Unreal: working with levels — creating, duplicating and setting default maps.
• Unreal: Level Instances — rooms as reusable, editable templates.
• Unreal: the Level Blueprint — map-specific events such as a trigger that opens the next level.
• Unreal: level streaming — persistent levels, streaming volumes, Load Stream Level.
• Unreal: Timelines — animating a door from a Blueprint.
• Unreal: UMG widgets — the level-select menu and the door prompt.
• MetaHuman — Epic's rigged human characters, inside the editor from 5.6.
• Mixamo — auto-rigging for any humanoid mesh, plus motion to retarget.
• Meshy — image-to-3D and text-to-3D character generation (Tripo is the comparable alternative).
• Unreal: IK Rig retargeting — putting the mannequin's animation on your avatar.
• Blender Rigify docs — generating and customizing the humanoid control rig.
• Blender weight paint docs — brushes, normalization, and fixing influence.
• Unreal Skeletal Mesh assets — importing a rigged character and how the Skeleton asset drives retargeting.
• Claude Code docs and Codex CLI — install and sign-in, for the Week 09 agent lab.