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

package/dist/systems/events.d.ts

@@ -17,6 +17,7 @@ export type EventSystemOptions = {
     showFeedback?: boolean;
     showHighlight?: boolean;
     maxPlayerDistance?: number;
+    priority?: number;
 };
 export declare const getDefaultOpts: (opts?: Partial<EventSystemOptions>) => EventSystemOptions;
 /**
@@ -47,6 +48,30 @@ export interface PointerEventsSystem {
      * @param entity - Entity where the callback was attached
      */
     removeOnPointerHoverLeave(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onProximityDown event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnProximityDown(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onProximityUp event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnProximityUp(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onProximityEnter event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnProximityEnter(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onProximityLeave event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnProximityLeave(entity: Entity): void;
     /**
      * @public
      * Execute callback when the user press the InputButton pointing at the entity
@@ -101,6 +126,46 @@ export interface PointerEventsSystem {
         entity: Entity;
         opts?: Partial<EventSystemOptions>;
     }, cb: EventSystemCallback): void;
+    /**
+     * @public
+     * Execute callback when the user presses the proximity button on the entity
+     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
+     * @param cb - Function to execute when click fires
+     */
+    onProximityDown(pointerData: {
+        entity: Entity;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
+    /**
+     * @public
+     * Execute callback when the user releases the proximity button on the entity
+     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
+     * @param cb - Function to execute when event fires
+     */
+    onProximityUp(pointerData: {
+        entity: Entity;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
+    /**
+     * @public
+     * Execute callback when the entity enters the proximity zone of the user
+     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
+     * @param cb - Function to execute when event fires
+     */
+    onProximityEnter(pointerData: {
+        entity: Entity;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
+    /**
+     * @public
+     * Execute callback when the entity leaves the proximity zone of the user
+     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
+     * @param cb - Function to execute when event fires
+     */
+    onProximityLeave(pointerData: {
+        entity: Entity;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
 }
 /**
  * @public

package/dist/systems/events.js

@@ -18,12 +18,14 @@ export function createPointerEventsSystem(engine, inputSystem) {
         EventType[EventType["Up"] = 2] = "Up";
         EventType[EventType["HoverEnter"] = 3] = "HoverEnter";
         EventType[EventType["HoverLeave"] = 4] = "HoverLeave";
+        EventType[EventType["ProximityEnter"] = 5] = "ProximityEnter";
+        EventType[EventType["ProximityLeave"] = 6] = "ProximityLeave";
     })(EventType || (EventType = {}));
     const eventsMap = new Map();
     function getEvent(entity) {
         return eventsMap.get(entity) || eventsMap.set(entity, new Map()).get(entity);
     }
-    function setPointerEvent(entity, type, opts) {
+    function setPointerEvent(entity, type, opts, interactionType = 0 /* InteractionType.CURSOR */) {
         const pointerEvent = PointerEvents.getMutableOrNull(entity) || PointerEvents.create(entity);
         pointerEvent.pointerEvents.push({
             eventType: type,
@@ -33,15 +35,19 @@ export function createPointerEventsSystem(engine, inputSystem) {
                 showHighlight: opts.showHighlight,
                 hoverText: opts.hoverText,
                 maxDistance: opts.maxDistance,
-                maxPlayerDistance: opts.maxPlayerDistance
-            }
+                maxPlayerDistance: opts.maxPlayerDistance,
+                priority: opts.priority
+            },
+            interactionType: interactionType ?? 0 /* InteractionType.CURSOR */
         });
     }
-    function removePointerEvent(entity, type, button) {
+    function removePointerEvent(entity, type, button, interactionType = 0 /* InteractionType.CURSOR */) {
         const pointerEvent = PointerEvents.getMutableOrNull(entity);
         if (!pointerEvent)
             return;
-        pointerEvent.pointerEvents = pointerEvent.pointerEvents.filter((pointer) => !(pointer.eventInfo?.button === button && pointer.eventType === type));
+        pointerEvent.pointerEvents = pointerEvent.pointerEvents.filter((pointer) => !(pointer.eventInfo?.button === button &&
+            pointer.eventType === type &&
+            pointer.interactionType === interactionType));
     }
     function getPointerEvent(eventType) {
         if (eventType === EventType.Up) {
@@ -53,9 +59,15 @@ export function createPointerEventsSystem(engine, inputSystem) {
         else if (eventType === EventType.HoverEnter) {
             return 2 /* PointerEventType.PET_HOVER_ENTER */;
         }
+        else if (eventType === EventType.ProximityEnter) {
+            return 4 /* PointerEventType.PET_PROXIMITY_ENTER */;
+        }
+        else if (eventType === EventType.ProximityLeave) {
+            return 5 /* PointerEventType.PET_PROXIMITY_LEAVE */;
+        }
         return 1 /* PointerEventType.PET_DOWN */;
     }
-    function removeEvent(entity, type) {
+    function removeEvent(entity, type, interactionType = 0 /* InteractionType.CURSOR */) {
         const event = getEvent(entity);
         const pointerEvent = event.get(type);
         if (pointerEvent?.opts.hoverText) {
@@ -78,7 +90,9 @@ export function createPointerEventsSystem(engine, inputSystem) {
                 if (eventType === EventType.Down ||
                     eventType === EventType.Up ||
                     eventType === EventType.HoverEnter ||
-                    eventType === EventType.HoverLeave) {
+                    eventType === EventType.HoverLeave ||
+                    eventType === EventType.ProximityEnter ||
+                    eventType === EventType.ProximityLeave) {
                     const command = inputSystem.getInputCommand(opts.button, getPointerEvent(eventType), entity);
                     if (command) {
                         checkNotThenable(cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
@@ -125,6 +139,38 @@ export function createPointerEventsSystem(engine, inputSystem) {
         getEvent(entity).set(EventType.HoverLeave, { cb, opts: options });
         setPointerEvent(entity, 3 /* PointerEventType.PET_HOVER_LEAVE */, options);
     };
+    const onProximityDown = (...args) => {
+        const [data, cb] = args;
+        const { entity, opts } = data;
+        const options = getDefaultOpts(opts);
+        removeEvent(entity, EventType.Down, 1 /* InteractionType.PROXIMITY */);
+        getEvent(entity).set(EventType.Down, { cb, opts: options });
+        setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options, 1 /* InteractionType.PROXIMITY */);
+    };
+    const onProximityUp = (...args) => {
+        const [data, cb] = args;
+        const { entity, opts } = data;
+        const options = getDefaultOpts(opts);
+        removeEvent(entity, EventType.Up, 1 /* InteractionType.PROXIMITY */);
+        getEvent(entity).set(EventType.Up, { cb, opts: options });
+        setPointerEvent(entity, 0 /* PointerEventType.PET_UP */, options, 1 /* InteractionType.PROXIMITY */);
+    };
+    const onProximityEnter = (...args) => {
+        const [data, cb] = args;
+        const { entity, opts } = data;
+        const options = getDefaultOpts(opts);
+        removeEvent(entity, EventType.ProximityEnter, 1 /* InteractionType.PROXIMITY */);
+        getEvent(entity).set(EventType.ProximityEnter, { cb, opts: options });
+        setPointerEvent(entity, 4 /* PointerEventType.PET_PROXIMITY_ENTER */, options, 1 /* InteractionType.PROXIMITY */);
+    };
+    const onProximityLeave = (...args) => {
+        const [data, cb] = args;
+        const { entity, opts } = data;
+        const options = getDefaultOpts(opts);
+        removeEvent(entity, EventType.ProximityLeave, 1 /* InteractionType.PROXIMITY */);
+        getEvent(entity).set(EventType.ProximityLeave, { cb, opts: options });
+        setPointerEvent(entity, 5 /* PointerEventType.PET_PROXIMITY_LEAVE */, options, 1 /* InteractionType.PROXIMITY */);
+    };
     return {
         removeOnClick(entity) {
             removeEvent(entity, EventType.Click);
@@ -141,6 +187,18 @@ export function createPointerEventsSystem(engine, inputSystem) {
         removeOnPointerHoverLeave(entity) {
             removeEvent(entity, EventType.HoverLeave);
         },
+        removeOnProximityDown(entity) {
+            removeEvent(entity, EventType.Down, 1 /* InteractionType.PROXIMITY */);
+        },
+        removeOnProximityUp(entity) {
+            removeEvent(entity, EventType.Up, 1 /* InteractionType.PROXIMITY */);
+        },
+        removeOnProximityEnter(entity) {
+            removeEvent(entity, EventType.ProximityEnter, 1 /* InteractionType.PROXIMITY */);
+        },
+        removeOnProximityLeave(entity) {
+            removeEvent(entity, EventType.ProximityLeave, 1 /* InteractionType.PROXIMITY */);
+        },
         onClick(value, cb) {
             const { entity } = value;
             const options = getDefaultOpts(value.opts);
@@ -153,6 +211,10 @@ export function createPointerEventsSystem(engine, inputSystem) {
         onPointerDown,
         onPointerUp,
         onPointerHoverEnter,
-        onPointerHoverLeave
+        onPointerHoverLeave,
+        onProximityDown,
+        onProximityUp,
+        onProximityEnter,
+        onProximityLeave
     };
 }

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

@@ -0,0 +1 @@
+export {};

package/dist/systems/physics-force.js

@@ -0,0 +1,140 @@
+import * as components from '../components';
+import { Vector3, createTimers } from '../runtime/helpers';
+import { KnockbackFalloff } from './physics-impulse';
+/** @internal */
+export function createPhysicsForceHelper(engine) {
+    const PhysicsCombinedForce = components.PhysicsCombinedForce(engine);
+    const Transform = components.Transform(engine);
+    const timers = 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 (!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 = Vector3.add(sum, v);
+        }
+        PhysicsCombinedForce.createOrReplace(engine.PlayerEntity, { vector: sum });
+        lastWrittenForceVector = sum;
+    }
+    function applyForceToPlayer(source, vector, magnitude) {
+        let finalVector;
+        if (Vector3.equalsToFloats(vector, 0, 0, 0))
+            return;
+        if (typeof magnitude === 'number') {
+            finalVector = Vector3.scale(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 = Vector3.subtract(Transform.get(engine.PlayerEntity).position, fromPosition);
+        if (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 === KnockbackFalloff.CONSTANT) {
+            return Vector3.scale(Vector3.normalize(diff), magnitude);
+        }
+        const distance = Vector3.length(diff);
+        if (distance > radius)
+            return null;
+        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;
+        }
+        if (effectiveMagnitude === 0)
+            return null;
+        // normalize(diff) * effectiveMagnitude in one step
+        return Vector3.scale(diff, effectiveMagnitude / distance);
+    }
+    function applyRepulsionForceToPlayer(source, fromPosition, magnitude, radius = Infinity, falloff = 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 };
+}

package/dist/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/systems/physics-impulse.js

@@ -0,0 +1,85 @@
+import * as components from '../components';
+import { Vector3 } from '../runtime/helpers';
+/**
+ * @public
+ * Falloff mode for knockback force over distance.
+ */
+export 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 || (KnockbackFalloff = {}));
+/** @internal */
+export 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 (Vector3.equalsToFloats(vector, 0, 0, 0))
+                return;
+            finalVector = Vector3.scale(Vector3.normalize(vector), magnitude);
+        }
+        else {
+            if (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 = 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 = Vector3.subtract(Transform.get(engine.PlayerEntity).position, fromPosition);
+        if (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(Vector3.scale(Vector3.normalize(diff), magnitude));
+            return;
+        }
+        const distance = 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(Vector3.scale(diff, effectiveMagnitude / distance));
+    }
+    return { applyImpulseToPlayer, applyKnockbackToPlayer };
+}

package/dist/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/systems/physics.js

@@ -0,0 +1,18 @@
+import { createPhysicsImpulseHelper } from './physics-impulse';
+import { createPhysicsForceHelper } from './physics-force';
+export { KnockbackFalloff } from './physics-impulse';
+/**
+ * @internal
+ */
+export function createPhysicsSystem(engine) {
+    const impulse = createPhysicsImpulseHelper(engine);
+    const force = createPhysicsForceHelper(engine);
+    return {
+        applyImpulseToPlayer: impulse.applyImpulseToPlayer,
+        applyForceToPlayer: force.applyForceToPlayer,
+        removeForceFromPlayer: force.removeForceFromPlayer,
+        applyKnockbackToPlayer: impulse.applyKnockbackToPlayer,
+        applyForceToPlayerForDuration: force.applyForceToPlayerForDuration,
+        applyRepulsionForceToPlayer: force.applyRepulsionForceToPlayer
+    };
+}

package/dist-cjs/components/extended/ParticleSystem.d.ts

@@ -0,0 +1,24 @@
+import { IEngine, LastWriteWinElementSetComponentDefinition } from '../../engine';
+import { PBParticleSystem, PBParticleSystem_BlendMode, PBParticleSystem_PlaybackState, PBParticleSystem_Point, PBParticleSystem_Sphere, PBParticleSystem_Cone, PBParticleSystem_Box } from '../generated/index.gen';
+export { PBParticleSystem_BlendMode as ParticleSystemBlendMode, PBParticleSystem_PlaybackState as ParticleSystemPlaybackState };
+/**
+ * @public
+ */
+export interface ParticleSystemHelper {
+    /** Emit from a single point */
+    Point: (point?: PBParticleSystem_Point) => PBParticleSystem['shape'];
+    /** Emit from the surface or volume of a sphere */
+    Sphere: (sphere?: PBParticleSystem_Sphere) => PBParticleSystem['shape'];
+    /** Emit from the base of a cone, projecting outward */
+    Cone: (cone?: PBParticleSystem_Cone) => PBParticleSystem['shape'];
+    /** Emit from the surface or volume of a box */
+    Box: (box?: PBParticleSystem_Box) => PBParticleSystem['shape'];
+}
+/**
+ * @public
+ */
+export interface ParticleSystemComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBParticleSystem> {
+    /** Helpers for constructing emitter shapes */
+    Shape: ParticleSystemHelper;
+}
+export declare function defineParticleSystemComponent(engine: Pick<IEngine, 'defineComponentFromSchema'>): ParticleSystemComponentDefinitionExtended;

package/dist-cjs/components/extended/ParticleSystem.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineParticleSystemComponent = exports.ParticleSystemPlaybackState = exports.ParticleSystemBlendMode = void 0;
+const index_gen_1 = require("../generated/index.gen");
+Object.defineProperty(exports, "ParticleSystemBlendMode", { enumerable: true, get: function () { return index_gen_1.PBParticleSystem_BlendMode; } });
+Object.defineProperty(exports, "ParticleSystemPlaybackState", { enumerable: true, get: function () { return index_gen_1.PBParticleSystem_PlaybackState; } });
+const ParticleSystemShapeHelper = {
+    Point(point = {}) {
+        return { $case: 'point', point };
+    },
+    Sphere(sphere = {}) {
+        return { $case: 'sphere', sphere };
+    },
+    Cone(cone = {}) {
+        return { $case: 'cone', cone };
+    },
+    Box(box = {}) {
+        return { $case: 'box', box };
+    }
+};
+function defineParticleSystemComponent(engine) {
+    const theComponent = (0, index_gen_1.ParticleSystem)(engine);
+    return {
+        ...theComponent,
+        Shape: ParticleSystemShapeHelper
+    };
+}
+exports.defineParticleSystemComponent = defineParticleSystemComponent;

package/dist-cjs/components/generated/ParticleSystem.gen.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-cjs/components/generated/ParticleSystem.gen.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticleSystemSchema = void 0;
+const particle_system_gen_1 = require("./pb/decentraland/sdk/components/particle_system.gen");
+/**
+ * @internal
+ */
+exports.ParticleSystemSchema = {
+    COMPONENT_ID: 1217,
+    serialize(value, builder) {
+        const writer = particle_system_gen_1.PBParticleSystem.encode(value);
+        const buffer = new Uint8Array(writer.finish(), 0, writer.len);
+        builder.writeBuffer(buffer, false);
+    },
+    deserialize(reader) {
+        return particle_system_gen_1.PBParticleSystem.decode(reader.buffer(), reader.remainingBytes());
+    },
+    create() {
+        // TODO: this is a hack.
+        return particle_system_gen_1.PBParticleSystem.decode(new Uint8Array());
+    },
+    jsonSchema: {
+        type: "object",
+        properties: {},
+        serializationType: "protocol-buffer",
+        protocolBuffer: "PBParticleSystem"
+    }
+};

package/dist-cjs/components/generated/component-names.gen.js

@@ -33,6 +33,7 @@ exports.coreComponentMappings = {
     "core::MeshCollider": 1019,
     "core::MeshRenderer": 1018,
     "core::NftShape": 1040,
+    "core::ParticleSystem": 1217,
     "core::PhysicsCombinedForce": 1216,
     "core::PhysicsCombinedImpulse": 1215,
     "core::PlayerIdentityData": 1089,