@woosh/meep-engine 2.33.23 → 2.33.24

package/core/math/random/makeRangedRandom.js

@@ -0,0 +1,19 @@
+/**
+ *
+ * @param {function():number} random returns a number between 0 and 1
+ * @param {number} min
+ * @param {number} max
+ * @returns {function():number} returns number between min and max
+ */
+export function makeRangedRandom(random, min, max) {
+
+    if (min === 0 && max === 1) {
+        //input already returns values in correct range
+        return random;
+    }
+
+    const scale = max - min;
+    return function () {
+        return random() * scale + min;
+    };
+}

package/core/math/random/randomFloatBetween.js

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param {function} random
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export function randomFloatBetween(random, min, max) {
+    const span = max - min;
+
+    const roll = random();
+
+    return roll * span + min;
+}

package/core/math/random/randomFromArray.js

@@ -0,0 +1,19 @@
+import { assert } from "../../assert.js";
+import { min2 } from "../min2.js";
+
+/**
+ * @template T
+ * @param {function} random
+ * @param {T[]} array
+ * @returns {T}
+ */
+export function randomFromArray(random, array) {
+    assert.isArray(array, 'array');
+    assert.isFunction(random, 'random');
+
+    const length = array.length;
+
+    const i = min2(length - 1, Math.floor(random() * length));
+
+    return array[i];
+}

package/core/math/random/randomGaussian.js

@@ -0,0 +1,15 @@
+/**
+ * Returns a random number within a normal distribution (Bell/Gaussian curve)
+ * @param {int} [quality=6] controls number of "die rolls" used to approximate curve, more rolls - better approximation but higher cost of computation
+ * @param {function():number} random
+ * @returns {number} value between 0 and 1 with normal weight at 0.5
+ */
+export function randomGaussian(random, quality = 6) {
+    let s = 0;
+
+    for (let i = 0; i < quality; i++) {
+        s += random();
+    }
+
+    return s / quality;
+}

package/core/math/random/randomIntegerBetween.js

@@ -0,0 +1,14 @@
+/**
+ * Inclusive random between two boundaries, result is integer
+ * @param {function} random
+ * @param {number} min lower boundary, must be an integer
+ * @param {number} max upper boundary, must be an integer
+ * @returns {number}
+ */
+export function randomIntegerBetween(random, min, max) {
+    const span = max - min;
+
+    const roll = random();
+
+    return Math.round(roll * span) + min;
+}

package/core/math/random/roundFair.js

@@ -0,0 +1,15 @@
+/**
+ * Performs a probabilistic rounding where a fraction is rounded up or down with probability equal to the fraction
+ * @param {number} number
+ * @param {function} random
+ * @returns {int}
+ */
+export function roundFair(number, random) {
+    const mantissa = number % 1;
+    const roll = random();
+    if (roll < mantissa) {
+        return Math.ceil(number);
+    } else {
+        return Math.floor(number);
+    }
+}

package/core/math/separation1D.js

@@ -0,0 +1,21 @@
+import { assert } from "../assert.js";
+import { min2 } from "./min2.js";
+import { max2 } from "./max2.js";
+
+/**
+ * Returns a number representing overlap distance between two 1D line segments.
+ * Positive number indicates overlap, negative number indicates that segments do not overlap; 0 indicates that segments are touching.
+ * @param {Number} a0
+ * @param {Number} a1
+ * @param {Number} b0
+ * @param {Number} b1
+ * @returns {number}
+ */
+export function separation1D(a0, a1, b0, b1) {
+    assert.isNumber(a0, "a0");
+    assert.isNumber(a1, "a1");
+    assert.isNumber(b0, "b0");
+    assert.isNumber(b1, "b1");
+
+    return min2(a1, b1) - max2(a0, b0);
+}

package/core/math/solveQuadratic.js

@@ -0,0 +1,25 @@
+/**
+ * Return solutions for quadratic
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @returns {number[]|null}
+ */
+export function solveQuadratic(a, b, c) {
+    let sol = null;
+    if (Math.abs(a) < 1e-6) {
+        if (Math.abs(b) < 1e-6) {
+            sol = Math.abs(c) < 1e-6 ? [0, 0] : null;
+        } else {
+            sol = [-c / b, -c / b];
+        }
+    } else {
+        let disc = b * b - 4 * a * c;
+        if (disc >= 0) {
+            disc = Math.sqrt(disc);
+            a = 2 * a;
+            sol = [(-b - disc) / a, (-b + disc) / a];
+        }
+    }
+    return sol;
+}

package/core/model/BoundedValue.js

