littlejsengine 1.18.2 → 1.18.7

package/test/math.test.mjs

@@ -1,774 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import {
-    PI, clamp, percent, percentLerp, lerp, mod, smoothStep, nearestPowerOfTwo, oscillate,
-    distanceWrap, lerpWrap, distanceAngle, lerpAngle,
-    isOverlapping, isIntersecting, lineTest,
-    vec2, Vector2, rgb, hsl, Color,
-    RandomGenerator,
-    rand, randInt, randBool, randSign, randVec2, randInCircle, randColor,
-} from '../dist/littlejs.esm.js';
-
-// small tolerance for floating point comparisons
-const EPS = 1e-9;
-const near = (a, b, eps=EPS) => Math.abs(a - b) <= eps;
-
-test('clamp', () =>
-{
-    assert.equal(clamp(0.5), 0.5);
-    assert.equal(clamp(-1), 0);
-    assert.equal(clamp(2), 1);
-    assert.equal(clamp(5, 0, 10), 5);
-    assert.equal(clamp(-5, 0, 10), 0);
-    assert.equal(clamp(15, 0, 10), 10);
-});
-
-test('percent', () =>
-{
-    assert.equal(percent(5, 0, 10), 0.5);
-    assert.equal(percent(0, 0, 10), 0);
-    assert.equal(percent(10, 0, 10), 1);
-    assert.equal(percent(-5, 0, 10), 0); // clamped
-    assert.equal(percent(15, 0, 10), 1); // clamped
-    assert.equal(percent(5, 5, 5), 0);   // division by zero guard
-});
-
-test('lerp', () =>
-{
-    assert.equal(lerp(0, 10, 0), 0);
-    assert.equal(lerp(0, 10, 1), 10);
-    assert.equal(lerp(0, 10, 0.5), 5);
-    assert.equal(lerp(0, 10, -1), 0);    // percent clamped
-    assert.equal(lerp(0, 10, 2), 10);    // percent clamped
-});
-
-test('percentLerp', () =>
-{
-    // equivalent to lerp(lerpA, lerpB, percent(value, percentA, percentB))
-    assert.equal(percentLerp(0, 0, 10, 100, 200), 100);   // at percentA
-    assert.equal(percentLerp(10, 0, 10, 100, 200), 200);  // at percentB
-    assert.equal(percentLerp(5, 0, 10, 100, 200), 150);   // midpoint
-    assert.equal(percentLerp(-5, 0, 10, 100, 200), 100);  // below range, clamped
-    assert.equal(percentLerp(99, 0, 10, 100, 200), 200);  // above range, clamped
-});
-
-test('mod', () =>
-{
-    assert.equal(mod(5, 3), 2);
-    assert.equal(mod(-1, 3), 2);        // negative handled
-    assert.equal(mod(-4, 3), 2);
-    assert.equal(mod(0, 3), 0);
-    assert.equal(mod(0.5), 0.5);         // default divisor = 1
-});
-
-test('smoothStep', () =>
-{
-    assert.equal(smoothStep(0), 0);
-    assert.equal(smoothStep(1), 1);
-    assert.equal(smoothStep(0.5), 0.5);
-    assert(smoothStep(0.25) < 0.25);     // slower start
-    assert(smoothStep(0.75) > 0.75);     // faster end (relative to linear)
-});
-
-test('nearestPowerOfTwo', () =>
-{
-    assert.equal(nearestPowerOfTwo(1), 1);
-    assert.equal(nearestPowerOfTwo(3), 4);
-    assert.equal(nearestPowerOfTwo(100), 128);
-    assert.equal(nearestPowerOfTwo(16), 16);
-});
-
-test('distanceWrap / lerpWrap', () =>
-{
-    assert(near(distanceWrap(0.1, 0.9), 0.2));    // shortest path wraps forward
-    assert(near(distanceWrap(0.9, 0.1), -0.2));
-    assert(near(distanceWrap(0, 0), 0));
-    // lerpWrap returns the un-wrapped interpolated value: 0.9 + 0.5*0.2 = 1.0
-    // (1.0 is equivalent to 0 modulo wrapSize — caller can re-wrap if needed)
-    assert(near(lerpWrap(0.9, 0.1, 0.5), 1.0));
-});
-
-test('distanceAngle / lerpAngle', () =>
-{
-    assert(near(distanceAngle(0, 2*PI), 0));        // same direction after wrap
-    assert(near(distanceAngle(0.1, -0.1), 0.2));
-    // lerpAngle picks shortest path but returns un-wrapped value.
-    // from -PI+0.1 to PI-0.1: shortest path is backward (through -PI), distance = -0.2
-    // so result = (-PI+0.1) + 0.5*(-0.2) = -PI
-    assert(near(lerpAngle(-PI+0.1, PI-0.1, 0.5), -PI, 1e-6));
-});
-
-test('isOverlapping AABB', () =>
-{
-    // two unit boxes centered at origin overlap
-    assert.equal(isOverlapping(vec2(0, 0), vec2(1, 1), vec2(0, 0), vec2(1, 1)), true);
-    // adjacent boxes do NOT overlap (edge case, uses strict inequality on one side)
-    assert.equal(isOverlapping(vec2(0, 0), vec2(1, 1), vec2(2, 0), vec2(1, 1)), false);
-    // partial overlap
-    assert.equal(isOverlapping(vec2(0, 0), vec2(2, 2), vec2(1, 1), vec2(2, 2)), true);
-    // far apart
-    assert.equal(isOverlapping(vec2(0, 0), vec2(1, 1), vec2(10, 10), vec2(1, 1)), false);
-});
-
-test('isIntersecting line-vs-AABB', () =>
-{
-    // line passes through box
-    assert.equal(isIntersecting(vec2(-5, 0), vec2(5, 0), vec2(0, 0), vec2(2, 2)), true);
-    // line misses box
-    assert.equal(isIntersecting(vec2(-5, 10), vec2(5, 10), vec2(0, 0), vec2(2, 2)), false);
-    // line starts inside
-    assert.equal(isIntersecting(vec2(0, 0), vec2(10, 0), vec2(0, 0), vec2(2, 2)), true);
-});
-
-///////////////////////////////////////////////////////////////////////////////
-// lineTest (grid-DDA raycast)
-
-test('lineTest returns undefined when nothing hits', () =>
-{
-    const hit = lineTest(vec2(0.5, 0.5), vec2(10.5, 0.5), () => false);
-    assert.equal(hit, undefined);
-});
-
-test('lineTest returns undefined for zero-length line', () =>
-{
-    // early return: totalLength is 0
-    const hit = lineTest(vec2(5, 5), vec2(5, 5), () => true);
-    assert.equal(hit, undefined);
-});
-
-test('lineTest finds first hit along horizontal ray', () =>
-{
-    // ray across cells (0,0) -> (10,0) at y=0.5, predicate hits at x=3
-    const hit = lineTest(vec2(0.5, 0.5), vec2(10.5, 0.5), pos => pos.x === 3);
-    assert(hit !== undefined);
-    assert.equal(Math.floor(hit.x), 3);              // hit is inside cell 3
-    assert.equal(Math.floor(hit.y), 0);
-});
-
-test('lineTest stops at the first hit, not a later one', () =>
-{
-    const visited = [];
-    const hit = lineTest(vec2(0.5, 0.5), vec2(10.5, 0.5), pos =>
-    {
-        visited.push(pos.x);
-        return pos.x === 2 || pos.x === 5;
-    });
-    assert(hit !== undefined);
-    assert.equal(Math.floor(hit.x), 2);              // earlier hit wins
-    // ray never advances past cell 2, and stops *on* cell 2 (not just never-visits-5)
-    assert(!visited.some(x => x > 2));
-    assert.equal(visited.at(-1), 2);
-});
-
-test('lineTest writes normal for horizontal hit', () =>
-{
-    // ray moves +x, hits on the left face of the hit cell -> normal (-1, 0)
-    const normal = vec2();
-    const hit = lineTest(vec2(0.5, 0.5), vec2(10.5, 0.5), pos => pos.x === 3, normal);
-    assert(hit !== undefined);
-    assert.equal(normal.x, -1);
-    assert.equal(normal.y, 0);
-});
-
-test('lineTest writes normal for vertical hit (downward ray)', () =>
-{
-    // ray moves -y, last step was in y, stepY = -1 -> normal (0, -stepY) = (0, 1)
-    const normal = vec2();
-    const hit = lineTest(vec2(0.5, 0.5), vec2(0.5, -10.5), pos => pos.y === -3, normal);
-    assert(hit !== undefined);
-    assert.equal(Math.floor(hit.y), -3);
-    assert.equal(normal.x, 0);
-    assert.equal(normal.y, 1);
-});
-
-test('lineTest returns immediately if start cell hits', () =>
-{
-    let calls = 0;
-    const hit = lineTest(vec2(2.5, 2.5), vec2(10, 10), pos =>
-    {
-        calls++;
-        return pos.x === 2 && pos.y === 2;
-    });
-    assert(hit !== undefined);
-    assert.equal(calls, 1);                          // only checked the start cell
-    assert.equal(Math.floor(hit.x), 2);
-    assert.equal(Math.floor(hit.y), 2);
-});
-
-test('vec2 constructor and factory', () =>
-{
-    let v = vec2();
-    assert.equal(v.x, 0); assert.equal(v.y, 0);
-    v = vec2(5);
-    assert.equal(v.x, 5); assert.equal(v.y, 5);   // single arg copies x to y
-    v = vec2(3, 4);
-    assert.equal(v.x, 3); assert.equal(v.y, 4);
-    v = new Vector2();
-    assert.equal(v.x, 0); assert.equal(v.y, 0);
-});
-
-test('Vector2 arithmetic', () =>
-{
-    const a = vec2(2, 3);
-    const b = vec2(4, 5);
-    assert.deepEqual({ x: a.add(b).x, y: a.add(b).y }, { x: 6, y: 8 });
-    assert.deepEqual({ x: a.subtract(b).x, y: a.subtract(b).y }, { x: -2, y: -2 });
-    assert.deepEqual({ x: a.multiply(b).x, y: a.multiply(b).y }, { x: 8, y: 15 });
-    assert.deepEqual({ x: a.scale(3).x, y: a.scale(3).y }, { x: 6, y: 9 });
-    // immutability: a should be unchanged
-    assert.equal(a.x, 2); assert.equal(a.y, 3);
-});
-
-test('Vector2 length / distance / dot / cross', () =>
-{
-    const v = vec2(3, 4);
-    assert.equal(v.length(), 5);
-    assert.equal(v.lengthSquared(), 25);
-    assert.equal(v.distance(vec2(0, 0)), 5);
-    assert.equal(v.distanceSquared(vec2(0, 0)), 25);
-    assert.equal(vec2(1, 0).dot(vec2(1, 0)), 1);
-    assert.equal(vec2(1, 0).dot(vec2(0, 1)), 0);
-    assert.equal(vec2(1, 0).cross(vec2(0, 1)), 1);
-});
-
-test('Vector2 normalize', () =>
-{
-    const n = vec2(3, 4).normalize();
-    assert(near(n.length(), 1));
-    const scaled = vec2(3, 4).normalize(10);
-    assert(near(scaled.length(), 10));
-    // zero vector returns (0, length) — the up-direction at requested length.
-    // Pin both components, not just length (which would pass for any unit vector).
-    const zero = vec2(0, 0).normalize();
-    assert.equal(zero.x, 0); assert.equal(zero.y, 1);
-    const zero5 = vec2(0, 0).normalize(5);
-    assert.equal(zero5.x, 0); assert.equal(zero5.y, 5);
-});
-
-test('Vector2 angle conventions (up = 0)', () =>
-{
-    // angle() returns atan2(x, y), so up (+y) is 0
-    assert(near(vec2(0, 1).angle(), 0));
-    assert(near(vec2(1, 0).angle(), PI/2));
-    // setAngle: x = length*sin(angle), y = length*cos(angle)
-    const v = new Vector2().setAngle(0, 5);
-    assert(near(v.x, 0)); assert(near(v.y, 5));
-    const w = new Vector2().setAngle(PI/2, 3);
-    assert(near(w.x, 3)); assert(near(w.y, 0));
-});
-
-test('Vector2 rotate preserves length', () =>
-{
-    const v = vec2(1, 0);
-    const r = v.rotate(PI/2);
-    assert(near(r.length(), 1));
-    // rotate by 2pi returns roughly the original
-    const full = v.rotate(2*PI);
-    assert(near(full.x, 1)); assert(near(full.y, 0));
-});
-
-test('Vector2 floor / abs / mod / area', () =>
-{
-    assert.equal(vec2(1.7, -2.3).floor().x, 1);
-    assert.equal(vec2(1.7, -2.3).floor().y, -3);
-    assert.equal(vec2(-1.5, 2.5).abs().x, 1.5);
-    assert.equal(vec2(-1.5, 2.5).abs().y, 2.5);
-    const m = vec2(5.5, -0.5).mod(1);
-    assert(near(m.x, 0.5));
-    assert(near(m.y, 0.5));
-    assert.equal(vec2(3, 4).area(), 12);
-});
-
-test('Vector2 lerp', () =>
-{
-    const r = vec2(0, 0).lerp(vec2(10, 20), 0.5);
-    assert.equal(r.x, 5); assert.equal(r.y, 10);
-    const zero = vec2(0, 0).lerp(vec2(10, 20), 0);
-    assert.equal(zero.x, 0); assert.equal(zero.y, 0);
-});
-
-test('Color factory + defaults', () =>
-{
-    const w = rgb();
-    assert.equal(w.r, 1); assert.equal(w.g, 1); assert.equal(w.b, 1); assert.equal(w.a, 1);
-    const red = rgb(1, 0, 0);
-    assert.equal(red.r, 1); assert.equal(red.g, 0); assert.equal(red.b, 0); assert.equal(red.a, 1);
-});
-
-test('Color arithmetic', () =>
-{
-    const a = new Color(0.5, 0.5, 0.5, 1);
-    const b = new Color(0.25, 0.25, 0.25, 0);
-    const sum = a.add(b);
-    assert.equal(sum.r, 0.75);
-    assert.equal(sum.a, 1);
-    const scaled = a.scale(2);
-    assert.equal(scaled.r, 1);
-    assert.equal(scaled.a, 2);        // alpha also scaled
-    const scaled2 = a.scale(2, 0.5);
-    assert.equal(scaled2.r, 1);
-    assert.equal(scaled2.a, 0.5);     // alpha scaled separately
-});
-
-test('Color lerp', () =>
-{
-    const a = new Color(0, 0, 0, 1);
-    const b = new Color(1, 1, 1, 1);
-    const mid = a.lerp(b, 0.5);
-    assert.equal(mid.r, 0.5); assert.equal(mid.g, 0.5); assert.equal(mid.b, 0.5);
-});
-
-test('Color hex round-trip', () =>
-{
-    const red = new Color().setHex('#ff0000');
-    assert(near(red.r, 1)); assert(near(red.g, 0)); assert(near(red.b, 0));
-    const short = new Color().setHex('#f00');
-    assert(near(short.r, 1)); assert(near(short.g, 0)); assert(near(short.b, 0));
-    // toString format is locked: lowercase hex, always 6 or 8 chars plus '#'.
-    // If a future change switches to uppercase, update both the function and these tests.
-    assert.equal(rgb(1, 0, 0).toString(false), '#ff0000');
-    assert.equal(rgb(0, 0, 0).toString(false), '#000000');
-});
-
-test('Color rgb↔hsl round-trip', () =>
-{
-    const red = rgb(1, 0, 0);
-    const [h, s, l, a] = red.HSLA();
-    const back = hsl(h, s, l, a);
-    assert(near(back.r, 1, 1e-6));
-    assert(near(back.g, 0, 1e-6));
-    assert(near(back.b, 0, 1e-6));
-});
-
-test('Color clamp', () =>
-{
-    const clamped = new Color(2, -1, 0.5, 1.5).clamp();
-    assert.equal(clamped.r, 1);
-    assert.equal(clamped.g, 0);
-    assert.equal(clamped.b, 0.5);
-    assert.equal(clamped.a, 1);
-});
-
-test('RandomGenerator determinism', () =>
-{
-    const r1 = new RandomGenerator(12345);
-    const r2 = new RandomGenerator(12345);
-    for (let i = 0; i < 10; i++)
-        assert.equal(r1.float(), r2.float());
-
-    // different seed => different sequence
-    const r3 = new RandomGenerator(54321);
-    const a = new RandomGenerator(12345).float();
-    const b = r3.float();
-    assert.notEqual(a, b);
-});
-
-test('RandomGenerator range bounds', () =>
-{
-    const r = new RandomGenerator(42);
-    for (let i = 0; i < 100; i++)
-    {
-        const x = r.float();
-        assert(x >= 0 && x < 1);
-    }
-    for (let i = 0; i < 100; i++)
-    {
-        const n = r.int(10);
-        assert(n >= 0 && n < 10);
-        assert.equal(Math.floor(n), n);
-    }
-});
-
-test('rand / randInt bounds', () =>
-{
-    // rand() => [0, 1) — valueB(0) + Math.random()*(valueA(1)-valueB(0))
-    for (let i = 0; i < 100; i++)
-    {
-        const x = rand();
-        assert(x >= 0 && x < 1);
-    }
-    // rand(valueA, valueB) returns valueB + rand()*(valueA - valueB).
-    // Inclusivity flips with arg order:
-    //   rand(10, 5) = 5 + r*5    => [5, 10)  -- valueB inclusive, valueA exclusive
-    //   rand(5, 10) = 10 + r*-5  => (5, 10]  -- valueA exclusive, valueB inclusive
-    for (let i = 0; i < 100; i++)
-    {
-        const y = rand(10, 5);
-        assert(y >= 5 && y < 10);
-        const z = rand(5, 10);
-        assert(z > 5 && z <= 10);
-    }
-    for (let i = 0; i < 100; i++)
-    {
-        const n = randInt(4);
-        assert([0, 1, 2, 3].includes(n));
-    }
-});
-
-test('randBool distribution', () =>
-{
-    let trues = 0;
-    for (let i = 0; i < 200; i++)
-        if (randBool()) trues++;
-    // Fair coin: mean=100, stddev≈7.07 for Binomial(200, 0.5).
-    // Window [60, 140] is ~5.6σ from the mean — false positive rate ~1e-8,
-    // but will still catch a function that's meaningfully biased.
-    assert(trues >= 60 && trues <= 140,
-        `randBool produced ${trues}/200 trues — outside 60..140 window`);
-    // chance=1 always true, chance=0 always false
-    for (let i = 0; i < 20; i++)
-    {
-        assert.equal(randBool(1), true);
-        assert.equal(randBool(0), false);
-    }
-});
-
-test('randSign returns exactly -1 or 1', () =>
-{
-    const signs = new Set();
-    for (let i = 0; i < 100; i++)
-    {
-        const s = randSign();
-        assert(s === -1 || s === 1);
-        signs.add(s);
-    }
-    assert.deepEqual([...signs].sort(), [-1, 1]);
-});
-
-test('randVec2 length', () =>
-{
-    // default length 1
-    for (let i = 0; i < 50; i++)
-        assert(near(randVec2().length(), 1, 1e-9));
-    // custom length
-    for (let i = 0; i < 50; i++)
-        assert(near(randVec2(7).length(), 7, 1e-9));
-});
-
-test('randInCircle stays within radius', () =>
-{
-    for (let i = 0; i < 200; i++)
-    {
-        const v = randInCircle(3);
-        assert(v.length() <= 3 + EPS);
-    }
-    // radius 0 returns origin
-    const zero = randInCircle(0);
-    assert.equal(zero.x, 0); assert.equal(zero.y, 0);
-});
-
-test('randColor returns a valid Color', () =>
-{
-    for (let i = 0; i < 20; i++)
-    {
-        const c = randColor();
-        assert(c instanceof Color);
-        assert(c.isValid());
-    }
-    // with explicit bounds, each channel stays between the two colors
-    const a = rgb(0.2, 0.2, 0.2, 1);
-    const b = rgb(0.8, 0.8, 0.8, 1);
-    for (let i = 0; i < 50; i++)
-    {
-        const c = randColor(a, b);
-        assert(c.r >= 0.2 && c.r <= 0.8);
-        assert(c.g >= 0.2 && c.g <= 0.8);
-        assert(c.b >= 0.2 && c.b <= 0.8);
-    }
-});
-
-///////////////////////////////////////////////////////////////////////////////
-// oscillate
-
-test('oscillate sine (default)', () =>
-{
-    // sine: value = -cos(phase * 2pi), output = amp/2 * (value + 1) ∈ [0, amp]
-    // phase=0 -> value=-1 -> 0
-    // phase=0.5 -> value=1 -> amp
-    // phase=0.25 -> value=0 -> amp/2
-    assert(near(oscillate(1, 2, 0), 0));
-    assert(near(oscillate(1, 2, 0.5), 2));
-    assert(near(oscillate(1, 2, 0.25), 1));
-    // must stay in [0, amplitude]
-    for (let i = 0; i <= 20; i++)
-    {
-        const v = oscillate(1, 1, i/20);
-        assert(v >= 0 - EPS && v <= 1 + EPS);
-    }
-});
-
-test('oscillate triangle', () =>
-{
-    // triangle (type 1) at phase=0 -> peaks at amp; phase=0.5 -> 0
-    assert(near(oscillate(1, 1, 0, 0, 1), 1));
-    assert(near(oscillate(1, 1, 0.5, 0, 1), 0));
-    // must stay in [0, amplitude]
-    for (let i = 0; i <= 20; i++)
-    {
-        const v = oscillate(1, 1, i/20, 0, 1);
-        assert(v >= 0 - EPS && v <= 1 + EPS);
-    }
-});
-
-test('oscillate square', () =>
-{
-    // square (type 2): -1 for phase<0.5, +1 for phase>=0.5
-    // so output 0 for phase<0.5, amp for phase>=0.5
-    assert.equal(oscillate(1, 1, 0, 0, 2), 0);
-    assert.equal(oscillate(1, 1, 0.25, 0, 2), 0);
-    assert.equal(oscillate(1, 1, 0.5, 0, 2), 1);
-    assert.equal(oscillate(1, 1, 0.9, 0, 2), 1);
-});
-
-test('oscillate sawtooth', () =>
-{
-    // sawtooth (type 3): value = 2*phase - 1, output = amp/2*(value+1) = amp*phase
-    assert(near(oscillate(1, 1, 0, 0, 3), 0));
-    assert(near(oscillate(1, 1, 0.5, 0, 3), 0.5));
-    // phase wraps at 1, so exactly at phase=1 we get 0 again via mod
-    assert(near(oscillate(1, 1, 1, 0, 3), 0));
-});
-
-///////////////////////////////////////////////////////////////////////////////
-// Vector2 gaps
-
-test('Vector2 copy / setFrom immutability', () =>
-{
-    const a = vec2(3, 4);
-    const b = a.copy();
-    b.x = 99;
-    assert.equal(a.x, 3);                           // original untouched
-    const c = new Vector2().setFrom(a);
-    assert.equal(c.x, 3); assert.equal(c.y, 4);
-});
-
-test('Vector2 divide', () =>
-{
-    const r = vec2(6, 8).divide(vec2(2, 4));
-    assert.equal(r.x, 3); assert.equal(r.y, 2);
-});
-
-test('Vector2 clampLength', () =>
-{
-    // already within limit: returns a copy at same length
-    const a = vec2(3, 4).clampLength(10);
-    assert.equal(a.x, 3); assert.equal(a.y, 4);
-    // exceeds limit: scales down to limit
-    const b = vec2(3, 4).clampLength(1);
-    assert(near(b.length(), 1));
-});
-
-test('Vector2 reflect', () =>
-{
-    // (1, -1) hitting a floor (normal 0,1) should reflect to (1, 1)
-    const r = vec2(1, -1).reflect(vec2(0, 1), 1);
-    assert(near(r.x, 1)); assert(near(r.y, 1));
-    // restitution 0.5 halves the bounce
-    const half = vec2(0, -2).reflect(vec2(0, 1), 0.5);
-    assert(near(half.y, 1));                        // -2 -> +1, not +2
-    // restitution 0 absorbs the normal component
-    const absorbed = vec2(1, -1).reflect(vec2(0, 1), 0);
-    assert(near(absorbed.x, 1));
-    assert(near(absorbed.y, 0));
-});
-
-test('Vector2 setDirection / direction (cardinal 0..3)', () =>
-{
-    // setDirection: 0=up(+y), 1=right(+x), 2=down(-y), 3=left(-x)
-    const up = new Vector2().setDirection(0, 1);
-    assert(near(up.x, 0)); assert(near(up.y, 1));
-    const right = new Vector2().setDirection(1, 1);
-    assert(near(right.x, 1)); assert(near(right.y, 0));
-    const down = new Vector2().setDirection(2, 1);
-    assert(near(down.x, 0)); assert(near(down.y, -1));
-    const left = new Vector2().setDirection(3, 1);
-    assert(near(left.x, -1)); assert(near(left.y, 0));
-    // direction() is the inverse for clean cardinal vectors
-    assert.equal(vec2(0, 1).direction(), 0);
-    assert.equal(vec2(1, 0).direction(), 1);
-    assert.equal(vec2(0, -1).direction(), 2);
-    assert.equal(vec2(-1, 0).direction(), 3);
-});
-
-test('Vector2 snap', () =>
-{
-    // snap divides by the grid, floors, multiplies back
-    // snap(2): bucket size 0.5 (1/2). 1.3 -> floor(1.3*2)/2 = floor(2.6)/2 = 2/2 = 1.0
-    const r = vec2(1.3, 1.9).snap(2);
-    assert(near(r.x, 1.0));
-    assert(near(r.y, 1.5));
-});
-
-test('Vector2 arrayCheck (tile-grid bounds)', () =>
-{
-    const size = vec2(10, 5);
-    assert.equal(vec2(0, 0).arrayCheck(size), true);
-    assert.equal(vec2(9, 4).arrayCheck(size), true);
-    assert.equal(vec2(10, 4).arrayCheck(size), false);    // x out (exclusive upper)
-    assert.equal(vec2(9, 5).arrayCheck(size), false);     // y out (exclusive upper)
-    assert.equal(vec2(-1, 0).arrayCheck(size), false);    // x negative
-    assert.equal(vec2(0, -1).arrayCheck(size), false);    // y negative
-});
-
-test('Vector2 isValid', () =>
-{
-    assert.equal(vec2(0, 0).isValid(), true);
-    assert.equal(vec2(-100, 3.14).isValid(), true);
-    const bad = vec2(1, 2);
-    bad.x = NaN;
-    assert.equal(bad.isValid(), false);
-    bad.x = 1; bad.y = NaN;
-    assert.equal(bad.isValid(), false);
-});
-
-///////////////////////////////////////////////////////////////////////////////
-// Color gaps
-
-test('Color copy / setFrom / set', () =>
-{
-    const a = new Color(0.25, 0.5, 0.75, 0.5);
-    const b = a.copy();
-    b.r = 0;
-    assert.equal(a.r, 0.25);                        // original untouched
-    const c = new Color().setFrom(a);
-    assert.equal(c.r, 0.25); assert.equal(c.a, 0.5);
-    c.set(1, 0, 0, 1);
-    assert.equal(c.r, 1); assert.equal(c.g, 0);
-});
-
-test('Color divide', () =>
-{
-    const r = new Color(1, 0.5, 0.25, 1).divide(new Color(2, 1, 0.5, 1));
-    assert.equal(r.r, 0.5); assert.equal(r.g, 0.5); assert.equal(r.b, 0.5); assert.equal(r.a, 1);
-});
-
-test('Color rgbaInt for simple cases', () =>
-{
-    // packed layout: R in lowest byte, then G, B, A
-    assert.equal(rgb(0, 0, 0, 0).rgbaInt(), 0);
-    assert.equal(rgb(1, 0, 0, 0).rgbaInt(), 255);
-    assert.equal(rgb(0, 1, 0, 0).rgbaInt(), 255 << 8);
-    assert.equal(rgb(0, 0, 1, 0).rgbaInt(), 255 << 16);
-});
-
-test('Color HSLA() at corner hues', () =>
-{
-    // pure primaries have saturation 1 and lightness 0.5
-    const [hR, sR, lR] = rgb(1, 0, 0).HSLA();
-    assert(near(hR, 0)); assert(near(sR, 1)); assert(near(lR, 0.5));
-    const [hG, sG, lG] = rgb(0, 1, 0).HSLA();
-    assert(near(hG, 1/3)); assert(near(sG, 1)); assert(near(lG, 0.5));
-    const [hB, sB, lB] = rgb(0, 0, 1).HSLA();
-    assert(near(hB, 2/3)); assert(near(sB, 1)); assert(near(lB, 0.5));
-    // grayscale: saturation 0, hue irrelevant (reports 0)
-    const [, sBlack, lBlack] = rgb(0, 0, 0).HSLA();
-    assert.equal(sBlack, 0); assert.equal(lBlack, 0);
-    const [, sWhite, lWhite] = rgb(1, 1, 1).HSLA();
-    assert.equal(sWhite, 0); assert.equal(lWhite, 1);
-});
-
-test('Color isValid', () =>
-{
-    assert.equal(new Color(0.5, 0.5, 0.5, 1).isValid(), true);
-    const bad = new Color(0, 0, 0, 1);
-    bad.r = NaN;
-    assert.equal(bad.isValid(), false);
-});
-
-test('Color mutate bounds', () =>
-{
-    // mutate uses Math.random directly so we can't seed it — test shape only.
-    const base = rgb(0.5, 0.5, 0.5, 0.5);
-    for (let i = 0; i < 50; i++)
-    {
-        const m = base.mutate(0.1, 0.05);
-        // all channels stay in [0, 1] (mutate calls .clamp() at the end)
-        assert(m.r >= 0 && m.r <= 1);
-        assert(m.g >= 0 && m.g <= 1);
-        assert(m.b >= 0 && m.b <= 1);
-        assert(m.a >= 0 && m.a <= 1);
-        // each channel is within `amount` of the base (before clamp, but base+amount stays in range here)
-        assert(Math.abs(m.r - 0.5) <= 0.1 + EPS);
-        assert(Math.abs(m.g - 0.5) <= 0.1 + EPS);
-        assert(Math.abs(m.b - 0.5) <= 0.1 + EPS);
-        assert(Math.abs(m.a - 0.5) <= 0.05 + EPS);
-    }
-    // alphaAmount defaults to 0: alpha unchanged
-    const m = base.mutate(0.1);
-    assert.equal(m.a, 0.5);
-});
-
-///////////////////////////////////////////////////////////////////////////////
-// RandomGenerator methods
-
-test('RandomGenerator bool / sign', () =>
-{
-    const r = new RandomGenerator(1);
-    let trues = 0, signs = new Set();
-    for (let i = 0; i < 100; i++)
-    {
-        if (r.bool()) trues++;
-        signs.add(r.sign());
-    }
-    // chance=0.5 default — expect neither 0 nor 100 trues on 100 draws
-    assert(trues > 20 && trues < 80);
-    assert.deepEqual([...signs].sort(), [-1, 1]);
-});
-
-test('RandomGenerator floatSign range and sign', () =>
-{
-    const r = new RandomGenerator(5);
-    const signs = new Set();
-    for (let i = 0; i < 100; i++)
-    {
-        const v = r.floatSign(2, 1);
-        // magnitude is in [1, 2), signed either way
-        assert(Math.abs(v) >= 1 && Math.abs(v) < 2);
-        signs.add(Math.sign(v));
-    }
-    assert.deepEqual([...signs].sort(), [-1, 1]);
-});
-
-test('RandomGenerator angle range', () =>
-{
-    const r = new RandomGenerator(7);
-    for (let i = 0; i < 100; i++)
-    {
-        const a = r.angle();
-        assert(a >= -PI && a < PI);
-    }
-});
-
-test('RandomGenerator vec2', () =>
-{
-    const r = new RandomGenerator(9);
-    const v = r.vec2(5);
-    assert(v instanceof Vector2);
-    assert(v.x >= 0 && v.x < 5);
-    assert(v.y >= 0 && v.y < 5);
-});
-
-test('RandomGenerator randColor determinism', () =>
-{
-    const a = new RandomGenerator(123).randColor();
-    const b = new RandomGenerator(123).randColor();
-    assert.equal(a.r, b.r);
-    assert.equal(a.g, b.g);
-    assert.equal(a.b, b.b);
-    assert.equal(a.a, b.a);
-});
-
-test('RandomGenerator mutateColor', () =>
-{
-    const base = rgb(0.5, 0.5, 0.5, 1);
-    const r = new RandomGenerator(42);
-    const m = r.mutateColor(base, 0.1, 0);
-    // result clamped to [0,1] and each channel within amount of base (0.1)
-    assert(m.r >= 0 && m.r <= 1);
-    assert(m.g >= 0 && m.g <= 1);
-    assert(m.b >= 0 && m.b <= 1);
-    assert.equal(m.a, 1);                           // alphaAmount=0, so alpha unchanged
-    assert(Math.abs(m.r - 0.5) <= 0.1 + EPS);
-    assert(Math.abs(m.g - 0.5) <= 0.1 + EPS);
-    assert(Math.abs(m.b - 0.5) <= 0.1 + EPS);
-});