Cyberpunk street build — agent brief (Claude Code harness, model = Muse Spark 1.1)

You drive a running Unreal Engine 5.8 editor through the simworld-bridge MCP tool execute_python_script (runs Python inside the editor, returns stdout). Build a fancy, non-repeating cyberpunk L-corner NIGHT street into a fresh map, then verify — by metric AND by looking at a rendered screenshot — and iterate until BOTH pass AND it genuinely looks like a dark cyberpunk night.

Use the skill (progressive disclosure)

Skill at .opencode/skill/cyber-street-build/. Read SKILL.md first, then open a file under references/ when you reach that phase. Read them with the Read tool.

Hard rules (a metric score is NOT enough — the PICTURE must look right)

• Write your OWN build code. No ready-made build script; do not look for one or exec one.
• Drive the editor ONLY via the execute_python_script MCP tool. Small increments (<= ~50 actors/call).
• Scale ALWAYS 1, ground z0, don't reassign materials to defaults.
• RESTRAINT: keep dynamic lights UNDER ~100 total. Piling on lights blows the scene out to white (light pollution) AND makes it so heavy the renderer crashes. A few big hero neons beat hundreds.
• The distant backdrop must be BUILDING/TOWER meshes — NEVER a billboard/screen/panel that shows a photo (several show a daytime BEACH). A beach/sky backdrop = automatic fail.
• Lock night exposure (unbound PostProcessVolume, auto_exposure min0.05/max0.5) — see the skill.
• Map name: use the exact map path given in your task prompt (it is unique per run).
• NEVER trigger a modal dialog (they freeze the editor headlessly). Before new_level, if the map already exists, unreal.EditorAssetLibrary.delete_asset(map) first. Save only with save_current_level() / EditorLoadingAndSavingUtils.save_map(world, path) (these overwrite silently); do not use any API that pops an "overwrite existing?" prompt.

The loop — metric + VISUAL gate (this is the whole point)

1. Build phases A-F from the skill (small calls), save after each with unreal.get_editor_subsystem(unreal.LevelEditorSubsystem).save_current_level().
2. Metric verify (via the bridge tool): exec(open(r"E:/UE/cyber_local_run/tools/verify_cyberpunk_scene.py",encoding="utf-8").read())
3. VISUAL gate — render via the SAME bridge tool (do NOT shell out to a separate renderer): a. Call execute_python_script with: exec(open(r"E:/UE/cyber_local_run/render_vgate.py",encoding="utf-8").read()) (renders your current map at eye level, light settings, to vgate/). It returns immediately; the render is async. b. Then in a Bash tool call: python E:/UE/cyber_local_run/analyze_frame.py (waits for the frame, prints pixel stats + VISUAL SCORE + issues, saves vgate_last.png). This is fast (no rendering). c. Then LOOK yourself: use the Read tool on E:/UE/cyber_local_run/vgate_last.png and judge it as a picture. Is it a believable DARK cyberpunk night street? Over-exposed? Washed to daytime? Is the backdrop a city or a beach? Too many lights? Write down the visual problems you SEE.
4. Fix the WORST problems — BOTH the low metric checks AND the visual problems you saw (e.g. delete excess lights, replace a beach-photo backdrop with tower meshes, strengthen the exposure lock). Re-verify + re-render + re-look. A high metric with a bad-looking render is a FAIL.
5. Done only when metric >= ~92 AND VISUAL SCORE >= 80 AND the picture genuinely looks like a dark cyberpunk night street to you.

Finish

Summary: round-by-round metric + visual scores, the visual problems you found and fixed, final map name. Work fully autonomously — do not ask questions.

Cyberpunk street build — agent brief

You drive a running Unreal Engine 5.8 editor through the simworld-bridge MCP tool execute_python_script (it runs Python inside the editor and returns stdout). Your job: assemble a fancy, non-repeating cyberpunk L-corner street into a fresh map, then self-verify and iterate.

Use the skill (progressive disclosure — read only what you need)

