@dcl/ecs 7.22.5-24836126953.commit-ddc8da1 → 7.22.5

package/dist-cjs/systems/physics-force.js

@@ -0,0 +1,167 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPhysicsForceHelper = void 0;
+const components = __importStar(require("../components"));
+const helpers_1 = require("../runtime/helpers");
+const physics_impulse_1 = require("./physics-impulse");
+/** @internal */
+function createPhysicsForceHelper(engine) {
+    const PhysicsCombinedForce = components.PhysicsCombinedForce(engine);
+    const Transform = components.Transform(engine);
+    const timers = (0, helpers_1.createTimers)(engine);
+    const durationTimers = new Map();
+    // Key = source entity producing the force (not the target); all forces target PlayerEntity.
+    const forceSources = new Map();
+    const repulsionSources = new Map();
+    let lastWrittenForceVector = null;
+    function recalcForce() {
+        if (forceSources.size === 0) {
+            if (PhysicsCombinedForce.has(engine.PlayerEntity)) {
+                PhysicsCombinedForce.deleteFrom(engine.PlayerEntity);
+            }
+            lastWrittenForceVector = null;
+            return;
+        }
+        const current = PhysicsCombinedForce.getOrNull(engine.PlayerEntity);
+        if (current && lastWrittenForceVector && current.vector) {
+            if (!helpers_1.Vector3.equals(current.vector, lastWrittenForceVector)) {
+                console.error('PBPhysicsCombinedForce was modified externally.', 'Expected:', lastWrittenForceVector, 'Found:', current.vector, '-- overwriting with local state.');
+            }
+        }
+        let sum = { x: 0, y: 0, z: 0 };
+        for (const v of forceSources.values()) {
+            sum = helpers_1.Vector3.add(sum, v);
+        }
+        PhysicsCombinedForce.createOrReplace(engine.PlayerEntity, { vector: sum });
+        lastWrittenForceVector = sum;
+    }
+    function applyForceToPlayer(source, vector, magnitude) {
+        let finalVector;
+        if (helpers_1.Vector3.equalsToFloats(vector, 0, 0, 0))
+            return;
+        if (typeof magnitude === 'number') {
+            finalVector = helpers_1.Vector3.scale(helpers_1.Vector3.normalize(vector), magnitude);
+        }
+        else {
+            finalVector = vector;
+        }
+        forceSources.set(source, finalVector);
+        recalcForce();
+    }
+    function removeForceFromPlayer(source) {
+        repulsionSources.delete(source);
+        const timerId = durationTimers.get(source);
+        if (timerId !== undefined) {
+            timers.clearTimeout(timerId);
+            durationTimers.delete(source);
+        }
+        if (!forceSources.has(source))
+            return;
+        forceSources.delete(source);
+        recalcForce();
+    }
+    function scheduleForceDuration(source, seconds) {
+        const existing = durationTimers.get(source);
+        if (existing !== undefined) {
+            timers.clearTimeout(existing);
+        }
+        const timerId = timers.setTimeout(() => {
+            durationTimers.delete(source);
+            removeForceFromPlayer(source);
+        }, seconds * 1000);
+        durationTimers.set(source, timerId);
+    }
+    function applyForceToPlayerForDuration(source, duration, vector, magnitude) {
+        applyForceToPlayer(source, vector, magnitude);
+        scheduleForceDuration(source, duration);
+    }
+    function computeRepulsionVector(fromPosition, magnitude, radius, falloff) {
+        const diff = helpers_1.Vector3.subtract(Transform.get(engine.PlayerEntity).position, fromPosition);
+        if (helpers_1.Vector3.equalsToFloats(diff, 0, 0, 0))
+            return { x: 0, y: magnitude, z: 0 };
+        // Fast path: default params — no need to compute distance
+        if (radius === Infinity && falloff === physics_impulse_1.KnockbackFalloff.CONSTANT) {
+            return helpers_1.Vector3.scale(helpers_1.Vector3.normalize(diff), magnitude);
+        }
+        const distance = helpers_1.Vector3.length(diff);
+        if (distance > radius)
+            return null;
+        let effectiveMagnitude;
+        switch (falloff) {
+            case physics_impulse_1.KnockbackFalloff.LINEAR:
+                effectiveMagnitude = magnitude * (1 - distance / radius);
+                break;
+            case physics_impulse_1.KnockbackFalloff.INVERSE_SQUARE:
+                effectiveMagnitude = magnitude / (distance * distance + 1);
+                break;
+            case physics_impulse_1.KnockbackFalloff.CONSTANT:
+            default:
+                effectiveMagnitude = magnitude;
+                break;
+        }
+        if (effectiveMagnitude === 0)
+            return null;
+        // normalize(diff) * effectiveMagnitude in one step
+        return helpers_1.Vector3.scale(diff, effectiveMagnitude / distance);
+    }
+    function applyRepulsionForceToPlayer(source, fromPosition, magnitude, radius = Infinity, falloff = physics_impulse_1.KnockbackFalloff.CONSTANT) {
+        repulsionSources.set(source, { fromPosition, magnitude, radius, falloff });
+        const vector = computeRepulsionVector(fromPosition, magnitude, radius, falloff);
+        if (vector) {
+            forceSources.set(source, vector);
+        }
+        else {
+            forceSources.delete(source);
+        }
+        recalcForce();
+    }
+    // Background system: recalculate repulsion vectors and clean up stale forces every tick.
+    // Stale forces can appear when CRDT sync from another client writes PhysicsCombinedForce
+    // externally (entity-1 ambiguity: each client interprets entity 1 as its own player).
+    engine.addSystem(() => {
+        // Repulsion forces need per-tick direction recalculation as the player moves
+        if (repulsionSources.size > 0) {
+            for (const [source, { fromPosition, magnitude, radius, falloff }] of repulsionSources) {
+                const vector = computeRepulsionVector(fromPosition, magnitude, radius, falloff);
+                if (vector) {
+                    forceSources.set(source, vector);
+                }
+                else {
+                    forceSources.delete(source);
+                }
+            }
+            recalcForce();
+            return;
+        }
+        // No local sources — clean up any externally-created component (e.g. from CRDT sync)
+        if (forceSources.size === 0 && PhysicsCombinedForce.has(engine.PlayerEntity)) {
+            PhysicsCombinedForce.deleteFrom(engine.PlayerEntity);
+            lastWrittenForceVector = null;
+        }
+    });
+    return { applyForceToPlayer, removeForceFromPlayer, applyForceToPlayerForDuration, applyRepulsionForceToPlayer };
+}
+exports.createPhysicsForceHelper = createPhysicsForceHelper;

