AI tools: Worlds, nature and light

Terrain, forests, water, weather, sky, lighting and streaming. 29 tools. You see every step your AI takes and can undo any of them.

build_path

The game's build path, read from the real project: world → player → enemies → goal → menus → sound → test → share, each done or not with what's there, the next step, and the Teach Me lesson for it. The person sees the same path in Make mode ("Your game"). Use it to know what's left and say it in their words; to show them how to do a step by hand, teach {action:"start", lesson}.

No arguments.

build_road

Lay a road of any type along control points (a smooth spline through them): city street, avenue, highway, ramp, country road, dirt or gravel track, alley, runway, taxiway, race track, bridge street. It joins the scene's road network: intersections build themselves where it meets other roads (corner curbs, crosswalks, stop lines, lane arrows, signals or stop signs), ramps merge into highways, it becomes a bridge with piers over water and deep valleys, the land is cut and filled to it, ground cover cleared, lamps, signs and guard rails placed by its type, and the lane graph updated for traffic. Same name again replaces that road. One undo step.

cost_map

What each part of the map costs the frame from this view, in GPU milliseconds, measured: every group of objects (or, with group, every object in that group) is left out of the live view for a moment and the frame timed against everything shown. The scene itself never changes. Use it while building to know what a thing costs, and before optimizing to know where to start. Lamps count with the object that owns them. Over HTTP it returns a job_id at once: read the result with tool_job.

design_land

Design land from intent: a base style plus features the landscape must satisfy, solved in order (cliffs, passes, level pads, lakes, then a river along the lowest ground, then roads routed and cut/filled to a maximum grade around the water). Roads become asphalt ribbons, rivers and lakes water. Reports what each feature became and a survey (walkable/drivable share, buildable areas, lookouts, whether features can be reached on foot and by car). Replaces a terrain of the same name.

grow_plant

