idOf(target: any) → string

on(target: any, name: string, fn: any) → void

Listen for `name` on `target` (an entity, its id or name, or "*" for every entity). fn(data, entityId). Returns an unsubscribe function. Events: use, open, close, on, off, unlock, denied, loot, board, unboard, enter, exit, stay, holder.

emit(entityId: string, name: string, data: any?) → void

Fire `name` on this peer only.

eventSink(entityId: string, name: string, data: any, _from: number) → void

one-shot events from the network

juice( ) → void

juiceKit's Juice, or nil and why not.

setEffects(on: boolean) → void

Turn the open/close effects off or on (they never change state).

fx(preset: string, at: any, opts: any?) → void

Play a juiceKit preset on this peer only (every peer runs state changes itself).

keyOf(peer: number) → string

The key a player's items are counted under in interactKit's inventory ("p<peer>").

setInventory(src: any?) → void

Use your own inventory for keys and keycards instead of interactKit's: { count = fn(peer, item) -> number, give = fn(peer, item, n) }. nil goes back to interactKit's own. It is read on the owner of each lock.

count(peer: number, item: string) → number

How many of `item` player `peer` holds (interactKit's inventory, or the one given to setInventory).

give(peer: number, item: string, n: number) → boolean

Give player `peer` n of `item` (negative takes; never below 0). Applied by the inventory's owner; from any other peer it is sent there.

items(peer: number) → any

Everything player `peer` carries in interactKit's inventory: { keys = 1, coins = 5, ... } (a copy).

registerInteractable(entityId: string, comp: any) → void

unregisterInteractable(entityId: string, comp: any) → void

registerDevice(entityId: string, dev: any) → void

A device registers its behaviour: { family, kind, comp, handle(peer, verb, args) -> ok, reason, status(peer) -> table, defaults, signal(action) }.

unregisterDevice(entityId: string, dev: any) → void

device(target: any) → any

registerLock(entityId: string, lock: any) → void

unregisterLock(entityId: string, lock: any) → void

lock(target: any) → any

vec(v: any, fallback: { number }) → void

settingsOf(entityId: string) → any

The prompt settings of `entityId` as this peer sees them, merged from its device and its Interactable.

usable( ) → void

Every usable entity id this peer knows.

statusOf(entityId: string, peer: number) → any

What the prompt should say for `peer` right now: { label, hint, locked, available, state, needsCode, codeLength, busy }.

setPromptStyle(style: string) → void

Set the prompt style every Interactable left on "default" uses: glyph, ring, tooltip, dot or pixel.

promptStyle( ) → string return kitSettings

setShowLabels(on: boolean) → void

Show or hide the text beside prompts.

showLabels( ) → boolean return kitSettings

inReach(peer: number, entityId: string) → void

holderBlocks(entityId: string, peer: number) → boolean

setHolder(entityId: string, peer: number) → void

decide(peer: number, entityId: string, verb: string, args: any) → void

_install( ) → void

A hot reload can re-run this module while interactKit.net keeps the handler of the copy before it. Every registration re-installs this copy's handler and event sink, so the registry the components fill is always the one requests are decided against.

resolve(target: any) → string

Resolve a wiring target (entity, id or name) to an entity id.

fire(sourceId: string, targets: any, action: string?, on: boolean, peer: number?) → void

Send `action` to every target ("follow" opens on `on` and closes on off; "invert" the reverse). Runs on the owner of the source.

signal(target: any, action: string, cb: any?) → void

Tell a device to `action` (open, close, toggle, unlock, lock) as wiring would.

use(target: any, args: any?, cb: any?) → void

Use `target` as the local player would (scripts, tests, cutscenes). args: { code, expect, scripted }.

_tickOwner( ) → void

Owner housekeeping: let go of holds whose player stopped refreshing them.

components( ) → any

component(name: string) → any

The component type of one of interactKit's components, by short name ("Door", "Switch", "Lock", ...): pass it to component.add / get / has. Works wherever interactKit is installed.

catalog(filter: any?) → void

Every kind with tags: catalog({ family = "door", tag = "scifi" }).

kinds(family: string) → void

tags( ) → void

spawn(id: string, pos: { number }, opts: any?) → any

Spawn a ready-made thing: spawn("door.airlock", {0,0,5}, { look = "scifi", yaw = 90, name = "Hatch", synced = true, fields = {...}, lock = {...}, interact = {...} }).

_spawnItem(pos: { number }, fields: any, opts: any?) → any

an Item on its own entity (spawnKey, container loot)

spawnKey(pos: { number }, opts: any?) → any

Spawn a key or keycard players pick up by walking over it, counted per player in interactKit's own inventory. opts: { kind = "key" | "keycard", color = "red" (keycards), look = "wood" | "scifi" | "cartoon", perPlayer = true, respawn = false, respawnTime, name, synced = true }. Returns the entity (it carries an interactKit.Item).

_ensureInventory( ) → void

In play, make sure the shared inventory exists: the host (or a peer alone) spawns it once; everyone else receives it.

ensureHud( ) → void

Make sure this peer has its prompt HUD (spawned by the first usable thing in play).

_settings( ) → any return kitSettings end

Settings shared with the HUD.