package/dist-cjs/systems/physics-impulse.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @public
+ * Falloff mode for knockback force over distance.
+ */
+export declare enum KnockbackFalloff {
+    /** Same force at any distance within radius */
+    CONSTANT = 0,
+    /** Smooth linear decrease to 0 at radius edge: F = magnitude * (1 - distance / radius) */
+    LINEAR = 1,
+    /** Sharp drop-off, physically realistic: F = magnitude / (distance^2 + 1) */
+    INVERSE_SQUARE = 2
+}

package/dist-cjs/systems/physics-impulse.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPhysicsImpulseHelper = exports.KnockbackFalloff = void 0;
+const components = __importStar(require("../components"));
+const helpers_1 = require("../runtime/helpers");
+/**
+ * @public
+ * Falloff mode for knockback force over distance.
+ */
+var KnockbackFalloff;
+(function (KnockbackFalloff) {
+    /** Same force at any distance within radius */
+    KnockbackFalloff[KnockbackFalloff["CONSTANT"] = 0] = "CONSTANT";
+    /** Smooth linear decrease to 0 at radius edge: F = magnitude * (1 - distance / radius) */
+    KnockbackFalloff[KnockbackFalloff["LINEAR"] = 1] = "LINEAR";
+    /** Sharp drop-off, physically realistic: F = magnitude / (distance^2 + 1) */
+    KnockbackFalloff[KnockbackFalloff["INVERSE_SQUARE"] = 2] = "INVERSE_SQUARE";
+})(KnockbackFalloff = exports.KnockbackFalloff || (exports.KnockbackFalloff = {}));
+/** @internal */
+function createPhysicsImpulseHelper(engine) {
+    const PhysicsCombinedImpulse = components.PhysicsCombinedImpulse(engine);
+    const Transform = components.Transform(engine);
+    const EngineInfo = components.EngineInfo(engine);
+    let impulseEventId = 0;
+    let lastWrittenEventId = 0;
+    let lastWrittenTick = -1;
+    function applyImpulseToPlayer(vector, magnitude) {
+        let finalVector;
+        if (typeof magnitude === 'number') {
+            if (helpers_1.Vector3.equalsToFloats(vector, 0, 0, 0))
+                return;
+            finalVector = helpers_1.Vector3.scale(helpers_1.Vector3.normalize(vector), magnitude);
+        }
+        else {
+            if (helpers_1.Vector3.equalsToFloats(vector, 0, 0, 0))
+                return;
+            finalVector = vector;
+        }
+        const currentTick = EngineInfo.getOrNull(engine.RootEntity)?.tickNumber ?? 0;
+        const existing = PhysicsCombinedImpulse.getOrNull(engine.PlayerEntity);
+        if (existing && existing.eventId !== lastWrittenEventId && lastWrittenEventId !== 0) {
+            throw new Error('PBPhysicsCombinedImpulse was modified outside Physics helper. ' +
+                'Do not mix direct component access with Physics.applyImpulseToPlayer().');
+        }
+        if (lastWrittenTick === currentTick && existing) {
+            finalVector = helpers_1.Vector3.add(existing.vector ?? { x: 0, y: 0, z: 0 }, finalVector);
+        }
+        else {
+            lastWrittenEventId = ++impulseEventId;
+        }
+        lastWrittenTick = currentTick;
+        PhysicsCombinedImpulse.createOrReplace(engine.PlayerEntity, {
+            vector: finalVector,
+            eventId: lastWrittenEventId
+        });
+    }
+    function applyKnockbackToPlayer(fromPosition, magnitude, radius = Infinity, falloff = KnockbackFalloff.CONSTANT) {
+        const diff = helpers_1.Vector3.subtract(Transform.get(engine.PlayerEntity).position, fromPosition);
+        if (helpers_1.Vector3.equalsToFloats(diff, 0, 0, 0)) {
+            applyImpulseToPlayer({ x: 0, y: magnitude, z: 0 });
+            return;
+        }
+        // Fast path: default params — no need to compute distance
+        if (radius === Infinity && falloff === KnockbackFalloff.CONSTANT) {
+            applyImpulseToPlayer(helpers_1.Vector3.scale(helpers_1.Vector3.normalize(diff), magnitude));
+            return;
+        }
+        const distance = helpers_1.Vector3.length(diff);
+        if (distance > radius)
+            return;
+        let effectiveMagnitude;
+        switch (falloff) {
+            case KnockbackFalloff.LINEAR:
+                effectiveMagnitude = magnitude * (1 - distance / radius);
+                break;
+            case KnockbackFalloff.INVERSE_SQUARE:
+                effectiveMagnitude = magnitude / (distance * distance + 1);
+                break;
+            case KnockbackFalloff.CONSTANT:
+            default:
+                effectiveMagnitude = magnitude;
+                break;
+        }
+        // normalize(diff) * effectiveMagnitude in one step
+        applyImpulseToPlayer(helpers_1.Vector3.scale(diff, effectiveMagnitude / distance));
+    }
+    return { applyImpulseToPlayer, applyKnockbackToPlayer };
+}
+exports.createPhysicsImpulseHelper = createPhysicsImpulseHelper;

