Field Manual

BasicsGetting started

RUMPUS ENGINE is a single-file browser game studio — build worlds, play them (FPS, racing, top-down, side-scroll), and share them. Nothing installs; the whole game is one page.

The home menu

• Deploy — play the current level (your autosaved work, a loaded file, or the default arena). Its equal twin Build / edit level opens the editor on the same level.
• Multiplayer — host or join a room (see Multiplayer). Community levels — browse and play what other creators have published.
• Play campaign / Load campaign — play a sequence of chained levels with carry-over loadout (in the footer strip).
• Instructions — a quick controls card. Help & tutorials — guided tutorials with loadable example projects. Field manual — this page. Credits — engine libraries plus the asset attributions collected for the current level.

BasicsControls

On foot

Driving (walk up to a vehicle, press E)

Editor

Gamepads and touch are supported: plug in a controller (press ] to switch between detected pads), or on a phone use the on-screen joysticks and drive cluster — pause → ✿ Customize controls to move or resize any on-screen button.

Rebinding: pause → ⌨ Keyboard bindings to remap movement and every action (click an action, press the new key; picking a key already in use swaps the two; Reset restores defaults). Weapon slots 1–5, Esc and the editor's own keys stay fixed, and on-screen prompts keep showing the default keys.

Controller menus: every menu is playable from the pad — D-pad or left stick moves the focus ring, A selects, B backs out, and left/right tunes sliders and dropdowns. The first press lands on Deploy.

Controller: Start pauses (solo) or opens the match menu (multiplayer). D-pad: up = inventory, down = map, left = melee, right = flashlight. In the supply cache, D-pad picks, A buys, B/Y closes; on the upgrade screen, bumpers or D-pad focus a card and A takes it (keyboard: press 1–3). Look sensitivity, aim sensitivity, stick deadzone and invert-Y live in the pause menu once a pad is connected.

Touch: besides the joysticks — CROUCH toggles, MELEE swings, BUILD opens the deploy radial (tap a slice to place), and hold USE to grab or drop a physics prop. LIGHT, BAG and CHAT appear automatically when a level has a flashlight, an inventory, or you're in a multiplayer room.

Motion, comfort & accessibility

Pause → Comfort. These belong to you, not to the level — they follow you into every level including ones other people made, which is the point: a creator cannot be relied upon to have thought about it. Every slider is a percentage of what the level authored, so 100% is exactly as shipped and nothing moves unless you move it.

Reduce all motion turns the lot down in one press; Restore defaults puts them back. If your operating system already asks for reduced motion, RUMPUS ENGINE starts calm without you having to say so again — and an explicit choice always wins after that, including the choice to turn it all back up.

Editor referenceEditor overview

Open the editor with Build / edit level on the home menu, or press P during a solo game. The panel on the right is organized into eight tabs; the last tab you used is remembered.

Most sections start collapsed — click a header to expand it. The ? button on the editor toolbar opens this manual. Everything you do in the editor is undoable with Ctrl+Z, and the level autosaves in your browser while you edit (toggle on the Save tab).

The menu bar

On a desktop-sized window there is a thin File · Edit · Tools · Help bar across the very top of the screen while you are editing — the same layout you already know from other creative software. It is a shortcut, not a second system: every item drives the exact same control in the panel, so it can never disagree with it. On phone-width screens the bar is hidden and the panel is the whole interface.

Editor referenceBuild tab

Add shape