@@ -5,7 +5,7 @@
 
 import Signal from "../events/signal/Signal.js";
 import { inverseLerp } from "../math/inverseLerp.js";
-import { computeHashFloat } from "../math/MathUtils.js";
+import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 
 /**
  *

package/core/model/node-graph/node/NodeInstancePortReference.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../assert.js";
-import { computeHashIntegerArray } from "../../../math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../collection/array/computeHashIntegerArray.js";
 
 /**
  * Reference for a port of a node instance

package/core/model/node-graph/node/Port.js

@@ -1,6 +1,6 @@
-import { computeHashIntegerArray } from "../../../math/MathUtils.js";
 import { computeStringHash } from "../../../primitives/strings/computeStringHash.js";
 import { PortDirection } from "./PortDirection.js";
+import { computeHashIntegerArray } from "../../../collection/array/computeHashIntegerArray.js";
 
 export class Port {
     constructor() {

package/core/model/reactive/evaluation/MultiPredicateEvaluator.spec.js

@@ -1,4 +1,3 @@
-import { randomFloatBetween, randomFromArray, randomIntegerBetween } from "../../../math/MathUtils.js";
 import { seededRandom } from "../../../math/random/seededRandom.js";
 import DataType from "../../../parser/simple/DataType.js";
 import { ReactiveLiteralBoolean } from "../model/terminal/ReactiveLiteralBoolean.js";
@@ -7,6 +6,9 @@ import { ReactiveLiteralString } from "../model/terminal/ReactiveLiteralString.j
 import { ReactiveReference } from "../model/terminal/ReactiveReference.js";
 import { createRandomReactiveExpression } from "../model/util/createRandomReactiveExpression.js";
 import { MultiPredicateEvaluator } from "./MultiPredicateEvaluator.js";
+import { randomFromArray } from "../../../math/random/randomFromArray.js";
+import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
+import { randomIntegerBetween } from "../../../math/random/randomIntegerBetween.js";
 
 test.skip('performance', () => {
     const random = seededRandom(12319);

package/core/model/reactive/model/ReactiveBinaryExpression.js

@@ -1,6 +1,6 @@
 import { assert } from "../../../assert.js";
-import { computeHashIntegerArray } from "../../../math/MathUtils.js";
 import { ReactiveExpression } from "./ReactiveExpression.js";
+import { computeHashIntegerArray } from "../../../collection/array/computeHashIntegerArray.js";
 
 /**
  * @extends {ReactiveExpression}

package/core/model/reactive/model/terminal/ReactiveLiteralNumber.js

@@ -1,8 +1,8 @@
 import { assert } from "../../../../assert.js";
 import Signal from "../../../../events/signal/Signal.js";
-import { computeHashFloat } from "../../../../math/MathUtils.js";
 import DataType from "../../../../parser/simple/DataType.js";
 import { ReactiveExpression } from "../ReactiveExpression.js";
+import { computeHashFloat } from "../../../../math/hash/computeHashFloat.js";
 
 const dummySignal = new Signal();
 

package/core/model/reactive/model/terminal/ReactiveReference.js

@@ -1,8 +1,8 @@
 import { assert } from "../../../../assert.js";
-import { computeHashIntegerArray } from "../../../../math/MathUtils.js";
 import DataType from "../../../../parser/simple/DataType.js";
 import { computeStringHash } from "../../../../primitives/strings/computeStringHash.js";
 import { ReactiveExpression } from "../ReactiveExpression.js";
+import { computeHashIntegerArray } from "../../../../collection/array/computeHashIntegerArray.js";
 
 
 /**

package/core/model/reactive/model/util/createRandomReactiveExpression.js

@@ -4,7 +4,6 @@
  * @param {ReactiveExpression} b
  * @returns {ReactiveExpression}
  */
-import { randomFromArray } from "../../../../math/MathUtils.js";
 import DataType from "../../../../parser/simple/DataType.js";
 import { ReactiveAdd } from "../arithmetic/ReactiveAdd.js";
 import { ReactiveDivide } from "../arithmetic/ReactiveDivide.js";
@@ -20,6 +19,7 @@ import { ReactiveAnd } from "../logic/ReactiveAnd.js";
 import { ReactiveOr } from "../logic/ReactiveOr.js";
 import { ReactiveLiteralNumber } from "../terminal/ReactiveLiteralNumber.js";
 import { ReactiveLiteralString } from "../terminal/ReactiveLiteralString.js";
