Traverser
The rooftop-and-climbing layer on a character body. Put it on a body that walks on the built-in `CharacterController` and carries climbKit's `ClimbMover` (the player body a `PlayerPrototype` names, or an NPC). Add `ClimbRig` beside it for animations, hand/foot IK, sounds and feed…
Traverser (traversalKit)
The rooftop-and-climbing layer on a character body. Put it on a body that walks on the built-in CharacterController and carries climbKit's ClimbMover (the player body a PlayerPrototype names, or an NPC). Add ClimbRig beside it for animations, hand/foot IK, sounds and feedback. traversalKit.kit.equip(body) adds all three.
body.component.add("climbKit.ClimbMover", {})
body.component.add("traversalKit.Traverser", { feel = "nimble", assist = "standard" })
body.component.add("traversalKit.ClimbRig", {})
What it adds to climbKit
| Move | How it starts |
|---|---|
| Climb by rule | Any steep, tall-enough surface of a climbable material (stone, wood, bark, rock, terrain, rough unknowns) climbs with no marker. Registered with climbKit's ledge.addClimbRule; climbByRule = false turns it off. |
| Vault | Running at vaultMinSpeed or faster at a thin top up to vaultMaxHeight (feel) with ground beyond: over it in vaultTime, keeping the run's speed. |
| Balance | Walking along a top narrower than the body (a beam, a wall cap, a roof ridge): movement is held to the ridge, sideways input steers a wobble. Past full lean: a slip. |
| Slip and catch | A slip slides down the roof to the eave and falls; jump in the window (assist slipCatchWindow, automatic on arcade) catches the edge as a hang. |
| Wall run | Running into a wall with jump when its edge is beyond a jump's reach but within wallRunSteps x wallRunRise: a few steps up, then a mantle or a hang. |
| Rope | Touching a surface of kind rope (or jumping at it): climb up and down along it, sideways goes round it, jump leaves it, pushing on at the top pulls onto the ledge there. |
| Ladder | A surface of kind ladder climbs through climbKit at the ladder's speed; the mode reads ladder. |
| Helped catch | Airborne toward a ledge or post within the assist's catchRadius: steered onto it and caught. |
| Drop and catch | Letting go of a ledge (back) catches the next ledge below (assist dropCatch). |
| Edge catch | Stepping off an edge and pulling back toward it within 0.9 s catches it as a hang, on every help level; arcade catches an edge walked off without the pull-back. Walking or running straight off still drops. |
Hold kinds tune climb and shimmy speed; under the strict assist, grip drains while holding on and lets go at zero.
Fields
| Field | Default | |
|---|---|---|
feel | nimble | nimble, armoured, ordinary, acrobat (see feels.module). Change it while running. |
assist | standard | arcade, standard, strict (see assists.module). Change it while running. |
climbByRule | true | surfaces nobody marked climb by rule |
vaultEnabled, balanceEnabled, wallRunEnabled, ropeEnabled, assistEnabled | true | each move on or off |
Telemetry (synced: read it on any peer)
mode: grounded, airborne, falling, climbing, ladder, rope, hanging, mantling, vaulting, wallrunning, balancing, slipping. hold: the hold kind in the hands (or underfoot on a ridge), holdMaterial, balance (-1..1), grip (0..1), gripX/Y/Z (where the hands hold), ropeAxisX/Y/Z, facingX/Z, moveProgress.
Events (synced: they fire on every peer)
onModeChanged {from, to}, onGrab {kind, how}, onRelease {kind, reason}, onPullUp {height}, onVault {height, speed}, onWallRun {steps, height}, onWobble {amount}, onRecover, onSlip {side}, onCatch {assisted, how}, onLand {speed, heavy}.
local tr = body.component.get("Traverser")
tr.events.onGrab:connect(function(e) print("grabbed", e.kind) end)
tr.events.onPullUp:connect(function(e) print("up and over", e.height) end)
Methods
setFeel(name), setAssist(name), isHolding(), letGo().
Multiplayer and controls
Only the peer that owns the body runs the moves; the body's position replicates with the engine's interpolation, mode and the events are synced, and ClimbRig draws every climber on every peer. It reads the controller's input bus (whatever drives the body: the controller's own input map, controlsKit's schemes on keyboard, gamepad and touch, or an AI), so there are no new bindings.
Balance direction
A balance runs along the beam itself: the longer horizontal axis of whatever is underfoot (a beam, a ridge cap, a roof slab), pointed the way the player is going, so stepping on a few degrees off still walks straight along it. Shapes with no clear long axis (terrain ridges) follow the direction the player stepped on with.
Ropes
- Up and down on a rope follow the player's forward (stick, keys or touch pad) against the camera, the same way a ladder does, whichever side of the rope they caught it from. AI and scripted climbers use the way the body faces.
- The lowest hold is floor-aware: a rope whose foot hangs just above a deck or roof keeps the climber's feet on that floor, and pushing down there steps off onto it.
- At the top, pushing on pulls onto the ledge the player is pushing toward first, then onto one the body faces.
Interface
What this asset declares: the schema it conforms to, what it exposes, and the rendered structured payload.
conforms to
zero/source-extract/v2Traverser: the rooftop-and-climbing layer traversalKit adds on top of climbKit's ClimbMover, on a body that walks on the built-in CharacterController. What it does on the peer that owns the body: * registers the climb-by-rule test with climbKit (rules.module), so surfaces climb by steepness, height and material with no tagging; * vaults waist-high obstacles at running speed without breaking stride; * balances along narrow ridges and beams: a wobble the player steers out of, a slip down the roof the player can catch at the edge; * runs a few steps up a wall to reach an edge a jump would not; * climbs ropes (up, down, round, jump off); * steers a jump onto a ledge or post it is heading for (assist level), catches the ledge below after letting go, catches an edge walked off; * reads which kind of hold is in the hands and tunes climb speed by it; * applies the movement feel and assist level, both swappable live; * publishes one synced `mode` and fires synced events for game code. Every other peer reads the synced fields; ClimbRig draws them.
localUserId( ) → string
isLocalPlayersBody( ) → boolean
ownsBody( ) → boolean
dropMyControls( ) → void
takeMyControls(cc: any) → void
| arg | type | description |
|---|---|---|
| cc | any |
cameraBasis( ) → void
intentOff(cc: any, isPlayer: boolean) → void
The intent of whoever drives the body while the controller is off: the controller's bus first (an AI, or a control scheme such as controlsKit that drives the body through it), else the local player's own controls against the camera.
| arg | type | description |
|---|---|---|
| cc | any | |
| isPlayer | boolean |
controller( ) → any
climber( ) → any
feet( ) → Vec
onGround(cc: any) → boolean
| arg | type | description |
|---|---|---|
| cc | any |
setFeet(p: Vec) → void
| arg | type | description |
|---|---|---|
| p | Vec |
selfExclude( ) → void
applyFeel(cc: any, cm: any) → boolean
| arg | type | description |
|---|---|---|
| cc | any | |
| cm | any |
applyAssist(cm: any, isPlayer: boolean) → void
| arg | type | description |
|---|---|---|
| cm | any | |
| isPlayer | boolean |
withLedge(t: any) → any
Which ledge or hold a grab or catch is about: `ledgeId` is its entity ("" when there is none, a rope's or a jump catch's), `topY` the height of the edge in hand.
| arg | type | description |
|---|---|---|
| t | any |
setHold(kind: string, material: string?) → void
| arg | type | description |
|---|---|---|
| kind | string | |
| material | string? |
materialText(entityId: string) → string
| arg | type | description |
|---|---|---|
| entityId | string |
senseWallHold(cc: any, cm: any) → void
Which hold the hands are on while climbing or hanging: a ray from the chest into the wall.
| arg | type | description |
|---|---|---|
| cc | any | |
| cm | any |
holdRoot(id: string) → string
| arg | type | description |
|---|---|---|
| id | string |
setIgnoredLedges(cm: any, holdEntity: string?) → void
| arg | type | description |
|---|---|---|
| cm | any | |
| holdEntity | string? |
tuneClimbSpeed(cm: any) → void
| arg | type | description |
|---|---|---|
| cm | any |
holdFacing(hold: boolean) → void
| arg | type | description |
|---|---|---|
| hold | boolean |
takeOver(cc: any) → void
| arg | type | description |
|---|---|---|
| cc | any |
giveBack(cc: any, vx: number, vy: number, vz: number) → void
Switch the controller back on. With no upward speed to hand over it keeps the horizontal velocity it had (a vault carries the run straight on); with some, it is handed over as a one-frame jump of that force, the jump buffer held at 0 so the request cannot fire again later at full force.
| arg | type | description |
|---|---|---|
| cc | any | |
| vx | number | |
| vy | number | |
| vz | number |
settle(cc: any) → void
| arg | type | description |
|---|---|---|
| cc | any |
face(dx: number, dz: number) → void
| arg | type | description |
|---|---|---|
| dx | number | |
| dz | number |
tryVault(cc: any, p: Vec, dx: number, dz: number, speed: number) → boolean
Vault: a top 0.45..vaultMaxHeight above the feet, thin enough to clear, with ground beyond to land on.
| arg | type | description |
|---|---|---|
| cc | any | |
| p | Vec | |
| dx | number | |
| dz | number | |
| speed | number |
vaultUpdate(cc: any, dt: number) → void
| arg | type | description |
|---|---|---|
| cc | any | |
| dt | number |
tryWallRun(cc: any, cm: any, p: Vec, dx: number, dz: number) → boolean
| arg | type | description |
|---|---|---|
| cc | any | |
| cm | any | |
| p | Vec | |
| dx | number | |
| dz | number |
wallRunUpdate(cc: any, cm: any, dt: number) → void
| arg | type | description |
|---|---|---|
| cc | any | |
| cm | any | |
| dt | number |
ropeExtent(id: string, at: Vec, up: Vec) → void
| arg | type | description |
|---|---|---|
| id | string | |
| at | Vec | |
| up | Vec |
onRope(s: number) → boolean
| arg | type | description |
|---|---|---|
| s | number |
ropeAxisOf(id: string) → Vec
| arg | type | description |
|---|---|---|
| id | string |
placeOnRope(cc: any) → void
| arg | type | description |
|---|---|---|
| cc | any |
groundAlong(p: Vec, tx: number, tz: number) → boolean
ground under a step of about a metre that way (never slide a player off a roof or a deck)
| arg | type | description |
|---|---|---|
| p | Vec | |
| tx | number | |
| tz | number |
slideAlong(cc: any, p: Vec, dx: number, dz: number) → void
| arg | type | description |
|---|---|---|
| cc | any | |
| p | Vec | |
| dx | number | |
| dz | number |
tryRope(cc: any, p: Vec, dx: number, dz: number) → boolean
| arg | type | description |
|---|---|---|
| cc | any | |
| p | Vec | |
| dx | number | |
| dz | number |
ropeUpdate(cc: any, cm: any, dt: number, isPlayer: boolean) → void
| arg | type | description |
|---|---|---|
| cc | any | |
| cm | any | |
| dt | number | |
| isPlayer | boolean |
startSlip(cc: any, side: number, rx: number, rz: number) → void
| arg | type | description |
|---|---|---|
| cc | any | |
| side | number | |
| rx | number | |
| rz | number |
slideUpdate(cc: any, cm: any, dt: number, isPlayer: boolean) → void
| arg | type | description |
|---|---|---|
| cc | any | |
| cm | any | |
| dt | number | |
| isPlayer | boolean |
narrowUnder(cc: any, p: Vec, ax: number, az: number) → void
| arg | type | description |
|---|---|---|
| cc | any | |
| p | Vec | |
| ax | number | |
| az | number |
sideDrops(sg: number) → boolean
| arg | type | description |
|---|---|---|
| sg | number |
narrowRunLength(p: Vec, ax: number, az: number) → number
How far the narrow top underfoot runs on along (ax, az), both ways together: rays down in 0.1 m steps, keeping the run level with the top under the feet. A post cap or a pillar top is narrow on every side but short every way too: somewhere to stand, not a beam to balance along (balancing there wobbled every climber off the top it had just pulled up onto).
| arg | type | description |
|---|---|---|
| p | Vec | |
| ax | number | |
| az | number |
beamAxis(underId: string?, dx: number, dz: number) → void
The direction a beam or ridge runs: the longer horizontal axis of the thing underfoot (a beam, a ridge cap, a roof slab), signed to match the way the player is heading. nil when it has no clearly long axis.
| arg | type | description |
|---|---|---|
| underId | string? | |
| dx | number | |
| dz | number |
lineOffset(p: Vec, rx: number, rz: number) → number
How far the middle of the walkable strip underfoot lies from the feet, across the line (positive along +r): rays down at small steps either side, keeping the contiguous run whose top is level with the one underfoot.
| arg | type | description |
|---|---|---|
| p | Vec | |
| rx | number | |
| rz | number |
supported(k: number) → boolean
| arg | type | description |
|---|---|---|
| k | number |
beamAhead(p: Vec, dx: number, dz: number, dist: number) → void
A beam or ridge just ahead while still on wide ground: rays down across a line `dist` ahead; the contiguous strip level with the ground underfoot that is narrower than a body is a beam to step onto. Answers how far its middle lies across (+r) from the path, and the entity, or nil.
| arg | type | description |
|---|---|---|
| p | Vec | |
| dx | number | |
| dz | number | |
| dist | number |
approachBeam(cc: any, p: Vec, dx: number, dz: number, dt: number) → void
On wide ground heading at a beam: steer onto its middle and along it.
| arg | type | description |
|---|---|---|
| cc | any | |
| p | Vec | |
| dx | number | |
| dz | number | |
| dt | number |
balanceUpdate(cc: any, dt: number, isPlayer: boolean) → void
| arg | type | description |
|---|---|---|
| cc | any | |
| dt | number | |
| isPlayer | boolean |
shelfClearance(cc: any, p: Vec, toward: { x: number, z: number }) → number
A let-go above a shelf it would land on: how far out from the hang the body has to drop so it passes the shelf's edge and the hang catch takes it. 0.3 m (just off the wall) when there is no shelf within catching distance below.
| arg | type | description |
|---|---|---|
| cc | any | |
| p | Vec | |
| toward | { x: number, z: number } |
below(d: number) → any
| arg | type | description |
|---|---|---|
| d | number |
assistedAir(cc: any, cm: any, p: Vec, dx: number, dz: number, dt: number) → void
| arg | type | description |
|---|---|---|
| cc | any | |
| cm | any | |
| p | Vec | |
| dx | number | |
| dz | number | |
| dt | number |
deriveMode(cc: any, cm: any) → string
| arg | type | description |
|---|---|---|
| cc | any | |
| cm | any |
setMode(m: string, cm: any) → void
| arg | type | description |
|---|---|---|
| m | string | |
| cm | any |
wire(cm: any) → void
| arg | type | description |
|---|---|---|
| cm | any |
update(dt: number) → void
| arg | type | description |
|---|---|---|
| dt | number |
setFeel(name: string) → void
Switch the movement feel while running (nimble, armoured, ordinary, acrobat, or a defined one). Owner only; other peers write the synced `feel` field through their own game logic.
| arg | type | description |
|---|---|---|
| name | string |
setAssist(name: string) → void
Switch the assist level while running (arcade, standard, strict, or a defined one).
| arg | type | description |
|---|---|---|
| name | string |
isHolding( ) → boolean
Whether the climber is holding on to something right now (climbing, ladder, rope or hanging).
letGo( ) → void
Let go of whatever is held or being done and fall/stand under the controller.
onDestroy( ) → void
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.
Problems
Everything affecting this asset right now: its own problems, anything wrong inside it, and problems on its direct dependencies.
agent_score is exposed.+ 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".
Scoped to this part · feeds back into the world's score.