A skill is available at .opencode/skill/cyber-street-build/. - Start by reading .opencode/skill/cyber-street-build/SKILL.md. - It has a reference index; open a file under references/ ONLY when you reach that phase (assets, ue-api, layout, lighting, signage, verify-and-iterate). Read them with your normal file tools.

Hard rules

• Write your OWN build code. There is no ready-made build script and you must not look for one or exec one. The skill gives you APIs + a plan; you author the Python you send to execute_python_script.
• Drive the editor ONLY via the execute_python_script MCP tool. NEVER take a screenshot.
• Build in small increments — at most ~40-50 actors per execute_python_script call, many short calls. Keep each script focused; do not send one giant script.
• Scale ALWAYS 1, ground at z≈0, don't reassign materials to defaults. (See the skill's golden rules.)
• The verifier script MAY be exec'd (only the BUILDER must be your own) — see the skill's references/verify-and-iterate.md.
• Keep total actors under ~1100.

Definition of done

A saved map /Game/Maps/CyberOC_1 scoring ≥ ~92/100 on the verifier, built in your own incremental code, with a final summary: round-by-round score progression, final scorecard, and what you built/changed. Work fully autonomously — do not ask questions.

name: cyber-street-build description: > Knowledge for assembling a fancy, non-repeating CYBERPUNK L-corner street inside a running Unreal Engine 5.8 editor (via execute_python_script), from marketplace assets — facades, ground, skyline, night lighting, dense neon signage, holograms, rain/puddles. Use when asked to BUILD or IMPROVE a cyberpunk street/scene. This skill gives you the plan, the key UE-Python APIs, the asset libraries, and the gotchas — you write your OWN build code from it. There is NO ready-made script to run.

Cyber-street build

You are assembling a believable night-time cyberpunk L-corner street: one long leg running along +X, turning up +Y at the corner. Everything is placed at scale 1 (assemble real meshes, never stretch them). You judge your own work with a 0-100 verifier and iterate.

Golden rules (break these and the verifier punishes you)

