@falloutmp/types 0.1.0 → 0.2.1

package/generated/client-api.d.ts

@@ -1,10 +1,130 @@
-import type { Entity, EventHandler, KeyHandler, MessageHandler, MessageReply, Quaternion, Unsubscribe, Vector3, WebEventHandler } from "../shared.js";
+import type { Entity, EventHandler, KeyHandler, MessageHandler, MessageReply, Unsubscribe, WebEventHandler } from "../shared.js";
 
 declare global {
   /**
    * Native events dispatched through `Events.on`. Each property is the exact callback argument tuple for that event.
    */
   interface EventMap {
+    /**
+     * Dispatched when a game menu opens, by its registered name, such as "PipboyMenu" or "ContainerMenu".
+     */
+    menuOpen: [name: string];
+
+    /**
+     * Dispatched when a game menu closes, by its registered name.
+     */
+    menuClose: [name: string];
+
+    /**
+     * Dispatched once when the local player goes down. The server decides when they come back.
+     */
+    localPlayerDeath: [];
+
+    /**
+     * Dispatched once when the local player is back up after a death.
+     */
+    localPlayerRespawn: [];
+
+    /**
+     * Dispatched when the local player moves into another worldspace or interior cell.
+     */
+    spaceChange: [space: PlayerSpace, previous: PlayerSpace];
+
+    /**
+     * Dispatched once when the local player gets into a power armor frame (`entered`) and once when they get out.
+     */
+    powerArmorChange: [entered: boolean];
+
+    /**
+     * Dispatched when the weapon in the local player's hands changes, its mods or ammo included; null for empty hands.
+     */
+    weaponChange: [weapon: PlayerWeapon | null];
+
+    /**
+     * Dispatched when what the local player wears changes; `outfit` is all of it.
+     */
+    outfitChange: [outfit: OutfitPiece[]];
+
+    /**
+     * Dispatched each time the local player fires: the TESObjectWEAP form ID and the ammo it took, 0 for none.
+     */
+    weaponFire: [weapon: number, ammo: number];
+
+    /**
+     * Dispatched when the local player starts a reload. `event` is the animation event their game played.
+     */
+    weaponReload: [event: string];
+
+    /**
+     * Dispatched when the local player's game awards XP, already scaled by the game.
+     */
+    xpGain: [amount: number];
+
+    /**
+     * Dispatched when the local player's level changes, from a level-up or the server's record.
+     */
+    levelChange: [level: number, previous: number];
+
+    /**
+     * Dispatched when the local player's game adds a perk rank (the chart, a magazine, a quest) or takes one away. `perk` is the rank's BGSPerk form ID.
+     */
+    perkChange: [perk: number, added: boolean];
+
+    /**
+     * Dispatched when the local player's game moves the base of a SPECIAL value: a bobblehead, the SPECIAL menu. `value` is the ActorValueInfo form ID.
+     */
+    valueChange: [value: number, base: number];
+
+    /**
+     * Dispatched in the frame after items moved into or out of the local player's inventory, with every count that moved.
+     */
+    inventoryChange: [changes: InventoryDelta[]];
+
+    /**
+     * Dispatched when the local player opens or closes a door the session shares, as the server is told. `ref` is the placed reference's form ID.
+     */
+    doorChange: [ref: number, open: boolean];
+
+    /**
+     * Dispatched when the local player picks, unlocks or locks a lock the session shares.
+     */
+    lockChange: [ref: number, locked: boolean];
+
+    /**
+     * Dispatched when the local player opens a container's menu and asks the server for it. The server may still refuse it, while another player holds it.
+     */
+    containerOpen: [ref: number];
+
+    /**
+     * Dispatched when the local player closes a container they had open, as its contents go to the server.
+     */
+    containerClose: [ref: number];
+
+    /**
+     * Dispatched when the local player drops items into the world: the base object and how many.
+     */
+    itemDrop: [form: number, count: number];
+
+    /**
+     * Dispatched when the server grants the local player a loose item they picked up: the base object and how many.
+     */
+    itemPickUp: [form: number, count: number];
+
+    /**
+     * Dispatched when the local player builds an object in workshop mode, as the server is asked for it: the base object, the workbench reference and where it stands.
+     */
+    workshopPlace: [form: number, workbench: number, position: { x: number; y: number; z: number }];
+
+    /**
+     * Dispatched when the local player puts a built object down somewhere else.
+     */
+    workshopMove: [form: number, position: { x: number; y: number; z: number }];
+
+    /**
+     * Dispatched when the local player scraps or stores a built object the session shares.
+     */
+    workshopRemove: [form: number];
+
     /**
      * Dispatched after a resource entry point has run and immediately before the resource becomes running.
      */
@@ -249,6 +369,512 @@ declare global {
     setRotation(pitch: number, yaw: number): boolean;
   };
 
+  /**
+   * Objects only the local player sees: the server and the other players never learn of them. Each stays in the cell or worldspace the local player was in when it was created, and shows again on coming back there. The resource that created one owns it: it is removed once that resource stops, and every one on disconnect.
+   */
+  const LocalObjects: {
+    /**
+     * Places an object in the local player's cell or worldspace; it appears over the next frames. The object's ID, or 0 when the form is unknown or not scenery, or 512 objects already exist.
+     * @param form The form ID of scenery: a static, movable static, static collection, tree or light. Nothing that can be taken, looted or activated. Editor IDs are not accepted: the game drops them for these types once loaded.
+     * @param placement World units, and radians about the X, Y and Z axes; yaw 0 faces +Y, clockwise.
+     * @param onLoad Called each time the object's 3D is loaded, the first time included. Not called once this resource stops.
+     */
+    create(form: number | string, placement: { x: number; y: number; z: number; pitch?: number; roll?: number; yaw?: number }, onLoad?: (id: number) => void): number;
+
+    /**
+     * Moves an object within its cell or worldspace. False when there is no such object.
+     * @param id From create.
+     * @param x World units.
+     * @param y World units.
+     * @param z World units.
+     */
+    setPosition(id: number, x: number, y: number, z: number): boolean;
+
+    /**
+     * Turns an object. False when there is no such object.
+     * @param id From create.
+     * @param pitch Radians about X.
+     * @param roll Radians about Y.
+     * @param yaw Radians about Z.
+     */
+    setRotation(id: number, pitch: number, roll: number, yaw: number): boolean;
+
+    /**
+     * Removes an object. False when there is no such object.
+     * @param id From create.
+     */
+    remove(id: number): boolean;
+
+    /**
+     * Where an object stands and how it is turned, as it was last placed or moved: world units and radians. Null when there is no such object.
+     * @param id From create.
+     */
+    getPose(id: number): { x: number; y: number; z: number; pitch: number; roll: number; yaw: number } | null;
+
+    /**
+     * Whether the object still exists: not removed, not refused by the game, and its resource still running.
+     * @param id From create.
+     */
+    exists(id: number): boolean;
+  };
+
+  /**
+   * The camera the world renders through, as of the last frame, whichever state holds it: first or third person, the fly camera, a scripted one.
+   */
+  const Camera: {
+    /**
+     * Where the camera is, in world units; null before the world is built.
+     */
+    getPosition(): { x: number; y: number; z: number } | null;
+
+    /**
+     * Where the camera looks: pitch in radians, positive down; yaw in radians in [0, 2pi), 0 facing +Y, clockwise. Null before the world is built.
+     */
+    getRotation(): { pitch: number; yaw: number } | null;
+
+    /**
+     * The field of view the world renders with, in degrees, across and up the screen. Null before the world is built.
+     */
+    getFov(): { horizontal: number; vertical: number } | null;
+
+    /**
+     * The game's back buffer, in pixels: the space worldToScreen answers in.
+     */
+    getScreenSize(): { width: number; height: number };
+
+    /**
+     * Projects a world point through last frame's camera into back-buffer pixels, origin top left (see getScreenSize; scale by the web view's size over it). onScreen is false for a point in front of the camera but outside the view. Null for a point behind the camera, or before the world is built.
+     * @param x World units.
+     * @param y World units.
+     * @param z World units.
+     */
+    worldToScreen(x: number, y: number, z: number): { x: number; y: number; onScreen: boolean } | null;
+  };
+
+  /**
+   * Markers on the local player's HUD compass and Pip-Boy map, drawn by the game's own widgets. Only this client sees them; they go when the resource that made them stops.
+   */
+  const Markers: {
+    /**
+     * Adds a marker and returns its ID, or 0 while the local player is in no cell. The compass shows it once placed, a frame or so later; the map from its next refresh, which every Pip-Boy value change brings.
+     * @param options Where, in world units of the worldspace or interior the local player is in now; the marker shows only while the player is there. label: the map's tooltip. compass and map: where it shows, both by default. kind: the icon, "quest" by default; "custom" is the player's own map marker, "powerArmor" the power armor one.
+     */
+    create(options: { x: number; y: number; z: number; label?: string; compass?: boolean; map?: boolean; kind?: "quest" | "custom" | "powerArmor" }): number;
+
+    /**
+     * Moves a marker. False for an unknown ID.
+     * @param id The marker's ID.
+     * @param x World units.
+     * @param y World units.
+     * @param z World units.
+     */
+    setPosition(id: number, x: number, y: number, z: number): boolean;
+
+    /**
+     * Removes a marker. False for an unknown ID.
+     * @param id The marker's ID.
+     */
+    remove(id: number): boolean;
+
+    /**
+     * Removes every marker this resource made.
+     */
+    clear(): void;
+  };
+
+  /**
+   * Game sounds only the local player hears, played through the game's audio as Sound.Play does. A resource's sounds stop when it stops.
+   */
+  const Sound: {
+    /**
+     * Plays a sound for this client alone. The instance ID, or 0 when nothing played: no such sound, 64 already playing, or the game refused it.
+     * @param sound A sound descriptor (SNDR), or a sound marker (SOUN) for its descriptor: its editor ID, or its form ID (a number, or a string starting 0x).
+     * @param options x, y, z: play at this world point, all three or none; without them the sound is unpositioned, heard the same wherever the camera is. volume: 0 to 1, 1 by default.
+     */
+    play(sound: string | number, options?: { x?: number; y?: number; z?: number; volume?: number }): number;
+
+    /**
+     * Stops a sound play started. False when it already ended or was never played here.
+     * @param id What play returned.
+     */
+    stop(id: number): boolean;
+
+    /**
+     * Whether a sound play started has yet to end; true while it is still starting.
+     * @param id What play returned.
+     */
+    isPlaying(id: number): boolean;
+  };
+
+  /**
+   * Screen and controller effects only the local player sees and feels. Fades are on Hud.fade.
+   */
+  const Effects: {
+    /**
+     * Applies an image space modifier, as ImageSpaceModifier.Apply does; it runs its own length, and is removed once this resource stops. False when there is no such modifier or no world to run it in.
+     * @param modifier An image space modifier (IMAD): its editor ID, or its form ID (a number, or a string starting 0x).
+     * @param strength 0 to 1, 1 by default.
+     */
+    applyImageSpace(modifier: string | number, strength?: number): boolean;
+
+    /**
+     * Stops as many instances of a modifier as this resource applied and are still running. The game stops the oldest instances of the record, which may be ones it started itself. False when none of this resource's are running.
+     * @param modifier The modifier's editor ID, or its form ID (a number, or a string starting 0x).
+     */
+    removeImageSpace(modifier: string | number): boolean;
+
+    /**
+     * Shakes the camera, as Game.ShakeCamera does from the player. False while there is no player in the world.
+     * @param strength 0 to 1.
+     * @param seconds How long; 0 for the game's default.
+     */
+    shakeCamera(strength: number, seconds: number): boolean;
+
+    /**
+     * Rumbles the gamepad, as Game.ShakeController does.
+     * @param left Left motor, 0 to 1.
+     * @param right Right motor, 0 to 1.
+     * @param seconds How long.
+     */
+    shakeController(left: number, right: number, seconds: number): void;
+  };
+
+  /**
+   * Where the player is: the worldspace it stands in, or the interior cell, which has none.
+   */
+  interface PlayerSpace {
+    /**
+     * The TESWorldSpace form ID; 0 inside an interior.
+     */
+    worldSpace: number;
+
+    /**
+     * The interior TESObjectCELL form ID; 0 outside.
+     */
+    interiorCell: number;
+  }
+
+  /**
+   * The weapon in the player's hands, drawn or holstered.
+   */
+  interface PlayerWeapon {
+    /**
+     * The TESObjectWEAP form ID.
+     */
+    form: number;
+
+    /**
+     * The ammo form ID it loads; 0 for none.
+     */
+    ammo: number;
+
+    /**
+     * The OMOD form IDs attached to it.
+     */
+    mods: number[];
+  }
+
+  /**
+   * One armor piece the player wears, with the mods attached to it.
+   */
+  interface OutfitPiece {
+    /**
+     * The TESObjectARMO form ID.
+     */
+    form: number;
+
+    /**
+     * The OMOD form IDs attached to it.
+     */
+    mods: number[];
+  }
+
+  /**
+   * The power armor frame the player wears.
+   */
+  interface PlayerPowerArmor {
+    /**
+     * The frame's reference form ID when the data files placed it; null for one the game created at runtime.
+     */
+    frame: number | null;
+
+    /**
+     * The frame's TESFurniture form ID; null when the game created that record at runtime.
+     */
+    base: number | null;
+
+    /**
+     * The charge left in the inserted fusion core, in whole units rounded up; 0 when it is empty or there is none.
+     */
+    battery: number;
+
+    /**
+     * The inserted fusion core's capacity, 100 for the game's own; 0 while none was ever inserted.
+     */
+    batteryMax: number;
+  }
+
+  /**
+   * What the player's body is doing.
+   */
+  interface PlayerMovement {
+    /**
+     * In the sneak stance.
+     */
+    sneaking: boolean;
+
+    /**
+     * Off the ground from a jump or a fall.
+     */
+    airborne: boolean;
+
+    /**
+     * Sprinting.
+     */
+    sprinting: boolean;
+
+    /**
+     * The weapon is out.
+     */
+    weaponDrawn: boolean;
+
+    /**
+     * Aiming down the sights of a drawn gun.
+     */
+    aiming: boolean;
+
+    /**
+     * A drawn gun lowered against a wall.
+     */
+    gunDown: boolean;
+
+    /**
+     * The Pip-Boy is up.
+     */
+    pipBoyOpen: boolean;
+  }
+
+  /**
+   * The player's health and armor.
+   */
+  interface PlayerVitals {
+    /**
+     * Current health.
+     */
+    health: number;
+
+    /**
+     * Health at full.
+     */
+    maxHealth: number;
+
+    /**
+     * Damage resistance from the armor worn.
+     */
+    armor: number;
+  }
+
+  /**
+   * The player this client controls, as it was captured this frame. Read-only: the server's `Player` changes it. Other players are not reachable on the client, which holds one only while it streams in.
+   */
+  const LocalPlayer: {
+    /**
+     * Where the player stands, in world units of their space.
+     * @returns Null outside a session or before the player stands in the world.
+     */
+    getPosition(): { x: number; y: number; z: number } | null;
+
+    /**
+     * How fast the player moves, in world units per second.
+     * @returns Null outside a session or before the player stands in the world.
+     */
+    getVelocity(): { x: number; y: number; z: number } | null;
+
+    /**
+     * Facing, in radians around Z.
+     * @returns Null outside a session or before the player stands in the world.
+     */
+    getHeading(): number | null;
+
+    /**
+     * Aim pitch, in radians.
+     * @returns Null outside a session or before the player stands in the world.
+     */
+    getAimPitch(): number | null;
+
+    /**
+     * What the player's body is doing: stance, weapon, Pip-Boy.
+     * @returns Null outside a session or before the player stands in the world.
+     */
+    getMovement(): PlayerMovement | null;
+
+    /**
+     * Health and armor, as captured at most a tenth of a second ago.
+     * @returns Null outside a session or before the player stands in the world.
+     */
+    getVitals(): PlayerVitals | null;
+
+    /**
+     * Whether the player is down.
+     * @returns False outside a session.
+     */
+    isDead(): boolean;
+
+    /**
+     * The worldspace or interior cell the player is in.
+     * @returns Null outside a session or before the player stands in the world.
+     */
+    getSpace(): PlayerSpace | null;
+
+    /**
+     * The weapon in the player's hands.
+     * @returns Null for empty hands, and outside a session.
+     */
+    getWeapon(): PlayerWeapon | null;
+
+    /**
+     * What the player wears.
+     * @returns One entry per armor piece; empty outside a session.
+     */
+    getOutfit(): OutfitPiece[];
+
+    /**
+     * The power armor frame the player wears.
+     * @returns Null when they wear none, and outside a session.
+     */
+    getPowerArmor(): PlayerPowerArmor | null;
+
+    /**
+     * The player's level.
+     * @returns 0 before the player stands in the world.
+     */
+    getLevel(): number;
+
+    /**
+     * The player's XP.
+     * @returns 0 before the player stands in the world.
+     */
+    getXp(): number;
+
+    /**
+     * Perk points the player has to spend.
+     * @returns 0 before the player stands in the world.
+     */
+    getPerkPoints(): number;
+
+    /**
+     * Whether the player holds a perk rank.
+     * @param perk The rank's BGSPerk form ID.
+     */
+    hasPerk(perk: number | string): boolean;
+
+    /**
+     * An actor value's current value on the player.
+     * @param value The ActorValueInfo form ID, such as 0x2D4 for Health.
+     * @returns Null for a form ID that is no actor value, or before the player stands in the world.
+     */
+    getValue(value: number | string): number | null;
+
+    /**
+     * An actor value's base on the player.
+     * @param value The ActorValueInfo form ID, such as 0x2D4 for Health.
+     * @returns Null for a form ID that is no actor value, or before the player stands in the world.
+     */
+    getBaseValue(value: number | string): number | null;
+
+    /**
+     * What the player carries, counted from their game.
+     * @returns One entry per base object and condition; empty before the player stands in the world.
+     */
+    getInventory(): InventoryItem[];
+
+    /**
+     * How many of an item the player carries.
+     * @param form The base object.
+     * @returns The count; 0 when they carry none.
+     */
+    getItemCount(form: number | string): number;
+  };
+
+  /**
+   * A stack the local player carries.
+   */
+  interface InventoryItem {
+    /**
+     * The base object's form ID.
+     */
+    form: number;
+
+    /**
+     * How many.
+     */
+    count: number;
+
+    /**
+     * The stack's condition in percent of full, 0 to 100: the charge a fusion core has left. 100 for an item that has none.
+     */
+    condition: number;
+  }
+
+  /**
+   * How many of an item came or went.
+   */
+  interface InventoryDelta {
+    /**
+     * The base object's form ID.
+     */
+    form: number;
+
+    /**
+     * Positive for items that came, negative for items that went.
+     */
+    delta: number;
+
+    /**
+     * The stack's condition in percent of full, 0 to 100; 100 for an item that has none.
+     */
+    condition: number;
+
+    /**
+     * The reference on the other side of the move (a container, a corpse, a world item); null when nothing named one.
+     */
+    counterpart: number | null;
+  }
+
+  /**
+   * The server's clock and sky, as this client holds them. Read-only: the server's `World` sets them.
+   */
+  const World: {
+    /**
+     * The game hour the server keeps, 0 to 24.
+     * @returns Null before the server's world streams in.
+     */
+    getHour(): number | null;
+
+    /**
+     * Game minutes per real minute; 0 holds the clock.
+     * @returns Null before the server's world streams in.
+     */
+    getTimeScale(): number | null;
+
+    /**
+     * The TESWeather form ID the server holds the sky to.
+     * @returns Null while the region decides the weather, and before the server's world streams in.
+     */
+    getWeather(): number | null;
+  };
+
+  /**
+   * The server's radio stations, as this client's Pip-Boy radio lists them. Read-only: the server's `RadioStation` creates them.
+   */
+  const Radio: {
+    /**
+     * Every station the server streams to this client.
+     * @returns One entry per station, in no particular order; empty outside a session.
+     */
+    getStations(): { name: string; frequency: number }[];
+  };
+
   /**
    * Mutable two-dimensional vector.
    */