@woosh/meep-engine 3.45.0 → 3.46.0

package/src/engine/physics/fluid/ecs/FluidComponent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FluidComponent.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/FluidComponent.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAEI;;OAEG;IACH,OAFU,UAAU,CAEK;IAEzB;;;;;;;OAOG;IACH,QAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEf;IAEnB;;;;;;;;OAQG;IACH,QAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEf;IAEnB;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;;;;;;;;;;;;;;;;;OAmBG;IACH,YAFU,MAAM,CAEC;IAEjB;;;;OAIG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;OAKG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;;;OAOG;IACH,iBANW,YAAY,GAAC,MAAM,EAAE,MACrB,MAAM,MACN,MAAM,MACN,MAAM,GACL,YAAY,GAAC,MAAM,EAAE,CAQhC;IAED;;;;;;;OAOG;IACH,iBANW,YAAY,GAAC,MAAM,EAAE,MACrB,MAAM,MACN,MAAM,MACN,MAAM,GACL,YAAY,GAAC,MAAM,EAAE,CAOhC;IAED;;;;;;;;;;;;;;OAcG;IACH,2BANW,YAAY,GAAC,MAAM,EAAE,MACrB,MAAM,MACN,MAAM,MACN,MAAM,GACL,YAAY,GAAC,MAAM,EAAE,CAQhC;IAED;;;;;;;OAOG;IACH,0BANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,MAAM,CAQjB;IAED;;;OAGG;IACH,cAHW,cAAc,GACb,OAAO,CAoBlB;IAED;;OAEG;IACH,QAFY,MAAM,CAgBjB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iCAmBC;IAGL,0BAAyC;CAFxC;2BA/P0B,kBAAkB"}
+{"version":3,"file":"FluidComponent.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/FluidComponent.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAEI;;OAEG;IACH,OAFU,UAAU,CAEK;IAEzB;;;;;;;OAOG;IACH,QAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEf;IAEnB;;;;;;;;OAQG;IACH,QAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEf;IAEnB;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;;;;;;;;;;;;;;;;;OAmBG;IACH,YAFU,MAAM,CAEC;IAEjB;;;;OAIG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;OAKG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;;;OAOG;IACH,iBANW,YAAY,GAAC,MAAM,EAAE,MACrB,MAAM,MACN,MAAM,MACN,MAAM,GACL,YAAY,GAAC,MAAM,EAAE,CAQhC;IAED;;;;;;;OAOG;IACH,iBANW,YAAY,GAAC,MAAM,EAAE,MACrB,MAAM,MACN,MAAM,MACN,MAAM,GACL,YAAY,GAAC,MAAM,EAAE,CAOhC;IAED;;;;;;;;;;;;;;OAcG;IACH,2BANW,YAAY,GAAC,MAAM,EAAE,MACrB,MAAM,MACN,MAAM,MACN,MAAM,GACL,YAAY,GAAC,MAAM,EAAE,CAQhC;IAED;;;;;;;OAOG;IACH,0BANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACL,MAAM,CAQjB;IAED;;;OAGG;IACH,cAHW,cAAc,GACb,OAAO,CAoBlB;IAED;;OAEG;IACH,QAFY,MAAM,CAwBjB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iCAmBC;IAGL,0BAAyC;CAFxC;2BAvQ0B,kBAAkB"}

package/src/engine/physics/fluid/ecs/FluidComponent.js

@@ -1,4 +1,4 @@
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { FluidField } from "../FluidField.js";
 