+import { randomFromArray } from "../../../../math/random/randomFromArray.js";
 
 /**
  *

package/core/model/stat/LinearModifier.js

@@ -1,5 +1,5 @@
 import { assert } from "../../assert.js";
-import { computeHashFloat } from "../../math/MathUtils.js";
+import { computeHashFloat } from "../../math/hash/computeHashFloat.js";
 
 
 /**

package/engine/animation/curve/AnimationCurve.js

@@ -0,0 +1,72 @@
+import { inverseLerp } from "../../../core/math/inverseLerp.js";
+
+/**
+ *
+ * @param {number} t
+ * @param {Keyframe} keyframe0
+ * @param {Keyframe} keyframe1
+ * @return {number}
+ */
+function evaluate(t, keyframe0, keyframe1) {
+
+    const dt = keyframe1.time - keyframe0.time;
+
+    const m0 = keyframe0.outTangent * dt;
+    const m1 = keyframe1.inTangent * dt;
+
+    const t2 = t * t;
+    const t3 = t2 * t;
+
+    const a = 2 * t3 - 3 * t2 + 1;
+    const b = t3 - 2 * t2 + t;
+    const c = t3 - t2;
+    const d = -2 * t3 + 3 * t2;
+
+    return a * keyframe0.value + b * m0 + c * m1 + d * keyframe1.value;
+}
+
+/**
+ * Modelled on unity's AnimationCurve
+ * @see https://github.com/nothke/ThreadableCurve/blob/master/ThreadableCurve.cs
+ */
+export class AnimationCurve {
+    constructor() {
+        /**
+         *
+         * @type {Keyframe[]}
+         */
+        this.keys = [];
+    }
+
+    evaluate(t) {
+        const keys = this.keys;
+        const key_count = keys.length;
+        if (key_count === 0) {
+            return 0;
+        }
+
+        if (key_count === 1) {
+            return keys[0].value;
+        }
+
+        if (t < keys[0].time) {
+            // before start
+            return keys[0].value;
+        }
+
+        for (let i = 1; i < key_count; i++) {
+            const f1 = keys[i];
+
+            if (t < f1.time) {
+                const f0 = keys[i - 1];
+                const kt = inverseLerp(f0.time, f1.time, t);
+
+                return evaluate(kt, f0, f1);
+            }
+        }
+
+        // past end
+        return keys[key_count - 1].value;
+    }
+
+}

package/engine/animation/curve/Keyframe.js

@@ -0,0 +1,27 @@
+export class Keyframe {
+    constructor() {
+        /**
+         *
+         * @type {number}
+         */
+        this.value = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.time = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.inTangent = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.outTangent = 0;
+    }
+}

package/engine/animation/keyed2/AnimationTrack.js

@@ -19,18 +19,43 @@ function AnimationTrack(properties) {
      */
     this.propertyCount = properties.length;
 
+    /**
+     *
+     * @type {number[]}
+     */
     this.keyValues = [];
+
+    /**
+     *
+     * @type {number[]}
+     */
     this.keyTimes = [];
 
     this.timeStart = Number.POSITIVE_INFINITY;
     this.timeEnd = Number.NEGATIVE_INFINITY;
 
+    /**
+     * Indices of keys from which transition takes place
+     * @type {number[]}
+     */
     this.transitionKeys = [];
+
+    /**
+     * Transition function associated with a key
+     * @type {function[]}
+     */
     this.transitionFunctions = [];
 }
 
