Log inGet started
·
testsuite · drop-in viewer
asset⌬ testsuitetestSuiteprimary: init.luau·part ofpackage concealKit.package·originates fromworld 30e6ada2-0…

concealKitTests.testSuite

12 edit-mode tests for concealKit: all 13 hiding-spot kinds are complete, aliases resolve, kinds can be defined and tuned, and kinds can be found by tag. The 5 alarm levels rise in order, and evidence kinds rate as the kit describes. The synced id-list helpers work, and aiKit con…

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

concealKitTests

12 edit-mode tests for concealKit: all 13 hiding-spot kinds are complete, aliases resolve, kinds can be defined and tuned, and kinds can be found by tag. The 5 alarm levels rise in order, and evidence kinds rate as the kit describes. The synced id-list helpers work, and aiKit concealment can be set and cleared. The hide-aware brains and presets register, Hide.extendBrain works, and the version and guides are where they should be.

These tests don't play the game. Hiding, takedowns, carrying, guards finding bodies and two-player sessions need play mode, and were checked there in the Out of Sight world.

Interface

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

conforms to

zero/source-extract/v2

nonstrict concealKit: the hiding-spot catalogue (13 kinds, aliases, defining and tuning kinds), the five alarm levels and evidence kinds as data, the list helpers synced fields use, aiKit concealment, the hide-aware guard brains and presets, and the package's version and guides. Runs in edit mode; the play-time loops (hiding, carrying, guards finding bodies) were checked in play in the Out of Sight world.

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.

