@nativewrappers/common 0.0.57 → 0.0.59

package/GlobalData.d.ts

@@ -1,4 +1,5 @@
 export declare class GlobalData {
+    static CurrentResource: string;
     static IS_SERVER: boolean;
     static IS_CLIENT: boolean;
     static NetworkTick: number | null;

package/GlobalData.js

@@ -1,4 +1,5 @@
 export class GlobalData {
+    static CurrentResource = GetCurrentResourceName();
     static IS_SERVER = IsDuplicityVersion();
     static IS_CLIENT = !GlobalData.IS_SERVER;
     static NetworkTick = null;

package/net/NetworkedMap.d.ts

@@ -5,10 +5,13 @@ type ChangeListener<V> = (value: V) => void;
 export declare class NetworkedMap<K, V> extends Map<K, V> {
     #private;
     constructor(syncName: string, initialValue?: [K, V][]);
+    get SyncName(): string;
     private onPlayerDropped;
-    addSubscriber(sub: number): void;
+    resync(source: number): void;
+    addSubscriber(source: number): void;
     removeSubscriber(sub: number): boolean;
     hasSubscriber(sub: number): boolean;
+    private handleSync;
     listenForChange(key: K, fn: ChangeListener<V>): void;
     set(key: K, value: V): this;
     clear(): void;

package/net/NetworkedMap.js

@@ -12,6 +12,48 @@ var MapChangeType;
     // Whenever they're subscribed initially and get the initial load of data
     MapChangeType[MapChangeType["Init"] = 4] = "Init";
 })(MapChangeType || (MapChangeType = {}));
+// Used to not make a bunch of on/raw events, we just reuse the same one and look up the data in the map
+class NetworkedMapEventManager {
+    #syncedCalls = new Map();
+    #playerDropped = new Map();
+    constructor() {
+        SERVER: if (GlobalData.IS_SERVER) {
+            on("playerDropped", () => {
+                // call the player dropped for each call
+                for (const [_k, fn] of this.#playerDropped) {
+                    fn();
+                }
+            });
+            return;
+        }
+        CLIENT: {
+            RegisterResourceAsEventHandler(`${GlobalData.CurrentResource}:syncChanges`);
+            addRawEventListener(`${GlobalData.CurrentResource}:syncChanges`, (msgpack_data) => {
+                const data = msgpack_unpack(msgpack_data);
+                const syncName = data[0];
+                const syncData = data[1];
+                const map = this.#syncedCalls.get(syncName);
+                if (!map) {
+                    throw new Error(`Tried to sync changes for a networked map but ${syncName} does't exist.`);
+                }
+                // @ts-ignore
+                map.handleSync(syncData);
+            });
+        }
+    }
+    addNetworkedMap(map) {
+        // abuse typescript, we don't want the end user to use these calls but we still want it to be accessible internally.
+        // @ts-ignore
+        this.#syncedCalls.set(map.SyncName, map);
+        // @ts-ignore
+        this.#playerDropped.set(map.SyncName, map.onPlayerDropped);
+    }
+    removeNetworkedMap(syncName) {
+        this.#syncedCalls.delete(syncName);
+        this.#playerDropped.delete(syncName);
+    }
+}
+const netManager = new NetworkedMapEventManager();
 /**
  * not ready to be used just thoughts right now
  */
@@ -24,7 +66,7 @@ export class NetworkedMap extends Map {
         super(initialValue);
         this.#syncName = syncName;
         GlobalData.NetworkedTicks.push(this);
-        on("playerDropped", () => this.onPlayerDropped());
+        netManager.addNetworkedMap(this);
         // if we don't have a network tick then we want to register it.
         SERVER: {
             if (!GlobalData.NetworkTick && GlobalData.IS_SERVER) {
@@ -35,26 +77,32 @@ export class NetworkedMap extends Map {
                 });
             }
         }
-        SERVER: if (GlobalData.IS_SERVER)
-            return;
-        CLIENT: {
-            RegisterResourceAsEventHandler(`${this.#syncName}:syncChanges`);
-            addRawEventListener(`${this.#syncName}:syncChanges`, (data) => this.#handleSync(data));
-        }
+    }
+    get SyncName() {
+        return this.#syncName;
     }
     // handles removing the player from the map whenever they're dropped
     onPlayerDropped() {
         this.removeSubscriber(source);
     }
     /*
-     * Adds a new subscriber to the map, if the
+     * 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
      */
-    addSubscriber(sub) {
-        this.#subscribers.add(sub);
+    resync(source) {
         const packed_data = msgpack_pack([
-            [MapChangeType.Init, this.size === 0 ? [] : Array.from(this)],
+            this.#syncName,
+            [[MapChangeType.Init, this.size === 0 ? [] : Array.from(this)]],
         ]);
-        TriggerClientEventInternal(`${this.#syncName}:syncChanges`, sub, packed_data, packed_data.length);
+        TriggerClientEventInternal(`${GlobalData.CurrentResource}:syncChanges`, source, packed_data, packed_data.length);
+    }
+    /*
+     * Adds a new subscriber to the map
+     */
+    addSubscriber(source) {
+        this.#subscribers.add(source);
+        this.resync(source);
     }
     removeSubscriber(sub) {
         return this.#subscribers.delete(sub);
@@ -62,8 +110,7 @@ export class NetworkedMap extends Map {
     hasSubscriber(sub) {
         return this.#subscribers.has(sub);
     }
-    #handleSync(msgpack_data) {
-        const data = msgpack_unpack(msgpack_data);
+    handleSync(data) {
         for (const [change_type, key, value, possibly_undefined_subvalue] of data) {
             switch (change_type) {
                 case MapChangeType.Add: {
@@ -79,6 +126,8 @@ export class NetworkedMap extends Map {
                     continue;
                 }
                 case MapChangeType.Init: {
+                    // We also use this for whenever we want to resync a table
+                    super.clear();
                     const key_value = key;
                     for (const [k, v] of key_value) {
                         this.set(k, v);
@@ -103,9 +152,9 @@ export class NetworkedMap extends Map {
         listener ? listener.push(fn) : this.#changeListeners.set(key, [fn]);
     }
     #triggerEventForSubscribers(data) {
-        const packed_data = msgpack_pack(data);
+        const packed_data = msgpack_pack([this.#syncName, data]);
         for (const sub of this.#subscribers) {
-            TriggerClientEventInternal(`${this.#syncName}:syncChanges`, sub, packed_data, packed_data.length);
+            TriggerClientEventInternal(`${GlobalData.CurrentResource}:syncChanges`, sub, packed_data, packed_data.length);
         }
     }
     #pushChangeForListener(key, value) {
@@ -153,6 +202,9 @@ export class NetworkedMap extends Map {
         }
         return this;
     }
+    /*
+     * Resets the map to its default state
+     */
     clear() {
         CLIENT: throw new Error(`Cannot call 'clear' on client`);
         // if we're clearing our map then we want to remove all queued changes and
@@ -173,10 +225,10 @@ export class NetworkedMap extends Map {
         }
     }
     [Symbol.dispose]() {
-        removeEventListener("playerDropped", this.onPlayerDropped);
         this.#subscribers.clear();
         this.#changeListeners.clear();
         this.#queuedChanges = [];
+        netManager.removeNetworkedMap(this.#syncName);
         GlobalData.NetworkedTicks.filter((v) => v !== this);
     }
     /**

package/package.json

@@ -4,7 +4,7 @@
   "author": "Remco Troost <d0p3t>",
   "license": "MIT",
   "type": "module",
-  "version": "0.0.57",
+  "version": "0.0.59",
   "repository": {
     "type": "git",
     "url": "https://github.com/nativewrappers/nativewrappers.git"