-AnimationTrack.prototype.initialize = function () {
-    const keysTyped = new Float64Array(this.keyValues.length);
+AnimationTrack.prototype.optimize = function () {
+    const key_value_count = this.keyValues.length;
+    const key_count = this.keyTimes.length;
+
+    // use a common buffer to get better cache locality
+    const buffer = new ArrayBuffer(key_count * 4 + key_value_count * 8);
+
+    const keyTimesTyped = new Float32Array(buffer, 0, key_count);
+    const keysTyped = new Float64Array(buffer, key_count * 4, key_value_count);
 
     //transfer original keys into typed array
     keysTyped.set(this.keyValues, 0);
@@ -38,7 +63,6 @@ AnimationTrack.prototype.initialize = function () {
     //overwrite the original array
     this.keyValues = keysTyped;
 
-    const keyTimesTyped = new Float32Array(this.keyTimes.length);
     keyTimesTyped.set(this.keyTimes, 0);
 
     this.keyTimes = keyTimesTyped;

package/engine/asset/Asset.js

@@ -4,9 +4,9 @@
  * @param {string} type
  * @constructor
  */
-import { computeHashIntegerArray } from "../../core/math/MathUtils.js";
 import { assert } from "../../core/assert.js";
 import { computeStringHash } from "../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../core/collection/array/computeHashIntegerArray.js";
 
 export class AssetDescription {
     /**

package/engine/asset/loaders/GLTFAssetLoader.d.ts

@@ -2,5 +2,5 @@ import {AssetLoader} from "./AssetLoader";
 import {Object3D} from "three";
 
 export class GLTFAssetLoader extends AssetLoader<Object3D> {
-
+    setDracoDecoderPath(path: string): void
 }

package/engine/asset/loaders/GLTFAssetLoader.js

@@ -127,6 +127,8 @@ export class GLTFAssetLoader extends AssetLoader {
 
         this.__dracoLoader = new DRACOLoader();
         this.__dracoLoader.setWorkerLimit(1);
+
+        // set default path
         this.__dracoLoader.setDecoderPath(buildDracoDecoderPath());
 
         const loader = new GLTFLoader();
@@ -156,6 +158,14 @@ export class GLTFAssetLoader extends AssetLoader {
         });
     }
 
+    /**
+     *
+     * @param {string} p
+     */
+    setDracoDecoderPath(p) {
+        this.__dracoLoader.setDecoderPath(p);
+    }
+
     /**
      *
      * @param {boolean} v

package/engine/asset/loaders/image/ImageRGBADataAsset.js

@@ -28,6 +28,12 @@ export class ImageRGBADataAsset extends Asset {
          */
         this.height = height;
 
+        /**
+         * Number of channels
+         * @type {number}
+         */
+        this.itemSize = 4;
+
         this.byteSize = data.length;
     }
 
@@ -35,7 +41,8 @@ export class ImageRGBADataAsset extends Asset {
         return {
             data: this.data,
             width: this.width,
-            height: this.height
+            height: this.height,
+            itemSize: this.itemSize
         };
     }
 }

package/engine/asset/loaders/material/computeMaterialHash.js

@@ -1,7 +1,9 @@
-import { computeHashArray, computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
 import { planeHash } from "./planeHash.js";
 import { computeTextureHash } from "./computeTextureHash.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { computeHashArray } from "../../../../core/collection/array/computeHashArray.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
 /**
  *

package/engine/asset/loaders/material/computeTextureHash.js

@@ -1,6 +1,7 @@
-import { computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
 import { max2 } from "../../../../core/math/max2.js";
 import { computeImageBitmapHash } from "./computeImageBitmapHash.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
 /**
  *

package/engine/ecs/animation/Animation.js

@@ -8,7 +8,8 @@ import ObservedString from "../../../core/model/ObservedString.js";
 import ObservedInteger from "../../../core/model/ObservedInteger.js";
 import Vector1 from "../../../core/geom/Vector1.js";
 import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../core/math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../core/math/hash/computeHashFloat.js";
 
 /**
  *

package/engine/ecs/animation/InverseKinematics.js

@@ -1,7 +1,8 @@
 import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
 import { NumericInterval } from "../../../core/math/interval/NumericInterval.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../core/math/MathUtils.js";
 import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../core/math/hash/computeHashFloat.js";
 
 class IKConstraint {
     constructor() {

package/engine/ecs/dynamic_actions/DynamicActorSystem.js

@@ -14,11 +14,12 @@ import { SerializationMetadata } from "../components/SerializationMetadata.js";
 import Tag from "../components/Tag.js";
 import { OverrideContextBehavior } from "../../../../model/game/util/behavior/OverrideContextBehavior.js";
 import { HashMap } from "../../../core/collection/HashMap.js";
-import { randomFloatBetween, randomFromArray } from "../../../core/math/MathUtils.js";
 import { assert } from "../../../core/assert.js";
 import { RuleExecution } from "./RuleExecution.js";
 import { computeContextualDynamicRuleDebugString } from "./rules/computeContextualDynamicRuleDebugString.js";
 import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+import { randomFromArray } from "../../../core/math/random/randomFromArray.js";
+import { randomFloatBetween } from "../../../core/math/random/randomFloatBetween.js";
 
 /**
  * In seconds

package/engine/ecs/dynamic_actions/DynamicRuleDescriptionTable.spec.js

@@ -3,15 +3,13 @@ import { DynamicRuleDescriptionTable } from "./rules/DynamicRuleDescriptionTable
 import { createRandomReactiveExpression } from "../../../core/model/reactive/model/util/createRandomReactiveExpression.js";
 import { ReactiveReference } from "../../../core/model/reactive/model/terminal/ReactiveReference.js";
 import { ReactiveLiteralNumber } from "../../../core/model/reactive/model/terminal/ReactiveLiteralNumber.js";
-import {
-    randomFloatBetween,
-    randomFromArray,
-    randomIntegerBetween
-} from "../../../core/math/MathUtils.js";
 import { ReactiveLiteralString } from "../../../core/model/reactive/model/terminal/ReactiveLiteralString.js";
 import { ReactiveLiteralBoolean } from "../../../core/model/reactive/model/terminal/ReactiveLiteralBoolean.js";
 import { DynamicRuleDescription } from "./rules/DynamicRuleDescription.js";
 import DataType from "../../../core/parser/simple/DataType.js";
+import { randomFromArray } from "../../../core/math/random/randomFromArray.js";
+import { randomFloatBetween } from "../../../core/math/random/randomFloatBetween.js";
+import { randomIntegerBetween } from "../../../core/math/random/randomIntegerBetween.js";
 
 describe.skip('performance', () => {
 

package/engine/ecs/dynamic_actions/actions/definition/WeightedRandomActionDescription.js

@@ -1,7 +1,7 @@
 import { AbstractActionDescription } from "./AbstractActionDescription.js";
 import { WeightedRandomBehavior } from "../../../../intelligence/behavior/selector/WeightedRandomBehavior.js";
 import { WeightedElement } from "../../../../intelligence/behavior/selector/WeightedElement.js";
-import { computeHashFloat } from "../../../../../core/math/MathUtils.js";
+import { computeHashFloat } from "../../../../../core/math/hash/computeHashFloat.js";
 
 export class WeightedRandomActionDescription extends AbstractActionDescription {
     constructor() {

package/engine/ecs/evaluation/complex/PointFitnessGaussianBlur.js

@@ -1,6 +1,6 @@
 import { PointFitnessFunction } from "../PointFitnessFunction.js";
 import { assert } from "../../../../core/assert.js";
-import { gaussian } from "../../../../core/math/MathUtils.js";
+import { gaussian } from "../../../../core/math/gaussian.js";
 
 export class PointFitnessGaussianBlur extends PointFitnessFunction {
     constructor() {

package/engine/ecs/foliage/ecs/Foliage2.js

@@ -4,7 +4,7 @@ import ObservedBoolean from "../../../../core/model/ObservedBoolean.js";
 import { InstancedFoliage } from "../InstancedFoliage.js";
 import { Base64 } from "../../../../core/binary/Base64.js";
 import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
-import { computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
 
 export class FoliageLayer {
     constructor() {

package/engine/ecs/fow/shader/FogOfWarRenderer.js

@@ -1,8 +1,8 @@
 import { buildScreenSpaceFogOfWarShader } from "./screenSpaceFogOfWarShader.js";
 import { assert } from "../../../../core/assert.js";
 import { Mesh, OrthographicCamera, Scene } from "three";
-import { isValueBetweenInclusive } from "../../../../core/math/MathUtils.js";
 import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../../../graphics/geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
+import { isValueBetweenInclusive } from "../../../../core/math/isValueBetweenInclusive.js";
 
 /**
  *

package/engine/ecs/gui/GUIElement.js

@@ -6,9 +6,9 @@ import ObservedBoolean from "../../../core/model/ObservedBoolean.js";
 import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
 import { COMPONENT_SERIALIZATION_TRANSIENT_FIELD } from "../storage/COMPONENT_SERIALIZATION_TRANSIENT_FIELD.js";
 import { assert } from "../../../core/assert.js";
-import { computeHashIntegerArray } from "../../../core/math/MathUtils.js";
 import { objectDeepEquals } from "../../../core/model/object/objectDeepEquals.js";
 import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
 
 /**
  *

package/engine/ecs/gui/hud/HeadsUpDisplay.js

@@ -7,7 +7,7 @@
 
 import Vector3 from '../../../../core/geom/Vector3.js';
 import { HeadsUpDisplayFlag } from "./HeadsUpDisplayFlag.js";
-import { computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
 
 class HeadsUpDisplay {
     /**

package/engine/ecs/gui/position/ViewportPosition.js

@@ -5,7 +5,8 @@
 import Vector2 from "../../../../core/geom/Vector2.js";
 import ObservedBoolean from "../../../../core/model/ObservedBoolean.js";
 import { BinaryClassSerializationAdapter } from "../../storage/binary/BinaryClassSerializationAdapter.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
 /**
  * @readonly

package/engine/ecs/systems/RangedAttackSystem.js

@@ -8,7 +8,7 @@ import PhysicalBody from '../components/PhysicalBody.js';
 import Motion from '../components/Motion.js';
 import Renderable from '../components/Renderable.js';
 import { Matrix4 as ThreeMatrix4, Vector3 as ThreeVector3 } from 'three';
-import { solveQuadratic } from "../../../core/math/MathUtils.js";
+import { solveQuadratic } from "../../../core/math/solveQuadratic.js";
 
 /**
  * Return the firing solution for a projectile starting at 'src' with