77+items
❒
package · born here
❒asset
# concealKit **Version 1.2.9** The hiding half of a stealth game, for any multiplayer Zero world. concealKit gives you: - **Hiding spots.** Walk up, press E, and climb into a barrel, burrow into a haystack, crawl under a veranda or slip behind a curtain. Thirteen kinds that all work the same way and swap with one setting, `kind`. Hold Peek to look out (a risk if a guard is looking straight at you). - **Bodies.** Any knocked-out or defeated character becomes a limp body a player can carry over the shoulder, drag, carry with a friend, load on a handcart, drop, throw into water or over a ledge, or stash in a hiding spot big enough. Characters that die through SecondWind become bodies too, whatever death style they use. Bloodless: just a limp person. - **Evidence.** Bodies, dropped weapons and doors left open make a guard who sees them more alert, on five alarm levels kept as plain data, from a glance to a lockdown. A body hidden properly is never found by a guard walking past. - **Hide-aware guards.** aiKit guards that walk past a hidden player they did not see go in, come over and drag out one they did, check the hiding spots near where they lost someone (nearest first) before they give up, and react to the evidence they see. Every player sees the same people hidden in the same places, the same bodies carried and stashed, and the same guards reacting. Everything works the same on a keyboard and mouse, a gamepad and a touch screen: hide, leave, peek, knock out, pick up, switch how you carry, put down, throw and stash. The help line on screen names the buttons of whatever the player is using. ## Install Search ZeroMind for **"concealKit"** and install `concealKit.package` into `/source` (with the `zeromind_install` tool, passing the guid from the search hit, or from the library panel). That one install brings everything concealKit builds on, aiKit and the navKit it walks with included; nothing has to be installed first. What concealKit builds on: | package | what concealKit uses it for | |---|---| | aiKit 1.3.19 | guard brains: sight, hearing, memory, patrols, search. concealKit's guards extend aiKit's guard state machine, and aiKit 1.3.0's `AI.setConcealed` is what hides a player from a guard's senses. aiKit brings navKit (walking) along. | | interactKit 1.6.7 | the "Press E" and "hold E" prompts on keyboard, gamepad and touch | | SecondWind 1.4.8 | health and death: bodies come from characters that die, go down or are knocked out | | juiceKit 1.2.12 | feel: the hiding vignette, a wobble on a spot when someone climbs in, camera shake when you are dragged out | | soundstage 2.1.3 | sound banks: concealKit registers its hiding, carrying and guard voice sounds as one | ## Quick start **1. Load concealKit on every peer.** At the top of your scene's `scenes/main.scene/entrypoint.luau`, add: ```lua local _Hide = require("concealKit.api") -- walking is quiet, running is heard: the default player walks at about -- 2.5 m/s on a keyboard, and aiKit's guards hear anyone faster than quietSpeed require("aiKit.api").config.quietSpeed = 3 ``` This registers the hide-aware guard presets and brains on every player's machine before any guard starts. Without it a guard spawned by another peer may not know its preset. The second line is the usual stealth rule, walk to sneak and run to be heard; leave it out and aiKit's own default (1.6 m/s) applies, which a keyboard player cannot walk under, so every walking guard hears them coming. **2. Add to `scenes/main.scene/build.luau`.** At the very top of the file: ```lua local Hide = require("concealKit.api") local NK = require("navKit.api") ``` and at the end of `function content()`, just before its `end` (a brand-new world's scene already has the ground, the light and the player): ```lua -- the ground the guards can walk on (baked when play starts) entity.spawn("NavMap").component.add(NK.MAP, { kind = "grid", size = { x = 40, y = 6, z = 40 } }) -- somewhere to hide: a barrel by the spawn, a haystack further out Hide.spot({ 3, 0, 5 }, "barrel") Hide.spot({ -4, 0, 8 }, "haystack", { name = "BigHaystack" }) -- a guard walking a square past them; he can be knocked out from behind and carried Hide.guard({ -6, 0, 12 }, { route = { { -6, 0, 12 }, { 6, 0, 12 }, { 6, 0, 18 }, { -6, 0, 18 } }, }) ``` **3. Press play.** The keys below are the keyboard's; on a gamepad or a touch screen use the buttons in the Controls table (the help line names them too). The guard walks his square. Walk up to the barrel and press E to climb in; the screen darkens at the edges and a help line appears. If the guard did not see you go in, he walks past. If he did, he comes over, checks the barrel and drags you out. Hold Q to peek: he can now see a little of you. Sneak up behind him and hold E to knock him out: walk, don't run (running, Shift, is heard within about 5 m), come up behind him while he walks away or pauses at a corner, and hold E once the "Knock out" prompt shows; the prompt only shows from behind. Then press E to pick him up, R to switch to dragging, and E at the haystack (within about 2 m) to stash him. This bare example gives the player no health, so once he catches you he keeps after you: stop and press play again, or give your players SecondWind health and handle "caught" as Camp After Dark does. Change `"barrel"` to `"wardrobe"` (or any kind in the table below) and the spot becomes that, model, prompt, sound and all. ## Hiding spots A `HidingSpot` is one component with one setting that matters: `kind`. Everything else follows from the kind's entry in `concealKit.spots`: the model, the prompt, how the player gets in, the sound, how much a peeking player shows, how many players and bodies fit, and how long a guard takes to check it. To see every kind side by side, play the gallery scene in the Out of Sight world on ZeroMind (it is part of that world, not of the package, so an install does not bring it): all thirteen stand in a row on a flagstone yard, each under three lines: its name, its prompt verb, and how many players and bodies it holds. Walk up to any one and try it. | kind | label | verb (prompt) | capacity | bodies | peekExposure | |---|---|---|---|---|---| | `barrel` | Barrel | Climb in | 1 | 1 | 0.3 | | `crates` | Stack of crates | Slip behind | 2 | 1 | 0.4 | | `haystack` | Haystack | Burrow in | 2 | 2 | 0.25 | | `strawBales` | Rice straw bales | Squeeze between | 2 | 2 | 0.35 | | `reeds` | Tall reeds | Crouch in | 2 | 2 | 0.3 | | `wardrobe` | Wardrobe | Step in | 1 | 1 | 0.2 | | `crawlSpace` | Crawl space | Crawl under | 2 | 2 | 0.3 | | `well` | Well | Climb down | 1 | 2 | 0.25 | | `curtain` | Curtain | Slip behind | 1 | 0 | 0.45 | | `hayCart` | Hay cart | Hide in the hay | 2 | 2 | 0.3 | | `foldingScreen` | Folding screen | Slip behind | 1 | 0 | 0.45 | | `log` | Fallen log | Crawl under | 1 | 1 | 0.3 | | `bush` | Thick bush | Push into | 1 | 1 | 0.3 | `capacity` is how many players fit at once, `bodies` how many bodies can be stashed, `peekExposure` the share of a peeking player a guard can see (0 = none, 1 = all of them). Other names work too and turn into the kinds above: `riceStraw`, `bales` (strawBales); `tallGrass`, `grass` (reeds); `cupboard`, `closet` (wardrobe); `veranda`, `porch`, `underFloor` (crawlSpace); `screen`, `byobu` (foldingScreen); `fallenLog` (log); `shrub` (bush); `cart` (hayCart); `crate` (crates). Each kind also has a **motion** (how the player's body moves in): `climb` (up and over, down inside: barrel, well, hay cart), `crawl` (drop low and slide under: crawl space, log), `slip` (sidestep behind: crates, straw bales, curtain, folding screen), `burrow` (sink into soft stuff: haystack, reeds, bush) and `step` (walk in and close: wardrobe). Reeds, curtain, folding screen and bush have no solid collider; the rest do. **Tags** let you pick kinds by setting: `Hide.findSpots({ tag = "forest" })` answers reeds, log and bush. Tags in use: `indoor`, `outdoor`, `forest`, `farm`, `town`, `camp`, `heist`, `warehouse`, `house`, `horror`, `japan`, `river`, `garden`, `theatre`, `plant`, `soft`, `stone`, `small`. `Hide.findSpots({ bodies = true })` answers kinds that can hold a body, `{ motion = "crawl" }` kinds you crawl into. **Your own kinds and tuning:** ```lua Hide.defineSpot("coffin", { base = "wardrobe", label = "Coffin", verb = "Lie in", peekExposure = 0.1 }) Hide.tuneSpot("bush", { peekExposure = 0.2, checkTime = 3 }) -- every bush in the game ``` Define and tune on every peer (in `entrypoint.luau` or a module your scripts require), before the spots that use them start. ## Controls | action | keyboard and mouse | gamepad | touch | |---|---|---|---| | **Use**: at a hiding spot, hide, or leave when inside. Carrying a body at a spot with room: stash it. At a standing character, from behind: **hold** to knock out. At a body: pick up over the shoulder (or "Help carry" when someone already carries it). At a handcart: push, let go, or load the body you carry. | E | west face button (X on Xbox, square on PlayStation) | Interact button (or tap the prompt) | | **Peek** (hold, while hidden) | Q or the right mouse button | left trigger | Peek button | | **Put down** (while carrying) | G | north face button (Y, triangle) | Put down button | | **Throw** (while carrying, not in a two-player carry) | T | right trigger | Throw button | | **Carry style**: switch between the shoulder and dragging (not in a two-player carry) | R | right shoulder | Carry style button | Use is the engine's Interact control, which interactKit's prompts answer on every device. Peek, Put down, Throw and Carry style are concealKit's own controls, in two input maps that ship in the package: `concealKit.hiding` (Peek), live only while the player is hidden, and `concealKit.carrying` (the other three), live only while they carry a body, so a touch screen shows those buttons only when they do something. The help line at the bottom of the screen (at the top on a touch screen, clear of the stick and the buttons) names the keys, the pad's buttons as that pad labels them, or the touch buttons, following whatever the player used last. To move a keyboard key, set `peekKey`, `dropKey`, `throwKey` or `switchKey` on `StealthPlayer`; the pad and touch buttons stay as they are. ## Bodies and carrying Put a `Body` on a character (`Hide.body(character)`; `Hide.guard` adds one by itself). While it stands, a player behind it gets a held "Knock out" prompt (or "Take down" with `lethal = true`). Once it is down, however it went down, its aiKit brain switches off and it goes limp. By default the whole body is laid flat on the ground; set `ragdoll = true` to use the engine's physics ragdoll for a skinned character instead (see Known limits before you do, for generated rigs). | how | speed (share of normal) | notes | |---|---|---| | over the shoulder (`shoulder`) | 0.6 | the default when you press E; quiet | | dragging (`drag`) | 0.45 | R to switch; scrapes along the ground, a noise guards hear about 7 m away | | two-player carry (`pair`) | 0.85 | a second player presses E ("Help carry"); quicker than either alone | | on a handcart (`cart`) | 0.7 | the pusher's speed; holds three bodies, turns slowly, its creaking axle carries about 9 m | Jumping is off while you carry, drag or push. From there: - **Put down** (G): the body lies where you are. In a two-player carry, the one who drops lets go and the other keeps it over the shoulder. - **Throw** (T): the body flies a few metres ahead of you in an arc and lands, so you can throw it into water or over a ledge. A wall in the way stops it. - **Stash** (Use within about 2 m of a hiding spot with room): the body vanishes into the spot. No guard walking past will see it; only one checking that very spot finds it. - **Load** (E at a handcart): the body lies on the cart, still in plain sight. Press E on it to take it off and carry it the last stretch. - **Dispose**: a body that comes to rest inside a `DisposalZone` is gone for good: in water it sinks with a splash; below a ledge (`kind = "drop"`) it is out of sight and out of the guards' minds. **SecondWind deaths.** A character with SecondWind health becomes a body however it goes down: `dead` when it dies (with any death style), `downed` when it is downed, and back on its feet if a teammate revives it. With `keepDown` on (the default) concealKit sets its death style to `stay`, so it does not respawn while players move it. ## Alarm levels What a guard does when it sees something is decided by the thing's level. Levels are plain data in `concealKit.alarms`. | level | id | what the guard does | look (s) | walks over | search (s / m) | spots checked | runs | calls others within | |---|---|---|---|---|---|---|---|---| | 1 | `glance` | stops, looks, shrugs, goes on | 1.6 | no | 0 / 0 | 0 | no | nobody | | 2 | `inspect` | walks over, looks it over, looks around | 1.2 | yes | 6 / 4 | 1 | no | nobody | | 3 | `search` | goes to it and searches the area, hiding spots first | 0.8 | yes | 20 / 10 | 3 | yes | nobody | | 4 | `alarm` | searches hard and calls the guards near it | 0.5 | yes | 35 / 14 | 5 | yes | 25 m | | 5 | `lockdown` | every guard in a wide radius comes and searches everything | 0.4 | yes | 60 / 20 | 8 | yes | 60 m | Each level also names the guard's voice line (`voice`), a sting (`sting`) and how long it stays alert (`stayAlert`, seconds). Tune any of it: ```lua Hide.tuneAlarm(4, { searchTime = 40, callRadius = 35 }) ``` ## Evidence kinds Every kind of evidence names its level. Bodies are evidence by themselves; anything else gets an `Evidence` component (`Hide.evidence(entity, "weapon")`). | kind | level | what a guard calls it | |---|---|---| | `door` | 1 | a door left open | | `noiseMark` | 1 | something knocked over | | `item` | 1 | something out of place | | `light` | 2 | a light put out | | `weapon` | 2 | a dropped weapon | | `downed` | 3 | someone down and hurt | | `unconscious` | 3 | a knocked-out guard | | `dead` | 4 | a dead body | | `pile` | 5 | a pile of bodies | Two or more bodies lying within 4 m of each other count as a `pile` (`Hide.alarms.PILE_COUNT`, `Hide.alarms.PILE_RADIUS`). Each guard reacts to each piece once; after a guard has found a body (or reported a piece of evidence), other guards only glance at it. ```lua Hide.setEvidenceLevel("door", 2) -- open doors now make guards walk over Hide.defineEvidence("lootBag", 2, "a dropped loot bag") ``` ## Guard presets concealKit registers these aiKit presets (use them with `Hide.guard(pos, { preset = ... })` or on any `aiKit.Brain`): | preset | built on | what it does | |---|---|---| | `hideGuard` | aiKit `guard` | patrols, chases what it sees, checks up to 3 hiding spots within 9 m of where it lost someone, drags out players it saw hide, reacts to evidence | | `hideNightwatch` | aiKit `nightwatch` | the same, but sees only where it is lit | | `hideSentry` | aiKit `sentry` | stands its post sweeping its gaze; checks no spots itself, but calls the other guards to bodies, evidence and players it sees hide | | `hideMonster` | aiKit `chaser` | for horror: roams, hunts anything it hears, checks up to 6 hiding spots within 14 m of where it lost someone, searches 25 s | Each has a `*Person` twin (`hideGuardPerson`, `hideNightwatchPerson`, `hideSentryPerson`, `hideMonsterPerson`) that draws no aiKit stand-in body, for a guard wearing a character of its own. `Hide.guard` puts the camp guard character on the guard and picks the `Person` twin by itself; pass `avatar = false` to keep aiKit's own look. The brains behind them are `hideGuard`, `hideSentry` and `hideChaser`. `Hide.extendBrain(base, name)` makes a hide-aware copy of any aiKit state machine brain, your own included. A hide-aware brain keeps every aiKit state and adds three: `notice` ("Huh?"), `inspectEvidence` ("Go look") and `checkSpot` ("Check hiding spot"), and replaces `search` with one that checks hiding spots nearest first. A preset's `hide` table sets `checkSpots` (how many spots its own search checks) and `spotRadius` (how far round where it lost someone, metres). **What a guard knows:** - A hidden player is concealed from every guard's senses. A guard that saw (or glimpsed) the player within 4.5 m of a spot in the last 10 s before they vanished goes and checks that spot, and drags them out. - A peeking player shows by the spot's `peekExposure`. - After checking for `checkTime` seconds, a guard pulls out the first player inside, or the first stashed body, which it then treats as evidence. ## Events `Hide.on(name, fn)` listens on this peer and returns a function that stops listening. Events fire on every peer. `"*"` listens to all of them (`fn(ev, name)`). | event | when | fields | |---|---|---| | `hidden` | a player got into a spot | `spot`, `avatar`, `peer`, `kind` | | `left` | a player left a spot (or was evicted by script) | `spot`, `avatar`, `peer`, `reason`, `kind` | | `caught` | a guard (or `Hide.pullOut`) dragged a player out | `spot`, `avatar`, `peer`, `reason`, `kind` | | `knockedOut` | a character went down unconscious or downed | `body`, `condition`, `by`, `pos` | | `killed` | a character died | `body`, `condition`, `by`, `pos` | | `pickedUp` | a player picked a body up (or helped carry it) | `body`, `avatar`, `peer`, `mode` | | `dropped` | a carried body was put down | `body`, `peer`, `pos` | | `thrown` | a carried body was thrown | `body`, `peer`, `pos` | | `stashed` | a body was hidden in a spot | `spot`, `body`, `avatar`, `peer`, `kind` | | `disposed` | a body came to rest in a disposal zone | `body`, `zone`, `kind`, `pos` | | `loaded` | a body was loaded on a handcart | `cart`, `body`, `avatar`, `peer` | | `cartPushed`, `cartReleased` | a player took or let go of a handcart | `cart`, `avatar`, `peer` | | `noticed` | a guard saw evidence | `guard`, `evidence`, `level`, `kind`, `pos` | | `found` | a guard reached the evidence | `guard`, `evidence`, `level`, `kind`, `pos` | | `alarm` | a guard called the others | `guard`, `pos`, `level`, `radius` | ```lua Hide.on("caught", function(ev) print("dragged out of the " .. ev.kind) end) ``` ## API reference `local Hide = require("concealKit.api")` **Building** (in `build.luau`, or at run time on the peer that should own the result): | call | what it does | |---|---| | `Hide.spot(pos, kind?, opts?)` | a synced hiding spot of `kind` (default `"barrel"`) at `pos`. `opts`: `name`, `yaw` (degrees) and any `HidingSpot` field. Returns the entity. An unknown kind is an error naming the kinds. | | `Hide.guard(pos, opts?)` | a synced hide-aware guard with the camp guard character and a `Body`. `opts`: `name`, `yaw`, `preset` (default `"hideGuard"`), `route` (a list of points), `team`, `body` (Body fields), `avatar` (`false` keeps aiKit's look). Returns the entity. | | `Hide.body(target, fields?)` | adds a `Body` to a character (if it has none) and returns the component | | `Hide.evidence(target, kind?, opts?)` | adds an `Evidence` of `kind` (default `"item"`); `opts` sets other Evidence fields (`level`, `label`, `whenOpen`, ...). Returns the component. | | `Hide.handcart(pos, opts?)` | a synced handcart; `opts`: `name`, `yaw` and any `Handcart` field | | `Hide.water(pos, size?, opts?)` | a disposal zone, `size = { w, h, d }` in metres (default 4, 2, 4); `opts`: `name`, `yaw`, `kind` (`"water"` or `"drop"`). A local entity: build it where every peer builds it (the scene). | Positions are `{ x, y, z }` lists, `{ x =, y =, z = }` tables or vectors. **Playing:** | call | what it does | |---|---| | `Hide.knockOut(target, opts?)` | knocks a character with a Body out; `opts.by` who did it, `opts.lethal = true` kills instead | | `Hide.revive(target)` | puts a body back on its feet, brain on | | `Hide.resetGuards(opts?)` | for a level restart, beside `AI.forget`: every guard forgets the evidence it reacted to and the spots it checked, and its owner puts it back at its post, facing the way it started, with its state machine restarted from the beginning (`{ home = false }` leaves it where it stands). A guard that walks rides its navigation agent, which has to be moved too: pass your navigation's warp, e.g. `Hide.resetGuards({ warp = require("navKit.api").warp })` | | `Hide.pullOut(player)` | takes a player out of the spot they are in, as a guard does (fires `caught`) | | `Hide.spotOf(player)` | the spot entity a player hides in, or nil | | `Hide.isHidden(player)` | true while a player is in a spot | | `Hide.carrying(player)` | the body entity a player carries, or nil | | `Hide.bodies()` | every body: `{ entity, condition, hidden, found, carried, position }` | | `Hide.allSpots()` | every spot: `{ entity, kind, occupants, bodies }` | | `Hide.on(name, fn)` | listen to an event (see Events) | | `Hide.ensurePlayer()` | adds this peer's `StealthPlayer` if it has none (concealKit does this itself) | **Data:** | call | what it does | |---|---| | `Hide.kinds()` | every spot kind, in catalogue order | | `Hide.defineSpot(name, def)` | adds a spot kind (`base` names a kind to start from) | | `Hide.tuneSpot(name, changes)` | changes a kind for the whole game | | `Hide.findSpots(query)` | kinds by `tag` (a tag or a list), `bodies = true`, `motion` | | `Hide.alarmLevels()` | the five levels (copies) | | `Hide.alarmLevel(n or id)` | one level (a copy) | | `Hide.tuneAlarm(n, changes)` | changes a level | | `Hide.setEvidenceLevel(kind, level)` | sets (or adds) an evidence kind's level | | `Hide.defineEvidence(kind, level, label?)` | adds an evidence kind with a label | | `Hide.extendBrain(base, name)` | a hide-aware copy of an aiKit state machine brain | **Also on `Hide`:** `Hide.VERSION`; the component names `Hide.SPOT`, `Hide.BODY`, `Hide.EVIDENCE`, `Hide.HANDCART`, `Hide.ZONE`, `Hide.PLAYER`; and the modules `Hide.spots` (`get`, `exists`, `kinds`, `aliases`, `find`, `define`, `tune`, `canonical`, `DEFAULTS`), `Hide.alarms` (`levels`, `level`, `tuneLevel`, `kinds`, `levelOf`, `labelOf`, `setKind`, `defineKind`, `COUNT`, `PILE_RADIUS`, `PILE_COUNT`), `Hide.media` (`MODELS`, `SOUNDS`, `GUARD_AVATAR`) and `Hide.guardBrains` (`extendBrain`, `callGuards`, `canSeePoint`, `hideAlarm`). ### Spot entry fields An entry of `concealKit.spots` (what `defineSpot` and `tuneSpot` take): `label`, `verb`, `exitVerb` (default "Leave"), `motion`, `model` (a bundle under `concealKit.package/art`), `height` (metres), `lift` (metres the model is raised, negative sinks it; default 0), `rest` (true lays the model on its own underside, tilted a little so both ends touch; `lift` adds to it), `footprint` (`{ w, d }`), `hidePoint` and `standPoint` (local metres, +Z the front), `capacity`, `bodies`, `peekExposure`, `checkTime` (seconds a guard spends checking), `sound`, `fx` (juiceKit effect), `view` (`{ color, alpha, peekAlpha }`, the vignette), `surface` (footstep surface), `collide`, `tags`. ## Components All of these work on their own (`entity.component.add("concealKit.<Name>", { ... })`); the `Hide.*` calls above are the short way. Fields marked *written by the owner* are state concealKit keeps; read them, do not set them. **`HidingSpot`** (`Hide.SPOT`): put it on a synced entity. `kind` (default `"barrel"`), `capacity` (0 = the kind's), `bodyCapacity` (-1 = the kind's, 0 = none), `showModel` (draw the kind's model; off to use your own), `collide`, `label` (empty = the kind's), `active` (off: nobody gets in). Written by the owner: `occupants`, `peeking`, `bodies` (comma-separated entity ids), `checking` (the guard checking it). Component events: `hidden` (`avatar`, `peer`), `left` (`avatar`, `peer`, `reason`). **`Body`** (`Hide.BODY`): put it on the character's synced root. `active`, `takedown` (players can knock it out from behind), `lethal` (a takedown kills), `keepDown` (SecondWind death style `stay`), `ragdoll` (off by default: laid flat; on: an engine ragdoll when skinned), `label`. Written by the owner: `condition` (`""`, `unconscious`, `downed`, `dead`), `carrier`, `carrier2`, `mode` (`""`, `shoulder`, `drag`, `pair`, `cart`), `cart`, `stashed` (a spot id or `zone:<id>`), `found`, `knockedBy`. **`Evidence`** (`Hide.EVIDENCE`): `kind` (default `"item"`), `level` (0 = the kind's), `label`, `whenOpen` (evidence only while the interactKit door or container on the entity stands open), `active`. Written by the owner: `reported`. **`Handcart`** (`Hide.HANDCART`): put it on a synced entity. `active`, `capacity` (3), `turnRate` (70 degrees a second), `speed` (0.7), `noise` (9 m), `showModel`. Written by the owner: `pusher`, `bodies`. **`DisposalZone`** (`Hide.ZONE`): `sizeX`, `sizeY`, `sizeZ` (metres, centred on the entity; default 4, 2, 4), `kind` (`"water"` or `"drop"`). **`StealthPlayer`** (`Hide.PLAYER`): concealKit adds one per peer in play, on a temporary local entity; nothing to place. `peekKey` (`KeyQ`), `dropKey` (`KeyG`), `throwKey` (`KeyT`), `switchKey` (`KeyR`): the keyboard keys (the right mouse button also peeks, and the pad and touch buttons always work); `showHelp` (the help line naming the buttons of the device in hand). **`Prop`**: one of concealKit's models standing on an entity, for dressing a level. `model` (`barrel`, `crates`, `haystack`, `strawbales`, `reeds`, `wardrobe`, `veranda`, `well`, `curtain`, `haycart`, `foldingscreen`, `fallenlog`, `bush`, `handcart`, `tent`, `campfire`, `lantern`, `weaponrack`, `sword`), `height` (metres), `lift` (metres above the entity), `rest` (lay it on its own underside, tilted a little along its long side so both ends touch), `collide` (a box collider the size of the model). ## Multiplayer - **The owner decides.** Each spot, body and cart is decided by the peer that owns its synced entity (the room host for scene objects nobody owns). interactKit carries a player's E press to that peer, which checks it (room in the spot, hands free) and writes the result. - **Synced fields carry the state.** Who is in which spot, who peeks, which bodies are stashed where, a body's condition, carrier and carry mode, a cart's pusher and load: all are synced fields, so every screen agrees and a player who joins late sees the same thing. - **Every peer conceals occupants.** Each peer tells its own aiKit guards that the players in a spot are hidden (`AI.setConcealed`, with the spot's `peekExposure` while they peek), and hides their bodies on its screen. - **Guards think on one peer**, as in aiKit: the peer running a guard senses, decides, checks spots and pulls players out. - **Events reach everyone.** `Hide.on` events are sent to every peer on the `concealKit:evt` channel; sounds a guard or spot makes are played for everyone. - Load concealKit on every peer (the `require` in `entrypoint.luau`) so every machine knows the presets and kinds. ## Guides Two guides ship in the package, under `guides/`: - **How to let players hide from guards and hide bodies** (`guides/how-to-let-players-hide-from-guards-and-hide-bodies.guide`): the ideas and where each piece fits: hiding, carrying, how guards find bodies, swapping spot kinds, tuning alarm levels, a horror monster, multiplayer. - **Example: sneak through a guarded camp at night** (`guides/example-sneak-through-a-guarded-camp-at-night.guide`): a whole small level built step by step. Open them with the `guides` tool, `man`, or the Docs panel. ## Known limits - **Engine ragdolls are off by default.** On the current engine, `animation.ragdoll` on a generated rig whose hands end without a child bone (the kit's own camp guard included) crashes the whole engine, even with the hand sizes stated (OrigoZero/zero issue #25592). So a body is laid flat on the ground by default. Set `ragdoll = true` only on characters whose rig you have checked (the built-in humanoid avatar, a proper imported humanoid). A flat body keeps its idle pose while it lies there. - **Characters have no colliders** (as in aiKit): guards walk the navKit map, so put the nav map over everywhere the guards should go. - **A stashed body is moved out of sight**, not into the model: it sits hidden under the spot until a guard pulls it out. - **Bloodless by design.** No blood or gore; a dead body looks like a knocked-out one, and only the guards' reaction differs. - **Disposal zones are local entities.** `Hide.water` spawns an unsynced entity; build zones in the scene so every peer has them. ## Version history - **1.2.9**: Guards react again on aiKit 1.3.19, and the fallen log really rests on the ground. aiKit 1.3.19's `AI.preset` raises for an unknown name (it used to return nil), so `Hide.guard` asking for a `<preset>Person` variant that does not exist stopped every guard from spawning with a brain (log: `aiKit: unknown preset 'hideGuardHearsPerson'`); it now checks `AI.presets()` instead. 1.2.8 sank the log 0.07 m, but its model is not level: it stands on a low branch stub near one end, so a straight sink buried the stub and left the other end of the trunk 3 to 8 cm above the floor (measured in the gallery yard). A `Prop` (and a spot kind) now takes `rest`: the model's underside is read with rays against the drawn mesh and the model is tilted a little along its long side so it lies on the points a flat floor would hold it by, then lowered onto them. The log uses `rest = true` with a 2 cm sink; thin stubs below it sink into the ground. Other kinds are unchanged. Built on aiKit 1.3.19 (navKit 1.5.6) and controlsKit 1.4.6. - **1.2.8**: The fallen log rests on the ground. Its model stands on one low branch stub, so fitted to its bounds the trunk hung 6 to 8 cm above the floor (seen in the gallery yard). A spot kind now takes `lift` (metres, negative sinks the model), which the spot hands to the `Prop` that draws it, and the log kind sinks 0.07 m so both ends of the trunk touch the floor. No other changes. - **1.2.7**: Documentation and the Out of Sight world only; the kit's code is 1.2.6's. Both guides and the reuse review name this version. In the gallery (not part of the package), the Crawl space and Wardrobe signs lost old saved edits that drew their titles oversized and clipped and put "Step in" over "1 player, 1 body", and every sign now sits on a dark plate so it reads against the sky. The starting scene's README describes Camp After Dark. No API changes. - **1.2.6**: A guard who has found a knocked-out guard once notices him again if he is woken and knocked out again. Each guard remembered every body he had seen by its id and never forgot it, so after a wake-up and a second knock-out the same guards walked past the same body as if they had already dealt with it. A guard now forgets a body as soon as it stands up again (woken, revived), so the next time it is down is a new find. Found in a play-test of takedownKit's Pass Ambush. No API changes. - **1.2.5**: The thick bush hiding spot is a new model: a full, leafy wild shrub with woody stems at its base (before, a coarse faceted ball of loose leaf triangles). The reuse review is current again: it names this version and every kit at the version installed, forestKit 0.3.1 among them. In the Out of Sight world (not part of the package), the gallery's signs are one line each, so the prompt verb no longer draws over the "players, bodies" line and the tops of the letters are no longer cut off; its floor is a flagstone yard; and opened after Camp After Dark it clears the camp's leftover forest trees that stood in front of the row. No API changes. - **1.2.4**: Documentation only. The camp guide's little game now ends with "CAUGHT" when a guard sees you in the open, as Camp After Dark does, not only when one drags you out of a hiding spot (before, a player seen in the open was chased with no end to the round). Its `sneak.WinZone` passes each guard's `spotted` event, which fires only on the machine running him, on to every player with `C.emit`, and draws its result above interactKit's prompts. No code changes in the kit. - **1.2.3**: Documentation only, from the second stranger's test. The camp guide's step 4 lays a 70 m grass field under the level: a new world's starter ground is 50 m across (to z = 25), so the sentry, the patrol's far corners and the goal at z = 42 stood past its edge and the player fell off before reaching the goal. The guide also says to come up to the fallen log from its long side to stash a body. No code changes. - **1.2.2**: From a stranger's test of the README and the camp guide in a brand-new world. New guard preset `hideDozer` (and `hideDozerPerson`): a guard asleep at his post who does not sweep his gaze and sees only about 7 m straight ahead. The guide's dozing guard was a `hideSentry`, whose gaze sweeps 100° either way, so he turned round, saw the player at the start and called the patrol. The README's first example and the guide set `require("aiKit.api").config.quietSpeed = 3`, so walking is quiet and running is heard: aiKit's default (1.6 m/s) is slower than a keyboard player can walk (about 2.5 m/s), so every walking guard heard every keyboard player and the documented "sneak up behind him" could not be done. `Hide.alarms.level(nil)` returns nil instead of erroring. The how-to guide said it was for 1.0.8. - **1.2.1**: Fixes from playing 1.2.0 on keyboard, gamepad and touch on today's engine. Carried bodies are held where they are held: over the shoulder the hips rest on the carrier's shoulder with the legs in front and the head hanging behind (before, the body hung at waist height and trailed behind like a plank), and a dragged body has its chest at the carrier's hands and its heels on the ground. A body laid down rests on sloping ground instead of floating up to 0.3 m over it. A body thrown while dragged leaves from the thrower's hands and flies its few metres (before, it hit the thrower's legs and stopped). No API changes. - **1.2.0**: Every action works on every kind of controller. Peek, Put down, Throw and Carry style now have gamepad buttons (left trigger, north face button, right trigger, right shoulder) and touch buttons, from two input maps in the package (`concealKit.hiding`, `concealKit.carrying`) that are live only while they apply; hide, leave, knock out, pick up and stash were already on every device. The help line names the buttons of whatever the player is using (keys, the pad's own labels, or the touch buttons) and moves to the top of a touch screen. A thrown body flies a few metres in an arc and lands (before, a body laid flat, the default, was dropped where you stood). The props no longer read as metal: twenty generated models said `metallic: 1`, which made tents, hay and wood shine pale silver under the night sky. The keyboard key fields still work. - **1.1.8**: Documentation only, from a fresh-install test. The first example and the camp guide say how to get behind a guard unheard: guards hear the footsteps of anyone moving faster than about 1.6 m/s within about 5 m, and crouching alone does not quiet you. No behaviour changes. - **1.1.7**: Fixes from a full play test on the current engine. A knocked-out walking guard's visible body now follows him when he is carried, dragged, stashed or laid flat (before, it stayed, floating, where he fell). The takedown prompt measures from where a walking guard is drawn, and his position is kept fresh while a player is near, so takedowns work with two players in the room. A player who joins late sees every guard at his post. A dropped body lies on the ground instead of floating at carry height. Crawl and burrow spots (log, crawl space, haystack, reeds, bush) no longer leave the hidden player under the ground, which sank the camera. The help line sits at the bottom of the screen again. A body revived after being stashed leaves its spot, so the spot takes the next body. Built on SecondWind 1.4.8. Installing concealKit no longer needs aiKit installed first. - **1.1.6**: Built on the current releases of everything concealKit uses: aiKit 1.3.16 (which brings navKit and SecondWind), interactKit 1.6.7, juiceKit 1.2.12 and soundstage 2.1.3. Released from the main line, which now holds every release from 1.1.0 on. No behaviour changes. - **1.1.5**: The barrel reads as wood at night too: its texture is very dark oak, so even as plain wood it stayed a near-black shape under moonlight. Its material now lifts the base colour (2.2, 1.9, 1.7), which gives reddish-brown staves and dark iron hoops by day and still readable wood by night. - **1.1.4**: The barrel hiding spot is plain wood, not part metal: its material said `metallic: 1`, which let the texture's metal mask make the staves about 30% metallic, so with no bright sky to reflect (at night, in shade) the barrel read as nearly solid black. It now lights as wood. Seen in Dockhands (disguiseKit's level). - **1.1.3**: A body that was knocked out, revived (woken, reset, a restart) and knocked out again lies flat again; before, it stayed standing because the lay-flat ran only the first time a body went down. - **1.1.2**: Every concealKit source that uses aiKit or SecondWind is published again from this world (aiKit 1.3.8, navKit 1.4.6 as one release), so each records those releases. A source keeps the versions it was last published with, so 1.1.1 still brought older aiKit and navKit pieces into a fresh world. No behaviour changes. - **1.1.1**: Built on aiKit 1.3.7 and published from this world with navKit as one release, so a fresh install runs (1.1.0 was sent from a world holding several navKit copies). No behaviour changes. - **1.1.0**: Guards who find a knocked-out guard walk over, shake him for 3.5 s and he comes round alert (`wakeBody` state, `Hide.tuneWake`, per-preset `hide.wakeBodies`; Body takes a scripted `revive` request; event `woken`). Made for takedownKit. - **1.0.8**: The README and the example guide say to install aiKit before concealKit: in a world with no aiKit yet, ZeroMind refuses concealKit because of an installer bug (ZeroMind issue 01M7B6A03FJ9SANBMYGMRVFANR). Checked from an empty world: aiKit, then concealKit, then the example guide followed as written builds and plays the night camp. - **1.0.7**: Built on aiKit 1.3.4. No changes of its own. - **1.0.6**: Removes concealKit's own navKit pin. 1.0.5 recorded navKit from two different releases (its own `navKit.api` beside the `navKit.crowd` aiKit 1.3.1 brought), so ZeroMind refused to install it. concealKit no longer names navKit at all: `Hide.resetGuards` takes the game's navigation warp as `opts.warp` for guards that walk (Camp After Dark passes navKit's `NK.warp`). Built on aiKit 1.3.3, which runs one navKit release throughout. - **1.0.5**: The kit is now called concealKit (it was published as hideKit up to 1.0.4; same package, same ZeroMind asset). Every `require("hideKit.*")` and `"hideKit.*"` component name becomes `concealKit.*`; nothing else about the API changes. The two guides are renamed **How to let players hide from guards and hide bodies** and **Example: sneak through a guarded camp at night**, and the example now builds a moonlit camp in its own steps. About ten times cheaper per frame: in Camp After Dark (4 guards, 18 hiding spots, 7 disposal zones) the kit went from about 5.3 ms to about 0.5 ms a frame. Props that stand still are checked four times a second and rewritten only when they move; hiding spots reapply concealment only when who is inside changes; bodies, disposal zones and the player do their slow checks on short timers; the shared registry lists are cached. - **1.0.4**: Fixes. A guard built on a brain with no chase of its own (aiKit's sentry, so `hideSentry`, the Sentry and anything dozing at a post) no longer breaks with "no chase state" once a "Huh?" escalates: it tracks the player with its gaze and calls the guards who can walk (alarm level 4, 30 m) to come and get them; missing attack, investigate and suspicious states fall back the same way. `Hide.resetGuards()` now really resets a round: each guard goes back to its post, facing the way it started, with its search cleared and its state machine restarted (a Patrol stuck on "Check hiding spot" starts its route again). A flat body put back on its feet (`Hide.revive`) stands upright again instead of keeping its lying-down rotation. Built on aiKit 1.3.1, whose `AI.canSee` now agrees with hiding (a hidden player is never seen) and which no longer warns every hit when a guard attacks someone with no health. Package tags describe this kit. - **1.0.3**: Feel. Every way into a hiding spot has its own timing and shape (climbing arcs over the rim, crawling drops low before sliding in, burrowing sinks with a wriggle, slipping sidesteps), getting out plays it backwards, and being dragged out is a fast yank that overshoots and settles. A carried body is heaved up rather than snapped, swings with the stride and lags behind turns (more when dragged). Impact feel through juiceKit, played by every peer from concealKit events: spots give when someone gets in, jolt and throw up dust when a guard drags someone out (who also gets a kick, a beat of freeze and a flash), bodies land with dust and a jolt for whoever let go. Every concealKit sound gets a small random pitch; getting out is quieter than getting in. New `C.juiceHere` and a spot `api.model()`. - **1.0.2**: Packaging only: a stray duplicate reeds model is gone and the bush model is a fresh take. No changes to how anything behaves. - **1.0.1**: Bodies are laid flat by default (`ragdoll` now defaults to false): building an engine ragdoll for the camp guard's generated rig crashed the whole engine, so ragdolls are opt-in for rigs you have checked. A guard whose search was cleared part-way (a level restart) no longer freezes with an error; it starts a fresh search. New `Hide.resetGuards()` makes every guard forget the evidence it reacted to and the spots it checked, for a level restart. An 11-test edit-mode suite (`concealKitTests`). - **1.0.0**: First release. Thirteen hiding spot kinds switched by one `kind` field, with peeking; bodies from takedowns and SecondWind deaths that can be carried, dragged, carried by two, loaded on a handcart, dropped, thrown, stashed or disposed of; evidence on five alarm levels kept as data; hide-aware aiKit guard presets (`hideGuard`, `hideNightwatch`, `hideSentry`, `hideMonster` and their `Person` twins) that check hiding spots nearest first, drag out players they saw hide and react to evidence; props for dressing levels; two guides; an 11-test edit-mode suite (`concealKitTests`). Built on aiKit 1.3.0, interactKit 1.6.3, SecondWind 1.4.6, juiceKit 1.2.10 and soundstage 2.1.3.
▲ 0↑ born
◇
component · born here
❒asset
# Body A knocked-out or defeated character other players can move. Put it on the character's synced root (`Hide.body`, or `Hide.guard` adds it). Works with an aiKit Brain (switched off while down) and SecondWind health (any death style, or downed, makes it a body) when the character has them. While it stands, a player behind it can hold E to knock it out. Down, it goes limp (ragdoll when skinned, else laid flat) and can be picked up over the shoulder (speed 0.6), dragged (0.45, noisy), carried by two (0.85), loaded on a Handcart, dropped, thrown, stashed in a HidingSpot or sunk in a DisposalZone. A body in the open is evidence (unconscious or downed level 3, dead level 4). Fields: `active`, `takedown`, `lethal`, `keepDown`, `ragdoll`, `label`. Written by the owner: `condition`, `carrier`, `carrier2`, `mode`, `cart`, `stashed`, `found`, `knockedBy`. Fires `knockedOut`, `killed`, `pickedUp`, `dropped`, `thrown`.
▲ 0↑ born
◇
component · born here
❒asset
# DisposalZone Water or a drop where a body is gone for good: a box, centred on its entity, that hides any body that comes to rest inside it. `Hide.water(pos, size, opts)` makes one. It is usually on a local entity built in the scene, so every peer has it; the body's owner decides. In `water` a body sinks out of sight with a splash; with `drop` it is out of sight below a ledge. Either way it fires `disposed` and no guard will find it. Fields: `sizeX`, `sizeY`, `sizeZ` (metres; default 4, 2, 4), `kind` (`water` or `drop`).
▲ 0↑ born
◇
component · born here
❒asset
# Evidence Something out of place that makes a guard who sees it more alert. Add it to any entity (`Hide.evidence(entity, kind)`); bodies are evidence by themselves and need none. `kind` names an entry of concealKit.alarms (door, noiseMark, item, light, weapon, downed, unconscious, dead, pile, or your own), which gives its level 1 to 5; `level` overrides it. With `whenOpen`, it counts only while the interactKit door or container on the same entity stands open. Each guard reacts to each piece once; after one has reported it, others only glance. Fields: `kind`, `level` (0 = the kind's), `label`, `whenOpen`, `active`. Written by the owner: `reported`.
▲ 0↑ born
◇
component · born here
❒asset
# Handcart A cart a player pushes, with room for several bodies. Put it on a synced entity (`Hide.handcart`); it draws its own model. E with empty hands pushes it, E again lets go; E while carrying a body loads it. It is clumsy: it turns at `turnRate`, slows the pusher to `speed` and its creak is a noise guards hear out to `noise` metres. Bodies on it are in plain sight until taken off (E on the body). Fields: `active`, `capacity` (3), `turnRate` (70), `speed` (0.7), `noise` (9), `showModel`. Written by the owner: `pusher`, `bodies`. Fires `loaded`, `cartPushed`, `cartReleased`.
▲ 0↑ born
◇
component · born here
❒asset
# HidingSpot A place a player can slip into to get away from guards. Put it on a synced entity (`Hide.spot` does this); it needs no sibling components and builds its own model and collider on every peer. `kind` decides what it is (one of the thirteen kinds in concealKit.spots, or one added with `Hide.defineSpot`). In play a player gets an interactKit prompt ("E Climb in"), E again leaves, holding Q peeks; a player carrying a body gets "Stash body" where it fits. The owner of the entity decides who gets in; every peer conceals the occupants from its guards. Fields: `kind`, `capacity` (0 = the kind's), `bodyCapacity` (-1 = the kind's, 0 = none), `showModel`, `collide`, `label`, `active`. Written by the owner: `occupants`, `peeking`, `bodies`, `checking`. Events: `hidden` (`avatar`, `peer`), `left` (`avatar`, `peer`, `reason`); it also fires concealKit's `hidden`, `left`, `caught` and `stashed` events.
▲ 0↑ born
◇
component · born here
❒asset
# Prop One of concealKit's models standing on an entity, scaled to a height in metres and stood on the ground under it, for dressing a level. Each peer builds its own copy, so it works on a local or a synced entity (a dropped sword players can move). ```lua entity.spawn("Tent", { position = { 4, 0, 6 } }).component.add("concealKit.Prop", { model = "tent", height = 2.6 }) ``` Fields: `model` (barrel, crates, haystack, strawbales, reeds, wardrobe, veranda, well, curtain, haycart, foldingscreen, fallenlog, bush, handcart, tent, campfire, lantern, weaponrack, sword), `height`, `lift` (metres above the entity), `rest` (lay it on its own underside, tilted a little along its long side so both ends touch), `collide` (a box collider the size of the model).
▲ 0↑ born
◇
component · born here
❒asset
# StealthPlayer What hiding, peeking and carrying feel like for the player on this screen. concealKit adds one by itself on a temporary local entity on every peer in play; there is nothing to place. It moves this player into a spot with the kind's motion (climb, crawl, slip, burrow, step), holds them there with a vignette and brings them back out; hides every hidden player's body on this screen; peeks while Peek is held (Q or the right mouse button, the pad's left trigger, the touch Peek button); slows the player while carrying, dragging or pushing, with Put down (G, the pad's north button, touch), Throw (T, right trigger, touch) and Carry style (R, right shoulder, touch) live only then; shakes and flashes the screen when a guard drags this player out; and shows a help line that names the buttons of whatever the player is using (at the bottom of the screen; at the top on a touch screen, clear of the stick and buttons). The controls come from two input maps in the package: `concealKit.hiding` (Peek), activated while this player is hidden, and `concealKit.carrying` (Put down, Throw, Carry style), activated while they carry a body. Fields: `peekKey` (`KeyQ`), `dropKey` (`KeyG`), `throwKey` (`KeyT`), `switchKey` (`KeyR`), the keyboard keys (another key set here works beside the maps' own; the pad and touch buttons always work); `showHelp`.
▲ 0↑ born
▣
module · born here
❒asset
# alarms How alarming each thing a guard can stumble on is, as data: five levels and the evidence kinds that map onto them. The guard brain reads it; designers tune the whole game by editing it. Levels: 1 `glance`, 2 `inspect`, 3 `search`, 4 `alarm`, 5 `lockdown`. Each has `lookTime`, `goLook`, `searchTime`, `searchRadius`, `checkSpots`, `run`, `callRadius`, `voice`, `sting`, `stayAlert`, plus `label` and `description`. Kinds: `door`, `noiseMark`, `item` (1), `light`, `weapon` (2), `downed`, `unconscious` (3), `dead` (4), `pile` (5). Two or more bodies within `PILE_RADIUS` (4 m) count as a pile (`PILE_COUNT` = 2). ```lua local Alarms = require("concealKit.alarms") -- also Hide.alarms Alarms.level(3) -- or Alarms.level("search"); a copy Alarms.levelOf("unconscious") -- 3 Alarms.tuneLevel(4, { searchTime = 40 }) Alarms.setKind("door", 2) Alarms.defineKind("lootBag", 2, "a dropped loot bag") ``` Also `levels()`, `kinds()`, `labelOf(kind)` and `COUNT`. Used by the guard brain, Evidence and Body.
▲ 0↑ born
▣
module · born here
❒asset
# api concealKit's one public interface: `local Hide = require("concealKit.api")`. Games, scenes and other kits call it; nothing else in the package needs to be required directly. - **Building:** `Hide.spot(pos, kind?, opts?)`, `Hide.guard(pos, opts?)`, `Hide.body(target, fields?)`, `Hide.evidence(target, kind?, opts?)`, `Hide.handcart(pos, opts?)`, `Hide.water(pos, size?, opts?)`. - **Playing:** `Hide.knockOut(target, opts?)`, `Hide.revive(target)`, `Hide.pullOut(player)`, `Hide.spotOf(player)`, `Hide.isHidden(player)`, `Hide.carrying(player)`, `Hide.bodies()`, `Hide.allSpots()`, `Hide.ensurePlayer()`. - **Events:** `Hide.on(name, fn)` (hidden, left, caught, knockedOut, killed, pickedUp, dropped, thrown, stashed, disposed, loaded, cartPushed, cartReleased, noticed, found, alarm); returns a function that stops listening. - **Data:** `Hide.kinds`, `Hide.defineSpot`, `Hide.tuneSpot`, `Hide.findSpots`, `Hide.alarmLevels`, `Hide.alarmLevel`, `Hide.tuneAlarm`, `Hide.setEvidenceLevel`, `Hide.defineEvidence`, `Hide.extendBrain`. - **Names and modules:** `Hide.VERSION`, the component names `Hide.SPOT`, `Hide.BODY`, `Hide.EVIDENCE`, `Hide.HANDCART`, `Hide.ZONE`, `Hide.PLAYER`, and `Hide.spots`, `Hide.alarms`, `Hide.media`, `Hide.guardBrains`. Requiring it also loads the guard module, which registers the hide-aware aiKit presets, so require it from the scene's `entrypoint.luau` on every peer. The package README lists every call with its options. Part of concealKit.
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
❒
bundle · born here
❒asset
▲ 0↑ born
·
inputmap · born here
❒asset
▲ 0↑ born
·
avatar · born here
❒asset
▲ 0↑ born
▣
module · born here
❒asset
# core The shared state and helpers every part of concealKit runs on. Games use `concealKit.api`; this module is what the components and the guard brain share (and what a game script may reach for when it needs this peer's player). - **Registries** of the hiding spots, bodies, evidence, carts and disposal zones this peer knows (`register`, `unregister`, `list(kind)`, `get(kind, x)`); each component registers itself on every peer. - **Lookups:** `spotOf(avatarId)`, `carriedBy(avatarId)`, `cartOf(avatarId)`. - **Players:** `players()`, `localAvatar()`, `avatarOf(peer)`, `isPlayer(id)`, `myPeer()`, `connected()`. - **Authority:** `isAuthority(e)`: the entity's owner may change it; while nobody owns it, the room host; offline, this peer (the same rule interactKit uses). - **Synced lists** stored in comma-separated string fields: `split`, `join`, `has`, `add`, `remove`. - **Vectors:** `vec`, `dist`, `flatDist`, `yawOf`, `toWorld`, `toLocal`, `idOf`, `now`. - **Sound and feel:** `sound(name, at?, opts?)` plays one of concealKit's sounds through a soundstage bank (`opts.everyone` sends it to every player); `juice(preset, target?, opts?)` and `flash()` reach juiceKit. - **Events:** `on(name, fn)`, `emit(name, ev)` (here and on every other peer over the `concealKit:evt` channel), `listen()`. - `ensurePlayer()` adds this peer's StealthPlayer in play.
▲ 0↑ born
▣
module · born here
❒asset
# guard Guards that know about hiding spots, bodies and evidence, built on aiKit. Each hide-aware brain is a copy of an aiKit state machine brain with three things added, so everything aiKit guards do still works: 1. A guard that saw a player go into a spot goes there, checks it and drags them out; one that did not walks past (hidden players are concealed with aiKit's `AI.setConcealed`; peeking shows the spot's `peekExposure`). 2. When it loses someone, its search checks the hiding spots near where it lost them, nearest first, before searching at random and giving up. 3. It notices bodies in the open and Evidence it can see and reacts by alarm level (concealKit.alarms), calling other guards on its team for levels with a call radius. Requiring it registers the brains `hideGuard`, `hideSentry`, `hideChaser` and the presets `hideGuard`, `hideNightwatch`, `hideSentry`, `hideMonster` and their `*Person` twins (no aiKit stand-in body). A preset's `hide = { checkSpots, spotRadius }` sets how thorough its search is. Exports: `extendBrain(base, name)` (also `Hide.extendBrain`), `callGuards(b, pos, level, radius?)`, `canSeePoint(b, p, ignore?)`, `hideAlarm(b, withEvidence)`. Added states: `notice`, `inspectEvidence`, `checkSpot`, and a replacement `search`. Loaded by the api and by HidingSpot and Body. Part of concealKit.
▲ 0↑ born
▲ 0↑ born
▲ 0↑ born
·
inputmap · born here
❒asset
▲ 0↑ born
▣
module · born here
❒asset
# media Every model and sound concealKit ships, resolved by name, written out one by one so each is a fixed reference the package records and an install brings along. - `MODELS`: bundles under `concealKit.package/art`, keyed by short name: the spot models (`barrel`, `crates`, `haystack`, `strawbales`, `reeds`, `wardrobe`, `veranda`, `well`, `curtain`, `haycart`, `foldingscreen`, `fallenlog`, `bush`), `handcart`, and level props (`tent`, `campfire`, `lantern`, `weaponrack`, `sword`). - `GUARD_AVATAR`: the rigged camp guard character (`concealKit.characters.guard`) that `Hide.guard` dresses guards in. - `SOUNDS`: the soundClips under `concealKit.package/sounds` (entering each kind of spot, body pickup, drop and drag, takedown, splash, cart, peek, stings, guard voice lines). Used by HidingSpot, Handcart and Prop (models), `Hide.guard` (the avatar) and core (sounds).
▲ 0↑ born
·
soundclip · born here
❒asset
# alert_sting This sound clip is a short, tense orchestral stinger with low strings and a muted brass hit. It is intended for use in a stealth game to indicate when the player has been detected.
▲ 0↑ born
·
soundclip · born here
❒asset
# body_drag This sound clip features the continuous scraping sound of a heavy, limp body being dragged across dirt and dry leaves. It is designed to be loopable for use in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# body_drop This sound clip is a heavy, dull thud with cloth rustling, representing a limp human body being dropped onto soft forest ground. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# body_pickup This sound clip features the sound of lifting a heavy, limp person onto a shoulder, including cloth rustle and a strained exhale. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# cart_roll This sound clip is the sound of a wooden handcart rolling on a dirt path, complete with a creaking axle and wheels. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# enter_barrel This sound clip depicts a person quickly climbing into a large, empty wooden barrel. It includes sounds of wood creaking, a hollow wooden thump, and a lid scraping shut. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# enter_bush This sound clip captures the sound of pushing into a thick, leafy bush, with soft branches snapping and leaves rustling. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# enter_cart This sound clip features the sounds of climbing onto a wooden hay cart, including a wooden creak and dry hay rustling. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# enter_crates This sound clip depicts a person squeezing behind stacked wooden crates, with sounds of wood scraping, creaking, and cloth rustling. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# enter_crawl This sound clip features the sounds of a person crawling under a wooden porch, with knees and elbows on dirt and gravel, and boards creaking overhead. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# enter_curtain This sound clip is the sound of a heavy velvet curtain swishing, with curtain rings sliding on a wooden rail. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# enter_hay This sound clip features the sound of a person burrowing into a pile of dry hay, with crunchy straw rustling. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# enter_log This sound clip depicts crawling into a hollow fallen log, with sounds of damp wood scraping and leaf litter crunching. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# enter_reeds This sound clip features the sound of a person pushing into tall, dry reeds and grass, creating a soft swishing rustle. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# enter_screen This sound clip captures the sound of slipping behind a paper folding screen, including a soft paper rustle and a light wooden tap. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# enter_wardrobe This sound clip features the sound of an old wooden wardrobe door creaking open, then closing softly with a latch click. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# enter_well This sound clip depicts climbing down into a stone well, with sounds of rope creaking, stone scraping with a hollow echo, and a small water drip. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# lose_sting This sound clip is a short, dark orchestral failure stinger, featuring a low drum hit and falling strings. It is intended for use as a sound effect to indicate a loss or failure in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# peek This sound clip is a tiny, soft cloth rustle, indicating someone shifting carefully. It is intended for use as a subtle sound effect in a game, perhaps for a 'peek' action.
▲ 0↑ born
·
soundclip · born here
❒asset
# pulled_out This sound clip features the sound of a person being yanked roughly out of a hiding place, including a scuffle, rustle, and a startled gasp. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# splash This sound clip is the sound of a heavy body splashing into a shallow stream. It is intended for use as a sound effect in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# suspicious_sting This sound clip is a soft, eerie single low string swell, intended to convey suspicion in a stealth game. It is for use as a sound effect to indicate a suspicious state.
▲ 0↑ born
·
soundclip · born here
❒asset
# takedown This sound clip depicts a quick, silent chokehold struggle, including a muffled grunt, cloth rustle, and a soft, limp exhale. It is intended for use as a sound effect for a takedown action in a game.
▲ 0↑ born
·
soundclip · born here
❒asset
# vo_body This sound clip is a voice-over stating, "Over here! Someone's down!" It is intended for use as a speech sound effect in a game, likely to alert other characters to a downed body.
▲ 0↑ born
·
soundclip · born here
❒asset
# vo_check This sound clip is a voice-over stating, "Let's see what's in here..." It is intended for use as a speech sound effect in a game, likely when a character is investigating a hiding spot.
▲ 0↑ born
·
soundclip · born here
❒asset
# vo_dead This sound clip is a voice-over stating, "He's dead! Raise the alarm! Search everywhere!" It is intended for use as a speech sound effect in a game, likely to indicate the discovery of a body and trigger an alert state.
▲ 0↑ born
·
soundclip · born here
❒asset
# vo_giveup This sound clip is a voice-over stating, "Must have been the wind." It is intended for use as a speech sound effect in a game, likely when a character dismisses a suspicious sound or event.
▲ 0↑ born
·
soundclip · born here
❒asset
# vo_gotyou This sound clip is a voice-over stating, "Got you! Out you come!" It is intended for use as a speech sound effect in a game, likely when a character discovers and pulls another character from a hiding place.
▲ 0↑ born
·
soundclip · born here
❒asset
# vo_huh This sound clip is a voice-over stating, "Huh? What was that?" It is intended for use as a speech sound effect in a game, likely when a character hears something suspicious.
▲ 0↑ born
·
soundclip · born here
❒asset
# vo_object This sound clip is a voice-over stating, "That wasn't there before." It is intended for use as a speech sound effect in a game, likely when a character notices a new or misplaced object.
▲ 0↑ born
·
soundclip · born here
❒asset
# vo_search This sound clip is a voice-over stating, "Somebody's been here. Check the hiding places." It is intended for use as a speech sound effect in a game, likely when a character discovers signs of intrusion and initiates a search.
▲ 0↑ born
·
soundclip · born here
❒asset
# win_sting This sound clip is a short, hopeful orchestral resolution with warm strings, conveying a quiet victory. It is intended for use as a sound effect to indicate a successful outcome or win in a game.
▲ 0↑ born
▣
module · born here
❒asset
# spots Every kind of hiding spot, as plain data. A HidingSpot's `kind` picks one entry; changing that one field turns a barrel into a haystack and everything follows: model, prompt, motion, sound, peek exposure, capacity, body room and how long a guard takes to check it. Thirteen built-in kinds: `barrel`, `crates`, `haystack`, `strawBales`, `reeds`, `wardrobe`, `crawlSpace`, `well`, `curtain`, `hayCart`, `foldingScreen`, `log`, `bush`, plus aliases (`closet`, `porch`, `shrub`, `byobu`, ...). ```lua local Spots = require("concealKit.spots") -- also Hide.spots Spots.get("barrel") -- the resolved entry (a copy): defaults, then its base chain, then itself Spots.kinds() -- every kind, in catalogue order Spots.find({ tag = "forest" }) -- also { bodies = true }, { motion = "crawl" } Spots.define("coffin", { base = "wardrobe", label = "Coffin", verb = "Lie in" }) Spots.tune("bush", { peekExposure = 0.2 }) ``` Also `exists(name)`, `aliases()`, `canonical(name)` and `DEFAULTS`. Entry fields: `label`, `verb`, `exitVerb`, `motion` (climb, crawl, slip, burrow, step), `model`, `height`, `footprint`, `hidePoint`, `standPoint`, `capacity`, `bodies`, `peekExposure`, `checkTime`, `sound`, `fx`, `view`, `surface`, `collide`, `tags`. Used by HidingSpot, StealthPlayer, the guard brain and `Hide.spot`. Define and tune on every peer.
▲ 0↑ born
backing path · concealKit.package/concealKitTests.testSuite

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.