@sagl/server 0.0.0-stage → 0.1.0-next.49

package/dist/native.js

@@ -0,0 +1,27 @@
+// Loads the C++ addon (build/Release/sagl_native.node) and describes its
+// shape. Internal: gamemodes use Server and Player instead.
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// The addon for this computer: the platform package npm installed beside
+// this one (@sagl/server-linux-x64, -win32-x64), else a local build (a
+// checkout: `npm run build:native`, or the Windows server zip).
+function load() {
+    const platform = `${process.platform}-${process.arch}`;
+    const tried = [];
+    for (const path of [`@sagl/server-${platform}`, "../build/Release/sagl_native.node"]) {
+        try {
+            return require(path);
+        }
+        catch (e) {
+            const code = e.code;
+            if (code !== "MODULE_NOT_FOUND")
+                throw e; // there, but it wouldn't load: say why
+            tried.push(path);
+        }
+    }
+    throw new Error(`@sagl/server has no server for ${platform} (tried ${tried.join(", ")}). ` +
+        "It runs on Linux x64 (glibc 2.28 or newer) and Windows x64. On another platform, build it from source: " +
+        "see the README in the SAGL repository.");
+}
+export const native = load();
+//# sourceMappingURL=native.js.map

package/dist/native.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.js","sourceRoot":"","sources":["../src/native.ts"],"names":[],"mappings":"AACA,yEAAyE;AACzE,4DAA4D;AAE5D,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AA6jB5C,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAE/C,yEAAyE;AACzE,uEAAuE;AACvE,gEAAgE;AAChE,SAAS,IAAI;IACX,MAAM,QAAQ,GAAG,GAAG,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;IACvD,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,MAAM,IAAI,IAAI,CAAC,gBAAgB,QAAQ,EAAE,EAAE,mCAAmC,CAAC,EAAE,CAAC;QACrF,IAAI,CAAC;YACH,OAAO,OAAO,CAAC,IAAI,CAAiB,CAAC;QACvC,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,IAAI,GAAI,CAA2B,CAAC,IAAI,CAAC;YAC/C,IAAI,IAAI,KAAK,kBAAkB;gBAAE,MAAM,CAAC,CAAC,CAAE,uCAAuC;YAClF,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnB,CAAC;IACH,CAAC;IACD,MAAM,IAAI,KAAK,CACb,kCAAkC,QAAQ,WAAW,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK;QAC1E,yGAAyG;QACzG,wCAAwC,CACzC,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,MAAM,GAAiB,IAAI,EAAE,CAAC"}

package/dist/objects.d.ts

