@nativewrappers/server 0.0.129 → 0.0.131

package/Game.d.ts

@@ -1,4 +1,3 @@
-import { Player } from "./entities/Player";
 export declare abstract class Game {
     static hashCache: Map<string, number>;
     /**
@@ -13,13 +12,7 @@ export declare abstract class Game {
     static get GameTime(): number;
     static get GameBuild(): number;
     static get GameName(): string;
-    static registerCommand(name: string, handler: (player: Player, args: any[]) => void, restricted?: boolean): void;
     static get RegisteredCommands(): [{
         name: string;
     }];
-    /**
-     * Get an iterable list of players currently on the server.
-     * @returns Iterable list of Player objects.
-     */
-    static PlayerList(): IterableIterator<Player>;
 }

package/Game.js

@@ -1,5 +1,6 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Delay } from "./common/utils/Delay";
 import { Player } from "./entities/Player";
 class Game {
   static {
@@ -34,28 +35,9 @@ class Game {
   static get GameName() {
     return GetGameName();
   }
-  static registerCommand(name, handler, restricted = false) {
-    RegisterCommand(
-      name,
-      (source, args) => {
-        const player = new Player(Number.parseInt(source));
-        handler(player, args);
-      },
-      restricted
-    );
-  }
   static get RegisteredCommands() {
     return GetRegisteredCommands();
   }
-  /**
-   * Get an iterable list of players currently on the server.
-   * @returns Iterable list of Player objects.
-   */
-  static *PlayerList() {
-    for (const id of getPlayers()) {
-      yield new Player(id);
-    }
-  }
 }
 export {
   Game

package/common/net/NetworkedMap.js

@@ -70,10 +70,12 @@ class NetworkedMap extends Map {
   }
   /*
    * Resyncs the entire map to the client, useful for if there's a mismatch in the clients map (when multiple players change things, in cases like inventories)
-   *
-   * NOTE: This doesn't check that the player is already subscribed to the map, you should do your own due-diligence to only call this for players already subscribed
    */
   resync(source2) {
+    if (!this.#subscribers.has(source2)) {
+      console.error(`[NetworkedMap:resync] Tried to call resync on a source that wasn't already subscribed`);
+      return;
+    }
     const packed_data = msgpack_pack([this.#syncName, [[4 /* Init */, this.size === 0 ? [] : Array.from(this)]]]);
     TriggerClientEventInternal(
       `${GlobalData.CurrentResource}:syncChanges`,
@@ -83,7 +85,7 @@ class NetworkedMap extends Map {
     );
   }
   /*
-   * Adds a new subscriber to the map
+   * Adds a new subscriber to the map, this will automatically call resync on the client.
    */
   addSubscriber(source2) {
     this.#subscribers.add(source2);
@@ -155,10 +157,45 @@ class NetworkedMap extends Map {
       ln(value);
     }
   }
+  /*
+   * Adds {@param value} to the map under {@param key}, {@param value} will automatically be turned into a proxy
+   * object and the NetworkedMap will automatically send events on SubValue changes.
+   * ```ts
+   *
+   *  const map = new NetworkedMap<number, { name:string , quantity: number, obj: { nested_obj_description: string }}>("someUniqueName");
+   *
+   *  const item = {
+   *    name: "magic_item",
+   *    quantity: 1,
+   *    obj: {
+   *      something_description: "Will never be updated after init"
+   *    }
+   *  }
+   *
+   *  // automatically converts `item` into a proxy object
+   *  map.set(1, item)
+   *
+   *  // if you immediately change the value this will not be recognized, you have to get the object again from the map
+   *  item.quantity = 2;
+   *
+   *  // reactive object
+   *  const proxy_object = map.get(1)!;
+   *
+   *  // sub value change will be sent to the client on the next network tick.
+   *  proxy_object.quantity = 2;
+   *
+   *  // NOTE: this doesn't work on deeply nested objects, it will only work on anything assigned to the first object
+   *  // This update will never be sent to the client, similar to how state bags work.
+   *  proxy_object.obj.nested_obj_description = "Some new value"
+   * ```
+   * i.e. if you have { name: "magic_item", quantity: 1}
+   * if you change the item.quantity field this will automatically be sync'd to the client, is only one depth deep
+   * so if you have { obj: { some_quantity: 1 } } setting item.obj.some_quantity will not update the client.
+   */
   set(key, value) {
     let v = value;
     if (value instanceof Object) {
-      const curMap = this;
+      const curThis = this;
       const objectChangeHandler = {
         get(target, prop, reciever) {
           return Reflect.get(target, prop, reciever);
@@ -166,9 +203,9 @@ class NetworkedMap extends Map {
         set(target, p, newValue, receiver) {
           const success = Reflect.set(target, p, newValue, receiver);
           if (success) {
-            curMap.#pushChangeForListener(key, target);
+            curThis.#pushChangeForListener(key, target);
             $SERVER: {
-              curMap.#queuedChanges.push([0 /* SubValueChanged */, key, p, newValue]);
+              curThis.#queuedChanges.push([0 /* SubValueChanged */, key, p, newValue]);
             }
           }
           return success;

package/entities/BaseEntity.d.ts

@@ -22,6 +22,10 @@ export declare class BaseEntity {
      */
     get AttachedTo(): BaseEntity | null;
     get Position(): Vector3;
+    /**
+     * This is an RPC native, meaning that it can fail to work.
+     */
+    set Position(pos: Vector3);
     get Heading(): number;
     get PositionAndHeading(): Vector4;
     get Health(): number;

package/entities/BaseEntity.js

@@ -70,6 +70,12 @@ class BaseEntity {
   get Position() {
     return Vector3.fromArray(GetEntityCoords(this.handle));
   }
+  /**
+   * This is an RPC native, meaning that it can fail to work.
+   */
+  set Position(pos) {
+    SetEntityCoords(this.handle, pos.x, pos.y, pos.z, false, false, false, false);
+  }
   get Heading() {
     return GetEntityHeading(this.handle);
   }

package/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./Game";
+export * from "./utils/waitForEntityToExist";
 export * from "./type/Anticheat";
 export * from "./type/Hash";
 export * from "./enum/OrphanMode";

package/index.js

@@ -1,4 +1,5 @@
 export * from "./Game";
+export * from "./utils/waitForEntityToExist";
 export * from "./type/Anticheat";
 export * from "./type/Hash";
 export * from "./enum/OrphanMode";

package/package.json

@@ -8,7 +8,7 @@
   ],
   "license": "MIT",
   "type": "module",
-  "version": "0.0.129",
+  "version": "0.0.131",
   "repository": {
     "type": "git",
     "url": "https://github.com/nativewrappers/nativewrappers.git"

package/utils/waitForEntityToExist.d.ts

@@ -0,0 +1,7 @@
+/**
+* Waits for the specified {@param netId} to exist, useful for when you're creating an entity on the client
+* ane sending it to the server, as it can "race" the net event, resulting in it never getting created.
+* @param netId the network id of the entity to wait to exist
+* @param [timeoutMs=1000] the amount of time to wait for the entity to exist before giving up
+*/
+export declare function waitForEntityToExist(netId: number, timeoutMs?: number): Promise<number | null>;

package/utils/waitForEntityToExist.js

@@ -0,0 +1,19 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Delay } from "../common/utils/Delay";
+async function waitForEntityToExist(netId, timeoutMs = 1e3) {
+  const startTime = GetGameTimer();
+  const timeout = startTime + timeoutMs;
+  while (GetGameTimer() < timeout) {
+    const entity = NetworkGetEntityFromNetworkId(netId);
+    if (entity !== 0) {
+      return entity;
+    }
+    await Delay(0);
+  }
+  return null;
+}
+__name(waitForEntityToExist, "waitForEntityToExist");
+export {
+  waitForEntityToExist
+};