Component reference
Every component an entity can have, with every field.
Every object in a scene is an entity with components. Each component below lists every field it has, its unit and range, and what it does. This page is generated from the engine source, so it matches the build: 110 components, 1370 fields.
| Component | What it does | Fields |
|---|---|---|
about | What this object is in the game, in plain words, for people and agents. | 2 |
action_2d | 2D: how an object takes part in action. One accepted hit (its anim_2d hit boxes touching another's hurt box, a stomp, or a script's self.hit) applies damage once and drives everything else: hit-stop on both sides, camera shake, the target's flash, knockback, a burst and a sound. Scripts get onMessage 'hurt' { damage, by, health, seq } and 'hit_landed' { target, seq }. | 14 |
anim_2d | 2D: frame control for the sprite's clips: per-frame durations, frame events (footsteps, the hit frame, sounds, spawned effects; each fires exactly once per crossing), per-frame hit and hurt boxes, and a state machine that picks the clip (states with priorities and cancel windows, transitions on params and buffered triggers). Runs on the actor's own clock, so hit-stop freezes it. Scripts: self.anim.fire("attack"), self.anim.set("dir", "side"), self.anim.state; onMessage 'frame' { event, value, clip, frame } and 'state' { state, from }. | 8 |
animator | Plays skeletal animation on a rigged character mesh. clip "auto" picks idle, walk, jog or sprint from how fast the object moves. | 19 |
attach | Rides along with another object, keeping an offset from it and turning with it (a light on a character, a flashlight on a guard). | 17 |
audio_emitter | An ambient loop or one-shot, recorded from the project's sound library when one fits (else a synthesized placeholder). Uses the real source position and geometry; no external sound packs. | 7 |
audio_mix | The scene's mix: music track (crossfaded), ambience bed, bus trims and ducking. All first-party synthesis unless a WAV is named. | 11 |
audio_motor | Continuous first-party motor and speed wind. Driven cars feed actual throttle/speed; RPM is explicit or a labelled audio approximation. | 10 |
audio_music | Layered adaptive score driven by the existing awareness states: three recorded stems (stems) or the original procedural score. The first enabled director by entity ID wins. | 10 |
audio_surface | First-party synthesized contact sound. Overrides inferred visual surface; does not change the look. | 2 |
audio_walker | Distance-driven procedural footsteps and landings. Players get defaults; other moving actors opt in here. | 6 |
awareness | How a guard, sentry or stalker notices players: a sight cone whose reach depends on the light actually on the player (dark_sight in the dark ... sight in good light, less against a crouching player; walls and furniture block it), footsteps heard by gait (running, walking, crouching), noises (game.noise, lures), and a suspicion meter: half full it comes to look (suspicious), full it chases; losing the player it searches where it last knew he was, then gives up and goes back (return). Scripts read self.awareness { state, suspicion, seeing, point, ... } and walk (kits/guard.js); self.alert(position), self.stun(seconds), self.calm(), self.sleep(wake). | 19 |
backdrop_2d | 2D: a full-screen picture that scrolls slower than the world for depth (parallax): far sky, hills, trees, mist in front. | 12 |
balance | A physical body under the animation (characters): its centre of mass sways on a spring over its feet. Pushes and bumps sway it (the trunk tips, the hips follow); a push that would carry it past its feet makes it take a recovery step; two characters with balance that walk into each other meet at the shoulders, are pushed apart (never through each other) and both sway. Scripts push with self.push([x, y, z]) (m/s) or self.pushAside(other) (hands on the other's near shoulder, then a shove away). Only what differs from the defaults is written: balance { }. | 3 |
blade_trail | A glowing trail left by a moving blade: a sword's cut, an axe's arc, a claw's swipe. The renderer samples the blade's edge (base to tip, in the object's own space) where it is drawn every frame, a sword held by a bone included, and draws the surface it swept as light: brightest toward the tip, a white-hot newest edge, streaks along the arc, fading over its life. It shows only while the tip moves faster than min_speed, so a cut leaves a trail and a walk doesn't. Scripts dial intensity for a heavy blow (entity.set("blade_trail.intensity", 2)). | 8 |
body_2d | 2D physics: a box (or a convex shape) that collides with tiles, slopes and other bodies. kind "player" runs and jumps from the controls (coyote time, jump buffering, variable jump height), "topdown" walks 8 ways from the controls with no gravity (pushes crates, picks up carry bodies with E), "projectile" flies at its velocity and reports "hit" on the first thing it meets (swept: never passes through), "actor" has gravity and is moved by its script (self.velocity), "dynamic" bounces and gets pushed, "solid" stands still or travels (moving platforms, blocks), "sensor" only reports overlaps (onEnter/onExit: coins, flags). Bumping a solid from below sends it "bumped". | 38 |
boost_pad | A boost pad: every vehicle driving onto it gets speed km/h more over seconds, once each time it crosses (player and AI cars alike). Its area is a box of size whose bottom sits at the object's position, turned with it; put it on a flat pad model. | 3 |
brain | Data-driven enemy brain using the existing awareness, actions, navigation and stats. Presets: patrol, hunter, chaser, shooter, pack, stalker, guard. add_brain configures it; set_patrol edits its route; ai_report explains each tick. Keep existing sensory settings. Do not also attach a movement-driving enemy/guard script to the same entity. | 8 |
building | A building the engine makes floor by floor from a style (plinth, shopfronts or a house front, bays of windows set into the wall with frames and sills, shutters, balconies, bands, cornice, a flat roof with its parapet and plant or a hip or gable roof with eaves). The object's position is the middle of its footprint at ground level; rebuild_buildings makes the models and a box collider. | 9 |
camera_2d | 2D: the view of a 2D scene, orthographic over X/Y. Smooth and sub-pixel by default (any resolution); pixel_perfect draws at a fixed virtual resolution scaled up by whole numbers. Follows an object with a deadzone and look-ahead, kept inside bounds. | 19 |
camera_look | The scene's photographic look: exposure, haze and color grade. Usually set with apply_look. | 73 |
camera_rig | A third-person camera on the character: over one shoulder, never inside a wall (swept as a ball, pulled in at once, easing back out), shoulder swap and first/third-person switch on keys, each change blended. Without it the character keeps its built-in camera. | 10 |
camera_zone_2d | 2D: a camera room. While the camera's followed object is inside the box, the camera stays inside it (hard edges) and uses the room's view height, deadzone and look-ahead if set. Higher priority wins where rooms overlap. Room changes blend over blend seconds without ever showing outside the two rooms. Scripts: game.cameraRoom, onMessage "camera_room". | 8 |
character | The player's character while the game plays: WASD moves, the mouse looks, Space jumps, Shift sprints. Tag it "player" so triggers notice it. | 27 |
checkpoint_2d | 2D: a checkpoint area. When the player enters the box, the game's state and position are remembered there (game over's Retry comes back to it) and, with autosave, the autosave slot is written. Scripts get onMessage "checkpoint" { name }. | 5 |
cine_camera | A physical cinema camera (sensor and lens kit, chosen by name): a sequence cut naming this object (camera) films through it with that lens on that sensor: real field of view, breathing, depth of field and bokeh, distortion and fall-off. Key its fields in a sequence for zooms, focus pulls and iris changes. camera_gear lists bodies and kits. | 13 |
cloth | Real cloth that moves in play: a flag on a pole, a curtain in a window, a banner between posts, a tarp on a frame, a sheet on a line, a cape. It hangs from its pins, blows in the scene's wind (gusts ripple across it) and never passes through the colliders and characters near it: poles, walls, crates, the player walking into it. A rectangle in the object's own XY plane facing +Z, width across centred on the origin and height up from it (a flag's left edge at x = -width/2, against the pole). Drawn from its own mesh; the editor shows it at rest (cloth tool view on runs it there). Tool: cloth (make, pin, retune, view, report). | 18 |
clouds | A layer of cumulus over the whole scene: real 3D clouds the sunlight passes through (bright tops, grey bottoms, silver edges toward the sun), drifting with the wind, fading into the haze far away. | 7 |
collider | Makes the object solid: characters and bots walk around it, and (with physics) things collide with it. | 5 |
combatant | Opt-in combat. Uses stats health. Anatomical bone hurtboxes by default; authored hurtbox entities override them. Scripts: self.attack(move), self.block(on), self.dodge(), self.combat, self.hitscan(options), self.projectile(options). Damage notifications are combat_damage/combat_hit (already applied, never subtract again). | 22 |
creature | A native fish school or bird flock member: bounded habitat, boids, obstacle clearance and optional landing. Fish require a named ocean. Generated meshes come from create_creature; spawn_school/spawn_flock place nonintersecting groups. | 14 |
cutscene | A cutscene (intro, story beat) as a timeline file: keyframes for any field in this list (transform.position, point_light.intensity, animator.expression...), camera shots with cuts and blends, timed events (say, sound, send, animate, power), and a hand-off to the player. Scripts start one with game.playCutscene(name). | 4 |
decal | A decal pressed onto the surfaces inside the object's box: an image (graffiti, a sign, a poster) or a built-in mark (bullet_hole, crack, rust_streak, water_stain, drips, scorch, chipped_paint, oil, glass_crack, grime, dust, paint: worn painted lines and markings; blood, blood_drop, blood_run, blood_pool: spatter, a drop's stain, a run down a wall, a pool; patch, skid, manhole, drain, gutter, litter, leaves, gum: street wear). It is lit, wet and reflective like what it lies on. It projects along the object's -Z: rotation (-90, 0, 0) lays it on the floor; on a wall turn the object to face out of the wall. Supports atlas tiles, ordered layers, color/normal/roughness channels and angle-faded edges on curved meshes. Scripts spawn them for bullet holes and damage. | 21 |
directional_light | Sunlight: parallel light from one direction, with shadows. | 10 |
driver | A character driving the vehicle it sits in, alive: its hands stay on the steering wheel as it turns, it leans into turns and with braking and boost, bounces on the seat over bumps, looks into the corner (at the next gate when the race marks one), breathes, and a tail or ears swing behind. A layer over its seated pose clip (seat_driver seats it and adds this). Reactions: game.driverReact(name, "boost" | "hit" | "win" | "lose"); boosts and hard knocks react by themselves. | 11 |
equip | What a character wears and holds, by slot (head, chest, legs, feet, hands, back, main_hand, off_hand, or a game's own): items from Assets/Items/<id>.item.json. Worn cloth is fitted to this body and drawn as part of it (skin under it hidden); helmets and weapons ride their bones as child objects "<name>/<slot>". Scripts: self.equip("short_sword"), self.unequip("main_hand"), self.equipped(); messages equipped/unequipped. Tools: equip_item, unequip_item, equipment_report, equip_prepare. | 3 |
flame | A real flame: a candle, an oil lamp, a torch or a fire (campfire, fireplace). It burns as a flame (a blue root, a darker cone over the wick, a white-yellow core, an orange rim, licking and flickering, leaning in a draft) and lights the scene with its own light, flickering and swaying in step with it and casting shadows, with hot air shimmering above. Put it where the wick (or the burning wood) is. | 12 |
flood | Rising water on this object's water body (a lake or pond outline drawn over the low ground; where the ground is above the level the water stays under it, so the outline can be generous): the level climbs from `from` to `to` over rise_time (and with the weather's rain), with a current that carries what floats in it. Give the water muddy colors and low clarity for flood water. Any change starts it over. Scripts hear 'flood_level' { level, name } every report_step. | 10 |
foliage | Ground cover grown by the GPU (no object per blade): lawn grass with real blades, meadows with wild flowers, flower beds, clover, pebbles, fallen leaves, reeds, ferns, weeds. Grows on this object's mesh or terrain, on the object named in `on`, or on a flat `area`; painted density, erase/trample strokes and scatter rules (leaves under trees, weeds by walls). Sways in the wind; thins and fades with distance. | 26 |
forest | A whole forest as one object: thousands of trees grown by rules over the land (no object per tree). Inside `radius` (or the `points` outline) it grows where noise patches `patch_size` across say so (`cover` the share), with clearings between and a soft `edge` where trees thin out and stay smaller. `density` trees per hectare, models picked from `meshes`, kept off water and steep ground. Seeded: the same settings grow the same trees. Near trees draw as ordinary objects (shadows, bounced light, twigs); far ones in batches. | 18 |
gait | Walks like its own person (with an animator on clip "auto"): about fifteen walk traits (step length and cadence, arm swing, pelvis sway, body bob, lean, head carriage, shoulders, elbows, toe-out, step width) made from a seed, shifted by presets (a mood, an age, a build), and every step a little different (about 2%, drifting slowly the way real steps do). The same seed is always the same person, on every machine and in replays; feet stay planted. With a stats component an empty stamina bar tires the walk. Only what differs from the defaults is written: gait { preset "tired" seed 41 }. Without a gait component every animated character still walks as its own everyday person (seeded from its id and the session seed; steps vary half as much on a character the player controls); gait { off true } walks exactly as the clips do. | 21 |
game_flow | The game's lifecycle for this scene: autosave timer, a checkpoint at the scene's start, autosaves at checkpoints, what Retry does on game over, the game's save-state version and lives. Title, pause, game over, win and save/load menus come from the game UI (add_ui_screen with lifecycle). Scripts: game.flow, game.saves. | 8 |
glass | How the glass in this object's model looks (its see-through materials: windows, windscreens, bottles, lenses): rain beads and running drops, condensation, frost growing from the edges (lower it over time to thaw), smudges, fingerprints, dust, old-glass waviness, and overrides of how strongly it bends light (ior), its thickness and its colour by thickness. Glass refracts what's behind it, reflects the room and sky (Fresnel: a mirror at grazing angles) and tints its shadow. Only what differs from the defaults is written: glass { rain 0.6 streaks 0.4 }. | 21 |
grade_zone | A colour grade for a place: while the camera is in the box its LUT (a .cube in Assets or a built-in look) blends over the scene's camera_look lut, fading in over `fade` metres, so each area grades itself as you walk between them (a green-lit funhouse, cold moonlight outside). | 4 |
ground_area | A paved ground area: a flat polygon (x, z pairs about the object, turned by its yaw) at `height` above the object, in a building look (its surface: lava setts, plaza tiles, car park asphalt), with an optional kerb band round its edge and sides running `depth` into the ground. rebuild_buildings merges it into the chunk models with the buildings and makes it solid to walk and drive on: forecourts, plazas, car parks, lot ground with crisp edges. | 7 |
gun_move | How a character moves holding a gun, like a shooter's mobility: walk, run and sprint speeds that fit its gait clips, the slow walk aiming down the sights, ADS and sprint-out times, speeding up and slowing down, the armed posture (lean, softer knees) and gun bob and sway. Every number at 0 takes the class's default. | 33 |
gun_sound | A weapon class's synthesized sound as data: weight (low boom), crack, tail, mechanism, size, pitch, level, suppressor. 0 keeps the class default. | 10 |
heat_haze | Heat shimmer: the wavy, see-through bending of light in hot air rising off a fire or a hot vent, streaming out of a jet or rocket exhaust, or lying over sun-baked ground. Only what is behind the hot air ripples; things in front of it and the interface stay sharp. Fire particles already make their own. | 7 |
highlight | An outline round the object while the game plays: the thing under the cursor, a pickup in reach, a placement ghost, a quest target, a teammate behind a wall. Scripts put it on and off like any component (entity.set("highlight.color", [1, 0.8, 0.2]) / entity.unset("highlight")). | 2 |
hurtbox | An authored bone-attached receiving sphere/capsule. Any authored hurtboxes replace the fighter's automatic anatomical set. No missing bone silently falls back to a guessed location. | 6 |
interactable | Something players, bots, creatures and scripts act on through actions: a hinged door (open, close, lock, unlock; blocked by what's in its way), a pickup (pick_up into the inventory), a switch (use: a message, the power) or a vehicle seat (enter, exit). Players get a prompt ("E: open"); scripts call self.act("open") or game.act(entity, "open"); bots use doors and keys to reach objectives. | 18 |
inventory | What it carries: a character's pockets, a chest, a shop's shelf, a stove. Items are the project's Assets/Items/<id>.item.json; slots hold stacks up to each item's stack size; items tagged currency go in a wallet, not a slot. give/take (keys, pickups, scripts) go through it. Scripts: self.inventory (add, remove, count, has, slots, move, split, sort), game.items, game.loot, game.crafting, game.shops. A shop or a station opens its screen when the player uses it. | 7 |
jiggle | Secondary motion for heavy or soft bodies (a belly, a heavy character settling after a fall, a dragon's wattle): how much the parts swing after the body moves, how stiffly they spring back and how fast they settle. Sequences key it like any field (jiggle.amount) so a heavy landing can wobble and settle. | 4 |
joint | A physics joint to another object while the game plays: hinge (a door, a lid, a wheel, a see-saw), ball (a lamp on a chain, a wrecking ball), rope (only pulls: a swinging sign, a rope bridge's planks, a hanging crate), rod (holds a fixed distance), slider (a drawer, a piston, a lift) or weld (glued until it breaks). This object needs a collider and a dynamic rigid_body; the other any collider, or none (`to` empty: fixed to the world). A motor turns a hinge or drives a slider; break_force makes it snap (scripts get onMessage(self, "joint_break")). Many links at once (a chain, a rope bridge): the physics_rope tool. | 20 |
light_2d | 2D: a light in a 2D scene (lane 2d/light). kind "point" (a lantern: round, fading over radius), "spot" (a cone aimed along direction), "directional" (moon or sun over everything) or "ambient" (adds base light). Lights material_2d objects (everything with lighting_2d lit_by_default) that share its mask; with shadows, occluder_2d objects cast hard shadows. Flicker for torches. Scripts: self.setField("light_2d.intensity", 2). | 18 |
light_volume | Baked lamp light for a room: a box (centred on the object, world-aligned) whose still lamps (point_light baked true) are worked out once with real ray-traced shadows into a grid of light from every direction. Surfaces and characters inside read the grid instead of shading each of those lamps every frame, and those lamps need no shadow maps: a room of many lamps runs like a room of few. It follows its lamps' brightness while they change together (power on and off) and rebakes by itself when they, their pattern or the room's still geometry change. Size the box over everything its lamps light (alcoves and passages too): their light that gets out of it isn't drawn while it is in use. Moving lamps stay live; a baked lamp whose brightness changes on its own (a flicker, a script) becomes a flicker layer by itself, and flames can be baked (flame baked) the same way. | 3 |
lighting_2d | 2D: the scene's light settings (one per scene, usually on the camera): ambient light, time_of_day (a day-night cycle: ambient and a sun or moon follow the clock), bloom on glowing parts, lit_by_default (light everything without a material_2d: an existing scene goes to night with one switch) and the light budgets. | 10 |
live_screen | A live screen: a rectangle centred on the object, facing its +Z, showing another scene of the project live while playing (an arcade cabinet's picture tube, a television, a terminal). The scene (a 2D game) runs alongside in a session of its own; its picture is drawn here every frame. Nobody's keys reach it until a script hands them over: game.liveScreen(name, { play: true }) (see the script reference). | 9 |
material_2d | 2D: how a sprite, tilemap or backdrop_2d answers 2D light, and its effects. mode "unlit", "lit" (painted art) or "lit_pixel" (pixel art: stepped light on the art's own pixels). normal: "" uses <image>.normal.png if present, "auto" makes one from the art, "flat", or a file. emissive: "" uses <image>.emissive.png if present, "auto" (brightest warm pixels: flames, windows), "none", or a file; glowing parts bloom. Effects: flash, dissolve, heat (scripts: self.flash(), self.dissolve(), self.heat()). | 22 |
mesh_renderer | Draws a mesh: a built-in shape or an imported model. | 9 |
motion_2d | 2D: lifelike animation for a rig_2d character, made from numbers instead of drawn frames: breathing, walk and run blended by speed, jump take-off / rise / apex / fall / landing squash, turn-arounds and slope lean; melee wind-up, strike and follow-through with smear copies, aiming, hurt flinch, knockback and death; hair and capes on springs; and a Paper Forge face's blinks, eye look-at, talking mouth shapes and emotions. It follows the body, the anim_2d state and script calls. Scripts: self.motion.play("attack"), .emotion("angry"), .say("Hello there"), .aim(30), .lookAt(p), .die(). Messages: onMessage 'motion' { event: telegraph | strike | contact | land | step | dead }. | 24 |
motion_ai | The body moved by the motion AI (NVIDIA MotionBricks, run inside the engine) instead of its clips: every frame generated from the frames it showed toward key poses from a walk of our own, placed where the character is going at its speed, the feet placed where the model plants them. Standing, or until the network has loaded, the clips play (they fade into each other); off true compares it with the clip walk on the same character. Needs the model (Assets/MotionAI/mmm_v6_soma_fp16.onnx or TTR_MOTIONBRICKS_MODEL) and ONNX Runtime beside it. | 17 |
move_hitbox | A bone-attached sphere/capsule belonging to a named fighter and move. Multiple boxes in a move hit each victim only once per activation. @root explicitly uses the entity frame. Frames are zero-based; active_end is exclusive. Shared clip/fps/frames must agree across a move's boxes. | 15 |
occluder_2d | 2D: blocks 2D light; lights with shadows cast hard shadows behind it. shape "box" (size, bottom middle on the position), "polygon" (points) or "sprite" (traced from the object's sprite outline, as a convex hull). | 7 |
ocean | An endless sea at this object's height: wind-driven waves, sky reflections and sun glitter, clear shallows over sand, deep blue water, foam on crests and along the shore. Aircraft and boats meet it at its surface. | 31 |
particles | A particle emitter at this object: fire, smoke, sparks, dust or steam. Thousands of soft glowing or smoky puffs rising, drifting with the wind and fading out, drawn on the graphics card at almost no cost. Pair fire with a point_light for its glow on the ground. | 23 |
particles_2d | 2D: ambient particles (floating light motes, falling leaves, dust), drawn from the clock alone: free to run, the same in every replay. | 15 |
perception | How a creature notices the player and reacts to light: hunt only in the dark (or the light), back off from a flashlight. Scripts read the verdict with self.perceive() (kits/enemy.js uses it). | 6 |
placements | Thousands of placed copies of a few models as one object (archetype instancing: a city's buildings, a port's crates). The copies are a list in `file` (a project path, one copy a line: `model x y z rx ry rz sx sy sz` and optionally `r g b`, `model` an index into `meshes`, in world space); copies near the eye draw as ordinary objects, farther ones as instance runs (no object per copy). placements_from_objects makes one from plain placed objects. | 11 |
point_light | A light at the object's position: in every direction (a bulb, a fire), or a spotlight cone (a flashlight, a headlight) when cone is set. | 15 |
population | The living city (one per scene): how many pedestrians and cars live round the player, from a table of kinds of place (population_zone) by the hour, scaled by a density dial per platform; spawned out of view in a band, recycled from pools, the farthest culled first; far people drawn as a crowd (baked animation) and past that as billboards. Uses the road_network's pedestrian and traffic templates. | 13 |
population_zone | What kind of place this part of the city is, for the population table (a box `size` metres across, centred here, turned with the object): downtown, commercial, residential, industrial, park, beach, nightlife, highway or a row of the project's table. | 4 |
portal | A doorway, window or opening between two rooms (or a room and the outdoors) for room visibility: a rectangle centred on the object, facing its +Z. The rooms it joins are found from where it stands. state open: seen through; closed: a shut door, nothing beyond is drawn through it; boarded: planks with gaps, still seen through. Scripts open and close it with the door. | 2 |
prefab | Makes this object a copy of a prefab: a saved object in Prefabs/<name>.ttrprefab (its first entity the object, any more its parts). Edit the prefab and every copy changes; this copy keeps its own version of the components in `keep` (an edit made to the copy adds it there). Where it stands, its name and group are always its own. Tools: prefab_make, prefab_place, prefab_apply, prefab_revert, prefab_refresh; scripts: world.spawnPrefab("Crate", position). | 2 |
reflection_capture | Room reflections: the lit room seen from this object, so glossy tile, varnished wood and metal inside the box reflect the room's own lamps, window and walls (corrected for where the walls are) instead of the sky. Put one in each room, at head height, sized to the room. Re-captured when lights or the capture change. | 5 |
rig_2d | 2D: a cut-out character: parts of one image on a hierarchy of bones, posed by keyed poses and clips (cross-blended), with attachment swaps (a sword for an axe), draw-order keys and two-bone IK (feet on the ground, a hand on a lever). anim_2d's states, frame events and boxes drive it like a sheet (a rig clip's keys are its frames). Scripts: self.rig.play("attack"), self.rig.attach("hand_r", "axe"), self.rig.target("leg_l", [x, y]). | 13 |
rigid_body | Physics: the object falls, tumbles and collides while the game plays. Needs a collider. | 10 |
road | A road: a smooth spline through control points, of a road TYPE (lanes, shoulders, curbs, sidewalks, markings, lamps and signs). Every road in the scene is one network: intersections, bridges, cut-and-fill on the land and the lane graph that traffic drives are built from these automatically (build_road / rebuild_roads). | 19 |
road_network | Settings for all the scene's roads: drive side, signal timing, lamps lit, cut-and-fill, ground cover clearing, wet pavement and wear. | 28 |
roof_2d | 2D: a roof group's reveal area. While a player's feet are inside the box, every sprite and tilemap whose roof is this group fades out (walk under a roof or canopy and see inside); it fades back once they leave the box grown by margin (no flicker at the edge). Collision is separate. Scripts: game.roof("inn"). | 6 |
room | A room for visibility: the box holding one room (walls to walls, floor to ceiling). The renderer draws the room the camera is in and the rooms seen through its open portals (doorways, windows), each only through its opening; what lies wholly inside a room nobody can see isn't drawn and its lamps fade out. Rooms within a few metres stay on, so nothing pops in at a doorway. Put one in every room and a portal in every doorway and window; objects spanning rooms (the house shell) are always drawn; what lies outside every room is the outdoors, seen through windows and outer doors. | 1 |
scenario_point | A place where somebody does something (GTA's scenario points): the city's people come here, face the way the object faces, act (a clip, or work, use, pick_up, sit, talk, phone, lean, smoke, kneel, push), stay a while and follow the chain to the next point (a mechanic: car → toolbox → locker) or go back to the street. vehicle: a parking spot a car pulls into, its driver getting out into the chain. | 13 |
script | Game logic: a JavaScript file from the project's Scripts folder, run while the game plays. | 3 |
sequence | A cinematic sequence as a timeline file: transform keys with bezier and ease curves (objects and single bones), property keys (lights, colours, visibility, any field in this list), animation clips cross-faded on characters, camera cuts and moves, events (sounds, particles, script messages, throws), and slow motion that slows physics, animation and particles together. Scripts start one with game.playSequence(name); the sequence tools write, record, scrub and render them. | 3 |
spin | Turns the object round one of its own axes while the simulation runs (vertical by default). | 2 |
sprite | 2D: a picture (one frame of a sprite sheet), animated by named clips. Positions in a 2D scene are world units on X (right) and Y (up). Scripts: self.play("run"), self.flip = true. | 26 |
stage_25d | 2D game in a real 3D world (on the camera_2d object): side-scrolling 2D gameplay on its plane, drawn into a lit 3D scene (meshes, lights, rain, water) through a perspective camera that follows the 2D camera; sprites are cards lit by the scene's lights. Build the 3D world in metres behind the play plane; units_per_metre maps 2D units to it. | 11 |
stats | Health, stamina and timed effects (the abilities kit's numbers). On the player the character obeys them: an empty stamina bar means no sprinting (walking speed) until it refills to stamina_recover; stunned or knocked down there is no control; slowed it walks slower. Scripts: self.stats, self.effect("stun" | "knockdown" | "slow" | "haste" | "unseen", seconds, amount), self.hurt(n), self.heal(n), self.cooldown(name, seconds). kits/health.js keeps its health here when there is one. | 8 |
street_dressing | What dresses the streets it covers (road objects whose name starts with one of `roads`, within `area`; empty and 0: every road): trees in the sidewalks by the kerb, cars parked in the parking lanes facing the traffic, and props by rule. Placed again on every rebuild_roads as objects of their own (tagged street_dressing). | 14 |
surface | Covers the object with a scanned real-world material (concrete, dirt, metal...), projected so it never stretches on scaled shapes. Combine with mesh_renderer color to tint it. | 5 |
terrain | Land shaped by a heightmap: hills, mountains, islands, valleys. Painted by slope and height (grass, rock on steep ground, sand by the water, snow on peaks). Walkable, drivable; bullets hit it. Make it with make_terrain, shape it with sculpt_terrain. | 13 |
tilemap | 2D: a grid of tiles written as rows of characters (top row first). Each character is a tile of the tileset with its own collision (solid, one_way, ladder, hazard); terrain tiles pick their art from their neighbours (grass on top, edges at the ends). Scripts: game.setTile(map, col, row, "#"). | 12 |
time_of_day | The scene's clock: the hour of the day running at a set speed (48 real minutes a day as in GTA V; 0 stops it). From the hour it places the sun as the real sky does at the latitude and date (sunrise, a high noon sun, a low golden sun throwing long shadows, night), and blends the colour grade through the day on top of camera_look: warm hazy mornings and golden hours, cool blue hours, night exposure. One per scene. Scripts: game.timeOfDay() reads it, game.timeOfDay({hour: 21, day_minutes: 0}) jumps and stops it. | 9 |
tornado | A tornado or waterspout touching down where this object stands: a rotating column of wind (solid-body core, winds falling off as 1/r outside, inflow along the ground, updraft up the core) that travels along its heading or path and ropes out at the end of its life. Everything that feels the wind feels it; loose bodies in reach are pushed, and the light ones lifted and spun (a crate flies, a tank doesn't). Drawn as a twisting funnel from the cloud base with dust and debris at its foot (spray for a waterspout). Scripts hear tornado_touchdown, tornado_rope_out, tornado_lifted and tornado_hit. | 16 |
traffic_signal | A lane stop line, facing the direction cars travel (+Z). Phase is scene/game data, never wall-clock time. | 2 |
trail | Persistent world-space smoke, steam, vapor or flame using the flight effects system. Key emitting to stop new puffs while old smoke drifts and fades. | 11 |
transform | Where the object is, how it's turned and how big it is. | 3 |
trigger | An invisible area that notices things entering and leaving (scripts get onEnter and onExit). | 2 |
tsunami | A tsunami on the scene's ocean, starting at this object's position: one long travelling wave layered on the sea, a solitary hump or an N-wave whose trough comes first (the sea draws back off the beach, then the crest comes in). It travels at the speed the water's depth allows (√(g·depth); the terrain's seabed where there is one), slows, shortens and grows as the water shoals, breaks into white water and spray when too tall for the depth, and runs a little way inland. Boats and floating things ride it and are carried. Any change starts it over (watch it again while tuning). Scripts hear 'tsunami_arrival' { where, height, name } at landfall. | 16 |
vehicle | Force-based wheeled vehicle: suspension, combined-slip tyres, engine/clutch/gears/differential, damage and cameras. New vehicles use this; existing recordings without it keep their legacy motor. Numeric zero uses the named preset. | 30 |
vortex | A swirling energy vortex filling an opening: a teleport portal, a rift, a summoning gate. Drawn live by the GPU (never a picture): bands of energy spiral in toward a white-hot eye over dark depths, filaments stream through them, the rim crackles with arcs, a halo spills onto what frames it, the world behind ripples and bends, motes are drawn in out of the air, and its light pulses on everything round it. The opening stands in the object's X (across) and Y (up) plane, its base on the object, facing +Z. Scripts dial intensity (entity.set("vortex.intensity", 0.3)). | 15 |
water | Water you place: a lake or pond inside an outline, a clear pool, or a river flowing along a line of points (downhill). Depth color over what's under it, sky and sun reflections, wind ripples, flow that follows the river, foam where it meets the shore and rocks (no hard edge). Swimmable; things float in it and rivers carry them. | 14 |
water_2d | A spring surface with buoyancy, swimming, flow, splashes and foam. Centred on the transform; polygon points in local units. Rotation and scale are not used. Runtime waves are not saved. | 18 |
waterfall | A waterfall pouring over a lip: a streaking white sheet that breaks into strands, spray where it lands, mist rolling off, foam spreading on the water below. Position = middle of the lip; it pours toward the object's forward (-Z) and falls `drop` meters. | 9 |
weapon_2d | 2D: guns. The object carries weapons and aims them (players: mouse or right stick, with aim assist; others: their script's self.aimAt / self.shoot), or with pickup true it is a gun on the ground for the player to take. Weapons are data: built-ins pistol, smg, shotgun, rifle, rocket, laser, orb (slow glowing enemy bullets), turret, or Assets/Weapons/<name>.weapon.json; tune changes any setting for this object. Shots use action_2d for team, hit-stop and flash; bullets hit hurt boxes (or the body box) of other teams, stop on walls, crates and cover. Scripts: self.aimAt(target), self.shoot(), self.reload(), self.equip(name), self.telegraph(seconds), self.pattern('spiral', {...}), self.weapon; onMessage 'fired', 'reloaded', 'weapon_pickup'. | 21 |
weather | The scene's weather: a preset (clear, overcast, rain, storm, thunderstorm, snow, fog, hurricane) at an intensity, blending over `transition` seconds when changed. Drives one wind field (gust fronts, turbulence, rotating storm cells), the plants' wind, the clouds, rain or snow around the camera, lightning and thunder, fog and surface wetness. One per scene; without it nothing changes. | 15 |
weather_aero | This body feels the weather's air: drag through the moving air, lift along its up axis, and a roll from the updraft difference across its span (gliders, light aircraft, debris in a storm). Needs a dynamic rigid_body. | 7 |
wind | The scene's wind for plants: trees, bushes and grass sway with it and gusts roll across lawns. One per scene (without it, a light breeze). | 3 |
wind_sway | Swings in the scene's wind in play: a hanging sign, a lantern, a string light's bulb, a loose tarp, a rope. It turns about its pivot like a damped pendulum toward the lean the wind across it asks for (gusts, turbulence and storms from the scene's wind or weather), with a flutter on top for cloth; the scene keeps its rest pose. Put the pivot where it hangs from. | 7 |
world_streaming | This scene is a big map streamed in cells: the objects live in one scene file per cell (c_<column>_<row>.ttrscene in the cells folder) and load around the camera and the player, leaving again behind them. The scene keeps what is always there (sky, sea, land, the player). Make the cells from a whole map with stream_split; watch them with stream_status. | 14 |
Arcwright Beta 2 (0.4.0) · generated from the engine source (25e375c86)Something wrong or missing? Tell us