Grow a park or garden plant natively, with real leaf detail and wind sway: oak (mature, broad crown), young_oak, maple (red leaf_color [0.62,0.07,0.04] for autumn), willow (weeping strands), pine, birch, bush, flowering_bush, hedge (a clipped segment `length` long to repeat along a path with add_hedge). Tropical: flame_tree (a wide umbrella crown in bloom), breadfruit (a dense round crown with fruit), banyan (broad and low, aerial roots hanging from its limbs, the oldest grown into pillar trunks); and big-leaf clumps heliconia, elephant_ear, bird_of_paradise, banana, tree_fern (real bent leaf blades or fronds on stalks cut from the species' photo atlas, flowers and fiddleheads on their own stalks; the tree fern on a photo-bark trunk); forest floor: fern (a crown of arching fronds from the ground, ~0.7 m) and bracken (a stalk with one broad frond held nearly level, ~1 m), from the library's fern fronds or leaf_atlas / species_atlas, and herb (broad leaves on long stalks in a low clump, ~0.3 m; give its leaf_atlas or species_atlas, e.g. one made with make_cover_atlas), sorrel (wood sorrel: a low mat of trefoils, ~0.1 m), bramble (arching shoots of three-leaflet leaves, ~0.55 m), ivy (a creeping ground carpet, ~0.12 m), holly (glossy spiny leaves on upright sprigs, ~0.5 m), dogs_mercury (~0.3 m) and seedling (a tree seedling, ~0.14 m), each from the engine's own leaf sheets; and bougainvillea, a climber covering a wall `length` wide and `height` tall (its face toward +z: place it against a wall, fence or facade), stems up the wall and a cascade over the top. Bark is a photo from the engine's material library (real fissures with depth, moss on the north side); leaves use the library's photo atlas for the species when it has one, else cut-out cards drawn in the species' leaf shape, crown-shaded, lit through from behind; two levels of detail are written beside it. Into Assets/Forge/Nature/<name>.glb (+ _LOD1, _LOD2). Same kind + another seed = another plant of that kind. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

light_truth

Does the light match what you see? Checks every see-through surface in the scene (windows, door glass, bottles, lamp globes: a material with transmission, or one named glass/window/pane) and reports two numbers each: how see-through it looks (the share of the view through it that reaches the eye: the material's transmission dimmed by its dust, frost, smudges and condensation) and how much of the sun's or moon's light it lets into the room (glass that casts shadows tints and dims the light by exactly the same layers; a pane with casts_shadows off passes it untouched; an opaque pane blocks it). A mismatch over 20 points is flagged: a pane that looks solid while full moonlight comes through it throws off the eye. Lamps within 1.5 m of a pane that stand in for light through it (a window fill) are listed with the share their light should keep. Also flags glass forged without transmission (it draws as a solid grey panel; re-forge with f.glass). fix: true turns casts_shadows on for real glass that passes light untouched (one undoable step); opaque glass needs a re-forge. Read-only otherwise.

lighting

Lighting report and settings: bounced light (probe grid spacing around the camera, the near-camera cascade that gives small rooms in big levels their own dense probes, probes re-traced per frame and GPU ms), the night sky (what lights the scene, sun or moon, the moon's direction, phase and light, star visibility) and reflections (screen-space strength, placed room captures and the automatic one in closed rooms), with fixes for common mistakes (a night made with a blue sun above the horizon, reflections at 0, rooms smaller than the probe spacing). Set near_cascade / near_cascade_budget / night_sky / auto_capture to change the renderer for this session (A/B). City scale (Open City): far_cascade (bounced light out to a few hundred metres past the 72 m grid), traced_reach (how far objects go into bounced light's traced scene), far_shadow / far_shadow_reach / far_shadow_every (the sun's shadow past the cascades, redrawn every few frames), city_glow_map (the night glow by where the city's buildings and lights are, not an even dome); the report gives each one's numbers. The moon itself is set on the directional_light: moon, moon_phase, moon_azimuth, moon_elevation, stars. For sheltered surfaces, author reflection_capture.weather_occlusion as interior or roof; the volume also shields scene-wide rain, damp and puddles on room-facing walls, while exterior faces and locally authored wetness remain exposed. Its fade is the bounded wall-face probe distance.

make_biome

Grow a whole biome over the land in one undoable step, every layer with its own noise patches: canopy trees (forest form, some dead and snags), a mid layer of young trees and shrubs, deadwood (logs, stumps), a litter layer of small forged pieces (needle clumps, leaves, twigs, cones, stones, moss pads, bark), photo ground cover (grass, ferns, leaves, pebbles) and painted ground layers. Presets: temperate_woods, pine_forest, beech_forest, or a saved Assets/Biomes/<name>.biome.json (save_as writes the preset to edit). Missing tree and litter models are grown first. Keeps clear of roads, trails and water. The same name again replaces the earlier biome. HTTP calls return a job_id immediately; read progress and the final result with tool_job instead of repeating the tool.

make_horizon

Surround the land with distant country so it never ends at a hard edge: its edge carried out (width, default 1200 m) and up into wooded ridges (ridge, default 30 m), with a ring of far trees (the trees' coarsest level; count, default 600) on it, fading into the haze. Visual only (nothing walks there). Replaces an earlier horizon.

make_terrain

Make land: hills, mountains, an island in a sea, a valley or a canyon, as a heightmap painted by slope and height (grass, rock on steep ground, sand by the water, snow on peaks). Players walk on it, cars drive on it, bullets hit it, bots path around steep ground. Shape it afterwards with sculpt_terrain. Replaces a terrain of the same name.

many_lights

Stochastic lamps (the idea of Unreal's MegaLights): each pixel shades two of the lamps that reach it, picked by how much each could light it, each with a ray-traced shadow, instead of shading every lamp, so a scene's cost stops growing with its lamp count and lamps without a shadow map cast real shadows (a bulb no longer lights through a wall). on: true/false for the session; debug: true shows the picks view (where pixels shade from their picks, where the picks were shadowed, where every lamp is still shaded in full). Reports the scene's lamps (in the pool: every lamp without its own shadow map, bulbs, spots, tubes and panels; the few lamps given a shadow map are shaded in full as before), and the lamp path: forward_up_to sets how many lamps in view every pixel walks before the clusters' lists take over and whether the last frame used the picks (it needs ray-traced shadows on this GPU). Measure it with frame_profile {"experiments": ["stochastic_lamps"]} (GPU busy is the number to trust) and judge it moving (it is averaged over frames) before keeping it on.

ocean_look

Put a reference-matched ocean look on the scene, one undoable step: the spectral sea's wind, fetch, spread, chop, colour, clarity, absorption and foam, the camera look's neutral tone curve (the filmic one crushes the sea's dark tones) and the cloud cover the look's references were photographed under. Every value stays a live ocean field afterwards (edit_entity, the Inspector). Without look: lists them.

plant_trees

Plant a forest, a grove or a row of trees here: models from grow_plant (or any tree/bush model) scattered over an area (center + radius, or an outline `points`), `count` or `per_100m2`, kept `spacing` apart, out of water and clear of named objects, sized and turned at random, standing on the land. Each tree gets a trunk collider. One group, one undoable change; the same name again replaces the earlier set.

rebuild_roads

Rebuild everything made from the scene's roads (meshes, props, signals, colliders, cut-and-fill, ground cover clearing) after editing roads by hand in scene text or the inspector. One undo step. Land whose cut-and-fill another scene's roads made (scenes sharing terrain files) is left alone and reported; take_land: true cuts it for this scene's roads instead.

road_network

Whole road layouts from intent, as ordinary roads in the network. kind "grid": a town grid of streets (columns × rows blocks, optional avenues), with building plots along the blocks facing their street (and buildings placed on them from `buildings` models, turned to the street). kind "route": a road from one point to another over the land, routed to keep its grade and stay out of water (a country road into the hills, a dirt track). kind "interchange": a highway lifted on a bridge over a crossing road with four ramps (a diamond). kind "settings": the network's drive side, signal timing, lit lamps, cut-and-fill, ground-cover clearing, wet pavement, wear. One undo step.

rooms

Room visibility (room and portal components): the renderer draws the room the camera is in and the rooms seen through its open portals (doorways, windows), each only through its opening; objects wholly inside a room nobody can see aren't drawn and its lamps fade out. Rooms within `near` m of the eye stay on, rooms linger `linger` s after they were last seen, lamps fade over `light_fade` s, portal openings count `portal_margin` (share of the half-screen) wider. view: true draws the rooms view (rooms green seen / yellow kept on / dark red off; portals cyan see-through / red closed). culling: false turns it off (A/B). Reports the rooms drawn this frame.

scatter

Scatter copies of models over the land by rules: how many, where (an area, a height band such as a beach, the steepest slope allowed), how far apart, size and lean variety, random turn. Seeded, so the same call gives the same layout; calling again with the same name replaces the earlier set (one undo step). For trees, palms, rocks, bushes, ruins, crates.

spider_webs

Spin spider webs between real surfaces (never floating: Gordon's rule, webs live in corners, connected to things). Give spots near corners: a post meeting a beam, a doorway's top corner, a counter by a wall, between ride bars. For each, rays go out into the scene's own triangles (every model near it, and the land) and the web is built from what they hit: kind "orb" (frame threads ending on the surfaces round the spot, radials and a sticky spiral; `facing` sets its plane's normal, default: tried round and the best kept), "sheet" (a cobweb's sagging tangle between the faces meeting at a corner), "strands" (a few long threads between surfaces), or "auto" (an orb where the surfaces surround the spot, else a corner sheet, else strands). A spot with too little to hang from gets no web, and the report says so. Each web is written as a model (Assets/FX/webs/gen/<name>_<hash>.glb, a new file each spin) on a new object at its spot, in one undo step. Replaces objects of the same names.

stream_build_hlod

Makes the far stand-ins of the open streamed map (HLOD): for each cell, its objects merged into one model (their coarsest levels where they stand, flat colours baked from materials and textures, things smaller than min_size left out, simplified to max_triangles), written to Assets/HLOD/<map>/c_<column>_<row>.glb. The map then shows each cell's stand-in out to far_radius while the cell itself isn't loaded, so the whole city stays on the horizon. Only cells whose file changed are rebuilt unless rebuild_all.

stream_split

Cuts the open scene (a whole map: a city blockout, an island) into a streamed map: every placed object goes into the scene file of the cell it stands in (an attached object goes with what it follows), and a new map scene keeps what is always there (land, sea, sky, sun, roads, the player and cameras, vehicles, creatures, ground cover, forests, water, weather, sound mixes, anything wider than three quarters of a cell) plus a world_streaming component pointing at the cells. The open scene is not changed. Open the new scene, fly around, and read stream_status.

stream_status

A streamed map (world_streaming) right now: the grid and its settings, where the eye is and where it is heading, cells loaded / entering / reading / leaving / failed, objects streamed in, what entered and left last frame, the step's cost, the slowest cells to load and why any failed. Turn the cell grid on in the view with the component's show_grid.

No arguments.

survey_land

Read a terrain the way a level designer would: walkable and drivable share, buildable flat areas, lookout points and how much they see, and whether named places can be reached from a start on foot and by car.

terrain_hole

Cut a hole in the land (a cave's mouth, a pit, a shaft) or close one again: the cells within an ellipse round `at` [x, z] (world, metres; `radius` one number or [along x, along z]) open: nothing is drawn or grown there, nothing stands on it, and rays, bodies and walkers pass through to whatever is below (a cave mesh brings its own walls; the land hangs a short rim into the hole). close: true fills them back. Saved beside the heightmap (<name>.ttrhole); undoable.

tornado

Tornadoes and waterspouts (the `tornado` component: one object each, touching down where it stands; every field stays live in the Inspector). action: spawn (at [x, y, z] plus any fields; name optional), steer (name, or none when there is one; change any field while it runs: a new heading or speed turns it from where it is, at moves its start), remove (name), or list (the default: every tornado now: stage forming / mature / rope_out / gone, age, where its foot is, how fast it moves, core radius and peak wind now). Fields: strength (EF 0...5), radius (core m; -1 typical for the strength), height (cloud base m; -1 the weather's), speed (m/s), heading (compass degrees it travels toward), waterspout, lifetime (s; 0 endless), loop, delay (s), wobble 0...1, path [[x, z], ...] (m from its position, followed at speed), clockwise, lift (scales lift on loose bodies), debris 0...2, seed, enabled. points [[x, y, z], ...] also reports the whole wind there (weather and tornadoes, m/s) and each tornado's own share. Loose bodies in reach are pushed and the light ones lifted (EF mass limits); scripts hear tornado_touchdown, tornado_rope_out, tornado_lifted and tornado_hit.

traffic_status

City traffic and pedestrians in play: how many traffic cars are round the player against how many the road network's traffic setting wants (cars per km of lane within traffic_radius, at most traffic_max), how many template cars they're copied from (cars tagged traffic_template), and how many came and went. Set traffic on the road_network object (edit_entity: road_network { traffic 8 }) and tag one or more parked cars traffic_template.

No arguments.

water

Ask the sea: its level and waves (length, period, speed, direction), and at given spots the water's surface right now, the depth to the bottom and what that means (dry land, wading, swimming, boats can pass, bottom visible). Matches what the renderer draws.

water_event

Tsunamis and floods. action "tsunami": a long travelling wave on the scene's ocean from `origin` [x, z] or [x, y, z] toward `heading` (compass degrees): amplitude (m in open water), wavelength (m), shape solitary or n_wave (the sea draws back first), drawdown, depth (m; 0 uses speed m/s), width (crest length, 0 endless), reach (m), start (s after Play; -1 waits for action start), break_ratio. It shoals against the terrain's seabed, breaks, runs inland; boats and floating things ride it. action "flood": rising water over `center` [x, y, z] in a circle of `radius` (or `outline` [[x, z], ...] around center): from / to (world heights, m), rise_time (s), start, current_heading, current_speed (m/s), rain_rise / drain (m/h with the weather's rain), ceiling, debris (floating planks and drums to drop in, 0-60); muddy water by default. action "start" (name): start or restart one now. action "remove" (name). action "query": `points` [[x, y, z], ...]: water surface, depth and current there. action "list" (default): what's set up and how far along it is. Scripts hear 'tsunami_arrival' and 'flood_level'.

weather

The scene's weather. Set any of: preset (clear, overcast, rain, storm, thunderstorm, snow, fog, hurricane), intensity 0...1, transition (seconds to blend in while playing), wind_heading (compass degrees it blows toward; -1 the preset's), wind_speed (m/s at 10 m; -1 the preset's), gusts and turbulence (multipliers), seed, storm_center [x, y, z] and storm_area (m), drive_plants / drive_clouds / precipitation_fx, cycle (a list of "<preset> <seconds> [intensity]" played in order and again: sun, overcast, fog, rain, thunderstorm, clearing). remove: true takes the weather out (the scene's own wind and clouds come back). Always reports the blended state now; `points` [[x, y, z], ...] also reports the wind there (m/s, with gust, updraft and turbulence); cells: true lists the storm cells alive now (centre, radius, rotation, up/downdraft, strength).

weather_view

The weather view, drawn over the viewport (editing or playing) so the person watches the weather being tuned: wind arrows on a grid around the camera at chosen heights (length = how far the air moves in 0.5 s; colour by speed: cyan calm < 6 m/s, green breeze, yellow 14+ gale, orange 24+ storm, red 33+ hurricane; they tilt with updrafts), storm cells as rings on the ground (core white, downdraft ring blue, updraft column green, scaled by strength), lightning bolts while they flash, and the sea's wind as one long blue arrow from the camera's foot.