package/dist-cjs/systems/physics.d.ts

@@ -0,0 +1,77 @@
+import { Entity } from '../engine';
+import { Vector3Type } from '../schemas';
+import { KnockbackFalloff } from './physics-impulse';
+export { KnockbackFalloff } from './physics-impulse';
+/**
+ * @public
+ */
+export interface PhysicsSystem {
+    /**
+     * Apply a one-shot impulse to the player entity.
+     * Multiple calls within the same frame are accumulated (summed).
+     *
+     * @param vector - a single `vector` whose length encodes the strength.
+     * or use overload for `direction` with a separate `magnitude` — the direction will be normalized before scaling.
+     */
+    applyImpulseToPlayer(vector: Vector3Type): void;
+    applyImpulseToPlayer(direction: Vector3Type, magnitude: number): void;
+    /**
+     * Apply a continuous force to the player from a given source entity.
+     * Multiple sources are accumulated: the registry sums all active forces
+     * and writes a single PBPhysicsCombinedForce component.
+     * Calling again with the same source replaces its previous force.
+     *
+     * @param source - Entity key identifying this force source
+     * @param vector - single `vector` whose length encodes the strength
+     * or use overload for `direction` with a separate `magnitude` — the direction will be normalized before scaling.
+     */
+    applyForceToPlayer(source: Entity, vector: Vector3Type): void;
+    applyForceToPlayer(source: Entity, direction: Vector3Type, magnitude: number): void;
+    /**
+     * Remove a continuous force from the player. Remaining sources are
+     * re-summed; if none remain the force is cleared. No-op if the source
+     * is not registered.
+     *
+     * @param source - Entity key identifying the force source to remove
+     */
+    removeForceFromPlayer(source: Entity): void;
+    /**
+     * Push the player away from a point. Computes direction from
+     * `fromPosition` to the player, applies falloff, and delegates
+     * to applyImpulseToPlayer.
+     *
+     * If the player is exactly at `fromPosition`, pushes upward.
+     *
+     * @param fromPosition - world-space origin of the knockback (explosion center, enemy position, etc.)
+     * @param magnitude - base impulse strength
+     * @param radius - max distance of effect (default: Infinity)
+     * @param falloff - how force decreases with distance (default: CONSTANT)
+     */
+    applyKnockbackToPlayer(fromPosition: Vector3Type, magnitude: number, radius?: number, falloff?: KnockbackFalloff): void;
+    /**
+     * Apply a continuous force to the player for a limited duration.
+     * After `duration` seconds the force is automatically removed.
+     * Calling again with the same source resets the timer.
+     *
+     * @param source - Entity key identifying this force source
+     * @param duration - how long the force lasts, in seconds
+     * @param vector - single `vector` whose length encodes the strength
+     * or use overload for `direction` with a separate `magnitude` — the direction will be normalized before scaling.
+     */
+    applyForceToPlayerForDuration(source: Entity, duration: number, vector: Vector3Type): void;
+    applyForceToPlayerForDuration(source: Entity, duration: number, direction: Vector3Type, magnitude: number): void;
+    /**
+     * Apply a continuous repulsion force that pushes the player away from a point,
+     * recalculating direction every tick as the player moves.
+     * Remove with `removeForceFromPlayer(source)`.
+     *
+     * Negative magnitude = attraction (pulls toward the source).
+     *
+     * @param source - Entity key identifying this force source
+     * @param fromPosition - world-space origin of repulsion
+     * @param magnitude - base force strength
+     * @param radius - max distance of effect (default: Infinity)
+     * @param falloff - how force decreases with distance (default: CONSTANT)
+     */
+    applyRepulsionForceToPlayer(source: Entity, fromPosition: Vector3Type, magnitude: number, radius?: number, falloff?: KnockbackFalloff): void;
+}