1. Scale ALWAYS 1. Never set actor scale != 1 to "make it fit". Pick a mesh that is the right size. (check: no_scaling)
2. Ground at z ≈ 0. Buildings/props sit on z=0; signs/lights float only where intended.
3. Never reassign a mesh's material to a default (worldgridmaterial etc.) — keep the asset's own MICs.
4. Continuous, SOLID facades on both sides of both legs — no see-through gaps, no daylight holes.
5. Every sign is VOLUME-AWARE: measure its bounds, face it toward the street, offset so it does not clip into the wall. Pair each sign with a neon RectLight. (checks: sign_light_pairing, tilted_signs)
6. It's NIGHT. Kill the sun (≤0.8), keep skylight dim (≤5), and lock auto-exposure so MRQ can't brighten it to daytime (this is the #1 thing people forget — see references/lighting.md).
7. Keep total actors under ~1100. If near the cap, prune/vary instead of piling on.

The build plan (phases)

Build in small increments (~40-50 actors per execute_python_script call, many short calls). Order:

• A — Ground & facades. Lay wet-asphalt road + sidewalks + curbs down both legs, then place a continuous run of building facades along both sides of both legs. Carve the corner so facades don't collide at the L junction. → references/layout.md, references/assets.md
• B — Distant skyline. Behind the facades, stack a dense backdrop of far towers of varied heights so the view down each street end is full, not empty. → references/layout.md
• C — Night lighting + weather. Dim moonlight directional, dim skylight, teal exponential fog, warm street lamps down the sidewalks, an exposure-locked PostProcessVolume, rain + puddles + steam. → references/lighting.md
• D — Dense diverse signage. Many DIFFERENT signs (blade/flush/hanging, varied heights) along both streets, each oriented to the street and paired with a colored neon RectLight. → references/signage.md
• E — Holograms. A few floating holographic projections above the street (these may float by design).
• F — Greeble & clutter. Restrained eye-level detail: AC units, pipes, cables, crates, bollards, scaffolds, a little litter (don't overload litter). → references/assets.md

How to work

1. Read this SKILL.md, then open ONLY the reference files you need for the phase you're on (they're short).
2. Discover concrete asset paths yourself with the Asset Registry — don't hardcode blindly. → references/assets.md
3. Build a phase, then run the verifier, read the scorecard, fix the lowest checks, repeat. → references/verify-and-iterate.md
4. Save after each phase/fix: unreal.get_editor_subsystem(unreal.LevelEditorSubsystem).save_current_level()

Three stages

1. Build the street (phases A–F above) — verify by metric AND by looking at a render.
2. Crowd — plan + place your own ZoneGraph pedestrian crowd. → references/crowd.md
3. Record — a fixed-recipe first-person walk-through video. → references/recording.md

You write ALL the code for every stage from these references; no prebuilt build/crowd/recording script is provided.

Reference index (open on demand)

• references/ue-api.md — the exact UE-Python calls to spawn meshes/lights/fog/decals/FX + apply materials.
• references/assets.md — which asset libraries exist and how to enumerate real mesh paths.
• references/layout.md — the L-corner geometry (legs, carriageway width, sidewalks, corner carve, skyline).
• references/lighting.md — the night-lighting recipe + the exposure-lock gotcha (critical).
• references/signage.md — the volume-aware sign-placement method + neon pairing.
• references/verify-and-iterate.md — every scored check, common failures, and the self-improve loop.
• references/crowd.md — Stage 2: ZoneGraph lanes (PedD2) + MassCrowd spawner (Density2 + MetaHuman).
• references/recording.md — Stage 3: the fixed first-person walk MRQ recipe + gotchas.

Asset libraries + how to find real mesh paths

Two marketplace packs cover everything. Enumerate them yourself — do NOT trust a memorized path; a wrong path makes load_asset return None and the piece silently doesn't spawn.

The two libraries

• /Game/CyberpunkMegaBundle/5_CP_CityRecife/ — the hero cyberpunk kit.
• Mesh/ — building facades, storefronts, walls, roofs, props, greeble, signs, litter.
• Particles/ — PS_WaterDrip, PS_SteamTube (Cascade emitters).
• /Game/Neon_Streets/ — neon-street dressing.
• Meshes/ — modular curbs (Modular/SM_Curb_1_2m), road/sidewalk planes, poles, emissive signs, props.
• Materials/Instances/ — e.g. MI_Ground_Asphalt (wet road), sign/neon MICs.
• Materials/Decals/DE_Puddle — puddle decal.
• FX/NS_Rain, FX/NS_Smoke — Niagara rain & smoke.

Enumerate what actually exists (do this first)

ar = unreal.AssetRegistryHelpers.get_asset_registry()
for a in ar.get_assets_by_path("/Game/CyberpunkMegaBundle/5_CP_CityRecife/Mesh", recursive=True):
    print(a.asset_name, a.get_editor_property("asset_class_path").asset_name)

Filter for StaticMesh. Build yourself category lists by matching the asset NAME, e.g.: - facades/walls: names containing Build, Wall, Set_, Store, Window, Roof, Corner. - signs: Sign, Neon, Billboard, Screen, Led, Arrow, Market, Hotel, Banner, Emissive. - greeble: Extractor, Antenna, Tube, Vent, Pipe, Cable, Crate, Barrel, Pallet, Bollard, Scaffold/Andaime, AC/Conditioner, Duct, Awning, Balcony. - litter (use SPARINGLY): Litter, Trash, Garbage, Papel, Lata, Garrafa, Debris. - holograms: Holo, Hologram, Holograma, Emissor.

CRITICAL: the distant skyline must be BUILDINGS, not a photo panel

The backdrop at the end of the street is the #1 thing that goes wrong. Use building / tower meshes (SM_Building_*, SM_Build*, tower blocks) stacked at scale 1. NEVER use billboard / screen / large flat "panel" meshes that carry a photographic texture for the backdrop — several of those in these packs show a daytime tropical beach / ocean / sky, and if you put one at the end of the street the whole scene reads as a bright beach postcard, not a cyberpunk night. If a mesh's texture is a photo of a landscape, it is NOT a skyline — don't use it as the backdrop.

Restraint beats piling on (avoids light-pollution + render crashes)

More is NOT better. Keep dynamic lights under ~100 total (RectLight+PointLight+SpotLight). A few big hero neons + restrained lamp spacing looks far better — and far darker/moodier — than hundreds of lights, which blow the scene out to white AND make it so heavy the renderer crashes. If a check wants "more lights", add a FEW bright ones, not dozens of dim ones.

Variety matters (anti-repetition check)

Keep a POOL of several different meshes per category and pick varied ones as you step down the street. Placing the same facade mesh 20× in a row triggers repeated_elements / monotone_walls. Rotate through the pool and jitter positions slightly.

Stage 2 — pedestrian crowd (MassAI / ZoneGraph)

Add a believable pedestrian crowd walking the finished street. YOU decide the lane layout; the crowd populates at runtime (in PIE / the recording), driven by MassAI over ZoneGraph lanes.

The mechanism (why each piece is needed)

• ZoneShape actors carry the walkable lanes (a polyline of points).
• Each ZoneShape's lane profile must be PedD2 = Pedestrian (Bit3) + Density2 (Bit12). That density bit is what makes the MassCrowd Density2 spawn-point generator register these lanes as crowd lanes. Profile ref: unreal.ZoneLaneProfileRef with name="PedD2" and id = GUID A1000000000000000000000000000020. (The profile is pre-committed in Config/DefaultPlugins.ini.)
• A BP_MassCrowdSpawner (/Game/AI/AgentConfig/BP_MassCrowdSpawner) with:
• spawn_data_generators = a MassCrowdZoneGraphSpawnPointGenerator_Density2 instance (/Game/AI/AgentConfig/MassCrowdZoneGraphSpawnPointGenerator_Density2) wrapped in a MassSpawnDataGenerator (proportion 1.0). Its density tier must match the lanes' PedD2 or it finds no spawn points.
• entity_types = a MassSpawnedEntityType with entity_config /Game/AI/AgentConfig/MassCrowdAgentConfig_MetaHuman (proportion 1.0) — this drives the walking peds.
• count = your target pedestrian count (the generator caps at available lane points).

Key API (write your own placement code from this)

zs = eas.spawn_actor_from_class(unreal.ZoneShape, unreal.Vector(0,0,0))
c  = zs.get_component_by_class(unreal.ZoneShapeComponent)
ref = unreal.ZoneLaneProfileRef(); ref.set_editor_property("name","PedD2"); ref.set_editor_property("id", guid)
c.set_editor_property("lane_profile", ref)
c.set_editor_property("points", [ ZoneShapePoint(position=Vector(x,y,GZ)) , ... ])   # the lane polyline

Guid: g=unreal.Guid(); # parse "A100...0020" — set it on the ref's id. Build a MassSpawnDataGenerator + MassSpawnedEntityType as above and set them on the spawner.

Plan (yours to design)

• Lanes both on the sidewalks AND inner lanes near the street centre (so peds walk close to a first-person camera at y≈0), with two-way flow. A busy street ≈ 150-200 peds, ~12-16 lanes.
• Cover the +X main leg (y≈0 corridor, |y|<~520) and the +Y corner leg. Ground the lanes at z ≈ 0 (peds hover / LOD-glitch if lanes float).
• Save to a new map (e.g. <yourmap>_crowd) so the street stays intact.

Verify (structural — the peds only appear at runtime, i.e. in the Stage-3 recording)

Confirm: number of ZoneShape lanes, exactly one BP_MassCrowdSpawner, the generator is the Density2 one and the lanes are PedD2, and the lanes sit inside the walkable corridor at z≈0. The actual walking crowd is confirmed visually in the Stage-3 recording (which warms up MassCrowd before frame 0).

Prereqs (already set up in this project)

Config/DefaultPlugins.ini has the PedD2 profile; the crowd character BP compiles. If the spawner finds 0 points, the lanes aren't PedD2 or the generator isn't Density2 — fix the mismatch.

L-corner geometry

A right-angle street. Work in centimetres (UE units).

The two legs

• Leg A (main): runs along +X from x=0 to x≈8000, centred on y=0.
• Leg B (corner): runs along +Y from y=0 to y≈8900, centred on x≈8000 — it fills the corner so the camera looking down Leg A sees the turn, not a void.

Cross-section (per leg)

• Carriageway (road): full width ≈ ±520 from the leg centreline (CARRIAGE_HALF ≈ 520). This is the walkable/road corridor — KEEP IT CLEAR of buildings (a later stage walks a camera down the centre).
• Sidewalk: a band just outside the carriageway (≈ 520 … 700 from centre). Curbs sit on the edge.
• Facades: start at the sidewalk's outer edge (≈ 700 from centre, FACADE ≈ 700) and face inward toward the street. Left side faces +perp, right side faces −perp.

Helper idea: a function that converts (distance-along-leg, perpendicular-offset) → world (x,y) depending on whether the leg axis is 'x' or 'y'. Step down the leg in increments equal to each facade's measured width (see references/signage.md for measuring bounds) so facades sit flush, continuous, no gaps.

Facing the street

• Leg A (axis x): a facade on side −1 (y<0) faces +Y; on side +1 (y>0) faces −Y → yaw 0 or 180.
• Leg B (axis y): faces ±X → yaw 90 or 270. Signs and lamps follow the same facing logic (face the carriageway).

Carve the corner

Where Leg A's end overlaps Leg B's start, facades from both legs can collide/interpenetrate. After placing both legs, detect actors in the overlap box (use get_actor_bounds) and remove the ones that intrude into the other leg's carriageway, so the junction is a clean open corner (check: no_collisions, l_corner_shape).

Distant skyline (phase B)

BEHIND the facades (perpendicular offset well beyond 700, e.g. 1500-4000 out, and past the leg ends), stack blocks of varied height into "towers" to form a dense far skyline. Bias them toward the ends of both legs and the corner so the view down each street is filled. Assemble at scale 1 from building blocks; vary heights and spacing so it doesn't read as a wall (checks: dark_skyline, no_backdrop).

Night lighting recipe (phase C) — and the exposure gotcha

The scene must read as night but NOT be pitch black. The verifier wants the sun essentially off, a dim ambient, dense warm street lamps, and colored neon — plus fog and wet ground.

1. Kill daylight

• DirectionalLight as a faint moon fill: intensity ≤ 0.8 (0.03–0.6 is typical). Cool color (e.g. 120,140,190). Sun intensity > 1.5 → verifier scores it as daytime (sun_on, hard fail).
• SkyLight for ambient: intensity ≤ 5 (2.5 or so). lower_hemisphere_is_black = True. SkyLight

  8 washes the scene to daytime (ambient_too_bright).

2. Fog (mood + depth)

unreal.ExponentialHeightFog, then on its component:

fc.set_editor_property("fog_density", 0.025)
fc.set_editor_property("fog_height_falloff", 0.05)
fc.set_editor_property("enable_volumetric_fog", True)
# tint the fog a cool teal via fog_inscattering_color (LinearColor)

No fog → no_fog warning.

3. THE EXPOSURE LOCK (do not skip — #1 forgotten step)

Auto-exposure will otherwise brighten your dark night back up to "daytime" when it's rendered. Lock it with an unbound PostProcessVolume:

pp = eas.spawn_actor_from_class(unreal.PostProcessVolume, unreal.Vector(4000,4000,300))
pp.set_editor_property("unbound", True)          # affects the WHOLE map, not just inside the box
s = pp.get_editor_property("settings")
s.set_editor_property("override_auto_exposure_min_brightness", True); s.set_editor_property("auto_exposure_min_brightness", 0.05)
s.set_editor_property("override_auto_exposure_max_brightness", True); s.set_editor_property("auto_exposure_max_brightness", 0.5)
s.set_editor_property("override_bloom_intensity", True);            s.set_editor_property("bloom_intensity", 1.5)
pp.set_editor_property("settings", s)

If you skip this, the map may score fine but RENDER bright/daytime — a real, easy-to-miss failure. (unbound=False = the lock only applies inside the box and usually misses the camera.)

4. Warm street lamps (density check)

Down each sidewalk, place lamp poles at intervals; give each a warm PointLight whose bulb is offset OUT over the carriageway (the head overhangs the road). Aim for ≥ ~15 dynamic lights per 100 m of street (light_density, too_few_lights). Mirror lamps on both sides (lamps_not_mirrored).

5. Warm/cool balance + a few HERO neons

Mix warm (amber) lamps with cool/saturated (cyan/magenta) neon so both are present (warm_cool_neon). Add a handful of GIANT bright neon RectLights (intensity ≥ ~8) as "hero" light pollution (no_hero_neon, no_light_pollution).

6. Wet ground + rain

Wet-asphalt road material + Niagara NS_Rain + puddle decals + a little steam. Missing → no_rain, wet_ground_rain loses points. Add SphereReflectionCaptures along the street so the wet ground reflects.

Stage 3 — record a first-person walk-through video

Render an 18s first-person WALK down the finished, crowded street, with head-bob and camera-following rain, as an MRQ frame sequence → assemble to mp4. These parameters are FIXED (so every model's recording is comparable) — you write the code, but don't change the recipe.

Fixed recipe: 1920×1080, 30 fps, 18 s. Eye height z=175, walk +X at 190 u/s from (0,0,175). engine_warm_up_count = 300 (so the MassCrowd populates before frame 0 — essential, or the street is empty). 4 camera-following rain emitters. Motion blur 0.2.

Why each piece

• MRQ is the only reliable headless render (viewport / PIE HighResShot wedge). Use MoviePipelineQueueSubsystem + MoviePipelinePIEExecutor.
• First-person POV: give the map a GameMode whose default_pawn_class = None, then place a DefaultPawn (auto_possess_player = PLAYER0) at eye height — it wins possession and IS the camera. Render an empty LevelSequence with NO camera-cut track so MRQ films the possessed pawn's POV.
• Walk + bob: register a slate post-tick callback (register_slate_post_tick_callback) that, using GameplayStatics.get_time_seconds, moves the pawn to x = SPEED*t, small y/z sin bob, and sets the controller rotation with a gentle sway. Force-possess your FlyViewer each tick (find it via an actor tag; some maps mis-possess a default pawn) and set_view_target_with_blend to it.
• Camera rain: spawn 4 NiagaraActors with /Game/Neon_Streets/FX/NS_Rain, tag them, and in the tick attach them to the pawn at offsets like (250,0,450),(250,±320,420),(420,0,300).
• Crowd warmup: the ped crowd only spawns at runtime, so engine_warm_up_count = 300 runs enough ticks that peds are walking before frame 0.

Critical gotchas

• Unique LevelSequence name per render (e.g. RecSeq_<ms-timestamp>). Re-using a name makes create_asset pop an "Overwrite Existing Object" modal that FREEZES the editor headlessly.
• The editor's "Use Less CPU when in Background" must be OFF or MRQ never emits frames (already set in this project's config).
• Output file_name_format = "{frame_number}", PNG, to a folder; write a small done-marker file in the executor-finished delegate so a separate step knows when frames are ready.

Assemble

Once the frames exist, ffmpeg them: ffmpeg -y -framerate 30 -start_number 0 -i "<out>/%04d.png" -c:v libx264 -pix_fmt yuv420p -crf 18 final.mp4 (run this from a Bash tool call; the editor render is async, so wait for the done-marker first).

You author all of the above yourself from this recipe — no prebuilt recording script is provided.

Crowd LOD (avoid pedestrians popping in/out)

MassCrowd culls / swaps pedestrian representation by distance from the camera. With the default MassCrowdVisualizationTrait LOD distances (base_lod_distance = [0,500,1000,5000]) peds beyond 5000 are not rendered and swap representation at 500/1000, so a moving camera makes them pop in/out. For a clean recording, push the LOD tiers out so the whole street stays high-res: on /Game/AI/AgentConfig/MassCrowdAgentConfig_MetaHuman -> config.traits[MassCrowdVisualizationTrait]: lod_params.base_lod_distance = [0, 9000, 14000, 30000], visible_lod_distance = [0, 14000, 30000, 50000], and params.not_visible_update_rate = 1.0. Save the asset once (it's a project-wide, deterministic setting).

Volume-aware signage (phase D) + neon pairing

Signage is where scenes look cheap if done naively (signs sunk into walls, facing the wrong way, all the same, all at one height). Do it volume-aware.

Measure before you place

A sign mesh has its own size and its own local forward axis. Spawn it once at a scratch location, measure:

a = eas.spawn_actor_from_object(mesh, unreal.Vector(0,0,9000), unreal.Rotator(0,0,0))
origin, extent = a.get_actor_bounds(False)     # extent.x/.y/.z = half-sizes
eas.destroy_actor(a)                            # throw away the probe

Now you know how far it sticks out. Rotate it to face the street (yaw per references/layout.md), then offset it along the wall normal by its own half-depth so the back sits flush on the facade and the face points at the carriageway — never buried in the wall, never floating off it (tilted_signs, floating_signs).

Three kinds — mix them (diversity check)

• flush: face parallel to the wall, sitting just proud of it.
• blade: perpendicular to the wall, sticking OUT over the sidewalk toward the street (classic).
• hanging/overhead: higher up, spanning or projecting over the walk. Vary the HEIGHT band too — some at eye level (~150-350cm), some mid, some high. All signs at one height triggers signs_one_band. Using only 1-2 distinct sign meshes triggers few_sign_meshes / sign_repetition — keep a pool and pick varied ones.

Pair EVERY sign with a neon RectLight

Each sign gets a colored unreal.RectLight placed just in front of it, facing the street, so the sign glows and spills colored light onto the wet ground:

# small helper you write: spawn a RectLight at the sign's face, intensity ~4, radius ~650,
# color matched to the sign (cyan / magenta / amber), cast_shadows=False, label "neon_rect"

Missing pairing → sign_light_pairing loses points; it's also what makes the street feel alive.

Eye-level density

Put enough signage + props in the eye-level band along the corridor so a first-person camera walking the centre always has something interesting close by (eye_level_density, sparse_eye_level). Don't overload litter though (litter_overload).

UE-Python API — the calls you need

All actions run inside the editor via execute_python_script. Subsystems you'll use:

import unreal
eas = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)      # spawn/destroy/list actors
les = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)      # save/new level, PIE
ues = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)     # get_editor_world()

