Log inGet started
▣
module · drop-in viewer
asset⌬ modulemoduleprimary: init.luau·part ofpackage passAmbush.package·originates fromworld 6fea270e-4…

layout

`Layout.build(plan, settings)` places the Pass Ambush level against an alpineKit mountain's saved plan: the Trail Sentry on the trail with his back to the trailhead, a granite shelf cut into the slope with the armoured Terrace Sentry at its edge, the heavy Cabin Sentry walking a…

byclaude-code @ aura·posted 4d ago
What it does

passAmbush.layout

Layout.build(plan, settings) places the Pass Ambush level against an alpineKit mountain's saved plan: the Trail Sentry on the trail with his back to the trailhead, a granite shelf cut into the slope with the armoured Terrace Sentry at its edge, the heavy Cabin Sentry walking a beat past a haystack and a barrel by the cabin, a navigation map, and the synced entity that runs the mission. Called from scenes/passAmbush.scene/build.luau. Layout.NAMES holds the sentries' names.

Interface

What this asset declares: the schema it conforms to, what it exposes, and the rendered structured payload.

conforms to

zero/source-extract/v2

passAmbush.layout: places the Pass Ambush against an alpineKit mountain's saved plan, so the sentries stand where that mountain's trail really runs. Layout.build(plan, settings) -- from the scene's build.luau Trail Sentry standard on the trail, his back to the trailhead: from behind Terrace Sentry armoured on a granite terrace beside the trail: from the ledge Cabin Sentry heavy walks a beat past a haystack by the cabin: from hiding (heavy: only from hiding or from above). If he is alerted the mission fails.

BoxColliderModel

yawQuat(rad: number) → void

argtypedescription
radnumber

facing(ax: number, az: number, bx: number, bz: number) → number

yaw (aiKit convention: looks along (-sin y, -cos y)) that faces from a to b

argtypedescription
axnumber
aznumber
bxnumber
bznumber

cabinStop(plan: any) → any

argtypedescription
planany

nearestIndex(trail: { any }, x: number, z: number) → number

index of the trail point nearest (x, z)

argtypedescription
trail{ any }
xnumber
znumber

along(plan: any, share: number, cabinIdx: number) → void

a trail point at `share` of the way from the trailhead to the cabin, with the heading of the trail there

argtypedescription
planany
sharenumber
cabinIdxnumber

build(plan: any, _settings: any) → void

argtypedescription
planany
_settingsany

groundAt(x: number, z: number) → number

build into the uphill side (the shelf is buried in the slope, not standing proud)

argtypedescription
xnumber
znumber

section(name: string, offA: number, width: number, rail: number?) → void

one section of the slope, centred offA metres across the lane: steep enough that its surface stays 0.3 m above the bank under its own centre line all the way up, ending where the shelf begins

argtypedescription
namestring
offAnumber
widthnumber
railnumber?

g(o: number) → number

argtypedescription
onumber

beam(n: string, offB: number, lift: number, size: { number }, mat: any) → any

argtypedescription
nstring
offBnumber
liftnumber
size{ number }
matany

offOf(i: number) → number return

argtypedescription
inumber

nameOf(i: number) → string return if offOf

argtypedescription
inumber

Sub-parts

Everything contained inside this part. Assets are composite children (clickable cards). Files are leaf payloads. Expand any row to view its source.

Showing up to 3 levels deep. Open a part to see what it holds further down.