package/dist-cjs/systems/physics.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPhysicsSystem = exports.KnockbackFalloff = void 0;
+const physics_impulse_1 = require("./physics-impulse");
+const physics_force_1 = require("./physics-force");
+var physics_impulse_2 = require("./physics-impulse");
+Object.defineProperty(exports, "KnockbackFalloff", { enumerable: true, get: function () { return physics_impulse_2.KnockbackFalloff; } });
+/**
+ * @internal
+ */
+function createPhysicsSystem(engine) {
+    const impulse = (0, physics_impulse_1.createPhysicsImpulseHelper)(engine);
+    const force = (0, physics_force_1.createPhysicsForceHelper)(engine);
+    return {
+        applyImpulseToPlayer: impulse.applyImpulseToPlayer,
+        applyForceToPlayer: force.applyForceToPlayer,
+        removeForceFromPlayer: force.removeForceFromPlayer,
+        applyKnockbackToPlayer: impulse.applyKnockbackToPlayer,
+        applyForceToPlayerForDuration: force.applyForceToPlayerForDuration,
+        applyRepulsionForceToPlayer: force.applyRepulsionForceToPlayer
+    };
+}
+exports.createPhysicsSystem = createPhysicsSystem;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dcl/ecs",
   "description": "Decentraland ECS",
-  "version": "7.22.5-24836126953.commit-ddc8da1",
+  "version": "7.22.5",
   "author": "DCL",
   "bugs": "https://github.com/decentraland/ecs/issues",
   "files": [
@@ -31,7 +31,8 @@
     "displayName": "ECS",
     "tsconfig": "./tsconfig.json"
   },