@@ -0,0 +1,249 @@
+import type { NativeServer } from "./native.js";
+import { type MapColor } from "./map.js";
+import { Ped } from "./ped.js";
+import { Player, type Vector3 } from "./player.js";
+import { Vehicle } from "./vehicle.js";
+/** Rotation in degrees about x, y and z (z: the heading). */
+export interface Rotation {
+    x: number;
+    y: number;
+    z: number;
+}
+type Sender<S> = (player: Player, spec: S) => void;
+/** @internal Something sent to some players (or everyone, players joining later too). */
+export declare class Broadcast<S extends {
+    id: number;
+}> {
+    #private;
+    spec: S;
+    constructor(send: Sender<S>, players: () => Player[], to: readonly Player[] | undefined, spec: S);
+    sees(player: Player): boolean;
+    sendAll(extra?: Partial<S>): void;
+    replay(player: Player): void;
+    /** Every connected player who sees it. */
+    each(fn: (player: Player) => void): void;
+}
+export interface ObjectOptions {
+    /** Default true. */
+    collision?: boolean;
+    /**
+     * Makes it breakable: players' shots, blows and cars wear this down, and
+     * at 0 it's destroyed for everyone (`onDestroyed`). Left out: nothing
+     * breaks it.
+     */
+    health?: number;
+    /** Who sees it. Default everyone (players joining later too). */
+    visibleTo?: readonly Player[];
+    /** The interior it's in (0 outside, the default); -1: every interior. */
+    interior?: number;
+    /**
+     * Made in each player's game only within this far of them (m). Default
+     * 300. Each game holds the nearest few hundred objects at most: thousands
+     * can be placed, they come and go as players move (as SA-MP's streamer).
+     */
+    streamDistance?: number;
+}
+type ObjectSpec = Parameters<NativeServer["serverObject"]>[1] & {
+    id: number;
+};
+type MaterialSpec = Parameters<NativeServer["objectMaterial"]>[1];
+/** A material's new texture (`object.setMaterial`). */
+export interface MaterialOptions {
+    /**
+     * A texture from a model's textures: `model` (a game model, or a custom
+     * model's id: then its own TXD), the dictionary `txd` (a game model's:
+     * the name its TXD has, as SA-MP's txdname) and the `texture` in it.
+     */
+    model?: number;
+    txd?: string;
+    texture?: string;
+    /** Or an image client file (PNG or JPG) as its texture. */
+    image?: string;
+    /** Tints it (its own texture, or the new one): `"#RRGGBB[AA]"` or 0xRRGGBBAA. */
+    color?: MapColor;
+}
+/** Text drawn as a material (`object.setMaterialText`). */
+export interface MaterialTextOptions {
+    /** The canvas (`MaterialSize`). Default 256x128. */
+    size?: number;
+    /** A font by name, as Windows has them (SA-MP's: "Arial", "Courier New"...). Default Arial. */
+    font?: string;
+    /** Its height in the canvas' pixels. Default 24. */
+    fontSize?: number;
+    bold?: boolean;
+    /** Default white. `{RRGGBB}` in the text colours what follows. */
+    color?: MapColor;
+    /** Behind the text; default none (clear: the object shows through). */
+    background?: MapColor;
+    /** `MaterialTextAlign`. Default left. */
+    align?: number;
+}
+/**
+ * One of the server's objects (`server.createObject()`): any of the game's
+ * object models, where you put it. Players' games never move or break it
+ * on their own; the server moves it (`move()`) and decides its damage.
+ */
+export declare class GameObject {
+    #private;
+    readonly id: number;
+    readonly model: number;
+    /** @internal */
+    constructor(id: number, model: number, b: Broadcast<ObjectSpec>, health: number, forget: (o: GameObject) => void, sendMaterial: (p: Player, m: MaterialSpec) => void);
+    /**
+     * Draws one of its model's materials (`index`, 0-15, in the order the
+     * model has them) otherwise, as SA-MP's SetObjectMaterial: another
+     * texture (from any model's textures, a custom model's, or an image
+     * client file), tinted, or both. Only this object changes.
+     *
+     * ```ts
+     * atm.setMaterial(1, { model: 2942, txd: "kmb_atmx", texture: "kmb_chip1" }); // a game texture
+     * atm.setMaterial(1, { image: "textures/poster.png" });                       // your own picture
+     * atm.setMaterial(0, { color: "#ff3030" });                                   // its own, tinted
+     * ```
+     */
+    setMaterial(index: number, options: MaterialOptions): void;
+    /**
+     * Text as one of its materials, as SA-MP's SetObjectMaterialText: drawn
+     * on a canvas (`MaterialSize`) in place of its texture. `\n` breaks a
+     * line; `{RRGGBB}` colours what follows.
+     *
+     * ```ts
+     * atm.setMaterialText(1, "{ffcc00}SAGL\nBANK", { size: MaterialSize.Size256x128, fontSize: 48, bold: true, align: MaterialTextAlign.Center });
+     * ```
+     */
+    setMaterialText(index: number, text: string, options?: MaterialTextOptions): void;
+    /** Material `index` as its model has it again (or all, with none given). */
+    resetMaterial(index?: number): void;
+    get exists(): boolean;
+    get position(): Vector3;
+    get rotation(): Rotation;
+    /** Its health (breakable ones), or Infinity. */
+    get health(): number;
+    /**
+     * Glides it to `position` (and `rotation`) over `ms` (0: puts it there).
+     * Resolves when it's there: gates, shutters, lifts.
+     */
+    move(position: Vector3, rotation?: Rotation, ms?: number): Promise<void>;
+    /** Collision on or off (walk through it, or not). */
+    set collision(on: boolean);
+    /**
+     * `fn(player, damage, weapon)` when a player hurts it (breakable ones),
+     * before it counts: return false to ignore it, or a number for the
+     * damage it does instead.
+     */
+    onHit(fn: (player: Player, damage: number, weapon: number) => number | boolean | void): this;
+    /** `fn(by)` when it's destroyed by damage (`by`: whoever did it). */
+    onDestroyed(fn: (by: Player | null) => void): this;
+    /** Takes it away for everyone; `shatter` breaks it apart first (glass, crates). */
+    destroy(options?: {
+        shatter?: boolean;
+    }): void;
+    /** @internal */
+    replay(player: Player): void;
+    /** @internal */
+    hit(player: Player, damage: number, weapon: number): void;
+}
+export interface PickupOptions {
+    /** Where it floats. */
+    position: Vector3;
+    /** A weapon (`Weapon`), with `ammo` (default 30): its model, and given on pickup. */
+    weapon?: number;
+    ammo?: number;
+    /** Health: brings theirs up to at least this (the game's heart: 100). */
+    health?: number;
+    /** Armour: brings theirs up to at least this. */
+    armour?: number;
+    /** Money: given. */
+    money?: number;
+    /** Any model instead (its look); give nothing unless `onPickup` does. */
+    model?: number;
+    /** Back this long (ms) after it's taken. Left out: taken once, then gone. */
+    respawn?: number;
+    /** Vehicles pick it up too. Default false. */
+    inVehicle?: boolean;
+    /** Who sees (and can take) it. Default everyone. */
+    visibleTo?: readonly Player[];
+    /** Floating text over it (see `server.labels`). */
+    label?: string;
+    /** The interior it's in (0 outside, the default); -1: every interior. */
+    interior?: number;
+}
+type PickupSpec = Parameters<NativeServer["pickup"]>[1] & {
+    id: number;
+};
+/** A pickup (`server.createPickup()`). */
+export declare class Pickup {
+    #private;
+    readonly id: number;
+    readonly options: Readonly<PickupOptions>;
+    /** @internal */
+    label: Label | null;
+    /** @internal */
+    constructor(id: number, options: PickupOptions, b: Broadcast<PickupSpec>, forget: (p: Pickup) => void, sound: (player: Player, sound: number) => void);
+    get exists(): boolean;
+    /** Taken, and not back yet. */
+    get taken(): boolean;
+    get position(): Vector3;
+    /**
+     * `fn(player)` when a player takes it, before they get what it holds:
+     * return false to refuse (it stays, they get nothing).
+     */
+    onPickup(fn: (player: Player) => boolean | void): this;
+    /** Takes it away for everyone. */
+    remove(): void;
+    /** @internal */
+    replay(player: Player): void;
+    /** @internal Their game says they walked into it: checked, then given. */
+    touch(player: Player): void;
+}
+export type LabelTarget = Vector3 | Ped | Player | Vehicle | GameObject | Pickup;
+export interface LabelOptions {
+    /** Default white. */
+    color?: MapColor;
+    /** Seen up to this far (m). Default 20. */
+    distance?: number;
+    /** Shown through walls. Default false. */
+    throughWalls?: boolean;
+    /** From what it's on (m). Default above it: a ped's or player's head, a vehicle's roof. */
+    offset?: Vector3;
+    /** Who sees it. Default everyone (players joining later too). */
+    to?: readonly Player[];
+    /** The interior it's shown in (0 outside); -1: every interior. Default 0 at a spot, -1 on something (it goes where that goes). */
+    interior?: number;
+}
+type LabelSpec = Parameters<NativeServer["label"]>[1] & {
+    id: number;
+};
+/** Floating text in the world (`server.labels.add()`). */
+export declare class Label {
+    #private;
+    readonly id: number;
+    /** @internal What it's on (LabelSpec.on, target). */
+    readonly on: number;
+    /** @internal */
+    readonly target: number;
+    /** @internal */
+    constructor(id: number, b: Broadcast<LabelSpec>, forget: (l: Label) => void);
+    /** Changes its text (game codes and `gxt()` work). */
+    set text(text: string);
+    get text(): string;
+    set color(color: MapColor);
+    remove(): void;
+    /** @internal */
+    replay(player: Player): void;
+}
+/** @internal The server's objects, pickups and labels. */
+export declare class WorldThings {
+    #private;
+    objects: Map<number, GameObject>;
+    pickups: Map<number, Pickup>;
+    labels: Map<number, Label>;
+    constructor(native: NativeServer, players: () => Player[]);
+    createObject(model: number, position: Vector3, rotation?: Rotation, options?: ObjectOptions): GameObject;
+    createPickup(options: PickupOptions): Pickup;
+    addLabel(text: string, at: LabelTarget, options?: LabelOptions): Label;
+    /** Labels on something that's gone (its id may be another's later). */
+    forgetTarget(on: number, target: number): void;
+    replay(player: Player): void;
+}
+export {};