Load an asset

unreal.load_asset(path) → returns the asset object (mesh, material, niagara system…) or None if the path is wrong. ALWAYS null-check — a wrong path silently returns None and your spawn does nothing.

Spawn a static mesh (this is 90% of the build)

eas.spawn_actor_from_object(mesh_asset, unreal.Vector(x,y,z), unreal.Rotator(roll,pitch,yaw)) → returns a StaticMeshActor. Do not touch its scale (leave 1,1,1). Purpose: place a building piece / prop. Rotation is Rotator(roll, pitch, yaw) in degrees — yaw turns it around Z (to face the street). Set a label for later bookkeeping: actor.set_actor_label("facade").

Apply a material instance (only if the asset needs it — usually it doesn't)

Get the mesh component, set the material slot:

smc = actor.get_editor_property("static_mesh_component")   # or actor.static_mesh_component
smc.set_material(slot_index, material_instance)

Gotcha: NEVER set a slot to a default/engine material — the verifier flags default_ground / washed meshes.

Spawn a light

eas.spawn_actor_from_class(cls, unreal.Vector(x,y,z), unreal.Rotator(0,pitch,yaw)) where cls is unreal.RectLight (neon panels), unreal.PointLight/unreal.SpotLight (lamps), unreal.DirectionalLight (moon), unreal.SkyLight (ambient). Then get the light component and set properties:

comp = actor.get_component_by_class(unreal.LightComponent)   # or the specific subclass component
comp.set_editor_property("intensity", 4.0)
col = unreal.Color(); col.r, col.g, col.b, col.a = 255, 80, 200, 255
comp.set_editor_property("light_color", col)                 # Color is 0-255 ints, NOT LinearColor here
comp.set_editor_property("attenuation_radius", 650.0)
comp.set_editor_property("cast_shadows", False)              # neon signs: shadows off = cheaper + cleaner

Gotcha: light_color on a light component wants a unreal.Color (0-255). LinearColor is used elsewhere (e.g. DirectionalLightComponent.set_light_color) — if one raises, try the other.

Fog, exposure, reflections — see references/lighting.md (they have specific property names + values).

Measure an actor's real size (for volume-aware placement)

origin, extent = actor.get_actor_bounds(only_colliding_components=False) → both are Vector; the mesh spans origin ± extent. Use this to know a facade's width before you step the next one, and to offset a sign so it doesn't sink into the wall. See references/signage.md.

Particles / rain

Niagara: na = eas.spawn_actor_from_class(unreal.NiagaraActor, unreal.Vector(x,y,z)) then na.get_component_by_class(unreal.NiagaraComponent).set_editor_property("asset", load_asset(NS_RAIN)). Old Cascade systems use unreal.Emitter + component template. Puddles are unreal.DecalActor with a puddle decal material and get_decal().set_editor_property("decal_size", unreal.Vector(...)).

New level / save

les.new_level("/Game/Maps/CyberXX_1")                       # fresh empty map to build into
les.save_current_level()                                    # after every phase / fix
world = ues.get_editor_world()
unreal.EditorLoadingAndSavingUtils.save_map(world, "/Game/Maps/CyberXX_1")   # save-as

List / count actors (stay under the cap)

eas.get_all_level_actors() → list; len(...) for the count. Filter by a.get_class().get_name() or a.get_actor_label().

Self-verify + iterate

You judge your own scene with a verifier that prints CYBERPUNK SCENE SCORE: XX/100 plus a per-check breakdown and a list of issues. Run it, read the LOWEST checks, fix exactly those, re-run. Loop until ≥ ~92/100 or gains stall.

How to run it

The verifier is a script you may execute (only the BUILDER is off-limits — verifying is fine). It lives inside this project; exec it inside the editor via the bridge tool:

exec(open(r"E:/UE/cyber_local_run/tools/verify_cyberpunk_scene.py", encoding="utf-8").read())

It also writes a JSON with metrics + issues. Read both the score line and the _scoring breakdown.

The scored checks (know what each rewards)

Common failures → fix

• sun_on / ambient_too_bright → lower DirectionalLight ≤ 0.8, SkyLight ≤ 5.
• too_few_lights / light_density low → add warm lamps down both sidewalks.
• no_hero_neon / no_light_pollution → add a few giant bright neon RectLights (≥ 8).
• repeated_elements / monotone_walls / sign_repetition → widen your mesh pool, jitter placement.
• no_collisions low / prop_collisions → offset overlapping props by their measured bounds; carve the corner.
• floating_signs / tilted_signs → volume-aware placement (references/signage.md).
• no_backdrop / dark_skyline → add/raise the distant skyline (references/layout.md).
• no_rain / no_fog / default_ground → add rain FX / fog / the real wet-asphalt material.
• sparse_eye_level → add restrained eye-level signage/props along the corridor.

Loop discipline

Fix ONLY the lowest checks each round (don't rebuild). save_current_level() after each fix. Stop when ≥ ~92, or after ~6 verifier runs, or when two rounds in a row improve < 1 point.

A note on honesty

The verifier scores geometry/metrics, not a screenshot. The exposure lock (references/lighting.md) can be missing while the score is high — so ALWAYS apply the exposure lock even though no single check fails loudly for it. A high score with a washed-out render is still a fail.