+ Box, + Sphere, + Cylinder, + Cone, + Ramp, + Stairs, + Dome, + Tube, + Ring drop a primitive in front of the camera. Every shape gets the full Material editor. The first four use exact box/sphere colliders; the construction shapes (Ramp/Stairs/Dome/Tube/Ring) collide with their real triangles, so you can walk and drive up a ramp or staircase, shelter under a dome (it's hollow — visible from inside), run through a tube, or hop through a ring. Like every primitive they're authored to a 1×1×1 footprint with the base at floor level, so scaling and floor-snapping behave exactly like the box: stretch a Ramp long and low for a drivable slope, or scale Stairs up for building-sized steps. A Pillar and the track pieces are also primitives under the hood.

Room

Object & selection → Room. A doorway used to be four boxes you placed and measured by hand. This builds the whole shell — floor, four walls, optional ceiling, and every opening cut through them — as ordinary props you can then edit, move, texture and delete one at a time.

Build room drops it where you are looking and tells you how many props it made. Undo removes the whole room in one press.

Path — wires & rails

Object & selection → Path (wires & rails). Select two or more props in the order you want them strung, pick a mode, and press the button. Power cables between poles, telephone wire across a street, a fence, a kerb, a catwalk handrail.

Track builder

Snap-together race track pieces — covered in depth in Track builder & racing. With pieces placed, the Track appearance panel restyles the whole course at once: road colour, roughness and an optional road texture (with a tiles dial), painted-line colour, the kerb stripe pair, and the barrier colour. Saved with the level; Reset to stock returns the classic asphalt look.

Search free models

One search box finds free 3D models on Poly Pizza (no key needed) and Sketchfab (needs a free API token — enter it once, everywhere else shows “Token saved · change”). Click a result to place it. Every searched asset is recorded for the level's Credits screen automatically.

Object & selection

With something selected, this section shows: swap/replace model, and the eight folds that give a prop behaviour — animation, locks, signals, dialogue, vehicle, joints, mechanisms, physics & destruction.

Material

For shape primitives: colour, texture map with U/V tiling and rotation, shininess, metalness, emissive glow — and Opacity. Opacity below 1 makes the shape see-through: glass = low opacity + high shininess, frosted plastic = mid opacity + low shininess, and a faint pane around 0.15 reads as a force field. A transparent prop stays completely solid — you can stand on a glass floor and bullets still hit it. Opacity saves with the level and carries through share links and multiplayer like every other material setting. Imported models keep their own materials — the section says so instead of hiding.

Invisible barriers — fencing off an area

Drag Opacity all the way to 0 and the shape becomes an invisible barrier: you cannot see it in play, and you still cannot walk through it. That is how you keep players out of an area without building a visible wall — the edge of your fairground, the back of a set, a ledge you do not want anyone reaching.

1. Add a box and stretch it into a wall across the gap you want to close.
2. Open Material and pull Opacity down to 0.
3. It disappears when you press Play, and the player walks into it.

Exactly what it does and does not do:

Transform & Handles

Transform is the numeric version of the gizmo: exact position, rotation and scale fields. Handles pick the gizmo mode (move / rotate / scale — also 1/2/3) and proportional scaling (4).

Taper — pinching one end of a box

Scale stretches a shape evenly. Taper pinches one end of a box, which is the thing three scale numbers can never do. Select a box and the Taper rows appear at the bottom of the Transform fold.

Pinch the picks which end: the top (+Y), the right end (+X) or the far end (+Z). The two sliders under it scale that end on the two axes across it — 1 leaves it alone, 0 pinches it to nothing, and anything above 1 flares it outward. The end you did not pick is never touched, and the shape keeps its base on the floor, so nothing you have already placed moves.

Step by step, for the dart shape:

1. Add a box and scale it into a long thin slab — say 1 × 1 × 20.
2. Open Transform and set Pinch the to far end (+Z).
3. Pull the first slider (X at that end) down to 0. Both corners of that end come together and you have a point.

The same two numbers give you a lot of shapes:

Groups

Every prop's Tag now sits at the top of Object & selection (and stays in the Signals fold — they edit the same tag). Ctrl+Shift+C collapses every editor section at once.

Outliner (scene hierarchy)

Press O (or the list button on the editor toolbar) for the Outliner — the whole placed scene as one panel: props, lights, enemy spawns, turrets and pickups, each with its tag. As levels grow this is the fastest way around:

• Search matches names, tags and folder names; the tag dropdown narrows the list to one tag.
• Folders: select some props, then use the Move → dropdown in the Props group to file them into a folder (or create a new one) — or just drag a row onto a folder (drop on the Props header to un-file it). Folders save with the level. Double-click a folder to rename it; a folder's eye/padlock hides or locks everything inside at once.
• Eye hides an object while editing only — deploys and play always show everything. Great for getting a roof out of the way.
• Padlock locks an object: viewport clicks and marquee boxes pass straight through it, so a big backdrop stops stealing every click. A locked object can't be selected or moved at all until you click its padlock again.
• Select all of a type: the grid button on a type header (or a folder) selects everything it contains — filter first to select just that slice (e.g. every prop tagged door).
• Double-click a prop or light to name it; names save with the level and make search actually useful.

Select multiple props and press Ctrl+G to group them — the group moves, rotates, scales and duplicates as one. Ctrl+Shift+G ungroups.

Prefabs

Turn any configured selection into a reusable component — a door with its trigger, an elevator, a trap, a whole furnished room. Select the props, type a name in the Prefabs section and hit Save selection: the capture keeps everything — signals, mechanism animation, physics and joints, vehicle tuning, locks, dialogue, materials. Place drops a copy 8 m ahead of the camera; every copy arrives grouped (moves as one) and heights are terrain-relative, so a room built on flat ground sits correctly on a hillside.

Your prefab library lives in your browser and follows you across levels — and every level embeds the prefabs it uses, so a shared or community level brings its components along (they join the library of whoever opens it, never overwriting same-named prefabs of their own).

Editing a prefab: change any placed copy — move parts, retag, recolor, even add new props to its group — select it and press Update on that prefab's row. The definition rewrites and every other copy in the level follows. Parts you deliberately changed on one specific copy (a raised panel, a renamed tag) are detected as local overrides and left exactly as you authored them — the toast reports how many were kept. Moving a whole copy around the map never counts as an override. Detach disconnects a copy so future updates skip it; × removes a prefab from your library (placed copies stay in their levels).

Editor referenceObject folds — giving props behaviour

Select any prop on the Build tab and open Object & selection. Eight folds, in panel order. (Signals and Mechanism get their full treatment in Signals, locks & mechanisms; Vehicle in Vehicle tuning.)

Animation

Plays a model's built-in clips. Pick the clip (or all clips at once), then when it plays — Auto (from level load), E Activate (player interacts), or Signals only (waits to be targeted) — and how: ⟳ Loop, ⇄ Ping-pong, or → Once. Built-in shapes have no clips (use Mechanism to move those); for models without animations, the Sketchfab search has an "Animated only" filter.

Signs — text in the world

Add a Sign from the shape list (Build tab → Add a shape). It is an ordinary prop — gizmo, snapping, duplication, prefabs, tags all work on it — that draws text on a board. Room labels, booth names, a warning over a door, a scoreboard on a wall.

Parenting — props that ride other props

Select the prop that should carry the others last (it becomes the primary), then press Parent to this prop. The children now follow it: a crate rides a moving platform, a lamp travels with the wagon, a whole assembly turns as one when the parent rotates. Their colliders move with them, so the player really does stand on the crate while the lift climbs.

Prop values — a counter on the prop itself

Logic tab → Do action → Set prop value. Every prop can hold its own named numbers, so “this plate has been hit 3 times” lives on the plate rather than in a level-wide variable you would need one of per plate. Pick Add or Set, a name, and a value. Leave the tag blank and it writes to the prop whose signal fired the graph — so one node serves every plate in the booth.

Lock

Lock picks the required key (red / blue / gold / green); pressing E on the prop then needs that key in hand — place a matching key pickup pad somewhere findable. Consume key on unlock spends the key (for one-key-one-door puzzles; off = a master key). A prop unlocks once per deploy, for everyone in MP.

Rig an imported model

A model you import is usually just geometry — no skeleton, so the animation editor can only move it as one piece. Select the prop and hit 🦴 Auto-rig model (T-pose) (in the Animation fold, beside the animation editor button): drop a marker on eight joints — chin, groin, both elbows, both wrists, both knees — and RUMPUS ENGINE builds a full humanoid skeleton and skins the mesh to it. After that the animation editor keyframes its arms, legs and spine like any character, and every custom clip in the level retargets onto it. It's the usual way to turn an imported character into an NPC.

The rig belongs to the model, not to one copy. Props share one loaded copy of each model, so the markers are stored against the model's URL — every copy of that shopkeeper stands up the same way, and the level saves one marker set however many you placed. Copies already standing in the scene pick up the new skeleton when the level reloads; a fresh one is rigged the moment it spawns. The same rigger is on the Player tab and the Enemies tab for those models. Works best on a model standing in a T-pose or A-pose.

Dialogue (NPC)

Name (shown over the prompt) + one line of dialogue per row (up to 120 × 200 chars); the player presses E to advance. The first line also fires the prop's On E signals — so a conversation can set the objective, drop a checkpoint, or open a door as it starts.

Replies, conditions & jumps

That's still all a simple NPC needs. When you want the player to answer, six marks turn the same box into a branching conversation — nothing else about it changes, and a script written before this still reads exactly the same way.

A condition compares two things with == != < <= > >=. Either side can be a number, a Logic variable, or item:someId — how many of that inventory item the player is carrying. [if hasKey] with no operator means “it has been set at all”. An unset variable reads as 0, so a condition is never comparing against nothing.

Have you found the brass key?
> Here it is. -> gotIt [if item:brassKey >= 1]
> Still looking. -> notYet
> Leave. -> end
#gotIt
Then the vault is yours. {set questStage = 2} {event vaultOpen} -> end
#notYet
[if questStage >= 1] You said that last time.
Keep looking. It glints in the dark. -> end

Rows that start with a reply and have no line above them render as a bare choice prompt — useful for “what do you do?”. A label that doesn't exist ends the conversation rather than looping. Everything the player sees is escaped, so a shared level can't inject markup through a line or a button. Pair this with values that carry over and an NPC can remember you between levels.

Joint (physics)

Joints take effect on Deploy.

Physics & destruction

Editor referenceWorld tab

Sections: Environment · Auto-generate · Zones

Environment

Movement — and the four traversal verbs

Global player physics: Walk speed (4–60) · Run speed (4–100) · Crouch speed (1–40) · Jump (0–30) · Launch power (0.25–4, jump-pad multiplier) · Gravity (5–80) · Eye height (0.4–20).

Four more sliders in the same fold give the player extra ways to move. All four are off at 0, which is exactly how every level built before them plays — turn one on and it is available for the whole level. Each is one number that both enables and tunes the verb, and all four are the jump key except the dash, so there is nothing new to teach a player and rebinding jump moves them together.

Lighting — control by control

Tip: the day/night cycle can't dim an HDRI sky texture (only fog, lights and flat-color skies) — for convincing nights, use a plain sky. Sun direction still sets where dawn breaks when the cycle is on.

Camera & view

Field of view (50–110) · View distance (60–2000 — the hard cutoff where geometry stops drawing; raise it for big racing arenas) · Fog density (lower = see farther into the dark) & colour · ground grid toggle. Depth of field: Focus distance = how far away stays sharp, In-focus range = the depth kept sharp around it, Blur strength = how soft everything else goes. Post-processing: Bloom + Bloom threshold (how bright a surface must be before it glows), Motion blur (trail strength), Vignette, Film grain, Saturation, Contrast — they all compose, DoF included, and they save with the level (the on/off switch is each player's preference).

Cull below (px) stops drawing a prop once it covers fewer than that many pixels on screen — the single biggest performance lever a creator has on a dense level, and it is 0 (off) by default because a setting that removes your content should be your decision, not the engine's. On a scattered 600-prop field, 2 cut draw calls by 57% and cost nothing visible; on a level of 60 big props it does nothing at all, so try it and watch the counters rather than assuming. Nothing within 40 m is ever culled whatever the setting, and a prop carrying a light is never culled — so it can shrink your frame cost but it cannot make a lamp go out or delete the thing you are standing next to. Save ▸ Level check reports what it removed while it is on.

Making a big level run well

Three numbers decide whether a level is playable on ordinary hardware, and Save ▸ Level check reports all three so you do not have to guess:

Sky

Browse Poly Haven HDRIs in-editor or paste any equirectangular .hdr/.jpg URL (an .hdr lights reflections too); presets Park / Mountain / Room / None (None = flat fog-colored sky). Reflection strength (0–3) sets how strongly the sky shows up on metallic floors and walls — 0 for fully matte scenes. Sky rotation° spins the panorama to aim its sun or horizon features.

Weather — control by control

The layer follows the camera and falls indoors too — keep sheltered scenes on None, or accept it as "atmosphere". Storm recipe: Rain, Amount 1, Size 1.4, Wind 2.5, day/night cycle parked at Dusk.

Floor & terrain

Floor colour / roughness / metalness, then three texture rows — the image itself, an optional normal map and an optional roughness map — with tile W/H and rotation that govern all three, plus a texture search. Terrain: Height (0–18) and Detail (1–8) with Generate / Regenerate / Flatten, plus a terrain brush painted directly onto the ground — Raise / Lower / Smooth sculpt the height, Paint blends materials, and Scatter plants props. A colour-coded cursor ring follows your pointer showing the brush radius; in Paint mode the inner ring is where full strength ends and the soft edge begins, in Scatter mode it shows the planting spacing.

Material painting (the Paint brush mode)

Make the base floor your ground material (say, tiled grass), then paint up to three more textures straight onto it — a dirt path, a stone plaza, scorched earth. Pick a Layer, give it a texture (URL or the built-in free-texture search) and a Tiles count, then drag on the floor. It works on flat floors and sculpted terrain alike, and the result saves with the level (share links, gallery, multiplayer).

Path recipe: base floor = grass texture; Layer 1 = dirt, Tiles ≈ your floor tiling, Brush size 4–6, Soft edge 0.6, Flow 0.4 — then drag your route in two or three slow passes.

Landscape scatter (the Scatter brush mode)

Plant randomized props by dragging: trees, bushes, rocks — anything. Fill up to three slots, either from the free-model search (credited automatically) or with Use selected prop, which clones whatever's selected at its exact scale — including built-in shapes. Each slot has its own Size dial: for searched models it's the real-world size in metres (default 7 — tree height; crank it to 25 for giants), for cloned props it's a multiplier on their captured scale. Each pass drops Density (1–6) props at random spots inside the brush circle, each randomly rotated, varied by Size jitter (±0–60%), and sat on the terrain — a slow drag along a hillside plants a treeline.

Scattered props are normal props: marquee-select to move or delete them, undo works, and they save with the level. Budget note: each searched model adds a draw call — a few dozen trees is fine, hundreds will cost frames. Scattered primitives (rocks from spheres, fence posts from cylinders) are basically free thanks to instancing. Forest recipe: slot 1 = a tree, slot 2 = a second tree variety, slot 3 = a bush; Density 3, Size jitter 0.4, Brush size 15 — then wander the map edge in one slow pass.

Walls & arena

Show boundary walls (off = invisible but still solid), wall material/texture controls, and Arena size (15–2000) — half-width of the playable square. Racing levels usually want 300+.

Audio

A looping music track plus per-event sound rows: grenade explosion, coin pickup, powerup pickup, jump, hit marker, enemy kill (with per-enemy-type overrides), player hurt, and the car set — engine loop, brake, skid, boost. A built-in Freesound browser searches free sounds; each pick is credited automatically.

Auto-generate

Procedurally builds a starting layout (cover, buildings, scatter) you then edit by hand. There's also an AI scene builder — describe a scene in a sentence and it searches and places matching models (works best with a Poly Pizza or Sketchfab key).

Zones

Paintable volumes under World → Zones — pick a type at the top of the section, then + Add (at me) drops one where you stand. Triggers (see below), Audio zones (positional sound while inside a radius: URL, volume, loop), Death zones (instant kill between Base Y and Base Y + Height — lava, pits, out-of-bounds), Jump pads (launch on contact, scaled by the Movement fold's Launch power), Ladders (climbable volumes: W up, S down, jump to hop off; Facing sets which side you step off at the top), and Fire zones (damage per second inside, with a full particle look: density, size, hue, turbulence, wind, saturation, sparks, smoke mode — hue 30 is natural fire, 210 blue, 285 purple; saturation 0 turns it into grey smoke).

Triggers — “when something gets here”

Every other zone is a fixed behaviour: a death zone kills, a jump pad launches. A trigger does nothing by itself — it fires a Logic event and hands the moment to your graph, which is where your game actually lives. Before triggers the only things that could start a chain were match start, a timer, an enemy dying, a wave starting, or the player pressing E on a prop. Now you can say “when the player reaches here.”

The whole loop, end to end: drop a trigger at the vault door, set its event to reachedVault, then in the Logic tab add On event reachedVault → Show message (or Open door, Spawn, Play cutscene, Set variable — anything the graph can do). Triggers are evaluated by the host in multiplayer, and never while you're editing or paused.

Water zones — control by control

Water is mechanical, not just visual: cars slow in it (light splash → 45% of top speed in the shallows → 18% in deep water) and throw bow spray; dynamic props bob to the surface and float; enemies and bots wade at roughly half pace — funneling hostiles through a river is a legitimate defensive design. One draw call per surface, so lakes are phone-friendly.

Waterfalls — control by control

They live inside the Water tool, below the zones list. Each fall is two layered sheets of streaming columns (the back layer runs slower and dimmer for depth) plus a churning foam pool.

Standing in the sheet pushes you down into the plunge pool — pour a fall into a deep water zone and the combination is safe to ride down; onto dry ground, the landing is on you.

Editor referencePlayer tab

Sections: Handles · Object & selection · Transform · Characters

• Player avatar — import any model as the third-person body; scroll in the preview to zoom.
• Player start — drag the blue marker to set where the run begins; Facing° (−180…180) sets the initial look direction.
• Characters — the roster of player & enemy character models, with animation-slot mapping (clips are grouped by taxonomy: locomotion, combat, hits, deaths…). Characters picked here appear in multiplayer's CHARACTER menu too.
• Slide on touch — tap CROUCH while sprint-running; a standing tap still toggles crouch. On a controller the bag and item inspector are fully navigable: stick/D-pad moves the ring, A opens/uses (including Use — hold & place), B backs out.
• First-run tutorial — your first solo deploy shows a small coach pill (Move, Look, Fire, Jump, Sprint, Build menu); each step ticks off when you do it, the wording matches your input device, and the ✕ dismisses it for good.
• Model loading bar — picking a Sketchfab or Poly Pizza model shows a live progress pill (percent and MB) while it downloads, so you know it's coming.
• Joint tweaks — models that import with bent wrists, A-pose arms or twisted forearms can be fixed in-app: pick a bone on the Player tab (Joint tweaks), nudge X/Y/Z in degrees, and the offset rides on top of every animation. Live in the preview, saved with the character.
• Auto-rigger — a static, unrigged humanoid model (T-pose or A-pose) becomes a fully animated character without leaving the game. Load the model on the Player tab or an Enemies-tab slot and press Auto-rig model (T-pose) (each enemy type keeps its own markers; roster characters inherit the Player tab's rig when you add or update them): a Mixamo-style modal shows the model front-on — click chin → wrists → elbows → knees → groin (with Use Symmetry on, one click per pair fills both sides; drag to turn, scroll to zoom, click a step row to re-place it). AUTO-RIG fits a full humanoid skeleton to your markers, computes skin weights automatically (weights blend smoothly across knees and elbows and are diffused along the mesh surface, so deep bends curve instead of creasing), and switches the animation library on — the model walks, runs, crouches and shoots immediately. The markers are a few numbers saved with the level, so the rig rebuilds on every load; works at any model scale and with any rest pose (T or A — library clips align to the model's rest automatically). Blocky/stylized models deform best — fine-tune joints afterwards with Joint tweaks if needed.
• Animation editor — author your own skeletal clips entirely in the browser (desktop only; no Blender or Mixamo needed). On the Player tab press 🎬 Animation editor: the model opens in a full-screen workspace with a bone tree (friendly names, search), an orbit viewport (click a joint to select it, drag the selected joint to rotate — hold X/Y/Z for a local axis, Shift-drag the hips to move them), an inspector (exact angles, reset, key buttons) and a timeline (scrub, play with Space, drag keys, snap-to-frame, K keys the selected bone, Shift+K keys the whole pose, Auto-key writes keys as you drag). Clips save into the level (share codes, multiplayer and campaigns carry them) and appear in every per-state clip picker next to built-in and library clips — or assign one directly from the editor's Assign panel (idle, walk, reload, death, any state). Because clips are stored against the engine's normalized skeleton, the same clip retargets onto any humanoid model. Ctrl+Z undoes inside the editor; deleting a clip warns where it's assigned. Generate with AI — press ✨ AI and describe the motion in plain language (“lifting a heavy box: start standing, bend down, grab it, then stand back up still holding it”). Claude blocks it out as real keyframes on this model’s skeleton — it writes anatomical joint angles, the engine converts them and clamps them to real joint limits, and the result drops onto the timeline for you to scrub, deepen, retime and polish like any clip you authored. Nothing is saved until you press SAVE CLIP. Works on props too (whole-model motion for doors, crates and vehicles). Needs your own Anthropic key — add it under Settings → API keys. Then keep going: the panel stays open and switches to Refine this clip — say “bend deeper at the bottom”, “hold the grab a beat longer”, “make the stand-up slower and heavier” and the clip is revised in place, as many passes as you like (Ctrl+Enter to fire, Ctrl+Z to step back a pass). Refining reads your clip back as joint angles, so it works on any clip — one you generated, one you keyframed by hand, or a Quaternius clip you pulled in with Edit existing (“make this walk bouncier”). Overlap & follow-through (on by default) drags each bone a few frames behind the one it hangs from, so the hips lead and the hands and feet trail — the difference between motion that reads alive and motion where everything snaps on the same frame. Turn it off for deliberately mechanical or robotic movement. Edit an existing animation — the Edit existing… dropdown copies any clip already on the model (its own clips, or a retargeted Quaternius library clip) into a new editable custom clip: it samples the clip into keyframes (automatically thinned so it's hand-editable, not one key per frame), names it “<clip> (edit)” so the original is never touched, and drops you straight into tweaking it. Take the pack's walk, adjust the arm swing, save — your version plays in its place. Production tools: Mirror pose / Mirror clip (left↔right), Copy/Paste pose and Copy/Paste keys at the playhead, a per-clip Curve mode (smooth / linear / step), Ghosts (onion-skin skeletons at the previous and next keys), Export/Import of .rumpusanim files to share clips between levels and creators, and timeline events — fire a sound (footsteps, casings, reload clicks) or a → Logic event (melee hit-windows, scripted beats) at any moment of the clip; they show as orange ticks on the timeline and fire wherever the clip plays. The editor also opens from the Enemies tab, and — since build 1064 — from any selected model prop (World tab → Animation): a humanoid prop uses the normal retargetable skeleton; a non-humanoid rig (dragon, windmill, crane) lists its own bones by name; and a model with no bones at all edits as a single Whole model track — rotate it, and Shift-drag to move it through space — so doors, floating crates and drive-by vehicles become keyframable cutscene pieces. Prop clips join the same level library and play through the prop’s normal triggers (Auto / E Activate / Signals, or a Logic Do action → anim) — saved clips re-arm live props instantly, and a clip never auto-plays unless you pick it on the prop. Combined with dialogue lines (a talkable prop is an NPC), this is the ambient-NPC and set-piece toolkit. Keys multi-select with Shift-click or by dragging a box across the dope sheet — the band now spans every bone row it crosses, so you can grab a whole span of keys across many bones at once (Shift adds to the selection). Select all grabs every key on every bone in one click, Deselect clears it, and Delete keys (or the Delete key) removes the whole selection; dragging any selected key moves the entire set together. A Root path toggle draws the hips trajectory so authored root motion is visible at a glance. The timeline is a dope sheet — one labeled row per keyed bone; grab keys on any row, scrub on the ruler — and Flatten to in-place removes the hips X/Z drift so an authored walk loops on the spot.
• Action bindings — the engine drives most animation states automatically (walk, jump, hit reactions), but several — dodge, parry, block, holster, knockdown, get up, idle-to-combat — have no trigger of their own. An action binding is how you reach them: on the Player tab, pick an animation — either any clip the model carries, including one you authored in the animation editor, or one of the named slots — a key (or mouse button, gamepad button, and an auto-generated touch button players can drag anywhere), and optionally a Logic event. The action plays the clip for its full length — wire the event into the Logic tab to make it do something: a dodge that grants a speed burst, a taunt that scores a point, a salute that unlocks a door. Add a cooldown, and tick lock movement to plant the player for the clip. Up to 8 per level, saved with the level and synced in multiplayer — everyone sees your dodge. The editor warns if a key already belongs to a default control or another action, or if a bind still points at a clip the current model doesn't have (it falls back to the slot behind it rather than playing nothing).
• Built-in animation library — pick Standard (43 clips) or Pro (120 clips — every animation slot filled: 8-direction locomotion, climbs, turns, dodges, five hit reactions, two deaths) under Animation states and RUMPUS ENGINE retargets the CC0 clip pack (by Quaternius) onto your model's own skeleton. Any humanoid rig works: Mixamo-rigged, UE-style, Rigify and most others are recognized by bone name, and every slot stays overridable — the pack's clips just appear in the pickers alongside the model's own. No more exporting animations one at a time and converting them — and a model with no rig at all can be rigged right here (next item). Characters hold guns with both hands automatically — a per-frame arm IK plants the support hand on the forestock (tracking your aim) and pulls the trigger hand in only when the gun sits beyond its reach, so your tuned grip survives into play; the Player-tab preview shows the same hold, and a Two-handed weapon hold (IK) checkbox turns it off per character.

Live third-person preview

The Player tab's viewport is a free orbit for inspecting your model, so it deliberately ignores the Side / Distance / Height sliders — which used to mean the only way to judge the chase framing was to press play, look, pause and tweak again. Turn on Live third-person preview under Third-person camera and a small window shows the real chase framing around your model, updating as you drag. The hip / aim switch in its header flips between the two slider groups, so the …when aiming set is just as visible.

It shows the framing you authored, with no follow damping and no wall pull-in — those are live reactions to the world, and a preview that ducked behind scenery would tell you nothing about your framing. Everything else — pivot, offsets, the parallel look direction that pushes the body off-centre — is the same code the game runs.

Editor referenceEnemies tab

Sections: Enemies · Object & selection · Transform · Enemy gunfire

• Type picker — choose an enemy type, import a model for it (⤢ Auto-fit size matches the collider), live preview.
• Collider radius / height — size the damage hit-cylinder only (0 = auto-fit). They no longer affect movement or spacing; toggle Show colliders to see the pink cylinders on live enemies. Offsets re-center off-pivot models.
• Spawn markers — place exact spawn points with patrol/hunt mode, patrol radius, detect radius, facing, a patrol route, and “Appears on wave N” (0 = every wave). No markers = classic random waves.
  • Height (build 1087) — put enemies on rooftops, balconies, catwalks and upper floors. Drag the marker up with the gizmo or type a Height in the inspector; it is measured from the ground beneath, like the player start, so it rides terrain edits instead of being stranded. A drop line and landing disc appear whenever the marker is floating above whatever it will land on — no line means it is already resting on a surface.
    The enemy stands on the highest surface it finds at that height (a marker left slightly under a roof still snaps up onto it). If there is nothing solid up there, it holds the height and falls. Set it to 0 — the default, and what every level built before 1087 has — for ground level.
    Heights go up to 1000. The slider drags to 120 by default and its track grows to fit anything taller — for a very high spawn, type the number in the box beside it.
• Enemy gunfire — how enemy fire looks: bolt tip, streak, trail and muzzle flash.

Sides — friendlies, allies and third parties

Not everything that moves has to be hostile. Two controls on a spawn marker decide what a creature is.

Friendly

Tick Friendly and you get a wandering NPC: it patrols its area or route, ignores the player and gunfire, does not count as a hostile, and killing it gives you nothing. It is the villager, the shopkeeper's dog, the crowd at the fairground — motion that makes a place feel inhabited without making it a fight.

Faction

A marker that is not friendly picks a Faction. The rule is simply that different sides fight each other, and the player is Your side:

Per-type tuning

Gameplay tab → Waves & difficulty. A grid of HP, Damage and Speed per enemy type, for this level only. Each field's placeholder is the factory value, so a blank box visibly means “as shipped”. Speed is a multiplier of that type's own range, so its natural variation in gait survives being tuned.

The eight enemy types — how each one fights

Later waves bias toward the tougher and ranged types automatically in Random mode. Water slows all of them to about half pace — terrain is a weapon.

Editor referenceGameplay tab

Sections: Objectives & rules · Pickups · Loot · Inventory items · Build menu · Logic graph · Cutscenes

Objectives & rules is the heart of the level — the full reference is in Objectives & rules. The other sections:

• Pickups — pads that grant ammo, health, weapons, power-ups, keys and items. See Pickups & inventory.
• Loot — what enemies and loot boxes drop when destroyed; place loot boxes with a custom model, per-box contents, or random loot.
• Inventory items — define carryable items: name, type (3D object you can rotate/zoom in the inspector, or a Journal / note text page), description, model, scale, and what using the item does (use-type / key / amount / consume). Hand them out via pickup pads or signals-gated props.
• Build menu — the in-game radial Deploy menu (Tab): choose which shapes/models players can spawn while playing. Players can open the build menu (on by default) turns the whole mechanic off for a level that has no place for it — Tab, the touch BUILD button and the pad all do nothing, and the slots below are kept for when you turn it back on. All ten primitives (box, cylinder, sphere, cone, pillar, ramp, stairs, dome, tube, torus) or any custom model, each with colour/texture/scale plus Explosive, Unbreakable (shots can't shatter it) and Anchored (a static building block — no physics tumble).
• Build mode — picking a slot enters placement: a translucent ghost follows your aim and snaps flush to the face you point at (grid-aligned, Minecraft-style) or to a ground grid. Fire places and keeps building, and a misplaced block deletes just as fast — aim at it and press X / middle-click (desktop), LT (controller) or AIM (touch); only blocks placed this session delete, never the level itself. Rotate the ghost 90° with the scroll wheel or R (Shift+R rotates back), RB/LB on a controller, or the ROT chip on touch — the hint shows the current angle. Right-click toggles snap, Esc/Tab (or BUILD on touch) exits. On hilly terrain the ghost hugs the landscape and placements land exactly where it shows. Anchored + Unbreakable slots make true building blocks for forts and towers.
• Logic graph — node-based visual logic: variables, branches, timers, counters, loops, randomness and reusable functions, no code. See Visual logic — the Logic graph.
• Cutscenes — the camera-sequence editor. See Cutscenes.

Editor referenceWeapons tab

Sections: Object & selection · Transform · Effects

Per weapon you can import a replacement model (with framing/transform for both hip and aim view), set its shoot & reload sounds, override its damage, and disable the muzzle flash. Effects covers gunfire's look: Impacts (sparks, marks & debris where shots land), Tracer (the streak fire leaves in the air) and Bullet holes — decals stamped where shots hit walls, floors and props. Tune their size and lifetime or upload your own decal image (a soft-edged transparent PNG works best); it saves with the level so everyone sees it. Decals are pooled and fade out on their own, so long firefights never clutter the scene. In multiplayer, everyone's gunfire reads: joiners', bots' and enemies' tracers stop at the wall they hit and spark (and stamp) there, just like your own.

The arsenal — full stats

The economy: attachments, upgrades, shop

Attachments — bought once with credits at the Weapon loadout screen, one per slot per weapon:

Between-wave upgrade cards (solo, pick 1 of 3 after each cleared wave, if enabled in the rules): High-Velocity Rounds (+25% damage) · Trigger Job (+15% fire rate) · Reinforced Plating (+25 max HP, heals) · Combat Stims (+12% move speed) · Vampiric Rounds (heal 4/kill) · Scavenger (+30% credits) · Field Medic (heal 25 each wave) · Munitions Cache (+1 grenade now & each wave).

Supply chests spawn periodically (one purchase each, then consumed): Medkit ◆60 · Overshield ◆100 · Damage Core ◆120 · Speed Cell ◆80 · 3 Frags ◆90 · Ammo Crate ◆50 — plus one-time weapon unlocks (SMG ◆200, Shotgun ◆220, Rocket ◆320, Sniper ◆400, Crowbar ◆140). The Ammo Station (if enabled) refills your current weapon for its listed price.

Editor referenceSettings tab

• API keys — one home for every key the editor can use. Claude (Anthropic) unlocks the AI scene builder and AI animation generation; Sketchfab and Poly Pizza search the 3D model libraries (a shared key is built in, so these work out of the box — add your own only if you want higher limits or your own account’s access). Keys are stored in this browser only and are never written into a level, a share link, a campaign export, or sent to other players — anyone playing your levels needs no keys at all.

Editor referenceHUD tab

Sections: HUD · Crosshair

• Custom widgets (logic-driven) — five kinds: + Text, + Timer, + Bar, + Button and + Image, up to 24 of them. They are live views of your Logic variables, and a Button fires logic back. Full treatment, with step-by-step builds, in Interfaces — widgets & menus.
• Colours — accent, health, score.
• Menus — Menu panel, Menu border, Menu text, Menu dim text. These theme the full-screen panels (the inventory and the item inspector) so a styled level does not open an engine-coloured menu in the middle of itself.
• Fonts — separate UI and display fonts from an 18-font set (Chakra Petch, Orbitron, Rajdhani, Press Start 2P, VT323, Russo One, Bungee, JetBrains Mono…).
• Panels — shape (Angular / Rounded / Square), background opacity, border.
• Show in play — toggle each element: minimap, score, wave counter, ammo, health, crosshair, kill feed, interact prompt, grab hint, objective banner, NPC dialogue.
• Per-element layout — pick an element, then: Size (0.4–2.5×), X/Y offset (±2000 px), Opacity, plus Font and Tint for the text elements. While the HUD tab is open you're in live preview: drag the dashed outlines to position elements directly. Reset per element or the whole HUD. These settings save with the level — everyone who plays it sees your HUD.
• Crosshair — style ✛ Classic · + Cross · • Dot · ◯ Circle · ⊤ T-shape · ∅ None, with size, thickness, gap, center dot and colour.

Editor referenceSave tab

Sections: Title screen · Level file · Campaign

• 💾 Save / Clear save — browser save slot; Autosave while editing keeps it fresh.
• 🔗 Copy share link — the whole level compressed into a URL. See Saving & sharing.
• ⬇ Export / ⬆ Import — the level as a .rumpus file you can back up, edit or send (plain JSON inside; old .breach and .json exports still import).
• 🗑 Delete all objects — fresh scene (undoable).
• Issues panel — live validation that catches the classic mistakes before a playtest does: locks with no matching key pad (and orphaned keys), pickup spots placed while pickups are off, audio zones with no sound URL, cutscene shots with fewer than 2 waypoints, signals targeting a tag no prop carries, signals with no target (only Win level and Play cutscene work targetless), contact signals filtered to a tag that doesn't exist, signals playing a cutscene that doesn't exist, and Signals-only mechanisms that nothing can ever trigger.
• Autosave — saves every few seconds while editing (never mid-PvP-match); the status line shows the last save time, or a storage-full warning that means "export a backup now". Undo holds the last 60 snapshots.
• Campaign — chain levels into a solo campaign: build a level → ➕ Add current level → repeat → ▶ Play campaign. Each level ends on its own win condition and loads the next; weapons, health and inventory carry over. Per-level: rename, Edit (loads it back into the editor with a "Save changes" button), ▲/▼ reorder, ✕ remove; Export/Import campaign moves the whole sequence as one file.

Title screen

Give a level its own home screen: anyone opening your share link or game URL lands on your title screen, not the engine menu. Tick Custom title screen, then set a game title, an optional tagline, an accent, and a backdrop — either Capture backdrop (a frame of your scene) or an uploaded image. Preview title screen shows it over the editor.

Look

Everything below is in the Look fold, and every control starts at exactly what the engine used to hardcode — a level made before this had no look settings and renders identically.

End screens

The screens a player actually screenshots. In the same Look fold: a heading for victory and another for defeat (blank keeps the engine's MISSION COMPLETE / TERMINATED), a colour for each, and an optional backdrop image for each. The Font above applies here too — even with the custom title screen switched off, so a level that doesn't want a home screen can still end in its own type. Each has its own Preview button that shows the real screen over the editor.

SystemsTrack builder & racing

Laying track

On the Build tab, the Track builder places snap-together road pieces. Press T for top-down view (scroll to zoom), then click pieces — each snaps onto the exit of the selected piece (select any piece to branch from there), or the last one placed. Del removes the selected piece.

The road is 12 m wide. All lengths are multiples of 8, so closed circuits line up exactly — and when the two ends nearly meet, Close loop bridges the remaining gap — since build 896 it is a real solver (combinations of curves plus stretched straights), so heading mismatches and sideways misses close too, not just straight-ahead gaps.

🎲 Random track rolls a complete closed circuit in one click — banked corners and a ramp section onto an upper deck included — and you can restyle or hand-edit it from there. Keep clicking until you like the shape.

✏ Draw track is the fastest way to build a circuit: click it, sketch your track outline as one loop (it flips to top view while you draw), and release — the builder lays every piece to match your sketch, adds a start line and barrier walls, and the loop is closed by construction. It replaces the existing track (one undo step restores it), so you can redraw until the shape feels right, then restyle it under Track appearance.

Barrier walls

Per-piece (Barrier walls checkbox on the selected piece) or course-wide (Walls: whole track / Walls: remove all). Walls are a concrete base plus a clear catch-screen to car-body height; they follow banking and ramps.

The Race objective — setting by setting

On deploy you're auto-seated in your car, which is auto-gridded at pole position regardless of where it was parked in the editor. Throttle is locked through the 3-2-1 countdown and releases on GO. Every track piece is a checkpoint: cut the infield and the lap is voided with a toast (you need ~60% of pieces each lap). Losing rivals don't stop — if one finishes your remaining laps first, you get the RACE LOST screen with their name. Drive off the course (or off a ramp with no way back) and a red RETURN TO TRACK countdown appears — get back within 3 seconds or the car is placed back on the racing line at your last on-track spot, stopped and facing down the course.

• Race HUD — position (P n/N), lap counter, live lap time and session best, top-center.
• Checkpoints — every piece is a checkpoint; cutting the infield voids the lap with a toast.
• Ghost lap — your best lap replays as a translucent ghost; toggle with G while driving. It's stored per track shape, so editing the course retires the old ghost.
• Contact — cars collide: rear-end a rival to shunt them, side-swipe to knock them off line. They recover, and so can you.
• Results — per-lap times with the best starred; if a rival finishes first you'll see RACE LOST.
• Multiplayer racing — use Host race in the multiplayer menu: it checks the loaded level (objective Race, a start line, a car) before opening the room, and explains anything missing. One placed car is enough — on deploy the grid fills itself: every authored car lines up in a staggered two-abreast field, extra racers get an identical cloned car, and each player is auto-seated in their own (host takes pole). You see your rivals as their cars, live on track — not their characters — and anyone on foot again (exited, spectating) shows as their avatar as usual. Standings sync live and the first to finish wins on every screen. AI rivals sit multiplayer out — the humans are the field.

SystemsVehicle tuning — the deep dive

Any prop can be a car: select it → Object & selection → Vehicle (drivable) → tick Drivable vehicle (this also makes the prop non-dynamic — the car system owns its physics). A units toggle switches every speed field and the in-game speedometer between km/h and mph.

Performance

Handling

Fitting a model

Camera, lights, effects, wheels

SystemsSignals, locks & mechanisms

These three folds are RUMPUS ENGINE's wiring: Mechanism makes a prop move, Signals connect cause to effect, and Lock gates it all behind keys. Together they build doors, elevators, traps, switch puzzles and win conditions.

Mechanism (the “xa” system)

Enable Animated mechanism on a prop, then set what it does — Move X/Y/Z (m), Rotate X/Y/Z (°), Scale X/Y/Z, a Pivot offset, and Duration (s):

• Playback: ⟳ Loop · ⇄ Ping-pong · → Once.
• Trigger: Auto (runs on level start) · E Activate (player presses E) · Signals only (waits for a signal).
• Waypoint path — add waypoints and the prop travels through them (overrides the Move offset): patrol platforms, cable cars, roaming hazards.

Signals

Making a prop usable with E is one checkbox now: Interactable (E) sits beside the Tag at the top of Object & selection. Tick it and the prop prompts Activate and fires its On E signals — no mechanism required. And a signal's target can simply be this (the first entry in the target drop-down): the prop the signal lives on, no tag needed. So "press E on the door, the door opens" is: Interactable ✓ + one signal On E → Toggle → this.

On the Signals fold, give props a tag, then add rules — when something happens to this prop, do something to a tagged target (or to this, the prop itself):

The world verbs

Everything above changes a prop or the UI. These change the world — and because they live in the same list, a prop signal and a Logic Do action node can both use them. None of them take a target tag; they take a place or a who.

Every stat is a multiplier of what the level authored, which means ×1 always puts it back exactly — there's no hidden “original value” to lose track of. Move speed ×0.4 is a swamp, Gravity ×0.3 is the moon, Jump ×2 plus Gravity ×0.5 is a floaty platformer. Applying the same rule twice never compounds, so a repeating trigger can't slow you to a standstill. Max health is a multiple of the engine's baseline 100 (×1.5 = 150), and raising the ceiling doesn't secretly heal you. A stat springs back at the start of every match — and only the stats a rule actually touched are reset, so a +25 max HP perk keeps its bonus.

A “place” is a tag. Type or pick one and it resolves to the prop carrying it — the same naming system the rest of the signal system uses, so you point at something you can see and select in the viewport. Two names are built in: me (blank means the same thing) is wherever the player is standing, and start is the level's player start. A trigger volume answers to its own event name, so the zone that fires a rule can also be the spot it acts on — On event reachedVault → Spawn 4 Brutes at reachedVault. If several props share a tag, each use picks one at random, so “spawn at guardPost” scatters a patrol across all of them. A place nobody carries does nothing — the verb is skipped rather than firing at the world origin.

The advanced gates

• Needs N different senders — the receiving prop only reacts once N different props have signalled it (the same sender firing twice counts once). Both pressure plates; all three generators.
• Needs item — a rule can require the player to be carrying an inventory item, with an optional consume: “On E, if carrying the fuse, do Open — and spend the fuse.” A locked prop without the item shows a LOCKED toast naming what's missing.
• On object placed extras — filter by a from tag (only the tagged object triggers it, blank = any physical prop), choose Touching it vs Inside it, and optionally consume the placed object (it vanishes when it lands — sacrificial offerings).

Locks & keys

The Lock fold requires a key (red / blue / gold / green) before E works on the prop, with optional Consume key on unlock. Keys are granted by key pickup pads (one-shot — they don't respawn), appear as HUD chips, and can carry a custom display name set on the pickup.

SystemsPoint & click — adventures, tycoons, RTS

Gameplay tab ▸ Player options · Object ▸ Signals ▸ On click

The mouse can reach the world. A prop can answer a click from across the room, the cursor and the crosshair both say what is clickable, and the player can be sent walking to wherever you click the floor. That is the whole toolkit behind a point-and-click adventure, a tycoon, an ARPG or an RTS — and none of it needs the Logic graph unless you want it.

The two switches

Both live on the Gameplay tab, in the Player options fold — and they are offered only in Top-down, Side-scroll, and in Third person once ARPG cursor aim is on. In first person the mouse is the camera, so the pair is not shown at all and a hint in its place says where it went.

How to: make a prop clickable

1. Select the prop. Open Signals.
2. + Add signal, and set when to On click.
3. Pick a do — Toggle a door, → Logic event to run a rule, Open/close a modal to show a menu, anything in the verb table.
4. Give the prop a Name (top of Object & selection). The name is what the player reads when they point at it, so “Vault Door” beats “box 14”.
5. Press ▶ Play and point at it.

What the player gets, free, with no extra authoring:

• The cursor becomes a hand over anything clickable (free-cursor views).
• A ring appears around the crosshair when it rests on something clickable (first person). It is the same answer, drawn where you are actually aiming.
• The prompt names it — CLICK Vault Door — using the prop's Name. If you are standing close enough for an E prompt, that one wins, because the thing at arm's reach is the actionable one.

How to: click-to-move

1. Player tab ▸ View & camera ▸ tick Free mouse cursor, then Click to move.
2. Play, and click the floor.

A ring pings at the destination in your HUD accent colour and holds there while you walk, vanishing when you arrive. Click somewhere the player cannot route to and the ring pings red and does not hold — so a refused click never looks like a click the game ignored. Clicking something with an On click signal runs that signal instead of walking; a click is one thing or the other, never both.

How to: a working prize counter

The full loop — click a thing, a menu opens, a button spends a variable — in six steps:

1. Place a prop. Name it Prize Counter.
2. Signals ▸ On click ▸ Open/close a modal ▸ Open… ▸ modal name shop, and tick freeze the world so the match stops while the menu is up.
3. HUD tab ▸ + Widget ▸ kind Button. Label Buy a prize, in modal shop, fires event buy.
4. Add a second widget, kind Text, in modal shop, label Tickets {tickets}.
5. Gameplay tab ▸ Open logic graph. Add On event named buy → Change variable tickets by -1.
6. Play, click the counter, press the button.

The Preview dropdown on the HUD tab shows that modal's widgets on screen while you lay them out, so you are not authoring blind. It is a view, not a setting: it is never saved and never opens the modal in play, and show when is ignored inside it so nothing is invisible while you arrange it.

SystemsVisual logic — the Logic graph

The signal system wires one cause to one effect. The Logic graph (Gameplay tab ▸ Logic graph ▸ Open logic graph) is the layer above it: a full-screen node canvas where you build real game logic — counters, timers, branches, variables, randomness, loops and reusable functions — without writing code. Drag the board to pan, wheel to zoom, drag nodes by their headers, drag an output port onto an input port to wire them, click a wire to remove it. Tag, event-name, animation-clip and sound fields are drop-downs: they list every tag your props and lights already carry (with a count), every event name declared anywhere, every clip name your placed models ship, and every sound URL the level already uses — pick from the list or type a brand-new value.

Reusable functions are the On event / Send event pair: build a chain once behind a named event and call it from anywhere — the calling chain continues after the call. A classic graph: On start → Set score = 0; a pressure plate fires → Logic event "scored" → Change score +1 → Branch score ≥ 5 → Show message → Win level.

Enemy hooks

The AI had exactly one connection to the graph: On enemy killed. Two more entries close the loop.

Neither carries which enemy it was, on purpose: pair them with Command enemies (above) and you have the whole classic loop in four nodes — On enemy spots you → Change alarm +1 → Command all enemies: Alert them to vaultDoor. A stealth game is the same loop plus Command enemies: Lose the player on the other side. Both cost nothing until you actually put one on the board.

Values that carry over

Normally every variable resets when a level starts — which quietly rules out anything with progress: a running coin total, a quest stage, a shortcut you unlocked. Under Gameplay ▸ Logic graph, below the Open button, every variable name in the level is listed with a tick box. Tick one and it survives into the next level of the campaign.

That asymmetry is on purpose: a player can never lose progress by dying, and can never farm a level by replaying the first half of it. A variable you tick but never write settles at 0 rather than nothing, so a Branch on it is never comparing against a blank.

Also keep them between sessions is a separate opt-in below the list. With it on, the carried values are written to the player's browser, so they can close the tab and come back to the same progress; with it off — the default — nothing is stored anywhere. The panel always shows what is being carried right now, with one button to throw it away.

SystemsInterfaces — widgets & menus

HUD tab → Custom widgets (logic-driven)

Everything on screen that is not the engine's own HUD is built here. A widget is one element — some text, a bar, a countdown, a button, a picture. Widgets read your Logic variables and a Button fires a logic event back, so the HUD is a two-way surface, not a readout. Give several widgets the same modal name and they become a menu that opens and closes as one: a shop, an upgrade screen, a card hand, a pause-style panel of your own.

The five widget kinds

Every widget also has: anchor (nine screen positions) plus an offset in pixels, size, theme colour (untick to pick your own), panel (the plate behind it), show when, and in modal. The image URL field exists on every kind, not just Image — on the others it is a backdrop, so a Button can be a card face and a Bar can sit inside a frame you drew.

Stacking — which widget covers which

Widgets draw in list order, last in front. Use ▼ back / ▲ front on a widget's card to restack. Put a panel frame or a card face at the back and the text and buttons over it.

Timer formats

Counting down

You do not need arithmetic for a timer. The Logic graph has a Countdown node (Flow category) with three modes:

The output is an ordinary logic variable, which is the whole point: a Timer widget shows it, Branch compares it, an expression reads it, and it stops while the game is paused or a cutscene is playing.

Modals — building a menu

Type a name into a widget's in modal field and it leaves the HUD and joins that menu. Every widget sharing the name opens and closes together, over a dimmed backdrop, with the mouse freed and the world no longer taking clicks. Nothing else has to be set up — the name is the menu.

Open and close it from the Logic graph: Do action → Open/close a modal, then Open… or Close and the modal's name. A prop signal can do the same, so a shop counter you walk up to and press E on opens the shop.

SystemsCampaigns & doorways

Save tab → Campaign · Logic tab → Go to level

A big level does not have to be one file. Split it into rooms — a hub and four wings, a fairground and its booths, a house you walk through — build each as its own level, chain them into a campaign, and put a doorway where they meet. This is how Half-Life and Portal are built, and the pieces are already here.

Chaining the levels

Two doors to the same place: the Campaign menu in the top bar (desktop), or Save tab → Campaign. The menu lists your campaign's levels by name — click one to open it for editing — and everything in it is also in the panel. Build a room, press ➕ Add current level, build the next, add it too. Reorder with ▲/▼, remove with ✕. ▶ Play campaign runs them in order. Export campaign writes the whole sequence as one file and Import campaign reads it back — that is what you share.

Saving the level you are working on

Adding a level to the campaign, or opening one with Edit (or from the Campaign menu), attaches it: from that moment, plain Save (Ctrl+S) updates the campaign copy automatically — the save note says "campaign level updated too", the campaign panel shows an Editing banner, and the top bar reads CAMPAIGN: EDITING "…" the whole time. You never need a second save step: work, save, play.

Done detaches, and Save goes back to being just the browser save. Loading anything else — a library level, an import, a shared link, File → New — also detaches, so you can never overwrite a campaign level with something unrelated by accident.

Doorways — the Go to level node

Logic tab → Go to level (in Actions). Three fields:

Worked example — a trigger that loads the next level

This is the whole thing, in the room you are leaving:

1. Build both levels first. Save tab → Campaign → Add current level for each one. The Go to level field can only offer rooms that are already in that list.
2. In the room you are leaving: World tab → Zones → Trigger → + Add trigger (here). Drag the blue dot to the doorway, set radius and height, leave when on Enters and who on Player.
3. Type a name in fires — say newLevel. A trigger does nothing on its own; it just announces that name.
4. Logic tab → add On event and type the same name, newLevel.
5. Add Go to level and wire the event's ▶ to its input.
6. Click level # and pick the room from the dropdown — it lists your campaign by name (1 → Intro, 2 → Level 2). You can also just type the number.
7. Press Ctrl+S — while a campaign level is attached, Save updates the campaign copy too (the note says so). Then Play campaign.

What crosses the threshold

Progress across sessions

Under the carry list: Also keep them between sessions writes the carried values into the player's browser, so they can close the tab and come back. Two more boxes appear under it once that is on — Carry the inventory too and Resume at the last checkpoint. Both are solo only, and finishing the game clears the checkpoint so the next run starts clean.

SystemsPickups & inventory

Pickup pads

Gameplay tab → Pickups. Toggle spawning, the base disc, and the bounce/rotate animation; then place pads with + Place ahead or edit each spot's kind, transform and (for items) which inventory item it grants. The kinds:

Inventory — the Use actions

Items defined under Inventory items land in the player's inventory (I): 3D objects open in a rotate/zoom inspector, journals open as text pages. Each item's Use action decides what the Use button does:

Consumed on use (default on) spends the item; off makes it reusable. Journal items get a text page; 3D items get a model + scale (1 ≈ 2 m across in the inspector). In campaigns, inventory carries between levels.

Loot & coins

Loot sets what enemies and loot boxes drop. Coins (spawned on kills) are the in-run currency for the shop and weapon attachments.

SystemsObjectives & rules

The eight objectives

Rules that shape the run

• Objective text — the goal banner (players re-read it with J; signals can rewrite it mid-run).
• Respawn at checkpoint (solo) — death returns you to the last checkpoint instead of ending the run.
• Wave mode — Random, or Pre-built from your spawn markers (optionally single-pass, no respawns); between-wave upgrade cards in solo.
• Fall damage — on/off for player and AI, with safe speed and damage scaling. Ragdoll on death. Crushing props — heavy movers deal damage, with min speed.
• Camera view — how players see your level: First person (the classic), Third-person, Top-down, or Side-scroller. Saved with the level, so it carries through share links, the community gallery and multiplayer.
  • Third-person — an over-the-shoulder chase camera that smoothly follows the player with damping (it eases after sprints, jumps and turns instead of being bolted rigid; aiming tightens it back to exact). Controls and aim stay first-person-style. Tune the framing and the Follow smoothing slider under Player tab → Third-person framing — smoothing is also a player preference, so it applies when anyone toggles third-person from the pause menu too.
  • Top-down — a fixed isometric-tilt camera follows the player; WASD moves on the map (screen-relative), and the mouse steers a cursor: your character faces it, shots hit whatever is under it, and grenades lob onto it (up to the grenade's throw-force range), twin-stick style. Cars keep their full handling — instant chase/racing levels. Camera distance sets the zoom (8–80).
  • Side-scroller — the camera locks to one side and players run along a single lane (pick east–west or north–south). A/D run, Space jumps, and the mouse aims anywhere within the plane (grenades arc to the cursor too). Players are held on the lane they deploy on, so build your level along it — ramps and stairs shine here.
  • Camera framing (build 1085) — both fixed views orbit the player, and every part of the orbit is yours:

    Control	What it does
    Camera distance	How far back the camera orbits (top 8–80, side 6–60)
    Rotate	Swings the camera around the player. Top-down: full 360°, and WASD rotates with it so W is always up-screen. Side-scroller: ±60° for an angled 2.5D look — the player still runs along the lane.
    Tilt	Angle above the horizon. Top-down 15°–89° (89 is almost straight down, low is strongly isometric); side-scroller −30°–60°, so you can look down on the lane or up at it.
    Height	Raises or lowers what the camera is centred on. Camera and aim point move together, so the whole frame shifts vertically without changing the angle — handy for showing more headroom, or a pit below.
    Roll	Tips the horizon up to ±30° for a dutch angle.

    Reset camera puts everything back to the mode's default. Levels built before build 1085 frame exactly as they always did — the old fixed angles are the defaults.
  • Seeing the camera while you build (build 1084) — top-down and side-scroller levels don't have a camera you place; it is worked out from the player start, the camera distance and (side only) the lane axis. So the editor draws it for you:
    • A blue box in the viewport is the camera, sitting exactly where the player's will be.
    • The blue rectangle in front of it is the frame — everything inside it is on screen at deploy, in your window's real aspect ratio. Drag the camera-distance slider and watch it grow and shrink.
    • In side-scroller levels a gold plane and ground line mark the lane. Players are locked to it, so anything you build off the plane is scenery they can never reach — this is the single easiest thing to get wrong, and now it is visible.
    • Live camera preview — a small window showing exactly what a player sees standing on the start point. It updates as you build, and you can drag it anywhere or close it. Also under Tools ▸ Play-camera preview.
    • Stand in it puts the editor's fly camera in the play camera's exact position and angle. Press F to go back to flying normally.
    Move the player start and everything follows it immediately. All of it is editor-only — none of it appears in play.
  • Cutscenes, turret seats and the PvP killcam keep their own cameras; the editor always flies free. In both fixed views your character model is visible and enemies aim at it as normal.
• Hands / unarmed — start with fists only, optionally allow picking up weapons found in the level; the flashlight (brightness, cone, softness, range, colour).
• Hit numbers — floating damage numbers with font size and hit/kill colours.
• Multiplayer spawn area — confine MP spawns to a circle or drawn polygon.
• End-screen messages — custom victory and defeat text.

SystemsCutscenes — shot by shot

Gameplay tab → Cutscenes. A cutscene is a list of camera shots played back-to-back with hard cuts; each shot flies through its own waypoints. Cutscene #1 is the intro (toggle Play intro flythrough on deploy); every additional cutscene is named and fired by a signal's Play cutscene action. Any key or tap skips playback.

Waypoints: fly the editor camera to a spot, click + Add camera waypoint (current view), repeat — 2+ points move the camera; a single point is a held shot. Per point: Go to (jump the editor view there), Set (overwrite with the current view), 👁 (aim the editor at your subject, then click to store a look-target), ⊘ (clear it), ✕ (delete).

▶ Cutscene previews all shots, ▶ This shot just one, and the camera preview window shows live framing while you scrub. Show character at the player start puts your avatar in frame for intros.

SystemsMultiplayer

Peer-to-peer over WebRTC — no accounts, no servers to rent. One player hosts and shares the 5-character room code (or joiners pick from the Open games list); everyone else joins, and the host's level transfers automatically — including custom models and sounds. While a host waits in the pre-game lobby, the room is listed in everyone's Open games list automatically (a tiny lobby directory on rumpusengine.com) and drops off the moment the match starts or the host leaves.

Modes — the actual rules

Bot difficulty — what the presets actually change

PvP hosts pick bot count (0–7) and difficulty when hosting, or Fill with bots from the lobby. Bots fight like players now: they carry visible weapons, throw grenades (including flushing you out of cover), duck behind cover to reload, and wear random characters from the level's roster so no two look alike.

Match rules — when hosting, the host can restrict which weapons are allowed (melee always stays in) and set starting grenades (0–6) for everyone; the rules reach every joiner and bot automatically.

The lobby is a proper pre-game screen: a live 3D character select (models rotate, colours preview, CHARACTERS and COLORS read as separate groups), a MATCH INFO panel, rotating tips — and creators can attach a lobby backdrop image to a level (Save tab ▸ Title screen ▸ Multiplayer lobby backdrop) that every player sees, softly blurred, behind the lobby. Joiners watching the level transfer see a live LOADING WORLD % instead of a frozen screen. Matches end with a podium ceremony — standings, medals, and an MVP callout in team modes.

What syncs: player movement and state, enemies, kill credit, coins and pickups, prop animations and mechanisms, unlocks and keys, objective progress, race standings, chat, and the host's custom HUD/sounds.

SystemsSaving & sharing

• Browser save — one save slot plus autosave while editing.
• .rumpus export/import — the level (or a whole campaign) as a file. Everything serializes: props, track, vehicle tuning, rules, cutscenes, HUD, and the asset-credit list. The file is plain JSON inside, and old .json exports import forever.
• Share link — the entire level compressed into a URL. Anyone who opens it plays it instantly. Models re-download from Poly Pizza / Sketchfab on the recipient's machine (Sketchfab models need the recipient's own free token).
• Challenge links — from the end screen, share the level plus your score to beat.
• Campaigns — chain levels with carry-over loadout and inventory; share as one file.
• Credits — every searched model, texture, HDRI and sound is attributed automatically and travels with the level; the Credits screen shows the per-level list.

The community library

Community levels on the home menu is a gallery of player-built levels hosted alongside the game — browse, then Play one or Open in editor to see how it's built (and remix it; loading is undoable).

To publish your own: editor → Save tab → Submit to community library. That grabs a screenshot of your current view as the gallery thumbnail, asks for a level name and your author name, and sends the level straight in for review — no account of any kind needed. Once it's approved it appears in everyone's gallery, credited to you. (If the submission server can't be reached, the game falls back to the old GitHub submission form, which needs a free GitHub account.) Levels that use Sketchfab models get a needs Sketchfab token badge, since those download with each player's own free token.

ExtrasLevel check — the panel that reads your level back

Save tab, bottom: ⚠ Level check — N things worth a look (saving still works)

It is not a validator and it never blocks anything. It is the engine telling you what it can already see about your level — the mistakes that are invisible while you are building because everything works on your machine, with your files, in the state you happen to have left it in. Run it before you publish and before you share a link. It also runs automatically when you press Publish.

What it looks for

ExtrasRecipes — things built end to end

Each of these is a complete thing you can build in one sitting, using nothing that is not in this manual. They are written as sequences to follow, not as ideas to take away.

Building a shooting range

Plates that score when you hit them, never disappear, and reset on demand. This is the recipe the engine's own 🎯 Shootable target flag exists for.

1. Build the plate. Add a box, scale it flat and stand it up. Open Object & selection → Physics & destruction and tick 🎯 Shootable target. Do not tick Dynamic — the plate should stay bolted where you put it.
2. Make it score, not shatter. In the same fold, untick Breakable. It now takes hits forever: the flash, the sound and the signal all still fire, it just never breaks.
3. Tag it. Give it the tag plate1. Duplicate it twice along the booth and tag the copies plate2 and plate3.
4. Wire the hit. On each plate: Signals → + Add signal → When hit → → Logic event named plateHit.
5. Count it. Logic tab → On event plateHit → Change variable score +1.
6. Show the score. Either a HUD widget (+ Text, label SCORE {score}) or a Sign on the back wall reading SCORE {score}. The sign is the nicer one for a fairground.
7. Add a reset. Place a lever prop, tick Interactable, and give it a signal: When E pressed → Reset props, tag plate1. Repeat for the others, or tag all three plate and use one signal — a tag names a set.

Building a movement course

An obstacle run that teaches its own verbs. Every switch below is on the World tab under Movement.

1. Turn the verbs on. Set Air jumps to 1 (a double jump), Wall jump to about 14, and Air dash to about 22. Leave Tap hop at 0.5 so a short press gives a short hop.
2. Teach them in order. Build the course in four stretches, each of which can only be crossed with one verb: a gap too wide for one jump (air jump), a chimney of two facing walls (wall jump), a long flat gap with no wall (air dash), and a low ceiling you have to tap-hop under.
3. Sign each stretch. A Sign at the entrance to each — “Jump again in mid-air”, “Jump off the wall”. Nobody reads a manual; everybody reads a sign in front of them.
4. Add checkpoints. A trigger zone at each stretch's start, each firing its own event name, and an On event → Do action → Set checkpoint for each. Falling then costs seconds, not the whole run.
5. Time it. Exactly the timed round above, with the format set to hundredths so two runs can be compared.

A room with someone in it

1. Import or place a character prop, and open Dialogue (NPC). Give it a Name and three lines.
2. Tick Interactable so the player gets a prompt.
3. In a dialogue line, write {set metGuard = 1} — the conversation now leaves a mark on the world.
4. Put a locked door across the exit: on the door prop, Signals → When E pressed → Open, and set the needs count beside the Tag box (“different sender(s) before it reacts”) if it should wait on more than one thing.
5. Logic tab: On event from the guard's last line → Do action → Open, tag the door.
6. Under Values that carry over, tick metGuard so the next room knows.

Stitching booths into a fairground

Once each booth works on its own, a campaign turns them into a place.

1. Save each booth as its own level and add them to the campaign in order — the hub first.
2. In the hub, put a tagged plinth at each booth's entrance and a trigger zone in front of it, wired to Go to level with that booth's number and keep gear on.
3. In each booth, one trigger at the exit goes back to level 1, arriving at a tag beside the door the player came out of.
4. Tick a booths variable to carry, add Change variable booths +1 when each booth is completed, and a Branch in the hub opens the finale at your booth count.
5. Put a Text widget reading {booths} / 4 booths cleared in the hub so the player always knows where they are.

ExtrasTips & troubleshooting

• Sketchfab search says it needs a token — it's a free API key: sketchfab.com → Settings → Password & API. Paste it once in any search box; every other box switches to “Token saved · change”.
• A shared level is missing models — Sketchfab downloads require each player's own token; Poly Pizza models need none. Prefer Poly Pizza for levels you plan to share widely.
• The game looks out of date — hard-refresh (Ctrl+Shift+R) and check the build number bottom-left of the home menu.
• Performance dips — post-FX sheds passes automatically under load, but the biggest wins are yours: fewer point lights, smaller textures, fewer high-poly Sketchfab models. Adaptive resolution (pause menu) trades sharpness for frame rate on sustained drops — turn it off if you'd rather keep full resolution and accept the dips.
• Edges look jagged / aliased — check Adaptive resolution in the pause menu: when the frame rate struggles it lowers the render resolution, which reads as shimmer on edges; untick it for full sharpness. (Since build 872, Visual effects keeps proper antialiasing — older builds lost it whenever effects were on.)
• My race rivals won't spawn — rivals need a closed track loop (use Close loop) and a placed drivable vehicle to clone. The Save tab's issues panel calls this out.
• A mechanism won't fire — check its Trigger: Signals only waits for a signal; E Activate may be gated by a Lock. The signal's target tag must match exactly.
• I can't find a setting — sections remember their collapsed state; expand the section headers. Selection folds (Vehicle, Signals…) only appear with a prop selected on the Build tab.