# jgengine-world — capability index Reach for these before hand-rolling. Each row is *the thing you need* → *the primitive that already does it*. ## action-contexts — Swap bindings live for on-foot, driving, menu or build modes by pushing and popping layered action maps. - `createActionContextStack` (function) · `import { createActionContextStack } from "@jgengine/core/input/actionContexts"` ## ai-decision-graph — Evaluate serializable selector, sequence, condition, action, utility, timer, and random AI decisions with interrupt hooks. - `createDecisionGraphRuntime` (function) · `import { createDecisionGraphRuntime } from "@jgengine/core/ai/decisionGraph"` ## ai-driver — difficulty-aware chase/route driving step producing throttle/brake/steer for the vehicle sim - `driveStep` (function) · `import { driveStep } from "@jgengine/core/ai/driver"` ## ai-driver-path-target — pure-pursuit lookahead target on a road/route polyline for street following - `pathTargetAhead` (function) · `import { pathTargetAhead } from "@jgengine/core/ai/driver"` ## ai-driver-state — fresh serializable state for one difficulty-aware AI driver - `createDriverState` (function) · `import { createDriverState } from "@jgengine/core/ai/driver"` ## air-metrics — measure a vehicle's jumps and air control — apex height and time, double jump, air rotation rates - `measureAir` (function) · `import { measureAir } from "@jgengine/core/physics/handlingProbe"` ## anim-graph — data-first animation state machine with blend trees, crossfades, layers, and clip events - `createAnimGraphRuntime` (function) · `import { createAnimGraphRuntime } from "@jgengine/core/anim/animGraph"` - `parseAnimGraph` (function) · `import { parseAnimGraph } from "@jgengine/core/anim/animGraph"` - `validateAnimGraph` (function) · `import { validateAnimGraph } from "@jgengine/core/anim/animGraph"` ## animation — build a masked one-shot overlay layer for upper-body actions and hit reactions - `actionLayer` (function) · `import { actionLayer } from "@jgengine/core/anim/actionLayer"` - `inferLegChains` (function) · `import { inferLegChains } from "@jgengine/core/anim/footPlacement"` - `lookAt` (function) · `import { lookAt } from "@jgengine/core/anim/ikSolver"` - `multiplyQuaternions` (function) · `import { multiplyQuaternions } from "@jgengine/core/anim/ikSolver"` - `placeFeet` (function) · `import { placeFeet } from "@jgengine/core/anim/footPlacement"` - `planBoneTexture` (function) · `import { planBoneTexture } from "@jgengine/core/anim/boneTexture"` - `quaternionFromUnitVectors` (function) · `import { quaternionFromUnitVectors } from "@jgengine/core/anim/ikSolver"` - `ragdollBoneOrientations` (function) · `import { ragdollBoneOrientations } from "@jgengine/core/anim/ragdollRig"` - `ragdollConfigFromPoses` (function) · `import { ragdollConfigFromPoses } from "@jgengine/core/anim/ragdollRig"` - `sampleBoneTexture` (function) · `import { sampleBoneTexture } from "@jgengine/core/anim/boneTexture"` - `solveFabrik` (function) · `import { solveFabrik } from "@jgengine/core/anim/ikSolver"` - `solveTwoBone` (function) · `import { solveTwoBone } from "@jgengine/core/anim/ikSolver"` - `withActionLayers` (function) · `import { withActionLayers } from "@jgengine/core/anim/actionLayer"` ## area-effect-field — source-following area membership with enter/refresh/leave edges, stacking, and cleanup - `createAreaEffectField` (function) · `import { createAreaEffectField } from "@jgengine/core/world"` ## area-stack-additive — sum a magnitude across overlapping area memberships - `sumMagnitude` (function) · `import { sumMagnitude } from "@jgengine/core/world"` ## area-stack-capped — cap area memberships per stack key at a maximum count - `cappedStacks` (function) · `import { cappedStacks } from "@jgengine/core/world"` ## area-stack-extremum — keep only the strongest or weakest overlapping area membership - `extremumStack` (function) · `import { extremumStack } from "@jgengine/core/world"` ## area-stack-independent — apply every overlapping area membership independently - `independentStacks` (function) · `import { independentStacks } from "@jgengine/core/world"` ## area-stack-unique — keep one area membership per stack key, strongest wins - `uniqueByStackKey` (function) · `import { uniqueByStackKey } from "@jgengine/core/world"` ## asset-anchor — resolve a model's pivot offset from its footprint center - `resolveAnchorOffset` (function) · `import { resolveAnchorOffset } from "@jgengine/core/world"` ## asset-facing — resolve a placement heading into a Three.js Y-rotation using canonical forward - `resolveFacingRotationY` (function) · `import { resolveFacingRotationY } from "@jgengine/core/world"` ## asset-footprint — rotate a rectangular footprint into its axis-aligned extent - `rotatedFootprint` (function) · `import { rotatedFootprint } from "@jgengine/core/world"` ## asset-heading — turn a north-relative degree heading into a Three.js Y-rotation - `headingToRotationY` (function) · `import { headingToRotationY } from "@jgengine/core/world"` - `normalizeDegrees` (function) · `import { normalizeDegrees } from "@jgengine/core/world"` - `rotationYToHeading` (function) · `import { rotationYToHeading } from "@jgengine/core/world"` ## asset-load-diagnostics — classify a model fetch (missing / HTML fallback / corrupt / unsupported) before parsing - `classifyAssetResponse` (function) · `import { classifyAssetResponse } from "@jgengine/core/scene/assetDiagnostics"` ## asset-space — parse serialized asset-space metadata into a validated shape - `parseAssetSpace` (function) · `import { parseAssetSpace } from "@jgengine/core/world"` - `validateAssetSpace` (function) · `import { validateAssetSpace } from "@jgengine/core/world"` ## asset-units — convert a source-space length to engine meters via catalog unit scale - `toEngineUnits` (function) · `import { toEngineUnits } from "@jgengine/core/world"` ## attack-move-order — advance-and-engage order that pursues hostiles en route and completes at its destination - `defineAttackMoveOrder` (function) · `import { defineAttackMoveOrder } from "@jgengine/core/world"` ## audio-voice-budget — bound simultaneous sound playback with per-sound caps, priorities, and deterministic stealing - `createVoiceAllocator` (function) · `import { createVoiceAllocator } from "@jgengine/core/audio/voiceAllocator"` ## authored-animation — consume live authored character animation with bounded per-frame work - `createAuthoredAnimationReader` (function) · `import { createAuthoredAnimationReader } from "@jgengine/core/world/authoredAnimation"` - `readAuthoredAnimation` (function) · `import { readAuthoredAnimation } from "@jgengine/core/world/authoredAnimation"` - `readAuthoredAnimationValue` (function) · `import { readAuthoredAnimationValue } from "@jgengine/core/world/authoredAnimation"` ## authored-entities — spawn authored mob/boss markers from the editor document at runtime - `authoredEntitySpawns` (function) · `import { authoredEntitySpawns } from "@jgengine/core/world/authoredEntities"` ## authored-environment — compose authored weather, shelter, accumulation, fire, flocks and effects using one simulation clock - `createAuthoredSimulation` (function) · `import { createAuthoredSimulation } from "@jgengine/core/world/authoredSimulation"` ## authored-objects — marker kinds resolved as entity spawns, not static props - `ENTITY_MARKER_KINDS` (const) · `import { ENTITY_MARKER_KINDS } from "@jgengine/core/world/authoredObjects"` - `markerAnimation` (function) · `import { markerAnimation } from "@jgengine/core/world/authoredObjects"` - `markerCatalogId` (function) · `import { markerCatalogId } from "@jgengine/core/world"` - `placeAuthoredObjects` (function) · `import { placeAuthoredObjects } from "@jgengine/core/world"` - `resolveAuthoredObjects` (function) · `import { resolveAuthoredObjects } from "@jgengine/core/world"` - `resolveAuthoredObjectsWithDiagnostics` (function) · `import { resolveAuthoredObjectsWithDiagnostics } from "@jgengine/core/world/authoredObjects"` ## authored-solids — collision for studio-authored world content such as city volumes - `resolveAuthoredSolids` (function) · `import { resolveAuthoredSolids } from "@jgengine/core/world/authoredSolids"` - `syncAuthoredSolids` (function) · `import { syncAuthoredSolids } from "@jgengine/core/world/authoredSolids"` ## authored-spawn — read spawn points and markers from the editor document - `authoredSpawnPosition` (function) · `import { authoredSpawnPosition } from "@jgengine/core/world/authoredSpawn"` - `authoredSpawnRotation` (function) · `import { authoredSpawnRotation } from "@jgengine/core/world/authoredSpawn"` - `markersOfKind` (function) · `import { markersOfKind } from "@jgengine/core/world/authoredSpawn"` ## authored-triggers — built-in announce/win/advance actions authorable on any marker or volume - `BUILTIN_TRIGGER_ACTIONS` (const) · `import { BUILTIN_TRIGGER_ACTIONS } from "@jgengine/core/scene/authoredTriggers"` - `collectAuthoredTriggers` (function) · `import { collectAuthoredTriggers } from "@jgengine/core/world"` - `createAuthoredTriggerRuntime` (function) · `import { createAuthoredTriggerRuntime } from "@jgengine/core/world"` - `createTriggerOutcome` (function) · `import { createTriggerOutcome } from "@jgengine/core/scene/authoredTriggers"` - `registerBuiltinTriggerActions` (function) · `import { registerBuiltinTriggerActions } from "@jgengine/core/scene/authoredTriggers"` - `registerTriggerAction` (function) · `import { registerTriggerAction } from "@jgengine/core/world"` ## authored-weather — Sample scheduled precipitation and local wind from one authored document and simulation clock. - `createAuthoredWeather` (function) · `import { createAuthoredWeather } from "@jgengine/core/world/authoredWeather"` ## authored-weather-validation — Reject invalid weather profiles, schedules, zones and wind before authoring mutations. - `validateAuthoredWeather` (function) · `import { validateAuthoredWeather } from "@jgengine/core/world/authoredWeather"` ## axis-shaping — shape raw input per axis — deadzone, response curve, keyboard ramp, self-centring, speed-sensitive scaling - `createAxisShaper` (function) · `import { createAxisShaper } from "@jgengine/core/input/axisShaper"` ## behavior-actions — register named callbacks for decision graph behavior descriptors - `registerBehaviorActions` (function) · `import { registerBehaviorActions } from "@jgengine/core/world"` ## behavior-control — pause/disable/resume/seek/inspect behavior instances per entity - `behaviorControl` (function) · `import { behaviorControl } from "@jgengine/core/world"` ## behavior-tick — auto-advance spawned patrol, wander, pursuit and decision graph behaviors with lifecycle control - `advanceBehaviors` (function) · `import { advanceBehaviors } from "@jgengine/core/world"` ## board-vehicle — board a rideable, freeze/hide its rider and apply caller camera policy - `boardVehicle` (function) · `import { boardVehicle } from "@jgengine/core/world"` ## boat-dynamics — force-based powered hull — hull-speed drag hump, planing, keel, rudder that needs flow or outboard thrust - `createBoatDynamics` (function) · `import { createBoatDynamics } from "@jgengine/core/physics/boatDynamics"` ## body-bind — mirror sim-body snapshots onto scene entities each tick, no per-body setPose - `createBodyBind` (function) · `import { createBodyBind } from "@jgengine/core/world"` ## boss-phase-state — fresh serializable boss phase state that opens in the first phase - `createBossState` (function) · `import { createBossState } from "@jgengine/core/ai/director/boss"` ## boss-phases — data-authored boss phases that change behaviour and fire a tell at health thresholds - `advanceBoss` (function) · `import { advanceBoss } from "@jgengine/core/ai/director/boss"` ## bounded-grid-route — distinguish no path from exhausted grid search work - `findPathResult` (function) · `import { findPathResult } from "@jgengine/core/nav/navGrid"` ## build-footprint-cells — grid cells a snapped build piece footprint covers (footprintGrid occupancy bridge) - `footprintCells` (function) · `import { footprintCells } from "@jgengine/core/world/buildSockets"` ## build-socket-catalog — data-driven named-socket snap catalog for modular base building - `createBuildSocketCatalog` (function) · `import { createBuildSocketCatalog } from "@jgengine/core/world/buildSockets"` ## building-generator — generate seeded buildings as placed facade parts — bays, floors, roof, decor - `createBuildingConfig` (function) · `import { createBuildingConfig } from "@jgengine/core/world/buildings"` - `generateBuilding` (function) · `import { generateBuilding } from "@jgengine/core/world/buildings"` - `generateBuildingDistrict` (function) · `import { generateBuildingDistrict } from "@jgengine/core/world/buildings"` ## building-kit — bind generated facade part slots to real models instead of untextured blocks - `buildingKitVariantCounts` (function) · `import { buildingKitVariantCounts } from "@jgengine/core/world/buildingKit"` - `defineBuildingKit` (function) · `import { defineBuildingKit } from "@jgengine/core/world/buildingKit"` - `resolveBuildingKitPart` (function) · `import { resolveBuildingKitPart } from "@jgengine/core/world/buildingKit"` ## building-lots — derive street-facing building lots from road frontage - `deriveBuildingLots` (function) · `import { deriveBuildingLots } from "@jgengine/core/world/buildingLots"` ## camera-shake — seeded serializable trauma-based camera shake/impulse controller (hit/explosion/landing juice) with pooled per-frame translation+rotation offset and snapshot/restore - `createCameraShake` (function) · `import { createCameraShake } from "@jgengine/core/world"` ## capture — force a framed capture camera over a game that owns its camera - `installCaptureCamera` (function) · `import { installCaptureCamera } from "@jgengine/core/world/captureCamera"` ## character-controller — capsule walk over the physics backend — slide, step-up, slopes, crouch, platforms - `createCharacterController` (function) · `import { createCharacterController } from "@jgengine/core/movement/characterController"` ## city-district — polygon math for road-derived blocks, parcels, and buildable footprints - `Vec2` (type) · `import { Vec2 } from "@jgengine/core/world/cityGeometry"` - `citySolids` (function) · `import { citySolids } from "@jgengine/core/world/cityKind"` - `extractGraphBlocks` (function) · `import { extractGraphBlocks } from "@jgengine/core/world/cityBlocks"` - `rectClearsPolyline` (function) · `import { rectClearsPolyline } from "@jgengine/core/world/cityGeometry"` - `rectsSeparated` (function) · `import { rectsSeparated } from "@jgengine/core/world/cityGeometry"` - `resolveCityObject` (function) · `import { resolveCityObject } from "@jgengine/core/world"` ## city-generator — subdivide street blocks into size-tiered street-fronting plots - `deriveCityPlots` (function) · `import { deriveCityPlots } from "@jgengine/core/world"` - `resolveCityLotContent` (function) · `import { resolveCityLotContent } from "@jgengine/core/world"` ## companion-intent — resolve a companion's command + threat context into a per-tick follow/hold/engage/assist intent - `resolveCompanionIntent` (function) · `import { resolveCompanionIntent } from "@jgengine/core/scene/companion"` ## companion-roster — manage tamed companions — allegiance, commands, per-companion stats/leveling, and mobBrain-shaped intent - `createCompanionRoster` (function) · `import { createCompanionRoster } from "@jgengine/core/scene/companion"` ## contour-interval — readable auto-spacing for elevation contours - `chooseContourInterval` (function) · `import { chooseContourInterval } from "@jgengine/core/world"` ## countdown-timers — named countdown/countup timer set on an injected clock — round timers, respawn clocks, ability cooldown/charge; read remaining/elapsed/progress + expiry, snapshot/restore - `createTimerSet` (function) · `import { createTimerSet } from "@jgengine/core/world"` ## course-metrics — measure a vehicle on driven tests — understeer gradient, skidpad g, slalom speed - `measureCourse` (function) · `import { measureCourse } from "@jgengine/core/physics/handlingProbe"` ## crouch-prone — stance/pose transitions that change the hitbox - `createPoseState` (function) · `import { createPoseState } from "@jgengine/core/world"` ## damage-direction — serializable hit-from damage-direction indicator brain — pooled directional arcs that flare on `registerHit(angle, intensity)` and fade on an injected clock, with optional same-direction merging - `createDamageDirectionTracker` (function) · `import { createDamageDirectionTracker } from "@jgengine/core/world"` ## day-night-cycle — one wired model gives a moving day-night cycle — running clock plus keyframed phase labels and tint/light colors a game drives an existing sky/daylight seam from - `createDayNightCycle` (function) · `import { createDayNightCycle } from "@jgengine/core/world"` ## decay-meter — survival meters that drain/refill over game time (hunger, water, oxygen, stamina) - `createDecayMeterSet` (function) · `import { createDecayMeterSet } from "@jgengine/core/procedural"` ## difficulty-ability-gate — spend-or-hold ability decision from a scored opportunity window - `shouldUseAbility` (function) · `import { shouldUseAbility } from "@jgengine/core/ai/difficulty"` ## difficulty-execution-error — symmetric aim/lead/timing error scaled by the profile - `executionError` (function) · `import { executionError } from "@jgengine/core/ai/difficulty"` ## difficulty-lookahead — depth/width-bounded deterministic planner for turn-based or sequential decisions - `planLookahead` (function) · `import { planLookahead } from "@jgengine/core/ai/difficulty"` ## difficulty-pick — noisy argmax over scored options; expert picks best, easy blunders - `pickScored` (function) · `import { pickScored } from "@jgengine/core/ai/difficulty"` ## difficulty-profile — derive a per-game decision-quality profile from a canonical tier - `difficultyProfile` (function) · `import { difficultyProfile } from "@jgengine/core/ai/difficulty"` ## difficulty-reaction-gate — delay acting on new information by the profile's reaction time - `advanceReactionGate` (function) · `import { advanceReactionGate } from "@jgengine/core/ai/difficulty"` ## difficulty-reaction-gate-state — fresh serializable reaction-gate state for one observed value - `createReactionGate` (function) · `import { createReactionGate } from "@jgengine/core/ai/difficulty"` ## difficulty-tiers — canonical easy/standard/expert decision-quality profiles for any opponent - `DIFFICULTY_TIERS` (const) · `import { DIFFICULTY_TIERS } from "@jgengine/core/ai/difficulty"` ## doppler-pitch — pitch a moving sound up as it approaches and down as it passes, from listener and emitter velocity - `dopplerRate` (function) · `import { dopplerRate } from "@jgengine/core/audio/doppler"` ## drivable-vehicle — drive a car from throttle/steer/handbrake input each tick: step the vehicle sim and pose its entity - `tickDrivableVehicle` (function) · `import { tickDrivableVehicle } from "@jgengine/core/world"` ## effect-resolve — turn a named library effect into emitter config, GPU sprite texture, blending and budget priority with per-call overrides - `resolveEffect` (function) · `import { resolveEffect } from "@jgengine/core/vfx/effectLibrary"` ## elevation-readout — cursor height and delta-from-reference feedback - `sampleElevation` (function) · `import { sampleElevation } from "@jgengine/core/world"` ## elevation-summary — selection min/max/mean and relief over a region - `summarizeElevation` (function) · `import { summarizeElevation } from "@jgengine/core/world"` ## encounter-expand — turn an authored wave into a deterministic, pressure-adjusted list of timed spawn orders - `expandWave` (function) · `import { expandWave } from "@jgengine/core/ai/director/encounter"` ## encounter-pressure — bounded difficulty tier read from player health, encounter progress and time - `evaluatePressure` (function) · `import { evaluatePressure } from "@jgengine/core/ai/director/pressure"` ## encounter-runner — open authored waves, emit their timed orders, and track wave progress through a save - `createEncounter` (function) · `import { createEncounter } from "@jgengine/core/ai/director/encounter"` ## engine-layers — layered engine audio: rpm-keyed samples crossfaded, with on-load and off-load sets picked by engine load - `createEngineLayers` (function) · `import { createEngineLayers } from "@jgengine/core/audio/engineLayers"` ## entity-meta — cast-free narrow of SceneEntity.meta via a type guard - `entityMetaOf` (function) · `import { entityMetaOf } from "@jgengine/core/world"` ## environment-motion — apply capped spatial wind and vortex forces to game-selected actors through shared motion intents - `installEnvironmentMotion` (function) · `import { installEnvironmentMotion } from "@jgengine/core/world/environmentForces"` ## fast-travel — network of fast-travel destinations with discovery, distance-sorted queries, nearest lookup, a travel gate, and serializable state - `createFastTravelNetwork` (function) · `import { createFastTravelNetwork } from "@jgengine/core/world"` ## feedback-cue-sounds — default procedural hit/hurt/kill/pickup/objective/wave/deny reactions on an "sfx" bus, overridable per game - `withFeedbackCueSounds` (function) · `import { withFeedbackCueSounds } from "@jgengine/core/audio/feedbackCues"` ## feedback-mixer — map sim telemetry to camera, audio and haptic parameters through curves, smoothing and threshold events - `createFeedbackMixer` (function) · `import { createFeedbackMixer } from "@jgengine/core/vfx/feedbackMixer"` ## fight-intent-composition — map assigned duties onto a squad combat composition in member order - `compositionForIntents` (function) · `import { compositionForIntents } from "@jgengine/core/ai/director/roles"` ## fight-intents — assign hold, flank, cover, assault and retreat duties from live squad state - `assignFightIntents` (function) · `import { assignFightIntents } from "@jgengine/core/ai/director/roles"` ## find-effect — look up one named particle effect in the shared library, or undefined when unknown - `findEffect` (function) · `import { findEffect } from "@jgengine/core/vfx/effectLibrary"` ## fire-input — bind a key or mouse button to a named action that runs the same-named command with the aim; repeatMs auto-fires while held - `ActionCodesMap` (type) · `import { ActionCodesMap } from "@jgengine/core/input/actionBindings"` ## flight-metrics — measure an aircraft's feel as numbers — roll rate, sustained turn, stall speed, climb, throttle response, hover drift - `measureFlight` (function) · `import { measureFlight } from "@jgengine/core/physics/handlingProbe"` ## follow-trail — trailing follower/snake formation that chases a leader - `createLeaderTrail` (function) · `import { createLeaderTrail } from "@jgengine/core/world"` ## footprint-grid — multi-cell footprint occupancy/reservation on a shared build grid - `createFootprintGrid` (function) · `import { createFootprintGrid } from "@jgengine/core/world"` ## force-field-validation — reject invalid localized force authoring before simulation - `validateForceField` (function) · `import { validateForceField } from "@jgengine/core/physics/forceVolume"` ## formation-assignment — stable deterministic member-to-slot matching for a group formation - `assignFormationSlots` (function) · `import { assignFormationSlots } from "@jgengine/core/world"` ## formation-box — box/grid slot generator for group destinations - `boxFormation` (function) · `import { boxFormation } from "@jgengine/core/world"` ## formation-circle — ring/cordon slot generator for group destinations - `circleFormation` (function) · `import { circleFormation } from "@jgengine/core/world"` ## formation-facing — group facing yaw from a travel direction on the XZ plane - `facingYaw` (function) · `import { facingYaw } from "@jgengine/core/world"` ## formation-line — line (abreast) slot generator for group destinations - `lineFormation` (function) · `import { lineFormation } from "@jgengine/core/world"` ## formation-placement — place a group formation's world slots around a destination - `placeFormation` (function) · `import { placeFormation } from "@jgengine/core/world"` ## formation-wedge — wedge/arrowhead slot generator for group destinations - `wedgeFormation` (function) · `import { wedgeFormation } from "@jgengine/core/world"` ## forward-axis — declared front convention for parametric assets — auto-orient product shots - `DEFAULT_FORWARD` (const) · `import { DEFAULT_FORWARD } from "@jgengine/core/world"` ## free-flight — camera-relative creative/spectator/noclip/hover flight with correct strafe, sprint, and optional gravity - `createFreeFlightController` (function) · `import { createFreeFlightController } from "@jgengine/core/world"` ## gamepad-input — Resolve sampled gamepad input into actions with deadzones and response curves. - `resolveGamepadFrame` (function) · `import { resolveGamepadFrame } from "@jgengine/core/input/gamepadModel"` ## glide — gliding/wingsuit descent control from a launch - `createGlideModel` (function) · `import { createGlideModel } from "@jgengine/core/world"` ## grapple-swing — grappling-hook rope swing physics with reel-in - `createGrappleSwing` (function) · `import { createGrappleSwing } from "@jgengine/core/world"` ## gravity-field — sample configurable uniform, radial, or combined gravity - `combineGravity` (function) · `import { combineGravity } from "@jgengine/core/world"` - `pointGravity` (function) · `import { pointGravity } from "@jgengine/core/world"` - `uniformGravity` (function) · `import { uniformGravity } from "@jgengine/core/world"` ## grounded — ground an XZ point onto the world surface as a pose triple - `grounded` (function) · `import { grounded } from "@jgengine/core/world"` ## handling-metrics — measure a vehicle's feel as numbers — 0–100, braking, lateral g, turn-in, sideslip, spin - `measureHandling` (function) · `import { measureHandling } from "@jgengine/core/physics/handlingProbe"` ## haptics — Continuous gamepad rumble from named channels (engine, road, impact) mixed by priority, plus fading pulses. - `createHapticChannels` (function) · `import { createHapticChannels } from "@jgengine/core/input/haptics"` ## hold-order — stand-ground order that holds position until preempted or canceled - `defineHoldOrder` (function) · `import { defineHoldOrder } from "@jgengine/core/world"` ## input-buffer — buffer early presses, coyote time, hold duration and double tap for responsive controls - `createInputBuffer` (function) · `import { createInputBuffer } from "@jgengine/core/input/inputBuffer"` ## interaction-prompt — observable nearest-interactable prompt registry over the proximity-prompt resolver — register/resolve/active with priority+range and change-notified snapshot/restore - `createPromptRegistry` (function) · `import { createPromptRegistry } from "@jgengine/core/world"` ## interest-census — running active/dormant gate tally folded into the caller's tick loop - `createInterestCensus` (function) · `import { createInterestCensus } from "@jgengine/core/world"` ## interest-gate — per-agent sleep/wake + cadence gate state so far agents skip expensive ticks - `createInterestGateState` (function) · `import { createInterestGateState } from "@jgengine/core/world"` ## interest-scheduler — advance a sleep/wake gate with hysteresis, cadence tiers, and stagger - `advanceInterestGate` (function) · `import { advanceInterestGate } from "@jgengine/core/world"` ## interest-stagger — deterministic per-id cadence phase that spreads sibling gate ticks across frames - `interestPhase` (function) · `import { interestPhase } from "@jgengine/core/world"` ## key-rebinding — conflict-aware key-remap session over the action-binding model — capture/reassign, conflict detection, reset-to-defaults, persist overrides, snapshot/restore - `createRebindSession` (function) · `import { createRebindSession } from "@jgengine/core/input/rebindSession"` ## kinematic-vehicle — arcade car/kart driving physics with throttle, brake, steer and retunable handling - `createKinematicVehicle` (function) · `import { createKinematicVehicle } from "@jgengine/core/world"` ## lane-graph — directed lane topology with junctions, signals and parking for vehicle traffic - `createLaneGraph` (function) · `import { createLaneGraph } from "@jgengine/core/world"` ## lane-graph-from-scene — read an authored lane graph, signals and parking out of the scene document - `laneGraphFromDocument` (function) · `import { laneGraphFromDocument } from "@jgengine/core/world"` ## lean-metrics — measure a motorcycle's lean — steady lean, time to lean, countersteer tip-in - `measureLean` (function) · `import { measureLean } from "@jgengine/core/physics/handlingProbe"` ## leave-vehicle — leave a rideable beside its current pose and restore on-foot camera/movement - `leaveVehicle` (function) · `import { leaveVehicle } from "@jgengine/core/world"` ## limb-health — per-body-part/region health tracked separately - `createMultiRegionHealth` (function) · `import { createMultiRegionHealth } from "@jgengine/core/procedural"` ## local-avoidance — bounded deterministic local collision avoidance for moving agents - `resolveLocalAvoidance` (function) · `import { resolveLocalAvoidance } from "@jgengine/core/world"` ## localized-forces — sample signed attraction, directional force, vortex spin and axial lift with target masks and caps - `sampleForceField` (function) · `import { sampleForceField } from "@jgengine/core/physics/forceVolume"` ## lockpick — a solvable grid depth-puzzle with fog-of-war, gates, and hidden traps - `generateLock` (function) · `import { generateLock } from "@jgengine/core/world"` ## locomotion-graph — resolve the animation graph a model config plays - `animGraphFromConfig` (function) · `import { animGraphFromConfig } from "@jgengine/core/anim/locomotionGraph"` - `locomotionGraph` (function) · `import { locomotionGraph } from "@jgengine/core/anim/locomotionGraph"` ## map-annotations — player-drawn map annotation layer — freehand strokes, area shapes, and pinned notes, projected into the map's routes/zones props and serializable - `createAnnotationLayer` (function) · `import { createAnnotationLayer } from "@jgengine/core/world"` ## material-appearance-signals — adapt selected surface response to sampled wetness and local card exposure - `resolveMaterialAppearance` (function) · `import { resolveMaterialAppearance } from "@jgengine/core/material/appearanceSignals"` - `sampleMaterialAppearance` (function) · `import { sampleMaterialAppearance } from "@jgengine/core/material/appearanceSignals"` ## merge-footprint-regions — pool adjacent compatible footprints with serializable capacity provenance - `mergeFootprints` (function) · `import { mergeFootprints } from "@jgengine/core/world"` ## mergeable-footprint-regions — check compatible adjacent regions within caller work budgets - `canMerge` (function) · `import { canMerge } from "@jgengine/core/world"` ## mesh-hitboxes — shots pass through holes in concave models — opted-in catalog assets raycast their actual triangles instead of the fitted box. - `ColliderShape` (type) · `import { ColliderShape } from "@jgengine/core/scene/colliders"` ## mesh-movement — the walking player slides against a mesh collider's compound `boxes` — a capsule walks THROUGH an opted-in archway opening and is stopped by its pillars/lintel instead of one outer box. - `ColliderShape` (type) · `import { ColliderShape } from "@jgengine/core/scene/colliders"` ## minimap-bake — rasterize authored terrain + zones into a top-down minimap image - `bakeMinimapImage` (function) · `import { bakeMinimapImage } from "@jgengine/core/world"` - `minimapBakeToPngDataUri` (function) · `import { minimapBakeToPngDataUri } from "@jgengine/core/world"` ## minimap-track — project a world point to a 0..1 fraction along a linear track axis - `trackFraction` (function) · `import { trackFraction } from "@jgengine/core/world/minimapTrack"` ## model-sockets — named attachment points read from a model - `ModelNode` (interface) · `import { ModelNode } from "@jgengine/core/world"` ## move-order — go-to-point order that completes on arrival, composed over a motion adapter - `defineMoveOrder` (function) · `import { defineMoveOrder } from "@jgengine/core/world"` ## movement-metrics — measure a walking character's feel as numbers — time to top speed, stop distance, jump height and apex, air control, turn-around - `measureMovement` (function) · `import { measureMovement } from "@jgengine/core/movement/movementProbe"` ## movement-telemetry — read physical grounded, vertical velocity and crouch state without animation-store writes - `playerMovementTelemetry` (function) · `import { playerMovementTelemetry } from "@jgengine/core/movement/playerMovement"` ## moving-box-sweep — detect contact with boxes crossing a projectile segment between simulation poses - `sweepMovingBounds` (function) · `import { sweepMovingBounds } from "@jgengine/core/physics/ballisticSweep"` ## moving-sphere-sweep — detect contact with spheres crossing a projectile segment between simulation poses - `sweepMovingSphere` (function) · `import { sweepMovingSphere } from "@jgengine/core/physics/ballisticSweep"` ## nav-crowd — move many agents across an editor-baked nav mesh with avoidance - `createNavCrowd` (function) · `import { createNavCrowd } from "@jgengine/core/world"` ## nav-from-solids — block world solids on a nav grid - `populateNavGridFromSolids` (function) · `import { populateNavGridFromSolids } from "@jgengine/core/nav/navFromEnvironment"` ## nav-runtime — route agents on an editor-baked nav mesh with authored links and re-bakes that keep polygon identity - `createNavRuntime` (function) · `import { createNavRuntime } from "@jgengine/core/world"` ## navmesh-bake — voxelize scene triangles into an agent-sized polygon nav mesh - `bakeNavMesh` (function) · `import { bakeNavMesh } from "@jgengine/navbake"` ## navmesh-from-scene — read the editor's baked nav mesh off a scene document - `navMeshFromBake` (function) · `import { navMeshFromBake } from "@jgengine/core/world"` ## navmesh-query — route, snap, and raycast on a polygon navmesh with retunable area costs and a bounded search - `createNavMeshQuery` (function) · `import { createNavMeshQuery } from "@jgengine/core/world"` ## object-slot-inventory — placed objects hold validated per-instance container contents that replicate and save with the placement - `SceneObjectSlots` (interface) · `import { SceneObjectSlots } from "@jgengine/core/world"` ## order-queue — serializable per-entity command queue with lifecycle, preemption, and pluggable order kinds - `createOrderQueue` (function) · `import { createOrderQueue } from "@jgengine/core/world"` ## order-registry — register order verbs (move/attack/custom) as data so engine code never branches on a verb - `createOrderRegistry` (function) · `import { createOrderRegistry } from "@jgengine/core/world"` ## particle-binding-validation — validate named particle follow spaces, render outputs, environment influence, and bounded collision child effects - `validateParticleAttachOptions` (function) · `import { validateParticleAttachOptions } from "@jgengine/core/vfx/particleDirector"` ## particle-director — named particle start/stop/burst/retune lifecycle, local/world following, render outputs, bounded cosmetic event exchange, and serializable emitter definitions - `createParticleDirector` (function) · `import { createParticleDirector } from "@jgengine/core/vfx/particleDirector"` ## particle-emitter-validation — validate finite spawn volumes, force fields, lifetimes, appearance curves, and bounded particle collision policies - `validateEmitterConfig` (function) · `import { validateEmitterConfig } from "@jgengine/core/vfx/particles"` ## particle-system — deterministic pooled particle emitter with spawn volumes, force fields, bounded collision/death events, live tuning, SoA render buffers, and serializable state - `createParticleSystem` (function) · `import { createParticleSystem } from "@jgengine/core/world"` ## path-follow-progress — read normalized/distance/segment progress from follow state - `pathFollowProgress` (function) · `import { pathFollowProgress } from "@jgengine/core/world"` ## path-follow-seek — jump a path-follower to normalized/distance/segment progress - `pathFollowSeek` (function) · `import { pathFollowSeek } from "@jgengine/core/world"` ## path-length — total polyline distance for progress math and seeding - `pathLength` (function) · `import { pathLength } from "@jgengine/core/world"` ## path-terrain — apply flatten/grade/carve/retaining path profiles to a terrain field - `applyPathProfiles` (function) · `import { applyPathProfiles } from "@jgengine/core/world"` - `withPathProfiles` (function) · `import { withPathProfiles } from "@jgengine/core/world"` ## patrol-order — waypoint-route order that cycles a path, looping or completing at the end - `definePatrolOrder` (function) · `import { definePatrolOrder } from "@jgengine/core/world"` ## perception-service — retain sightings, sounds and damage with cone, range, occlusion, decaying memory and shared squad knowledge - `createPerception` (function) · `import { createPerception } from "@jgengine/core/world"` ## physics-backend — one interface over interchangeable rigid-body solvers — bodies, joints, raycast, shapecast, snapshot - `PhysicsBackend` (interface) · `import { PhysicsBackend } from "@jgengine/core/physics/physicsBackend"` ## physics-backend-conformance — the shared test contract a physics adapter runs to prove it matches the seam - `runPhysicsBackendConformance` (function) · `import { runPhysicsBackendConformance } from "@jgengine/core/physics/physicsBackendConformance"` ## physics-world-backend — the zero-dependency PhysicsWorld solver exposed through the PhysicsBackend seam - `createPhysicsWorldBackend` (function) · `import { createPhysicsWorldBackend } from "@jgengine/core/physics/physicsWorldBackend"` ## piece-sockets-from-model — derive build-piece snap sockets from a model's named attach points - `pieceSocketsFromModel` (function) · `import { pieceSocketsFromModel } from "@jgengine/core/world/buildSockets"` ## place-asset — resolve a placement commit into a shared asset placement payload - `PlaceAssetResult` (interface) · `import { PlaceAssetResult } from "@jgengine/core/world"` - `placeAssetFromCommit` (function) · `import { placeAssetFromCommit } from "@jgengine/core/world"` - `resolvePlaceAsset` (function) · `import { resolvePlaceAsset } from "@jgengine/core/world"` ## placement-controller — interactive build-mode ghost preview and commit - `createPlacementController` (function) · `import { createPlacementController } from "@jgengine/core/world"` ## placement-math — grid/surface footprint validity for build mode - `validatePlacement` (function) · `import { validatePlacement } from "@jgengine/core/world"` ## placement-rotation — apply a rotation policy to a candidate placement heading - `applyRotationPolicy` (function) · `import { applyRotationPolicy } from "@jgengine/core/world"` - `parseRotationPolicy` (function) · `import { parseRotationPolicy } from "@jgengine/core/world"` - `snapHeading` (function) · `import { snapHeading } from "@jgengine/core/world"` ## plan-particle-budget — cap live particles to a graphics tier and drop whole effects lowest-priority-first when over budget - `planParticleBudget` (function) · `import { planParticleBudget } from "@jgengine/core/vfx/particleBudget"` ## pole-line — editor-authorable poles + sagging cables along a path - `POLE_LINE_KIND` (const) · `import { POLE_LINE_KIND } from "@jgengine/core/world/poleLineKind"` ## police-response — witness-gated heat, tiered police response, last-sighting search areas and lane-graph roadblocks - `createPoliceResponse` (function) · `import { createPoliceResponse } from "@jgengine/core/world"` ## police-roads — lane-graph roadblock sites and an indexed nearby-lane query for search areas - `policeRoadsFromLaneGraph` (function) · `import { policeRoadsFromLaneGraph } from "@jgengine/core/world"` ## population-director — ambient per-region creature population manager with timed weighted respawns and caps - `createPopulationDirector` (function) · `import { createPopulationDirector } from "@jgengine/core/ai/populationDirector"` ## portable-marker-source — project caller-owned arrays or subscribable stores into cached minimap marker snapshots without a MarkerSet - `createMarkerSource` (function) · `import { createMarkerSource } from "@jgengine/core/world"` ## proximity-prompt — a "press E" contextual prompt shown near an interactable - `resolveActivePrompt` (function) · `import { resolveActivePrompt } from "@jgengine/core/world"` ## pursue-behavior — scheduled pursuit with bounded target acquisition and saved cooldown/leash state - `pursue` (function) · `import { pursue } from "@jgengine/core/world"` ## pursuit — enemy/mob aggro chase-to-reach with a cooldown-gated attack and optional leash-to-home; owns the attack cooldown - `advancePursuit` (function) · `import { advancePursuit } from "@jgengine/core/ai/pursuit"` ## qte — a quick-time-event timed input sequence with hit windows - `evaluateQteSequence` (function) · `import { evaluateQteSequence } from "@jgengine/core/world"` ## rapier-physics-backend — native capsules, shapecasts, rotation, CCD, joints, and collision queries - `createRapierBackend` (function) · `import { createRapierBackend } from "@jgengine/rapier"` ## rate-window-policy — Evaluate deterministic request windows with retry timing. - `decideRateWindow` (function) · `import { decideRateWindow } from "@jgengine/core/time/rateWindow"` ## reputation — faction standing that crosses named reputation tiers - `tierForStanding` (function) · `import { tierForStanding } from "@jgengine/core/world"` ## resource-node — depletable, respawning harvest nodes with tool-dependent yields - `createResourceNodeField` (function) · `import { createResourceNodeField } from "@jgengine/core/world/resourceNode"` ## ride-metrics — measure a sprung vehicle's ride — settle time, dive, roll per g, landing bounce - `measureRide` (function) · `import { measureRide } from "@jgengine/core/physics/handlingProbe"` ## rigid-aircraft — force-and-torque aircraft — lifting surfaces with stall and drag polar, control surfaces, inertia, loops and rolls - `createRigidAircraft` (function) · `import { createRigidAircraft } from "@jgengine/core/physics/aircraftDynamics"` ## rts-control-groups — map Ctrl+digit / digit / double-tap presses onto selection-bookmark bind / recall / focus intents - `controlGroupKey` (function) · `import { controlGroupKey } from "@jgengine/core/world"` - `resolveControlGroupIntent` (function) · `import { resolveControlGroupIntent } from "@jgengine/core/world"` ## rvo-avoidance — reciprocal collision avoidance between many steering agents - `createRvoCrowd` (function) · `import { createRvoCrowd } from "@jgengine/core/world"` ## scatter-coverage — shared density/budget semantics for scatterable kinds - `ScatterCoverageKind` (type) · `import { ScatterCoverageKind } from "@jgengine/core/world"` ## screen-effects — serializable, pooled screen-feedback controller — transient flash/vignette and sustained low-health-style pulses with eased opacities, free-string kinds the game styles, and snapshot/restore - `createScreenEffects` (function) · `import { createScreenEffects } from "@jgengine/core/world"` ## selection-bookmark-recall — fold a saved set into the active selection with stale-ref pruning and a caller focus hook - `recallSelectionBookmark` (function) · `import { recallSelectionBookmark } from "@jgengine/core/world"` ## selection-bookmarks — keyed saved-set store (RTS control groups, camera bookmarks, saved squads) with prune + serialize - `createSelectionBookmarks` (function) · `import { createSelectionBookmarks } from "@jgengine/core/world"` ## sequence-director — data-driven cutscene timeline — fire typed camera/dialogue/event cues on one injected clock with play/pause/seek/skip and snapshot/restore - `createSequenceDirector` (function) · `import { createSequenceDirector } from "@jgengine/core/world"` ## shared-annotations — broadcast local map-drawing edits over the party feed and mirror inbound edits — collaborative annotations over any replicated feed - `createSharedAnnotations` (function) · `import { createSharedAnnotations } from "@jgengine/core/world"` ## skeleton-standard — map a rig on the standard scheme onto the standard's slots - `KAYKIT_SCHEME` (const) · `import { KAYKIT_SCHEME } from "@jgengine/core/anim/skeletonStandard"` - `SKELETON_STANDARD` (const) · `import { SKELETON_STANDARD } from "@jgengine/core/anim/skeletonStandard"` - `mapRigToStandard` (function) · `import { mapRigToStandard } from "@jgengine/core/anim/skeletonStandard"` - `retargetBoneScales` (function) · `import { retargetBoneScales } from "@jgengine/core/anim/skeletonStandard"` - `retargetTracks` (function) · `import { retargetTracks } from "@jgengine/core/anim/skeletonStandard"` - `runtimeBoneName` (function) · `import { runtimeBoneName } from "@jgengine/core/anim/skeletonStandard"` - `standardBoneMask` (function) · `import { standardBoneMask } from "@jgengine/core/anim/skeletonStandard"` ## skill-check — a timing-bar skill check where you release inside a zone - `skillCheckZoneAt` (function) · `import { skillCheckZoneAt } from "@jgengine/core/world"` ## soil-patch — editor-authorable terrain crack/moss material variation - `SOIL_KIND` (const) · `import { SOIL_KIND } from "@jgengine/core/world"` ## solid-obstacles — the one blocking-geometry query the player resolver and NPC movers share - `obstacleFromSolid` (function) · `import { obstacleFromSolid } from "@jgengine/core/movement/solidObstacles"` - `solidObstaclesNear` (function) · `import { solidObstaclesNear } from "@jgengine/core/movement/solidObstacles"` ## solid-route — bounded local planning over indexed collision geometry - `planSolidRoute` (function) · `import { planSolidRoute } from "@jgengine/core/nav/solidRoute"` ## sound-hunting — send a bounded set of nearby enemies to investigate a noise with decaying memory - `createSoundHunt` (function) · `import { createSoundHunt } from "@jgengine/core/ai/director/sound"` ## spatial-incremental — Update one entity's spatial cell after a committed write without scanning the population - `createSpatialApi` (function) · `import { createSpatialApi } from "@jgengine/core/scene/spatial"` ## spatial-region-box — sample uniformly within an axis-aligned 3D box - `boxRegion` (function) · `import { boxRegion } from "@jgengine/core/world"` ## spatial-region-custom — wrap a caller-defined sampler and bounds test as a region - `customRegion` (function) · `import { customRegion } from "@jgengine/core/world"` ## spatial-region-point-set — sample from a fixed, optionally weighted candidate point table - `pointSetRegion` (function) · `import { pointSetRegion } from "@jgengine/core/world"` ## spatial-region-polygon — sample within an arbitrary closed polygon on the XZ plane - `polygonRegion` (function) · `import { polygonRegion } from "@jgengine/core/world"` ## spatial-region-shell — sample within a 3D spherical shell, volume- or radius-uniform - `shellRegion` (function) · `import { shellRegion } from "@jgengine/core/world"` ## spatial-region-sphere — sample within a filled 3D ball, volume- or radius-uniform - `sphereRegion` (function) · `import { sphereRegion } from "@jgengine/core/world"` ## spatial-region-weighted — compose sub-regions behind a weighted selection policy - `weightedRegion` (function) · `import { weightedRegion } from "@jgengine/core/world"` ## spatial-sample — draw one deterministic position from a region under include/exclude/distance constraints - `samplePoint` (function) · `import { samplePoint } from "@jgengine/core/world"` ## spatial-sample-batch — place many deterministic spaced points from a region with minimum separation - `sampleBatch` (function) · `import { sampleBatch } from "@jgengine/core/world"` ## spatial-sample-stratified — evenly cover an area with one jittered point per grid cell, deterministic - `sampleStratified` (function) · `import { sampleStratified } from "@jgengine/core/world"` ## split-footprint-regions — split pooled regions along retained contributions without area-based capacity loss - `splitRegion` (function) · `import { splitRegion } from "@jgengine/core/world"` ## stop-order — halt-and-complete order that brings a unit to an immediate standstill - `defineStopOrder` (function) · `import { defineStopOrder } from "@jgengine/core/world"` ## street-generator — build a deterministic street/track graph (nodes, edges, streets, junctions, sidewalks, bridges, tunnels) from sliders - `generateStreets` (function) · `import { generateStreets } from "@jgengine/core/world/streetGenerator"` ## surface-drape — lift an XZ polyline onto sculpted terrain - `drapePolyline` (function) · `import { drapePolyline } from "@jgengine/core/world"` ## surface-grid — terrain-following reference grid that is not occluded by relief - `surfaceGridLines` (function) · `import { surfaceGridLines } from "@jgengine/core/world"` ## surface-ring — surface-following placement guide ring - `surfaceRing` (function) · `import { surfaceRing } from "@jgengine/core/world"` ## sync-authored-objects — synchronize edited catalog prop poses, elevation and removal through the existing object store - `syncAuthoredObjects` (function) · `import { syncAuthoredObjects } from "@jgengine/core/world/authoredObjects"` ## tactical-cover-points — derive cover candidates from navigation-mesh boundaries - `coverPoints` (function) · `import { coverPoints } from "@jgengine/core/ai/tacticalQueries"` ## tactical-position-score — rank bounded tactical positions with caller-defined weights - `scorePositions` (function) · `import { scorePositions } from "@jgengine/core/ai/tacticalQueries"` ## target-acquirer — stateful held-target wrapper over an acquisition policy with retention - `createTargetAcquirer` (function) · `import { createTargetAcquirer } from "@jgengine/core/world"` ## target-acquisition — composable candidate/eligibility/range/perception/score/tie-break/retention target pick - `acquireTarget` (function) · `import { acquireTarget } from "@jgengine/core/world"` ## targeted-order — pursue-a-target order with leash/standoff that ends when the target is gone - `defineTargetedOrder` (function) · `import { defineTargetedOrder } from "@jgengine/core/world"` ## terrain-contours — iso-elevation contour lines that drape on sculpted terrain - `extractContours` (function) · `import { extractContours } from "@jgengine/core/world"` ## terrain-guides — one-call adaptive contours for a terrain field - `terrainContourGuides` (function) · `import { terrainContourGuides } from "@jgengine/core/world"` ## terrain-raycast — pick a point on a heightfield along a camera/pointer ray - `raycastHeightField` (function) · `import { raycastHeightField } from "@jgengine/core/world/terrain"` ## territory-cell-chunk — Map ownership cells to persisted world chunks. - `territoryChunkKey` (function) · `import { territoryChunkKey } from "@jgengine/core/world/territory"` ## territory-footprint — Resolve exactly the ownership cells touched by a placement footprint. - `territoryFootprintCells` (function) · `import { territoryFootprintCells } from "@jgengine/core/world/territory"` ## territory-owner-query — Read a loaded land cell owner for authoritative placement checks. - `territoryOwnerOf` (function) · `import { territoryOwnerOf } from "@jgengine/core/world/territory"` ## territory-ownership — Claim, release and query land through host-owned snapshot storage. - `createTerritory` (function) · `import { createTerritory } from "@jgengine/core/world/territory"` ## territory-placement — Purchase footprint cells atomically with object placement. - `placeWithTerritory` (function) · `import { placeWithTerritory } from "@jgengine/core/world/territory"` ## territory-read-scope — Load the footprint and foreign-owner gap without scanning the world. - `territoryChunkKeys` (function) · `import { territoryChunkKeys } from "@jgengine/core/world/territory"` ## touch-controls — switch the on-screen touch control set when gameplay context changes (enter/exit vehicle, mount, build mode) - `setTouchControlsMode` (function) · `import { setTouchControlsMode } from "@jgengine/core/input/touchControlsMode"` - `touchButtonShape` (function) · `import { touchButtonShape } from "@jgengine/core/input/touchScheme"` ## traffic — lane-graph traffic with car following, signals, right-of-way, lane changes and parking - `createTraffic` (function) · `import { createTraffic } from "@jgengine/core/world"` ## ui-sound-cues — default procedural click/hover/open/close/confirm/deny/notify cues on a "ui" bus, overridable per game - `withUiCueSounds` (function) · `import { withUiCueSounds } from "@jgengine/core/audio/uiCues"` ## uphill-grade-step — constrain sampled heightfield ascent with axis sliding and a configurable terrain-policy sampler - `resolveTerrainGradeStep` (function) · `import { resolveTerrainGradeStep } from "@jgengine/core/movement/terrainGrade"` ## utility-brain — pick actions by decaying-need appeal with response curves, hysteresis and interrupts - `createUtilityBrain` (function) · `import { createUtilityBrain } from "@jgengine/core/world"` ## vehicle-backend-link — collide a vehicle sim with a physics backend — shove props, stop at walls, slide along them - `createVehicleBackendLink` (function) · `import { createVehicleBackendLink } from "@jgengine/core/physics/vehicleBackendLink"` ## vehicle-damage — fixed-zone crash damage that changes handling and shows a bounded dent, serializable - `createVehicleDamage` (function) · `import { createVehicleDamage } from "@jgengine/core/world"` ## vehicle-dynamics — force-based car handling — tires, load transfer, drivetrain, assists — tuned with physical numbers - `createVehicleDynamics` (function) · `import { createVehicleDynamics } from "@jgengine/core/physics/vehicleDynamics"` ## vehicle-parts — compose data-driven tuning parts (tires, engine, brakes) onto a vehicle tuning and read the resulting feel - `applyVehicleParts` (function) · `import { applyVehicleParts } from "@jgengine/core/world"` ## vehicle-seats — enter, exit and swap seats in a car or mount (GTA-style boarding) with driver and passenger slots - `createVehicleSeats` (function) · `import { createVehicleSeats } from "@jgengine/core/world"` ## visibility-field — per-viewer-group observed/remembered/hidden fog-of-war knowledge with terrain memory and authoritative entity disclosure - `createVisibilityField` (function) · `import { createVisibilityField } from "@jgengine/core/world"` ## volumetric-clouds — raymarched cloud layer sky option - `VolumetricCloudsConfig` (interface) · `import { VolumetricCloudsConfig } from "@jgengine/core/world"` ## walker-solid-step — slide an NPC's step against the geometry that blocks the player - `resolveWalkerStep` (function) · `import { resolveWalkerStep } from "@jgengine/core/movement/solidObstacles"` ## walker-solid-step-source — slide a step against solid geometry from a pure rules package - `resolveSourceWalkerStep` (function) · `import { resolveSourceWalkerStep } from "@jgengine/core/movement/solidObstacles"` ## wave-runner — observable serializable wave/spawn runner over the seeded spawn director — WAVE N, wave progress, budget/alert readout, onSpawn sink, snapshot/restore - `createWaveRunner` (function) · `import { createWaveRunner } from "@jgengine/core/world"` ## waypoint-store — serializable player waypoint layer — place/track/clear pins, mirror to a MarkerSet, and on-screen bearing/distance guidance for the tracked waypoint - `createWaypointStore` (function) · `import { createWaypointStore } from "@jgengine/core/world"` ## weather-environment-field — Connect authored precipitation and temperature changes to spatial environment queries. - `createWeatherEnvironmentField` (function) · `import { createWeatherEnvironmentField } from "@jgengine/core/world/authoredWeather"` ## weather-surface-accumulation — Persist and retune bounded surface wetness, snow, temperature and exposure independently of rendering. - `createWeatherExposure` (function) · `import { createWeatherExposure } from "@jgengine/core/world/authoredWeather"` ## world-environment — compose editor/preset-derived outdoor dressing — terrain, weather, water, structures — into a legacy environment feature - `environment` (function) · `import { environment } from "@jgengine/core/world"` ## world-intersections — connect sidewalks and lane guidance through generated intersections - `buildIntersectionMarkings` (function) · `import { buildIntersectionMarkings } from "@jgengine/core/world/roads"` - `buildJunctionConnector` (function) · `import { buildJunctionConnector } from "@jgengine/core/world/roads"` - `buildTrimmedIntersections` (function) · `import { buildTrimmedIntersections } from "@jgengine/core/world"` - `trimBandAtJunctions` (function) · `import { trimBandAtJunctions } from "@jgengine/core/world"` ## world-physics-colliders — Synchronize terrain and authored static colliders with a physics backend. - `syncWorldColliders` (function) · `import { syncWorldColliders } from "@jgengine/core/physics/worldColliders"` ## world-place — declare the place a game happens in — flat/round/voxel/board ground, surface laws, per-place physics - `world` (function) · `import { world } from "@jgengine/core/world"` ## world-seed — derive a deterministic generator/scatter seed from world id + save/run seed - `seedForPlace` (function) · `import { seedForPlace } from "@jgengine/core/world"` ## world-solid-bounds — world AABB and nav footprint of a world solid - `worldSolidBounds` (function) · `import { worldSolidBounds } from "@jgengine/core/world/worldSolids"` - `worldSolidFootprint` (function) · `import { worldSolidFootprint } from "@jgengine/core/world/worldSolids"` ## world-solids — collision for generated and authored world geometry (buildings, city lots, walls) - `createWorldSolids` (function) · `import { createWorldSolids } from "@jgengine/core/world/worldSolids"` ## world-solids-from-data — derive collision boxes from generated buildings and wall runs - `buildingSolids` (function) · `import { buildingSolids } from "@jgengine/core/world/worldSolids"` - `structureSolids` (function) · `import { structureSolids } from "@jgengine/core/world/worldSolids"` - `wallSolids` (function) · `import { wallSolids } from "@jgengine/core/world/worldSolids"`