Build a Level

One level, from an empty template to something you can walk around.

1. Start from a template

Template scenes live in Assets/Bubbly Games/Templates, with the section headers already created.

Always start from one. Hand-building the structure is exactly how it drifts, and a scene missing
its section headers is reported on import anyway.

2. Create the scene layers

A Unity scene is one file, and .unity is locked while you hold it. So one scene per level would
mean one person per level. A level is where the environment artist, the designer, lighting and
audio all converge, often in the same week. So every level is split into additively loaded scenes,
one per discipline:

Scene Contains Owner
SC_[Level]_Base Scene set definition, load orchestration, level-wide settings Level owner
SC_[Level]_Environment Kit geometry, props, terrain, decals Environment artist
SC_[Level]_Gameplay Spawns, triggers, interactables, AI, navigation Designer
SC_[Level]_Lighting Lights, reflection probes, fog and post-process volumes Lighting artist
SC_[Level]_Audio Ambience emitters, reverb zones Audio
SC_[Level]_UI Level-specific UI UI

Level names are PascalCase, and match the kit name where the level is built from one kit.

Small projects

For a jam or a small game, Base + Environment + Gameplay is enough. Add a layer when a second
person needs to work in it.

→ Scene Structure

3. Block it out

Primitives first: overall shapes, with boolean and extrusion features, plus quick room generation
with window and door placement and procedural stairs and ramps. Get the space right while it is
still cheap to change.

Our tools are built for this: the block-out is meant to be replaced piece by piece with kit
geometry, not thrown away.

→ Level Design Tools

4. Dress it with kit pieces

The kit tools do the work: socket and connector snapping between parts, grid and rotation snapping,
auto-wall and auto-floor fill, and the kit palette panel. Splines handle roads, rivers, fences, pipes
and scattering.

Kit pieces snap because they were modelled to the grid with deliberate pivots. If two pieces will not
line up, that is usually a kit bug worth reporting to its owner rather than something to nudge into
place by hand.

→ Modular 3D Assets > Grids & Increments

5. Keep the hierarchy clean

Nothing loose at the scene root. Everything lives under a ---UPPERCASE--- section header.

SC_AbandonedTavern_Environment
├── ---ARCHITECTURE---
│   ├── Floors
│   ├── Walls
│   ├── Ceilings
│   └── Stairs
├── ---PROPS---
│   ├── Static
│   └── Interactive
├── ---NATURE---
└── ---DECALS---
  • Section headers never move. (0,0,0), identity rotation, unit scale. Moving one moves
    everything beneath it, which is nearly invisible in the inspector and very annoying to trace.
  • Keep static geometry shallow. Two or three levels under a header is plenty; deep hierarchies
    cost transform updates and hurt batching.
  • Mark static geometry Static. Required for batching, occlusion culling and navmesh baking.
  • Name things when you create them. Never ship (1), (2) or GameObject. Duplicates get
    _01, _02.

Non-prefab objects take a prefix: TRG_, SPN_, WP_, CAM_, LGT_, SND_, VOL_, MRK_,
SYS_, INT_, NAV_, DCL_, COL_, VFX_, UI_, PRB_. Prefab instances keep their prefab name.

→ Scene Structure > Hierarchy Structure

6. Watch the two traps

Build in the right scene. _Base is the active scene. New objects go into the active scene and
lighting settings come from it. Check which one is active before you build, and set it explicitly on
load.

Cross-scene references do not serialise. Unity will not save a reference from an object in one
scene to an object in another, and it fails quietly. Resolve at runtime through a registry, an event
channel, or SceneManager lookups. Wanting a direct reference is a sign the two objects belong in
the same layer.

7. Commit

One layer, one lock. Working across layers means holding several, each blocking a different
person. Keep it short and commit as soon as you can.

Do not move objects between layers casually: it breaks references and produces a conflicting commit
in two files at once. If something is in the wrong layer, tell both owners first.

Runtime-spawned objects get their own root container. Never parent pooled or spawned objects into a
hand-authored section. It makes the hierarchy unreadable at play time and creates diffs that are
not real.