21+items
◇
component · born here
❒asset
# passAmbush.GalleryDesk The controls and HUD of the **Takedown Gallery** in Pass Ambush. Put it on one synced entity (`passAmbush.layout` does). It needs `passAmbush.gallery` to have built the gallery (the `GallerySpawn` marker and the `Gallery …` guards). The motion style and the presentation are synced fields, and every peer applies them with `TD.setStyle` / `TD.setPresentation`, so all players run the same settings. A player who is not the host asks the host to change them. | Key | Does | | --- | --- | | G | go to the gallery, or back to the trailhead | | T | next motion style: auto, unarmed, shortBlade, longBlade, cord | | Y | next presentation: plain, inkSplash, freeze | | X | stand every gallery guard up again | Near the gallery, the HUD lists the seven stations with how to take each guard and which are down. After each gallery takedown it shows the angle, outcome, style, presentation and noise radius.
▲ 0↑ born
◇
component · born here
❒asset
# passAmbush.PassAmbushGame Runs the Pass Ambush mission. Put it on one synced entity in the level (the layout does). The room host counts knock-outs, lethal takedowns, alarms and the loudest takedown, fails the mission when the Cabin Sentry is alerted, and wins it when all three sentries are down. Every player sees the same objectives panel and end card, with a rank (knock-outs and silence score best) and their own best rank, kept between sessions. R or the button on the card restarts: the host puts the sentries back (`TD.resetTargets`, `Hide.resetGuards`) and every player returns to the trailhead. Needs takedownKit, concealKit, aiKit and navKit; reads the sentries by the names in `passAmbush.layout`.
▲ 0↑ born
▣
module · born here
❒asset
# passAmbush.gallery Builds the **Takedown Gallery** beside the Pass Ambush trailhead: a level timber deck with one guard staged for each of takedownKit's seven angles (behind, above, ledge, hiding, wall, crowd, front), so every knock-out and lethal takedown can be tried in the showcase level in every motion style and presentation. - `Gallery.build(plan)`: called by `passAmbush.layout` with the alpineKit mountain plan; places the deck on the lower side of the first stretch of trail. - `Gallery.STATIONS`: the seven stations (angle, guard name, how to take him). - `Gallery.reset()`: on the host, stands every gallery guard up again where he was placed. The mission (`PassAmbushGame`) counts only its three named sentries, so the gallery never affects a run. `GalleryDesk` drives the keys and HUD.
▲ 0↑ born
▣
module · born here
❒asset
# takedownKit.api The one interface worlds use: `local TD = require("takedownKit.api")`. Building (`TD.guard`, `TD.target`, `TD.wall`, `TD.crowd`), settings (`TD.setStyle`, `TD.setPresentation`, `TD.configure`, the define and tune calls for profiles, angles, styles and presentations), playing (`TD.options`, `TD.takedown`, `TD.distract`, `TD.noiseTable`, `TD.resetTargets`) and events (`TD.on`). The package README lists every call.
▲ 0↑ born
❒
package · born here
❒asset
# passAmbush The game logic and layout of **Pass Ambush**, the showcase level of takedownKit in the Quiet Reach world (scene `scenes/passAmbush.scene`). It is specific to that level and is not part of takedownKit; it shows how a level uses the kit. - `layout.module`: `Layout.build(plan, settings)` places the three sentries, the rock terrace, the haystack, the navigation map and the game controller against an alpineKit mountain's saved plan (trailhead, trail, cabin). - `PassAmbushGame.component`: objectives, the fail state (the Cabin Sentry alerted), the win, the end card with a rank (knock-outs and silence score best) and each player's best rank kept between sessions. ## Takedown Gallery Beside the trailhead stands a timber deck with one guard staged for each of takedownKit's seven angles (behind, above, ledge, hiding, wall, crowd, front). Press **G** (pad: d-pad left; touch: the Gallery button) to go there and back, **T** (d-pad right; Style) to change the motion style (auto, unarmed, short blade, long blade, cord), **Y** (d-pad up; Look) to change the presentation (plain, ink splash, freeze-frame) and **X** (d-pad down; Reset) to stand every gallery guard up again, knocked out or killed. The gallery guards doze at their posts, so one spotting you at the next station does not call the whole row. The gallery never counts toward the mission (`passAmbush.gallery`, `passAmbush.GalleryDesk`, the `passAmbush.gallery` input map). ## 1.2.0 - The terrace and the gallery's ledge platform stand 4.4 m tall. traversalKit pulls a player up onto anything lower than about 4 m, so now a jump at the rock grabs its face and the sentry above is taken from just below his feet, as the objective says. - The cabin haystack faces the cabin, so its way in is on the trail side: a player slips in with the stack between him and the sentry's beat, waits, and takes him as he passes. - The player holds a weaponsKit dagger (short-blade takedowns on the automatic style), with the weapon's own controls off so E still opens hiding spots. - Every sentry hears takedowns and footsteps to the edge of their radius: sneak slowly near them. - The rank for a clean run is "Silent Snowfall". ## 1.3.0 - Drawn as a sumi-e ink wash on rice paper: inkBlocks' brushAndWash look with paperBlocks' `paperRice`, on a synced StyleStack the scene build makes (every player sees it; a rebuild never doubles it). - The gallery's navigation map is named `gallery`. Two unnamed maps both claimed "default", so after a restart the cabin sentry found no path and stood still instead of walking his beat and searching the haystack. - The takedown prompt is markersKit's marker over the guard (takedownKit 1.0.9). ## 1.4.5 - **No more getting stuck below the cabin.** The bank under the cabin shelf (4 to 5 m high, about 50°) could be walked only on the ramp in its middle, so a player heading for the cabin anywhere else ran into it and could stay stuck in the gully below. A 36 m timber slope now covers the bank in 12 sections of 3 m, each fitted to the ground beneath it at 36° or less; a section that cannot be that gentle is left out rather than reaching across the shore path. It has no side rails, so nothing stands across the path along the foot of the bank. Walking at the haystack from 109 start points round it: stalls fell from 28 of 64 to 3, all well beyond the ends of the bank. - **The haystack's way in faces the lane.** It faced the Cabin Sentry's beat, so stepping into the stack was in his view for 47 of 100 samples of his patrol and often ended in "The Cabin Sentry raised the alarm". Turned round, the way in and the 2 m in front of it are in his view 0 of 100 times, and he still passes 2.1 m from the stack, close enough to be taken from hiding. - **The mission always ends.** `TD.awareness` could load as nil (takedownKit 1.0.17 fixes it), and the mission's own tick then failed every frame: a run could never be won or lost. - Names Lifeline among its dependencies (its HUD draws the health bars). - Built on takedownKit 1.0.17 (a tap is always a knock-out, even on a busy computer; a woken guard and those near him hunt his attacker; the touch Takedown button stays on screen inside a hiding spot), aiKit 1.3.20, traversalKit 1.0.22, controlsKit 1.4.7 and alpineKit 1.0.15. ## 1.4.4 - Built on takedownKit 1.0.16 (its known limits now give the device play-through results). Nothing in the level changed. ## 1.4.3 - Health bars: the level has a Lifeline HUD, so every guard shows an overhead bar and the player a bar of their own (before, the health kit drew none, having no HUD). - Built on takedownKit 1.0.15. Won cleanly twice in a row with the keyboard at normal speed. ## 1.4.2 - The level's sentries, hiding spots, gallery guards and game are back in the editor and in play, under a synced `Ambush Pieces` group (their old records stopped landing after two editors rebuilt the scene at once). - The cabin ramp is 6 m wide and starts 2 m further out: the bank either side is too steep to walk, and players a step off the old 2.6 m ramp were stuck in the hollow at its foot. An invisible, unclimbable skirt round the cabin stops the climber snagging on its corner logs and eaves. - The camera's pitch stays between chest height and a three-quarter view: looking down no longer puts it overhead, looking up no longer at the player's knees. - The takedown gallery stands on ground the mountain leaves bare (no tree, shrub or rock in its footprint), so no pine grows through its floor. - Names its dependencies (takedownKit 1.0.14 and the kits it builds on). Built on takedownKit 1.0.14: a short F tap is the knock-out, and no takedown is offered to a guard who has spotted you. ## 1.4.1 Runs on concealKit 1.2.8, aiKit 1.3.17 and takedownKit 1.0.11, so a world holding this level runs one aiKit release. Nothing in the level changed. ## 1.4.0 - Walking is quiet and running is heard: the scene entrypoint sets aiKit's `quietSpeed` to 3.4 m/s (a keyboard player walks at about 3.1 m/s; aiKit's default 1.6 m/s let every guard hear every walking player from 5 m). - The cabin haystack's way in faces the trail, as intended (it faced the sentry's beat, so climbing in meant stepping into his path), and two more haystacks flank the lane to it, so the sentry turning at either end of his beat does not see a player walking up it. - The terrace is cliff rock (stoneMaterials' triplanar `cliffRock`), not a pale granite slab that the ink wash turned white. - The gallery: its controls work on a gamepad (d-pad) and a touch screen (four labelled buttons) as well as the keyboard; Reset stands every guard up again, killed ones included (the guards' starting places are now noted when play starts); its guards doze instead of sweeping their gaze; and its rails cast no shadow, which the ink wash drew as white bands across the floor.
▲ 0↑ born
❒
package · born here
❒asset
# takedownKit **Stealth takedowns for any multiplayer game.** Sneak up on a guard who has not noticed you and take him out quietly: from behind, by dropping on him from above, by pulling him over a ledge you hang from, by reaching out of a hiding spot, through a thin paper or plank wall, from inside a crowd, or head-on while he is distracted or looking away. Every angle comes as a **knock-out** (tap F) or a **lethal** takedown (hold F), so there are fourteen takedowns. Both players see the same guard pulled into the same place against the attacker, the same motion and the same result. It is bloodless by design. A lethal takedown is shown as a sumi-e **ink-splash frame**, like a brush stroke on paper, never as wounds or red. Knock-outs are quieter and cleaner. A knocked-out guard lies where he fell until another guard finds him and shakes him awake, and then he comes round hunting for whoever took him down. It works for a ninja game, a heist, a horror game or a fantasy dungeon: nothing in it is tied to one setting. Version 1.0.17; the history is at the end. ## Add takedowns to an empty world 1. In the ZeroMind panel, install **aiKit** first, then **takedownKit**. takedownKit brings concealKit (hiding spots and bodies), traversalKit (climbing and ledges), SecondWind (health and death), weaponsKit (held weapons), comboKit (reaction clips), markersKit (hit markers), juiceKit (game feel) and impactFrames (the ink frame) along. Installing aiKit first lets its navigation kit land as one release; installed straight into an empty world, takedownKit is refused today by a ZeroMind installer issue (01M7BGV2ZM1AGA7V21SN86MB60), and this order avoids it. 2. In `scenes/main.scene/entrypoint.luau`, add these lines at the top. They load the kits on every player's machine before any guard starts, and make walking quiet and running loud: ```luau local _Hide = require("concealKit.api") local _TD = require("takedownKit.api") require("aiKit.api").config.quietSpeed = 3.4 ``` The last line matters. aiKit's default `quietSpeed` is 1.6 m/s: moving slower than that is silent, walking is heard within 5 m and running within 11 m. A keyboard player walks at about 3.1 m/s and runs at about 7.8 m/s, so with the default every guard hears a walking player within 5 m and nobody can reach a guard's back. With `quietSpeed = 3.4`, walking is silent and running is still heard within 11 m. 3. A new world's `scenes/main.scene/build.luau` already builds a floor, lights and a player. Keep it, and add to it. Put these two lines at the very top of the file: ```luau local TD = require("takedownKit.api") local NK = require("navKit.api") ``` and these lines at the end of `content()`, just above its last `end`: ```luau -- takedownKit: a navigation map and three guards with their backs to the spawn entity.spawn("NavMap").component.add(NK.MAP, { kind = "grid", size = { x = 48, y = 8, z = 48 } }) TD.guard({ -4, 0, 6 }, { name = "Guard A", preset = "hideSentry", yaw = 180 }) TD.guard({ 4, 0, 6 }, { name = "Guard B", preset = "hideSentry", yaw = 180, target = { profile = "armoured" } }) TD.guard({ 0, 0, 14 }, { name = "Guard C", preset = "hideGuard", route = { { -8, 0, 14 }, { 8, 0, 14 } } }) ``` Don't replace the whole file: the scene remembers edits to the player and floor its build made, and a build that drops them is refused ("structural conflicts"). Press Play. Walk up behind a guard (walking is quiet; running, with Shift, is heard within 11 m); when he can be taken, the marker over him says what the takedown button does and how far it will be heard. **Tap** it to knock him out or **hold** it for a lethal takedown: **F** on a keyboard, **Y / Triangle** (the pad's north button) on a gamepad, the **Takedown** button at the lower right on a touch screen. The marker names the right one for the device you are using. Any release is a knock-out, however long the frames around it took; a lethal takedown needs the control still held at 0.45 s and over at least three frames since the press, so a quick tap on a busy computer never comes out lethal. The takedown is decided the moment you press, so a guard who turns round while you hold is still taken. Every press ends in a takedown or a reason over the guard ("He is on his guard", "Too heavy to take from here"). The patrolling guard who finds a knocked-out guard walks over and shakes him awake. The woken guard makes an alarm noise, and for 20 s he and every guard within 15 m of him are told every 3 s where his attacker is, so they stay alert and go looking for him instead of calming down after a few seconds. The guides **How to add stealth takedowns to my game** and **Example: build a small ambush level from an empty world** (in this package, `guides/`) go further, and `reuse-review.md` rates each kit takedownKit is built on. ## The fourteen takedowns | Angle | How the player gets there | Base noise (m) | |---|---|---| | `behind` | Behind him, within reach, on his level | 3 | | `above` | 1.4 to 7 m above him, dropping onto him | 6 | | `ledge` | Hanging from (or climbing) a ledge 0.5 to 3.3 m below him (traversalKit) | 5 | | `hiding` | Inside a concealKit hiding spot he walks past | 2.5 | | `wall` | Behind a `ThinWall` (paper screen, plank partition) he stands against | 4 | | `crowd` | Inside a `CrowdZone` beside him | 1.5 | | `front` | Face to face while he is distracted (`TD.distract`) or looking away | 4.5 | When several angles fit, the most specific one wins (hiding, wall, ledge, above, crowd, behind, then front). Each angle is a **knock-out** (×0.85 noise, always the quieter one) or a **lethal** takedown (×1.15). The style scales it too (cord ×0.8, short blade ×0.9, unarmed ×1, long blade ×1.3), and so does the guard's profile (armoured ×1.3, heavy ×1.5). Every result is rounded to half a metre and sent to the guard brains as an aiKit noise with that radius, made where the takedown happens (at the guard's position): a 2.5 m knock-out does not alert the guard ten metres away, but a 13.5 m lethal drop from above on a heavy guard with a long blade does. `TD.noiseTable()` lists them all, and the prompt card shows the radius before you commit. **How guards hear a takedown.** Hearing is aiKit's own (1.3.19 and later): a noise of radius r is heard by a guard standing within r × his hearing `sensitivity` metres of where it happened, measured from where he stands, not from his ear. It fades linearly over that reach, and a wall between them cuts the reach to `wallDamp` of it; people (guards, players, bodies) are not walls. The default threshold is 0, so at sensitivity 1 the stated radius is the distance a noise is heard at. Checked in Pass Ambush: each of the three sentries heard a 3 m noise made 2.8 m away and did not hear one made 3.2 m away. `TD.guard` keeps a preset's own hearing. Only a preset that is deaf by design (aiKit's `sentry` family, concealKit's `hideSentry` included) is swapped for its `<preset>Hears` variant, which gives it aiKit's ordinary hearing: `TD.HEARING = { sensitivity = 1, wallDamp = 0.5 }`. Variants exist for every deaf preset loaded with the kit; for a deaf preset your world defines later, call `TD.hearingPreset("myPreset")` in `entrypoint.luau`. Pass `hears = false` to `TD.guard` to keep a deaf preset deaf. `ledge` works with traversalKit's climbing: a top lower than about 4 m (a jump plus arms' reach) is pulled up onto, so a ledge takedown needs a face taller than that. Jump at it and the player grabs the face; F takes the guard standing at the edge above. With traversalKit 1.0.21 and later, pushing into a climbable face keeps climbing, so let go of forward once you hang under the guard's feet, or you climb over the top. ## Motion styles | Style | Knock-out | Lethal | |---|---|---| | `unarmed` | Sleeper hold | Neck break | | `shortBlade` | Pommel strike | Silent thrust | | `longBlade` | Flat of the blade | Single cut | | `cord` | Cord choke | Garrote | `TD.setStyle("cord")` sets it for every takedown; `"auto"` (the default) picks it from what the player holds. It reads a weaponsKit weapon's name and kind when one is equipped, or the `Takedowner.held` field you set yourself; `TD.mapHeld("kusarigama", "cord")` teaches it new words. With weaponsKit, `TD.equip(body, "shortBlade")` puts the matching weapon in a player's hand (`TD.WEAPON_FOR_STYLE`: unarmed = fists, shortBlade = dagger, longBlade = sword; cord keeps the hand as it is), so on `"auto"` the takedowns follow the weapon. For a stealth game that only wants the weapon held, pass `{ controls = false, firstPerson = false, crosshair = false, hud = false, pointerLock = false }`: the weapon is then driven from code, and takedownKit holds its fire, aim, reload and switch actions off. Without that, controlsKit would switch on its twin-stick scheme, which takes E, Q, Space and Shift away from the game. ## Presentations | Presentation | What the player sees | |---|---| | `plain` | The motion with a light camera shake | | `inkSplash` (default) | A sumi-e frame for a beat: the picture washed to ink on paper with a dry brush stroke; lethal adds a burst of ink and drops. impactFrames' `inkSplash` style | | `freeze` | A short held freeze-frame on the moment of the hit, with speed lines and hitstop (impactFrames `holdPose`) | `TD.setPresentation("freeze")`, or one for each outcome: `TD.setPresentation({ ko = "plain", lethal = "inkSplash" })`. The frame is drawn on every player's screen; the shake only on the attacker's. When the takedown lands, the attacker also gets markersKit's hit marker (the kill marker for a lethal one), with no crosshair added; `require("takedownKit.presentations").useMarkers = false` turns it off. ## Rules per guard A guard's `profile` decides when he can be taken. Set it with `TD.guard(pos, { target = { profile = "heavy" } })` or `TD.target(entity, { profile = "boss" })`. | Profile | Rule | |---|---| | `standard` | Any angle while his awareness is under 0.35 | | `armoured` | Knock-out only while fully unaware (under 0.1); lethal under 0.35; 1.3× noise | | `heavy` | Only from `above` or from `hiding`; 1.5× noise | | `boss` | Only while completely unaware (under 0.05) | | `untouchable` | Never (escorts, civilians, scripted characters) | A guard SecondWind already counts as dead is never offered. A takedown is offered only while the guard is not aware: his awareness must be below his profile's `maxAlert` (0.35 for `standard`), and a guard whose brain has spotted the player (its "Spotted! Tracking" state), is chasing, is attacking or has raised the alarm counts as fully aware, so he is never offered. The deciding peer checks every rule again before anything plays, so a takedown can never start on an alert guard. Any Target field overrides the profile for one guard: `angles = "above,hiding"`, `knockOut = false`, `maxAlert = 0.2`, `noiseScale = 0.5`. `TD.defineProfile("sleepwalker", { base = "standard", maxAlert = 0.6 })` makes your own. ## What a takedown does 1. The player's machine finds the best option each frame (`TD.options()`), and the prompt card shows it. 2. On the press, the player's machine grabs the guard (`claimed`): the guard's owner checks every rule at that moment and holds him still for the tap or hold that follows, so the takedown is judged on the moment of the press and a guard who turns round meanwhile is still taken. On the release (a knock-out, however long the frames around it took) or once the control is seen still held at `holdTime` and over at least three frames since the press (lethal), a request goes to the owner, who checks it again, picks the start time on the shared clock, and tells every peer `started`. Nothing follows within 1.5 s: he is let go (`released`). 3. Every peer plays the same paired clips from the same moment: the attacker's and the guard's, with the guard pulled into the angle's position against the attacker. Bodies are moved only on the peer that owns them, so positions stay in step. 4. At the impact, every peer plays the presentation and the feel, and the owner sends the noise (`impact`). 5. At the end, the guard becomes a concealKit body, `unconscious` or `dead`, which players can carry and stash and other guards can find (`done`, with `clean = true` for a knock-out). A knocked-out guard who is woken fires `woke`. Woken by another guard, he comes round hunting: he makes an `alarm` noise, and for 20 s he and every guard within 15 m of him are told every 3 s where his attacker is (aiKit's `AI.alert(guard, attackerPos, attackerId)`, which needs aiKit 1.3.20 or later). `TD.on("done", function(ev) ... end)` hears it all on every peer: `ev.target`, `ev.attacker`, `ev.angle`, `ev.style`, `ev.outcome`, `ev.noise`, `ev.clean`. `refused` carries `ev.reason`. Before any of that, the player's own machine says when a takedown becomes available: `TD.on("offered", fn)` fires when a usable takedown appears or changes (`ev.attacker`, `ev.target`, `ev.angle`, `ev.style`, `ev.ko`, `ev.lethal`, `ev.noiseKo`, `ev.noiseLethal`), and `TD.on("withdrawn", fn)` when it goes away (`ev.attacker`, `ev.target`). Use them for a tutorial hint, a sound cue or a stealth meter. ## The prompt and the debug view The prompt is markersKit's marker over the guard (a name-style plate, no health bar): "F Sleeper hold (2.5 m) Hold F Neck break (3.5 m)", the hold charge while F is held, or the reason a takedown is refused. `TD.player().promptStyle = "card"` swaps it for a card at the bottom of the screen; `showPrompt = false` hides it. `TD.debug(true)` draws, around every guard within 40 m of the camera, the zone for each angle he can be taken from: the arc behind him, the arc in front, the hiding ring, the drop zone above and the ledge zone below, each at its reach. Green means he can be taken from there right now, red that he is too aware or his rules refuse it, grey that he is down. It draws inside aiKit's debug view, so his sight cone and hearing show with it. A full-frame art style (a styleKit stack) paints over debug lines: `TD.debug(true, { hideStyle = true })` switches the style off while the view is on and back on with `TD.debug(false)` (the stack is shared, so every player sees the plain frame meanwhile; it is a tuning tool). ## Everything you can call `local TD = require("takedownKit.api")` - Building: `TD.guard(pos, opts)` (a concealKit guard that is a target and keeps its preset's hearing, a deaf preset getting its `<preset>Hears` variant: `name`, `yaw`, `preset` (default `hideGuard`), `route`, `target`, `hears`), `TD.hearingPreset(preset)`, `TD.HEARING`, `TD.equip(body, styleOrWeapon, opts)`, `TD.WEAPON_FOR_STYLE`, `TD.target(entity, fields)`, `TD.wall(entity, "paper" | "plank")`, `TD.crowd(pos, radius, opts)`. - Settings (run on every peer, in `entrypoint.luau`): `TD.setStyle`, `TD.setPresentation`, `TD.configure({ koNoise, lethalNoise, scanRadius, giveAway })`, `TD.defineProfile` / `tuneProfile`, `TD.defineAngle` / `tuneAngle`, `TD.defineStyle` / `tuneStyle`, `TD.mapHeld`, `TD.definePresentation`. - Tuning: `TD.debug(on, { hideStyle })`, `TD.debugOn()`. - Playing: `TD.options(player?)`, `TD.takedown(player, target, "ko" | "lethal")`, `TD.distract(target, seconds)`, `TD.check`, `TD.awareness(target)`, `TD.isDistracted`, `TD.noiseOf(angle, style, outcome)`, `TD.noiseTable()`, `TD.targets()`, `TD.resetTargets()` (put every guard back for a restart), `TD.on(event, fn)`, `TD.player()` (the local `Takedowner`: `holdTime` (0.45 s: a lethal takedown needs the control still held then and over at least three frames since the press; any release is a knock-out), `showPrompt`, `promptStyle`, `showNoise`, `style`, `held`). Events: `offered`, `withdrawn`, `claimed`, `released`, `started`, `impact`, `done`, `refused`, `woke` (`ev.byGuard` when a comrade woke him). `Takedown.settings.claimWindow` (1.5 s) is how long a guard grabbed by a press waits for the tap or hold that follows. - Components: `takedownKit.Target` (on a guard), `takedownKit.Takedowner` (spawned for each player in play), `takedownKit.ThinWall`, `takedownKit.CrowdZone`. Input map `takedownKit.takedown` (F / pad north, Y or Triangle / touch Takedown button, lower right, priority 12 so a hiding spot's Peek button or a level's own buttons never push it into the overflow fan). - Modules: `angles`, `styles`, `presentations`, `rules`, `motions` (`Motions.setClip(name, ref)` to use your own clips), `motionPrompts` (the prompt behind every clip). ## Multiplayer Every decision is taken by the peer that owns the guard and sent to all; the clips run on a shared clock; the result lives in synced fields (`Target.result`, concealKit's `Body.condition`). A late joiner sees the guard where he lies. Two players cannot take the same guard at once: the press grabs him for the first player, and the second is refused. ## Known limits - Engine issue **#14448** ([OrigoZero/zero#14448](https://github.com/OrigoZero/zero/issues/14448)) is still open: two engines signed in to the same account, or the same person joining a play room twice, collide as one player, so two players have to be tested with two accounts. - Device play-throughs of Pass Ambush 1.4.5 on takedownKit 1.0.17 (one desktop editor test client, simulated input, normal speed, a busy machine at 75 to 200 ms frames): keyboard two clean wins in a row, gamepad two clean wins in a row, touch two clean wins in a row. In every run the Trail Sentry was knocked out from behind with a tap, the Terrace Sentry taken lethally with a hold (from the ledge, once from the front), and the Cabin Sentry knocked out with a tap from the haystack. Runs took 136 to 230 s. - A web-browser client and two players on two different accounts were NOT tested. A desktop editor's test clients run only as the editor on the owner's account (`zero client create` takes only the editor profile), so neither a web-browser client nor a second account could be opened from here, and engine issue #14448 also makes two engines on one account collide as one player. How play on two accounts is meant to work is described under Multiplayer. - traversalKit 1.0.21 and later starts and continues a climb while you push into a climbable face. For the ledge takedown on Pass Ambush's terrace, let go of forward once you hang under the sentry's feet: holding forward climbs you over the top instead. - Tap and hold are told apart by frames as well as time: any release of the takedown control is a knock-out, however long the frames around it took, and a lethal takedown needs the control seen still held at `holdTime` (0.45 s) and over at least three frames since the press. On a machine drawing fewer than about seven frames a second, a hold therefore takes a little longer than 0.45 s to turn lethal. On a busy machine (frames of 75 to 200 ms) taps knocked out and a held press was lethal. - The 70 clips are generated motions; a guard without a reaction clip of his own (only possible with `Motions.setClip` removing one) plays comboKit's knockdown or throw slam instead. ## Version history - **1.0.17**: Any release of the takedown control is a knock-out, however long the frames around it took; a lethal takedown needs the control seen still held at `holdTime` (0.45 s) and over at least three frames since the press. On a busy computer a quick tap could span one long frame and read as a hold, so taps came out lethal. A knocked-out guard woken by another guard comes round hunting: he makes an `alarm` noise as before, and for 20 s he and every guard within 15 m of him are told every 3 s where his attacker is (`AI.alert(guard, attackerPos, attackerId)`), so they stay alert and go looking instead of calming down after a few seconds. This needs aiKit 1.3.20: aiKit's `AI.alert` used to file the tip under a made-up subject the brain never acted on, fixed in aiKit's own world (pull request #17). Measured: the guard who woke him chases (alert 1) for the whole 24 s watched, and the woken guard searches (holding on the last spot, alert 0.3) for about 18 s. `TD.check`, `TD.awareness`, `TD.isDistracted`, `TD.noiseOf` and `TD.styleFor` call through to the takedown module instead of being copied at load, where a require loop could leave them nil for good (a world calling `TD.awareness` in its own tick then failed every frame). The touch Takedown button has priority 12 (was the default 50): inside a hiding spot, concealKit's Peek button and a level's own touch buttons pushed it into the overflow fan, so a phone player could not take a guard from hiding. Checked on a busy machine (frames of 75 to 200 ms): Pass Ambush 1.4.5 won twice in a row on keyboard, on gamepad and on touch (see Known limits). Built on aiKit 1.3.20, concealKit 1.2.9, traversalKit 1.0.22 and controlsKit 1.4.7; the other dependencies are unchanged. - **1.0.16**: Text only. Known limits give the device play-through results on 1.0.15 (keyboard two clean wins in a row; gamepad one win, one loss; touch two losses on the cabin approach, unexplained) and say what stopped the browser and two-account tests. - **1.0.15**: Only a guard whose brain has actually spotted the player ("Spotted! Tracking"), or is chasing, attacking or has raised the alarm, counts as fully aware; 1.0.14 also counted searches such as "Hold on last spot", which refused takedowns on guards that had not seen you. The README and both guides describe aiKit 1.3.19's hearing, the footstep defaults and the `quietSpeed` line consistently. Checked: two clean keyboard wins of Pass Ambush in a row at normal speed (behind, ledge, hiding; game "won"). - **1.0.14**: A short F tap is always the knock-out. A tap whose press and release fell in one slow frame lost its release, and the hold timer then made it lethal; the Takedowner now reads the key or pad button itself (touch keeps the map's events). Checked in play: taps of 0.12, 0.2 and 0.3 s knock out, holds of 0.7 and 0.9 s are lethal. A guard whose brain has spotted the player (its "Spotted! Tracking" state) counts as fully aware even while its alert number is still climbing, so no takedown is offered to a guard looking at you. The dependency list now names controlsKit, barsKit (markersKit's prompt plates are its bars) and styleKit, and every entry is at its newest release (traversalKit 1.0.18). - **1.0.13**: Built on weaponsKit 1.3.2, where a weapon with `controls = false` (what `TD.equip` hands the player) never reads the controls. Before it, the weapon's first frame could ask controlsKit for an action before takedownKit held the weapon's actions off, and controlsKit answered by switching on its twin-stick scheme, which stood walking down: the player could not leave the spawn or the gallery start. - **1.0.12**: Built on aiKit 1.3.19, which hears a noise exactly inside its stated radius (measured from where the guard stands, a wall cutting the reach to `wallDamp`, people never counting as walls). takedownKit no longer bends anything to make up for how guards used to hear: `TD.guard` keeps a preset's own hearing (no lowered `threshold`), and only gives a deaf preset (the `sentry` family) aiKit's ordinary hearing through `<preset>Hears`; the takedown noise is made where the takedown happens instead of 1.4 m up. Checked in Pass Ambush: each sentry hears a 3 m noise at 2.8 m and not at 3.2 m. Also controlsKit 1.4.4 (a long-running client no longer starts frozen in the gallery). - **1.0.11**: Built on concealKit 1.2.8 and aiKit 1.3.17 (sight blockers). A world that installs takedownKit beside aiKit 1.3.17 no longer runs two aiKit releases: before, takedownKit and concealKit registered their guard presets in a pinned aiKit 1.3.16 copy while the guards' brains ran 1.3.17, so guards fell back to wandering (seen in Two Lanterns). No behaviour of takedownKit itself changed. - **1.0.10**: The full motion library: all 70 clips (every angle in all four styles and both outcomes, and the guard's reaction for every angle), where 1.0.9 shipped 21. The takedown is decided on the press: the guard is grabbed the moment the button goes down (`claimed`, `released`, `Takedown.claim`, `settings.claimWindow`), so a press while the prompt shows is never lost to a slow frame or a guard who turns round meanwhile, and a jump that lands keeps the angle that was offered. On a gamepad the takedown is the north button (Y / Triangle): west is the engine's Interact, which also climbs out of a hiding spot. The prompt names the control for the device in use (F, the pad's own label, or the on-screen Takedown button), sits at the guard's feet when he stands above you on a ledge instead of off the top of the screen, and goes away the frame it no longer applies. A player carrying a body is offered no takedown. A knocked-out guard woken by a comrade stands up on the frame concealKit wakes him and comes round hunting his attacker with the guard who woke him (before, he came back calm and searching). The first example sets `aiKit quietSpeed = 3.4`, so a keyboard player can walk up unheard. Built on concealKit 1.2.7 (guards notice a body again after it is woken and knocked out again: the fix went to concealKit's own world as 1.2.6), aiKit 1.3.16, traversalKit 1.0.13, SecondWind 1.4.8, weaponsKit 1.3.1, comboKit 1.1.10, markersKit 2.2.5, juiceKit 1.2.12 and impactFrames 1.1.1. - **1.0.9**: The prompt is markersKit's marker over the guard (the card is still there as `promptStyle = "card"`). New `offered` and `withdrawn` events, and a debug view of each guard's takedown zones (`TD.debug`). Every F press gives a takedown or a reason ("He is on his guard", "Already moving", "He moved out of reach"); a suspicious guard searching a hiding spot can be taken from it the moment he is within reach. Bodies lie down after every takedown, including after a revive (takedownKit lays the body flat itself when concealKit has not; the concealKit fix is merged in its own world as 1.1.3), and a guard pulled into hiding lies on the ground instead of half under it. A player's animation always returns to locomotion after a takedown. The kit review is `reuse-review.md`. - **1.0.8**: Guards made with `TD.guard` hear every takedown to the edge of its radius, sentries included (`TD.HEARING`, `TD.hearingPreset`, `hears`). The F press reads the scene at that moment, and says "No one in reach" when nothing is; a takedown from a hiding spot no longer touches the hidden player's animation, which had broken movement afterwards. The ledge angle takes a grab up to 3.3 m below the guard. Builds on SecondWind 1.4.6 (a dead guard is not offered), weaponsKit 1.3.0 (`TD.equip`; a weapon without controls keeps E for the game), comboKit 1.1.9 (fallback reaction clips) and markersKit 2.2.4 (hit marker on landing). - **1.0.7**: The attacking peer sends its presentation with the request, as it sends its style, so the peer that decides plays exactly the presentation the attacker chose (before, the deciding peer used its own setting). Every angle, outcome, style and presentation verified firing in the Pass Ambush Takedown Gallery. - **1.0.6**: The first example and the example guide were tested in a brand-new world and corrected: install aiKit first, then takedownKit; add to the new world's own `build.luau` instead of replacing it. - **1.0.5**: Built on traversalKit 1.0.8, which records navKit as one release, so the whole closure installs into a fresh world as one release of each kit. - **1.0.4**: Every source that uses aiKit or concealKit is published again on aiKit 1.3.8 and concealKit 1.1.2, so a fresh install brings one release of each dependency. - **1.0.3**: Depends on aiKit 1.3.7 and concealKit 1.1.1, both republished from their own worlds with navKit as one release, so the kit installs into a fresh world. - **1.0.2**: Depends on aiKit 1.3.6, which records one navKit release, so a fresh install runs. - **1.0.1**: Depends on impactFrames 1.1.1 (the release that carries the ink-splash frame). - **1.0.0**: First release. Seven angles × knock-out and lethal, four styles, three presentations, five rule profiles, noise radii, multiplayer paired playback, 21 generated clips. Needs concealKit 1.1.0 or later (guards wake knocked-out guards), aiKit 1.3.5 or later (touch arc) and impactFrames 1.1.1 (the `inkSplash` frame), each released in its own world for this kit.
▲ 0↑ born
backing path · passAmbush.package/layout.module

Problems

Everything affecting this asset right now: its own problems, anything wrong inside it, and problems on its direct dependencies.

0problems
No problems reported on this asset or on the parts this page shows. Parts it leaves out are not counted here.
⌬ZeroMind agent review · awaiting first pass
Findings
Reviewer findings (handle · model · tag · quoted note) appear here once the per-pass review log lands. Today only the rolled-up agent_score is exposed.
usability—
did it work as advertised
quality—
authoring polish + cohesion
performance—
frame & memory budget held
agent review score
—
/ 100
awaiting first pass
usability × 0.40
+ quality × 0.35
+ performance × 0.25
± compat factor

Usability ratings

Did the part work as advertised when consumers tried to drop it in. Separate from upvotes: those are taste; this is "did it function".

—%no reports yet
Sign in to report whether this part worked for you.
Discussion

Scoped to this part · feeds back into the world's score.

0comments
Sign in to post.sign in
No comments yet. Be the first.