lecodes-sdk 1.1.0 → 1.2.0

package/dist/types/gl/Light.d.ts

@@ -22,6 +22,9 @@ export type SunOptions = {
      *   3 - 2048 map, contact-hardening soft edges (PCSS: sharp where the caster touches, softer
      *       away; discrete-GPU territory, ~+60 % of a frame on an iGPU)
      * A lightmapped level already carries every static shadow, so 0 is a legitimate choice there.
+     * On a level with a baked light grid the variance / PCSS filters cannot be used (they need every
+     * receiver in the shadow map, and the baked statics are kept out of it): 3 renders as PCSS on the
+     * depth map - the same contact-hardening look - and 2 renders as 1.
      */
     shadowsQuality?: 0 | 1 | 2 | 3;
     /**

package/dist/types/gl/Particles.d.ts

@@ -184,6 +184,15 @@ export type ParticlesOptions = ParticlesMaterialOptions & {
      *  without this the engine picks who covers whom per frame (smoke popping over a fireball).
      *  Default 0; a fireball wants 2, its smoke 1, a smoke trail -1. */
     order?: number;
+    /** Sprites take the light of the PLACE each one is in — the level's baked light grid (`env.lightmap.volume`).
+     *  A sprite is unlit: its colour is the picture, which is right for fire and wrong for dust — a puff kicked up
+     *  under an awning glows as if it stood in the sun. With `lit` every particle's colour is multiplied by the light
+     *  where it is, relative to the level's OPEN ground: exactly the authored colour out in the sun, the ambient's
+     *  share of it (tinted the way the shade is) under a roof — per particle, so a trail of puffs laid from the sun
+     *  into the shade is lit along its length. Author the colour for the open; nothing else to tune. Without a grid
+     *  — a level with no bake, a host that has none — the colours are drawn as authored. Points, quads, stretch and
+     *  `Trail`; mesh particles are lit by their material. Default false. */
+    lit?: boolean;
     /** Coarse draw order among ALL blended draws, 0 (first) … 7 (last) — see `Mesh.renderPriority`.
      *  Default 5: meshes sit at 4 and decals at 3, so smoke covers a car's glass and its skid marks
      *  whatever the camera does (the engine's depth sort compares object centres, and an emitter's
@@ -234,6 +243,8 @@ export declare class Particles extends Node {
     /** Lay a frame's spawns along a curve through the emitter's path, not the straight chord. */
     set smooth(val: boolean);
     set order(val: number);
+    /** Colours × the baked light where each particle is — see `ParticlesOptions.lit`. */
+    set lit(val: boolean);
     /** Coarse draw order, 0 … 7 — see `Mesh.renderPriority`. Write-only. */
     set renderPriority(v: number);
     set velocityOverLife(v: VelocityOverLife);
@@ -279,6 +290,9 @@ export type TrailOptions = Omit<ParticlesMaterialOptions, "render" | "stretch">
      *  frame rate, since a longer frame bows further off its own chord. Default false; see
      *  `ParticlesOptions.smooth`. */
     smooth?: boolean;
+    /** The strip takes the baked light of the place each of its points is at — `ParticlesOptions.lit`. Smoke and
+     *  dust trails; leave it off for a glowing one. Default false. */
+    lit?: boolean;
     /** Which way the strip's WIDTH points.
      *
      *  `'camera'` (default) rolls the strip about its own length to stay flat to the viewer — it can
@@ -317,6 +331,7 @@ export declare class Trail extends Node {
     set minDistance(val: number);
     /** Follow a curve through the emitter's path instead of the straight chord between frames. */
     set smooth(val: boolean);
+    set lit(val: boolean);
     /** Which way the strip's width points — see `TrailOptions.orient`. Keeps the current `faceCamera`. */
     set orient(val: "camera" | "x" | "y" | "z");
     /** The hybrid's floor — see `TrailOptions.faceCamera`. */

package/dist/types/gl/animation/Locomotion.d.ts

@@ -6,8 +6,9 @@ import type { WarpOptions } from "./Warp";
 import type { Node } from "../Node";
 /** How fast the character wants to go: the gait picks its clips and its speed. */
 export type Gait = "walk" | "run" | "sprint";
-/** What the engine shows: the idle, a start, the gait loop, a turn while moving, a stop, or a turn on the spot. */
-export type LocomotionState = "idle" | "start" | "move" | "turn" | "stop" | "spin";
+/** What the engine shows: the idle, a start, the gait loop, a turn while moving, a stop, a turn on the spot —
+ *  an ACTION (`act()`): a one-shot that owns the body until it hands over — or the STRAFE blend (`move({ strafe })`). */
+export type LocomotionState = "idle" | "start" | "move" | "turn" | "stop" | "spin" | "action" | "strafe";
 /** Who moves the body:
  *  `'hybrid'` (the default) — the clip's own recorded motion moves it; while the gait loop shows it
  *    is ADJUSTED toward what the simulation wants by at most `tuning.adjust` metres a second, and a
@@ -42,6 +43,10 @@ export type LocomotionSet = {
     turns?: LocomotionClip[];
     /** turns on the spot — what a facing still owed by a standing body plays */
     spins?: LocomotionClip[];
+    /** the STRAFE set: the same gait recorded forward, backward, to either side and on the diagonals — the members of
+     *  the directional blend `move(dir, { face, strafe: true })` shows. `angle` = the way a take travels in the body's
+     *  frame (degrees, + = left); left out, the engine reads it off the take's root. */
+    strafes?: LocomotionClip[];
 };
 /** The tuning. Times are seconds, speeds m/s, angles degrees. */
 export type LocomotionTuning = {
@@ -199,6 +204,8 @@ export declare class Locomotion extends Aspect<"loco", Node, LocomotionEvents> {
     private _mag;
     private _gait;
     private _seq;
+    private _act;
+    private _strafe;
     private readonly _in;
     private readonly _out;
     private readonly _names;
@@ -225,11 +232,53 @@ export declare class Locomotion extends Aspect<"loco", Node, LocomotionEvents> {
     /** State the movement intent for this frame: a world direction (its length is the stick's pull,
      *  clamped to 1) and the gait. `null` = no movement — the body stops, but it keeps facing where it
      *  was last asked to, and turns there on the spot if it still owes the turn.
-     *  `face` states a facing of its own (aiming, strafing, a camera-relative shooter). */
+     *  `face` states a facing of its own (aiming, a camera-relative shooter) — and with `strafe: true` the body MOVES
+     *  where the direction points while it faces there: the loop becomes the directional blend of `set.strafes` (a
+     *  guard, a lock-on), the facing is steered standing too, state `'strafe'`. Stated every frame like the rest. */
     move(direction: Vec3Like | null | undefined, options?: {
         gait?: Gait;
         face?: Vec3Like;
+        strafe?: boolean;
     }): void;
+    /** Play an ACTION: a one-shot that OWNS the body the way a start or a stop does — a roll, a backstep, a lunging
+     *  attack. Its recording moves the body alone (in every displacement mode but `'data'`, where the host does),
+     *  the steering and the selector stand by, and when it hands over the usual rules carry on: a direction held
+     *  starts (or, still carrying speed, runs on), nothing held stands.
+     *
+     *  `direction` is where its TRAVEL must go, world (`Vec3`, or a heading in degrees, 0 = +Z, + = toward +X). A
+     *  clip travels some way relative to the body — forward, left, back; measured off its own root, or `angle`
+     *  (degrees, + = left) — and the body is turned by what is left between that and `direction`, over `turn`
+     *  seconds (default 0.12), so the travel lands exactly where it was pointed. Which clip to play is yours to
+     *  pick: the one whose travel is nearest the direction IN THE BODY'S FRAME (`direction − facing`) leaves the
+     *  least to turn. Left out = it plays where the body faces.
+     *
+     *  `at` enters the clip that many seconds in (a wind-up skipped), `rate` plays it faster or slower (its metres
+     *  stay, the time changes), `travel` takes only that share of its recorded travel (an attack aimed at a target:
+     *  0.3 to stop at the blade's length from one that is close, 1.3 to reach one a step too far — the pose is
+     *  untouched, so keep it to a fast step; `{ share, at, after }` takes another share from clip time `at` on: a
+     *  swing's take travels on after its cut, into a body that stands at the blade's length), `fade` is the transition into it and `out` the one out of it (default: the tuning's
+     *  `blend`; an action ends in ITS stance, not the idle's, and a longer way out is what hides that), and `exit` is the
+     *  clip time from which a MOVE intent may take over — the cancel window: along the way the body faces at once, a
+     *  heading that needs a turn as soon as the body has slowed to where a start can answer; with nothing asked for it plays out, to
+     *  its end (an action ends in its own recovery, at rest), and the body then STANDS THE WAY THE ACTION LEFT IT:
+     *  the facing intent that outlives a released key is not a demand after an action — no turn on the spot.
+     *  WHEN an action may be asked for (out of another one, out of a start) is the caller's rule: this cuts into
+     *  whatever shows. `state` reads `'action'` while it does. False = no such clip. */
+    act(clip: string, options?: {
+        direction?: Vec3Like | number;
+        angle?: number;
+        turn?: number;
+        at?: number;
+        exit?: number;
+        fade?: number;
+        out?: number;
+        rate?: number;
+        travel?: number | {
+            share: number;
+            at: number;
+            after: number;
+        };
+    }): boolean;
     /** Face this way without moving — the facing intent on its own (`Vec3`, or a heading in degrees,
      *  0 = +Z, + = toward +X). A standing body turns to it on the spot. */
     face(direction: Vec3Like | number): void;

package/dist/types/gl/terrain/Terrain.d.ts

@@ -176,6 +176,14 @@ export declare class Terrain {
     heightAt(x: number, z: number): number;
     /** The drawn triangle's normal at a local (x, z) (unit Vec3, +Y up). */
     normalAt(x: number, z: number): Vec3;
+    /** The LAYER WEIGHTS at a local (x, z) — what the splat shader blends there: the control map read bilinearly
+     *  between its samples and normalised to sum 1 (`[1, 0, 0, 0]` where the map is empty, as the shader has
+     *  it). Index = the layer's in `layers`. Outside the grid the edge answers. This is how a game asks WHAT the
+     *  ground is under a point — footprints in the sand and none on the cobble, a footstep sound per layer, dust
+     *  by surface — and the blend is already in the numbers, so a transition is a fade and not a line. */
+    weightsAt(x: number, z: number): [number, number, number, number];
+    /** The heaviest layer's index at a local (x, z) — `weightsAt` when only "which one" is asked. */
+    layerAt(x: number, z: number): number;
     /** The smooth (vertex) normal at integer sample (ix, iz). */
     sampleNormal(ix: number, iz: number): Vec3;
     /** Extent in local metres: `[width, depth]`. */

package/dist/types/runtime/input.d.ts

@@ -82,6 +82,13 @@ export interface GamepadState {
     axis(name: GamepadAxisName, deadzone?: number): number;
     /** Held? Same as `Input.key(code, index)`. */
     button(code: string): boolean;
+    /** Rumble: `strong` = the heavy low-frequency motor, `weak` = the light high-frequency one, both
+     *  0..1, for `durationMs` (default 200, hosts cap at 5000). A new call replaces the running
+     *  effect. The host stops the motors by itself — after the duration, on focus loss and when the
+     *  project is swapped — so there is nothing to clean up. False when the pad or host has no motors. */
+    rumble(strong: number, weak?: number, durationMs?: number): boolean;
+    /** Stop the running rumble now. */
+    stopRumble(): void;
 }
 export declare const Input: {
     /**