@@ -197,16 +197,24 @@ export class FluidComponent {
      * @return {number}
      */
     hash() {
-        return combine_hash(
-            this.enabled ? 1 : 0,
-            this.anchored ? 1 : 0,
-            computeHashFloat(this.cell_size),
-            computeHashFloat(this.hysteresis),
-            computeHashFloat(this.origin[0]),
-            computeHashFloat(this.origin[1]),
-            computeHashFloat(this.origin[2]),
-            computeHashFloat(this.offset[0]),
-            computeHashFloat(this.offset[1]),
+        return hash_mix3(
+            hash_mix3(
+                hash_mix3(
+                    hash_mix3(
+                        hash_mix3(
+                            this.enabled ? 1 : 0,
+                            this.anchored ? 1 : 0,
+                            computeHashFloat(this.cell_size)
+                        ),
+                        computeHashFloat(this.hysteresis),
+                        computeHashFloat(this.origin[0])
+                    ),
+                    computeHashFloat(this.origin[1]),
+                    computeHashFloat(this.origin[2])
+                ),
+                computeHashFloat(this.offset[0]),
+                computeHashFloat(this.offset[1])
+            ),
             computeHashFloat(this.offset[2]),
             this.field.hash()
         );

package/src/engine/physics/fluid/effector/AbstractFluidEffector.d.ts

@@ -53,8 +53,8 @@ export class AbstractFluidEffector {
     equals(other: AbstractFluidEffector): boolean;
     /**
      * Fast hash. The base implementation returns a constant — concrete effectors
-     * override to hash their own state. Should stay cheap (a few `combine_hash` calls
-     * over scalar fields).
+     * override to hash their own state. Should stay cheap (a few `hash_mix2` / `hash_mix3`
+     * calls over scalar fields).
      * @return {number}
      */
     hash(): number;

package/src/engine/physics/fluid/effector/AbstractFluidEffector.js

@@ -63,8 +63,8 @@ export class AbstractFluidEffector {
 
     /**
      * Fast hash. The base implementation returns a constant — concrete effectors
-     * override to hash their own state. Should stay cheap (a few `combine_hash` calls
-     * over scalar fields).
+     * override to hash their own state. Should stay cheap (a few `hash_mix2` / `hash_mix3`
+     * calls over scalar fields).
      * @return {number}
      */
     hash() {

package/src/engine/physics/fluid/effector/GlobalFluidEffector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GlobalFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/GlobalFluidEffector.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH;IAEI;;;;;OAKG;IACH,OAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEhB;IAElB;;;;;OAKG;IACH,MAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEjB;IAEjB;;;;;;;OAOG;IACH,MAFU,MAAM,CAEP;CA2HZ;sCAvMqC,4BAA4B"}
+{"version":3,"file":"GlobalFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/GlobalFluidEffector.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH;IAEI;;;;;OAKG;IACH,OAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEhB;IAElB;;;;;OAKG;IACH,MAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEjB;IAEjB;;;;;;;OAOG;IACH,MAFU,MAAM,CAEP;CA+HZ;sCA3MqC,4BAA4B"}

package/src/engine/physics/fluid/effector/GlobalFluidEffector.js

@@ -1,4 +1,4 @@
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { AbstractFluidEffector } from "./AbstractFluidEffector.js";
 
@@ -180,12 +180,16 @@ export class GlobalFluidEffector extends AbstractFluidEffector {
      * @return {number}
      */
     hash() {
-        return combine_hash(
-            computeHashFloat(this.force[0]),
-            computeHashFloat(this.force[1]),
-            computeHashFloat(this.force[2]),
-            computeHashFloat(this.wind[0]),
-            computeHashFloat(this.wind[1]),
+        return hash_mix3(
+            hash_mix3(
+                hash_mix3(
+                    computeHashFloat(this.force[0]),
+                    computeHashFloat(this.force[1]),
+                    computeHashFloat(this.force[2])
+                ),
+                computeHashFloat(this.wind[0]),
+                computeHashFloat(this.wind[1])
+            ),
             computeHashFloat(this.wind[2]),
             computeHashFloat(this.drag)
         );

package/src/engine/physics/fluid/effector/ImpulseFluidEffector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImpulseFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/ImpulseFluidEffector.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAEI;;;OAGG;IACH,UAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEb;IAErB;;;;;;OAMG;IACH,OAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEhB;IAElB;;;;;;OAMG;IACH,QAFU,MAAM,CAEL;CA8Md;sCA5PqC,4BAA4B"}
+{"version":3,"file":"ImpulseFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/ImpulseFluidEffector.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAEI;;;OAGG;IACH,UAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEb;IAErB;;;;;;OAMG;IACH,OAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEhB;IAElB;;;;;;OAMG;IACH,QAFU,MAAM,CAEL;CAkNd;sCAhQqC,4BAA4B"}

package/src/engine/physics/fluid/effector/ImpulseFluidEffector.js

@@ -1,4 +1,4 @@
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { v3_matrix4_multiply } from "../../../../core/geom/vec3/v3_matrix4_multiply.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { AbstractFluidEffector } from "./AbstractFluidEffector.js";
@@ -225,12 +225,16 @@ export class ImpulseFluidEffector extends AbstractFluidEffector {
      * @return {number}
      */
     hash() {
-        return combine_hash(
-            computeHashFloat(this.position[0]),
-            computeHashFloat(this.position[1]),
-            computeHashFloat(this.position[2]),
-            computeHashFloat(this.force[0]),
-            computeHashFloat(this.force[1]),
+        return hash_mix3(
+            hash_mix3(
+                hash_mix3(
+                    computeHashFloat(this.position[0]),
+                    computeHashFloat(this.position[1]),
+                    computeHashFloat(this.position[2])
+                ),
+                computeHashFloat(this.force[0]),
+                computeHashFloat(this.force[1])
+            ),
             computeHashFloat(this.force[2]),
             computeHashFloat(this.radius)
         );

package/src/engine/physics/fluid/effector/WakeFluidEffector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WakeFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/WakeFluidEffector.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IAEI;;;;;OAKG;IACH,UAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEb;IAErB;;;;;;OAMG;IACH,mBAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEJ;IAE9B;;;;;OAKG;IACH,QAFU,MAAM,CAEL;IAEX;;;;;OAKG;IACH,UAFU,MAAM,CAEH;IAoBb;;;;;OAKG;IACH,oBAKC;;CAgSJ;sCAnZqC,4BAA4B"}
+{"version":3,"file":"WakeFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/WakeFluidEffector.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IAEI;;;;;OAKG;IACH,UAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEb;IAErB;;;;;;OAMG;IACH,mBAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEJ;IAE9B;;;;;OAKG;IACH,QAFU,MAAM,CAEL;IAEX;;;;;OAKG;IACH,UAFU,MAAM,CAEH;IAoBb;;;;;OAKG;IACH,oBAKC;;CAsSJ;sCAzZqC,4BAA4B"}

package/src/engine/physics/fluid/effector/WakeFluidEffector.js

@@ -1,4 +1,5 @@
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { v3_matrix4_multiply } from "../../../../core/geom/vec3/v3_matrix4_multiply.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { AbstractFluidEffector } from "./AbstractFluidEffector.js";
@@ -368,14 +369,20 @@ export class WakeFluidEffector extends AbstractFluidEffector {
      * @return {number}
      */
     hash() {
-        return combine_hash(
-            computeHashFloat(this.position[0]),
-            computeHashFloat(this.position[1]),
-            computeHashFloat(this.position[2]),
-            computeHashFloat(this.previous_position[0]),
-            computeHashFloat(this.previous_position[1]),
-            computeHashFloat(this.previous_position[2]),
-            computeHashFloat(this.radius),
+        return hash_mix2(
+            hash_mix3(
+                hash_mix3(
+                    hash_mix3(
+                        computeHashFloat(this.position[0]),
+                        computeHashFloat(this.position[1]),
+                        computeHashFloat(this.position[2])
+                    ),
+                    computeHashFloat(this.previous_position[0]),
+                    computeHashFloat(this.previous_position[1])
+                ),
+                computeHashFloat(this.previous_position[2]),
+                computeHashFloat(this.radius)
+            ),
             computeHashFloat(this.strength)
         );
     }

package/src/engine/sound/ecs/audio/AudioEmitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AudioEmitter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/audio/AudioEmitter.js"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AACH;IA4HI;;;OAGG;IACH,4BAFa,YAAY,CAMxB;IAlID;;;;;;;;;;;;OAYG;IACH,OAFU,gBAAgB,CAEK;IAE/B;;;OAGG;IACH,QAFU,OAAO,CAEO;IAExB;;;;OAIG;IACH,UAFU,OAAO,CAED;IAEhB;;;;;OAKG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;OAKG;IACH,cAFU,MAAM,CAEqB;IAErC;;;;;OAKG;IACH,aAFU,mBAAmB,CAEW;IAExC;;;;;;;;;;;;;;;OAeG;IACH,aAFU;QAAC,KAAK,EAAE,OAAO,YAAY,CAAC,CAAA;KAAC,CAIrC;IAEF;;;OAGG;IACH,cAHW,YAAY,GACV,OAAO,CASnB;IAED,eASC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MASC;IAED,0BAaC;CAWJ;;;;iCAlJgC,4CAA4C;oBAHzD,kCAAkC;oCAElB,oDAAoD;mBAHrE,0CAA0C"}
+{"version":3,"file":"AudioEmitter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/audio/AudioEmitter.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH;IAgII;;;OAGG;IACH,4BAFa,YAAY,CAMxB;IAtID;;;;;;;;;;;;OAYG;IACH,OAFU,gBAAgB,CAEK;IAE/B;;;OAGG;IACH,QAFU,OAAO,CAEO;IAExB;;;;OAIG;IACH,UAFU,OAAO,CAED;IAEhB;;;;;OAKG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;OAKG;IACH,cAFU,MAAM,CAEqB;IAErC;;;;;OAKG;IACH,aAFU,mBAAmB,CAEW;IAExC;;;;;;;;;;;;;;;OAeG;IACH,aAFU;QAAC,KAAK,EAAE,OAAO,YAAY,CAAC,CAAA;KAAC,CAIrC;IAEF;;;OAGG;IACH,cAHW,YAAY,GACV,OAAO,CASnB;IAED,eAaC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MASC;IAED,0BAaC;CAWJ;;;;iCAtJgC,4CAA4C;oBAHzD,kCAAkC;oCAElB,oDAAoD;mBAHrE,0CAA0C"}

package/src/engine/sound/ecs/audio/AudioEmitter.js

@@ -1,4 +1,5 @@
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import Signal from "../../../../core/events/signal/Signal.js";
 import Vector1 from "../../../../core/geom/Vector1.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
@@ -104,12 +105,16 @@ export class AudioEmitter {
     }
 
     hash() {
-        return combine_hash(
-            this.event.hash(),
-            this.autoplay ? 1 : 0,
-            this.acoustic ? 1 : 0,
-            computeHashFloat(this.sourceRadius),
-            this.directivity.hash(),
+        return hash_mix2(
+            hash_mix3(
+                hash_mix3(
+                    this.event.hash(),
+                    this.autoplay ? 1 : 0,
+                    this.acoustic ? 1 : 0
+                ),
+                computeHashFloat(this.sourceRadius),
+                this.directivity.hash()
+            ),
             computeHashFloat(this.volume.getValue())
         );
     }

package/src/engine/sound/ecs/trigger/AudioEventTrigger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AudioEventTrigger.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/trigger/AudioEventTrigger.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH;IAuBI;;;;;OAKG;IACH,wBALW,MAAM,SACN,gBAAgB,cAChB,MAAM,GAAC,IAAI,GACT,qBAAqB,CAUjC;IAuCD;;;OAGG;IACH,4BAFa,qBAAqB,CAMjC;IAlFD;;;;OAIG;IACH,YAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,WAFU,MAAM,GAAC,IAAI,CAEJ;IAEjB;;;;OAIG;IACH,OAFU,gBAAgB,CAEK;IAkB/B;;;OAGG;IACH,cAHW,qBAAqB,GACnB,OAAO,CAMnB;IAED,eAMC;IAED;;;;;;;;;;;;;;;;;;;;;;;MAMC;IAED,0BASC;CAWJ;AAED;;;;;;;;GAQG;AACH;IAcI;;;OAGG;IACH,mBAHW,qBAAqB,EAAE,GACrB,iBAAiB,CAQ7B;IA6CD;;;OAGG;IACH,4BAFa,iBAAiB,CAM7B;IA3ED;;;;;;;;;OASG;IACH,OAFU,qBAAqB,EAAE,CAEtB;IAcX;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAiBnB;IAED,eAUC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;MAIC;IAED,0BAEC;CAWJ;;;;iCA1LgC,4CAA4C"}
+{"version":3,"file":"AudioEventTrigger.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/trigger/AudioEventTrigger.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH;IAuBI;;;;;OAKG;IACH,wBALW,MAAM,SACN,gBAAgB,cAChB,MAAM,GAAC,IAAI,GACT,qBAAqB,CAUjC;IAuCD;;;OAGG;IACH,4BAFa,qBAAqB,CAMjC;IAlFD;;;;OAIG;IACH,YAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,WAFU,MAAM,GAAC,IAAI,CAEJ;IAEjB;;;;OAIG;IACH,OAFU,gBAAgB,CAEK;IAkB/B;;;OAGG;IACH,cAHW,qBAAqB,GACnB,OAAO,CAMnB;IAED,eAMC;IAED;;;;;;;;;;;;;;;;;;;;;;;MAMC;IAED,0BASC;CAWJ;AAED;;;;;;;;GAQG;AACH;IAcI;;;OAGG;IACH,mBAHW,qBAAqB,EAAE,GACrB,iBAAiB,CAQ7B;IA6CD;;;OAGG;IACH,4BAFa,iBAAiB,CAM7B;IA3ED;;;;;;;;;OASG;IACH,OAFU,qBAAqB,EAAE,CAEtB;IAcX;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAiBnB;IAED,eAUC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;MAIC;IAED,0BAEC;CAWJ;;;;iCA1LgC,4CAA4C"}

package/src/engine/sound/ecs/trigger/AudioEventTrigger.js

@@ -1,191 +1,192 @@
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
-import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
-import { EventDescription } from "../../sopra/definition/EventDescription.js";
-
-/**
- * One trigger rule: "when this entity receives `startEvent`, play `event`; when it receives
- * `stopEvent`, stop what this rule started".
- *
- * The legacy `SoundController.Rule` carried `tracks[] / loop / volume / channel` alongside its event
- * names, and its system did the picking and the routing at trigger time. Here all four collapse into
- * the {@link EventDescription} itself — a random pick is a `RandomContainerAudioClip`, looping is the
- * clip's own loop flag, volume is `gainDb`, and the channel is `busId`. That is the whole point of the
- * native model: what plays is authored data, not a rule the runtime re-interprets on every trigger.
- */
-export class AudioEventTriggerRule {
-
-    /**
-     * Entity event name that starts this rule's event. Required — a rule with nothing to start does
-     * nothing at all.
-     * @type {string}
-     */
-    startEvent = "";
-
-    /**
-     * Entity event name that stops whatever this rule started, or null for a fire-and-forget rule
-     * (a one-shot ends on its own; a looping event then lives until the component unlinks).
-     * @type {string|null}
-     */
-    stopEvent = null;
-
-    /**
-     * The authored event this rule plays. Same data an {@link AudioEmitter} would hold — the difference
-     * is only in what makes it sound: linking, versus receiving an entity event.
-     * @type {EventDescription}
-     */
-    event = new EventDescription();
-
-    /**
-     * @param {string} startEvent
-     * @param {EventDescription} event
-     * @param {string|null} [stopEvent]
-     * @returns {AudioEventTriggerRule}
-     */
-    static from(startEvent, event, stopEvent = null) {
-        const r = new AudioEventTriggerRule();
-
-        r.startEvent = startEvent;
-        r.event = event;
-        r.stopEvent = stopEvent;
-
-        return r;
-    }
-
-    /**
-     * @param {AudioEventTriggerRule} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.startEvent === other.startEvent
-            && this.stopEvent === other.stopEvent
-            && this.event.equals(other.event);
-    }
-
-    hash() {
-        return combine_hash(
-            computeStringHash(this.startEvent),
-            this.stopEvent === null ? 0 : computeStringHash(this.stopEvent),
-            this.event.hash()
-        );
-    }
-
-    toJSON() {
-        return {
-            startEvent: this.startEvent,
-            stopEvent: this.stopEvent,
-            event: this.event.toJSON()
-        };
-    }
-
-    fromJSON(json) {
-        this.startEvent = json.startEvent !== undefined ? json.startEvent : "";
-        this.stopEvent = json.stopEvent !== undefined && json.stopEvent !== null ? json.stopEvent : null;
-
-        this.event = new EventDescription();
-
-        if (json.event !== undefined) {
-            this.event.fromJSON(json.event);
-        }
-    }
-
-    /**
-     * @param {*} json
-     * @returns {AudioEventTriggerRule}
-     */
-    static fromJSON(json) {
-        const r = new AudioEventTriggerRule();
-        r.fromJSON(json);
-        return r;
-    }
-}
-
-/**
- * Plays authored sopra events in response to entity events — the native replacement for the legacy
- * `SoundController`, whose system wrote `SoundTrack`s into the entity's `SoundEmitter` and so could not
- * outlive it.
- *
- * Where an {@link AudioEmitter} sounds because it was linked, an `AudioEventTrigger` sounds because the
- * entity received an event: "unit took damage" → a hurt sound. Driven by {@link AudioEventTriggerSystem};
- * the entity's {@link Transform} supplies position, exactly as for an emitter.
- */
-export class AudioEventTrigger {
-
-    /**
-     * Authored rules, evaluated independently — several may listen to the same event, and each owns the
-     * instances it started.
-     *
-     * Read once when the component links: the system registers one entity-event listener per rule then,
-     * so mutating this array on a linked component has no effect until it is re-linked (remove and
-     * re-add the component), which mirrors {@link AudioEmitter.event}.
-     *
-     * @type {AudioEventTriggerRule[]}
-     */
-    rules = [];
-
-    /**
-     * @param {AudioEventTriggerRule[]} rules
-     * @returns {AudioEventTrigger}
-     */
-    static from(rules) {
-        const r = new AudioEventTrigger();
-
-        r.rules = rules;
-
-        return r;
-    }
-
-    /**
-     * @param {AudioEventTrigger} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        const rules = this.rules;
-        const otherRules = other.rules;
-
-        if (rules.length !== otherRules.length) {
-            return false;
-        }
-
-        for (let i = 0; i < rules.length; i++) {
-            if (!rules[i].equals(otherRules[i])) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    hash() {
-        const rules = this.rules;
-
-        let hash = rules.length;
-
-        for (let i = 0; i < rules.length; i++) {
-            hash = combine_hash(hash, rules[i].hash());
-        }
-
-        return hash;
-    }
-
-    toJSON() {
-        return {
-            rules: this.rules.map(rule => rule.toJSON())
-        };
-    }
-
-    fromJSON(json) {
-        this.rules = json.rules === undefined ? [] : json.rules.map(AudioEventTriggerRule.fromJSON);
-    }
-
-    /**
-     * @param {*} json
-     * @returns {AudioEventTrigger}
-     */
-    static fromJSON(json) {
-        const r = new AudioEventTrigger();
-        r.fromJSON(json);
-        return r;
-    }
-}
-
-AudioEventTrigger.typeName = "AudioEventTrigger";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
+import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { EventDescription } from "../../sopra/definition/EventDescription.js";
+
+/**
+ * One trigger rule: "when this entity receives `startEvent`, play `event`; when it receives
+ * `stopEvent`, stop what this rule started".
+ *
+ * The legacy `SoundController.Rule` carried `tracks[] / loop / volume / channel` alongside its event
+ * names, and its system did the picking and the routing at trigger time. Here all four collapse into
+ * the {@link EventDescription} itself — a random pick is a `RandomContainerAudioClip`, looping is the
+ * clip's own loop flag, volume is `gainDb`, and the channel is `busId`. That is the whole point of the
+ * native model: what plays is authored data, not a rule the runtime re-interprets on every trigger.
+ */
+export class AudioEventTriggerRule {
+
+    /**
+     * Entity event name that starts this rule's event. Required — a rule with nothing to start does
+     * nothing at all.
+     * @type {string}
+     */
+    startEvent = "";
+
+    /**
+     * Entity event name that stops whatever this rule started, or null for a fire-and-forget rule
+     * (a one-shot ends on its own; a looping event then lives until the component unlinks).
+     * @type {string|null}
+     */
+    stopEvent = null;
+
+    /**
+     * The authored event this rule plays. Same data an {@link AudioEmitter} would hold — the difference
+     * is only in what makes it sound: linking, versus receiving an entity event.
+     * @type {EventDescription}
+     */
+    event = new EventDescription();
+
+    /**
+     * @param {string} startEvent
+     * @param {EventDescription} event
+     * @param {string|null} [stopEvent]
+     * @returns {AudioEventTriggerRule}
+     */
+    static from(startEvent, event, stopEvent = null) {
+        const r = new AudioEventTriggerRule();
+
+        r.startEvent = startEvent;
+        r.event = event;
+        r.stopEvent = stopEvent;
+
+        return r;
+    }
+
+    /**
+     * @param {AudioEventTriggerRule} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.startEvent === other.startEvent
+            && this.stopEvent === other.stopEvent
+            && this.event.equals(other.event);
+    }
+
+    hash() {
+        return hash_mix3(
+            computeStringHash(this.startEvent),
+            this.stopEvent === null ? 0 : computeStringHash(this.stopEvent),
+            this.event.hash()
+        );
+    }
+
+    toJSON() {
+        return {
+            startEvent: this.startEvent,
+            stopEvent: this.stopEvent,
+            event: this.event.toJSON()
+        };
+    }
+
+    fromJSON(json) {
+        this.startEvent = json.startEvent !== undefined ? json.startEvent : "";
+        this.stopEvent = json.stopEvent !== undefined && json.stopEvent !== null ? json.stopEvent : null;
+
+        this.event = new EventDescription();
+
+        if (json.event !== undefined) {
+            this.event.fromJSON(json.event);
+        }
+    }
+
+    /**
+     * @param {*} json
+     * @returns {AudioEventTriggerRule}
+     */
+    static fromJSON(json) {
+        const r = new AudioEventTriggerRule();
+        r.fromJSON(json);
+        return r;
+    }
+}
+
+/**
+ * Plays authored sopra events in response to entity events — the native replacement for the legacy
+ * `SoundController`, whose system wrote `SoundTrack`s into the entity's `SoundEmitter` and so could not
+ * outlive it.
+ *
+ * Where an {@link AudioEmitter} sounds because it was linked, an `AudioEventTrigger` sounds because the
+ * entity received an event: "unit took damage" → a hurt sound. Driven by {@link AudioEventTriggerSystem};
+ * the entity's {@link Transform} supplies position, exactly as for an emitter.
+ */
+export class AudioEventTrigger {
+
+    /**
+     * Authored rules, evaluated independently — several may listen to the same event, and each owns the
+     * instances it started.
+     *
+     * Read once when the component links: the system registers one entity-event listener per rule then,
+     * so mutating this array on a linked component has no effect until it is re-linked (remove and
+     * re-add the component), which mirrors {@link AudioEmitter.event}.
+     *
+     * @type {AudioEventTriggerRule[]}
+     */
+    rules = [];
+
+    /**
+     * @param {AudioEventTriggerRule[]} rules
+     * @returns {AudioEventTrigger}
+     */
+    static from(rules) {
+        const r = new AudioEventTrigger();
+
+        r.rules = rules;
+
+        return r;
+    }
+
+    /**
+     * @param {AudioEventTrigger} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        const rules = this.rules;
+        const otherRules = other.rules;
+
+        if (rules.length !== otherRules.length) {
+            return false;
+        }
+
+        for (let i = 0; i < rules.length; i++) {
+            if (!rules[i].equals(otherRules[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    hash() {
+        const rules = this.rules;
+
+        let hash = rules.length;
+
+        for (let i = 0; i < rules.length; i++) {
+            hash = hash_mix2(hash, rules[i].hash());
+        }
+
+        return hash;
+    }
+
+    toJSON() {
+        return {
+            rules: this.rules.map(rule => rule.toJSON())
+        };
+    }
+
+    fromJSON(json) {
+        this.rules = json.rules === undefined ? [] : json.rules.map(AudioEventTriggerRule.fromJSON);
+    }
+
+    /**
+     * @param {*} json
+     * @returns {AudioEventTrigger}
+     */
+    static fromJSON(json) {
+        const r = new AudioEventTrigger();
+        r.fromJSON(json);
+        return r;
+    }
+}
+
+AudioEventTrigger.typeName = "AudioEventTrigger";