+  "dependencies": {},
   "types": "./dist/index.d.ts",
   "typings": "./dist/index.d.ts",
-  "commit": "ddc8da1f80f3b488609d8a2a694f0c9fd5fe2c54"
+  "commit": "b6da827dbab8b88795119b50ab578d457e552d0c"
 }

package/dist/components/manual/CreatedBy.d.ts

@@ -1,9 +0,0 @@
-import { IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine/types';
-export interface ICreatedByType {
-    address: string;
-}
-export type ICreatedBy = LastWriteWinElementSetComponentDefinition<ICreatedByType>;
-declare function defineCreatedBy(engine: Pick<IEngine, 'defineComponent'>): import("../../engine/types").MapComponentDefinition<import("../..").MapResult<{
-    address: import("../../schemas").ISchema<string>;
-}>>;
-export default defineCreatedBy;

package/dist/components/manual/CreatedBy.js

@@ -1,8 +0,0 @@
-import { Schemas } from '../../schemas';
-function defineCreatedBy(engine) {
-    const CreatedBy = engine.defineComponent('core-schema::Created-By', {
-        address: Schemas.String
-    });
-    return CreatedBy;
-}
-export default defineCreatedBy;

package/dist/serialization/crdt/authoritativePutComponent.d.ts

@@ -1,15 +0,0 @@
-import { Entity } from '../../engine/entity';
-import { ByteBuffer } from '../ByteBuffer';
-import { AuthoritativePutComponentMessage } from './types';
-/**
- * @public
- */
-export declare namespace AuthoritativePutComponentOperation {
-    const MESSAGE_HEADER_LENGTH = 16;
-    /**
-     * Call this function for an optimal writing data passing the ByteBuffer
-     *  already allocated
-     */
-    function write(entity: Entity, timestamp: number, componentId: number, data: Uint8Array, buf: ByteBuffer): void;
-    function read(buf: ByteBuffer): AuthoritativePutComponentMessage | null;
-}

package/dist/serialization/crdt/authoritativePutComponent.js

@@ -1,47 +0,0 @@
-import { CrdtMessageProtocol } from './crdtMessageProtocol';
-import { CrdtMessageType, CRDT_MESSAGE_HEADER_LENGTH } from './types';
-/**
- * @public
- */
-export var AuthoritativePutComponentOperation;
-(function (AuthoritativePutComponentOperation) {
-    AuthoritativePutComponentOperation.MESSAGE_HEADER_LENGTH = 16;
-    /**
-     * Call this function for an optimal writing data passing the ByteBuffer
-     *  already allocated
-     */
-    function write(entity, timestamp, componentId, data, buf) {
-        // reserve the beginning
-        const startMessageOffset = buf.incrementWriteOffset(CRDT_MESSAGE_HEADER_LENGTH + AuthoritativePutComponentOperation.MESSAGE_HEADER_LENGTH);
-        // write body
-        buf.writeBuffer(data, false);
-        const messageLength = buf.currentWriteOffset() - startMessageOffset;
-        // Write CrdtMessage header
-        buf.setUint32(startMessageOffset, messageLength);
-        buf.setUint32(startMessageOffset + 4, CrdtMessageType.AUTHORITATIVE_PUT_COMPONENT);
-        // Write ComponentOperation header
-        buf.setUint32(startMessageOffset + 8, entity);
-        buf.setUint32(startMessageOffset + 12, componentId);
-        buf.setUint32(startMessageOffset + 16, timestamp);
-        const newLocal = messageLength - AuthoritativePutComponentOperation.MESSAGE_HEADER_LENGTH - CRDT_MESSAGE_HEADER_LENGTH;
-        buf.setUint32(startMessageOffset + 20, newLocal);
-    }
-    AuthoritativePutComponentOperation.write = write;
-    function read(buf) {
-        const header = CrdtMessageProtocol.readHeader(buf);
-        if (!header) {
-            return null;
-        }
-        if (header.type !== CrdtMessageType.AUTHORITATIVE_PUT_COMPONENT) {
-            throw new Error('AuthoritativePutComponentOperation tried to read another message type.');
-        }
-        return {
-            ...header,
-            entityId: buf.readUint32(),
-            componentId: buf.readUint32(),
-            timestamp: buf.readUint32(),
-            data: buf.readBuffer()
-        };
-    }
-    AuthoritativePutComponentOperation.read = read;
-})(AuthoritativePutComponentOperation || (AuthoritativePutComponentOperation = {}));

package/dist-cjs/components/manual/CreatedBy.d.ts

@@ -1,9 +0,0 @@
-import { IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine/types';
-export interface ICreatedByType {
-    address: string;
-}
-export type ICreatedBy = LastWriteWinElementSetComponentDefinition<ICreatedByType>;
-declare function defineCreatedBy(engine: Pick<IEngine, 'defineComponent'>): import("../../engine/types").MapComponentDefinition<import("../..").MapResult<{
-    address: import("../../schemas").ISchema<string>;
-}>>;
-export default defineCreatedBy;

package/dist-cjs/components/manual/CreatedBy.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const schemas_1 = require("../../schemas");
-function defineCreatedBy(engine) {
-    const CreatedBy = engine.defineComponent('core-schema::Created-By', {
-        address: schemas_1.Schemas.String
-    });
-    return CreatedBy;
-}
-exports.default = defineCreatedBy;

package/dist-cjs/serialization/crdt/authoritativePutComponent.d.ts

@@ -1,15 +0,0 @@
-import { Entity } from '../../engine/entity';
-import { ByteBuffer } from '../ByteBuffer';
-import { AuthoritativePutComponentMessage } from './types';
-/**
- * @public
- */
-export declare namespace AuthoritativePutComponentOperation {
-    const MESSAGE_HEADER_LENGTH = 16;
-    /**
-     * Call this function for an optimal writing data passing the ByteBuffer
-     *  already allocated
-     */
-    function write(entity: Entity, timestamp: number, componentId: number, data: Uint8Array, buf: ByteBuffer): void;
-    function read(buf: ByteBuffer): AuthoritativePutComponentMessage | null;
-}

package/dist-cjs/serialization/crdt/authoritativePutComponent.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthoritativePutComponentOperation = void 0;
-const crdtMessageProtocol_1 = require("./crdtMessageProtocol");
-const types_1 = require("./types");
-/**
- * @public
- */
-var AuthoritativePutComponentOperation;
-(function (AuthoritativePutComponentOperation) {
-    AuthoritativePutComponentOperation.MESSAGE_HEADER_LENGTH = 16;
-    /**
-     * Call this function for an optimal writing data passing the ByteBuffer
-     *  already allocated
-     */
-    function write(entity, timestamp, componentId, data, buf) {
-        // reserve the beginning
-        const startMessageOffset = buf.incrementWriteOffset(types_1.CRDT_MESSAGE_HEADER_LENGTH + AuthoritativePutComponentOperation.MESSAGE_HEADER_LENGTH);
-        // write body
-        buf.writeBuffer(data, false);
-        const messageLength = buf.currentWriteOffset() - startMessageOffset;
-        // Write CrdtMessage header
-        buf.setUint32(startMessageOffset, messageLength);
-        buf.setUint32(startMessageOffset + 4, types_1.CrdtMessageType.AUTHORITATIVE_PUT_COMPONENT);
-        // Write ComponentOperation header
-        buf.setUint32(startMessageOffset + 8, entity);
-        buf.setUint32(startMessageOffset + 12, componentId);
-        buf.setUint32(startMessageOffset + 16, timestamp);
-        const newLocal = messageLength - AuthoritativePutComponentOperation.MESSAGE_HEADER_LENGTH - types_1.CRDT_MESSAGE_HEADER_LENGTH;
-        buf.setUint32(startMessageOffset + 20, newLocal);
-    }
-    AuthoritativePutComponentOperation.write = write;
-    function read(buf) {
-        const header = crdtMessageProtocol_1.CrdtMessageProtocol.readHeader(buf);
-        if (!header) {
-            return null;
-        }
-        if (header.type !== types_1.CrdtMessageType.AUTHORITATIVE_PUT_COMPONENT) {
-            throw new Error('AuthoritativePutComponentOperation tried to read another message type.');
-        }
-        return {
-            ...header,
-            entityId: buf.readUint32(),
-            componentId: buf.readUint32(),
-            timestamp: buf.readUint32(),
-            data: buf.readBuffer()
-        };
-    }
-    AuthoritativePutComponentOperation.read = read;
-})(AuthoritativePutComponentOperation = exports.AuthoritativePutComponentOperation || (exports.AuthoritativePutComponentOperation = {}));