minimojs 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/internal/SoundSystem.d.ts

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

package/dist/internal/SoundSystem.js

@@ -0,0 +1,55 @@
+/** @internal */
+export class SoundSystem {
+    constructor() {
+        /** @internal */
+        this._audioCtx = null;
+    }
+    sound(freq, durationMs) {
+        const ctx = this.getAudioContext();
+        const oscillator = ctx.createOscillator();
+        const gain = ctx.createGain();
+        oscillator.type = "square";
+        oscillator.frequency.setValueAtTime(freq, ctx.currentTime);
+        gain.gain.setValueAtTime(0.08, ctx.currentTime);
+        gain.gain.exponentialRampToValueAtTime(0.001, ctx.currentTime + durationMs / 1000);
+        oscillator.connect(gain);
+        gain.connect(ctx.destination);
+        oscillator.start(ctx.currentTime);
+        oscillator.stop(ctx.currentTime + durationMs / 1000);
+    }
+    soundSequence(...tones) {
+        if (tones.length === 0)
+            return;
+        const ctx = this.getAudioContext();
+        let startTime = ctx.currentTime;
+        for (const [freq, durationMs] of tones) {
+            if (!Number.isFinite(freq) || !Number.isFinite(durationMs))
+                continue;
+            if (freq <= 0 || durationMs <= 0)
+                continue;
+            const durationSec = durationMs / 1000;
+            const oscillator = ctx.createOscillator();
+            const gain = ctx.createGain();
+            oscillator.type = "square";
+            oscillator.frequency.setValueAtTime(freq, startTime);
+            gain.gain.setValueAtTime(0.08, startTime);
+            gain.gain.exponentialRampToValueAtTime(0.001, startTime + durationSec);
+            oscillator.connect(gain);
+            gain.connect(ctx.destination);
+            oscillator.start(startTime);
+            oscillator.stop(startTime + durationSec);
+            startTime += durationSec;
+        }
+    }
+    /** @internal */
+    getAudioContext() {
+        if (!this._audioCtx) {
+            this._audioCtx = new AudioContext();
+        }
+        const ctx = this._audioCtx;
+        if (ctx.state === "suspended") {
+            ctx.resume();
+        }
+        return ctx;
+    }
+}

package/dist/internal/SpriteSystem.d.ts

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

package/dist/internal/SpriteSystem.js

@@ -0,0 +1,32 @@
+/** @internal */
+export class SpriteSystem {
+    constructor(
+    /** @internal */ animationSystem, 
+    /** @internal */ game) {
+        this.animationSystem = animationSystem;
+        this.game = game;
+        /** @internal */
+        this._sprites = [];
+    }
+    add(sprite) {
+        sprite._setGame(this.game);
+        this._sprites.push(sprite);
+        return sprite;
+    }
+    destroySprite(sprite) {
+        const idx = this._sprites.indexOf(sprite);
+        if (idx !== -1) {
+            this._sprites.splice(idx, 1);
+        }
+        this.animationSystem.clearSpriteAnimations(sprite);
+    }
+    getSprites() {
+        return [...this._sprites];
+    }
+    getMutableSprites() {
+        return this._sprites;
+    }
+    clearAll() {
+        this._sprites = [];
+    }
+}

package/dist/internal/TextSystem.d.ts

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

package/dist/internal/TextSystem.js

@@ -0,0 +1,16 @@
+/** @internal */
+export class TextSystem {
+    constructor() {
+        /** @internal */
+        this._entries = [];
+    }
+    drawText(text, x, y, fontSize, color = "#ffffff", centered = false) {
+        this._entries.push({ text, x, y, fontSize, color, centered });
+    }
+    getEntries() {
+        return this._entries;
+    }
+    clear() {
+        this._entries = [];
+    }
+}

package/dist/internal/TimerSystem.d.ts

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

package/dist/internal/TimerSystem.js

@@ -0,0 +1,43 @@
+/** @internal */
+export class TimerSystem {
+    constructor() {
+        /** @internal */
+        this._timers = [];
+        /** @internal */
+        this._timerIdCounter = 0;
+    }
+    update(dtMs) {
+        const timers = this._timers;
+        const toRemove = new Set();
+        const toFire = [];
+        for (const timer of timers) {
+            timer.elapsed += dtMs;
+            if (timer.elapsed >= timer.delayMs) {
+                toFire.push(timer);
+                if (timer.repeat) {
+                    timer.elapsed -= timer.delayMs;
+                }
+                else {
+                    toRemove.add(timer.id);
+                }
+            }
+        }
+        if (toRemove.size > 0) {
+            this._timers = timers.filter((t) => !toRemove.has(t.id));
+        }
+        for (const timer of toFire) {
+            timer.callback();
+        }
+    }
+    addTimer(delayMs, repeat, callback) {
+        const id = ++this._timerIdCounter;
+        this._timers.push({ id, delayMs, elapsed: 0, repeat, callback });
+        return id;
+    }
+    clearTimer(id) {
+        this._timers = this._timers.filter((t) => t.id !== id);
+    }
+    clearAll() {
+        this._timers = [];
+    }
+}

package/dist/internal/TrailSystem.d.ts

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

package/dist/internal/TrailSystem.js

@@ -0,0 +1,116 @@
+const DEFAULT_OPTIONS = {
+    durationMs: 300,
+    spacingMs: 40,
+    fadeMs: 180,
+    alpha: 0.45,
+    scaleTo: 0.8,
+};
+/** @internal */
+export class TrailSystem {
+    constructor() {
+        /** @internal */
+        this._emitters = [];
+        /** @internal */
+        this._ghosts = [];
+    }
+    animateTrail(sprite, options, onComplete) {
+        const durationMs = this.sanitizeDuration(options?.durationMs, DEFAULT_OPTIONS.durationMs);
+        const spacingMs = this.sanitizeDuration(options?.spacingMs, DEFAULT_OPTIONS.spacingMs);
+        const fadeMs = this.sanitizeDuration(options?.fadeMs, DEFAULT_OPTIONS.fadeMs);
+        const alpha = this.sanitizeAlpha(options?.alpha, DEFAULT_OPTIONS.alpha);
+        const scaleTo = this.sanitizeScale(options?.scaleTo, DEFAULT_OPTIONS.scaleTo);
+        const emitters = this._emitters.filter((entry) => entry.sprite !== sprite);
+        emitters.push({
+            sprite,
+            elapsedMs: 0,
+            durationMs,
+            timeUntilNextEmitMs: 0,
+            spacingMs,
+            fadeMs,
+            alpha,
+            scaleTo,
+            onComplete,
+        });
+        this._emitters = emitters;
+    }
+    update(dtMs, getSnapshot) {
+        const emitters = this._emitters;
+        const toRemove = [];
+        for (let i = 0; i < emitters.length; i++) {
+            const emitter = emitters[i];
+            emitter.elapsedMs += dtMs;
+            emitter.timeUntilNextEmitMs -= dtMs;
+            while (emitter.timeUntilNextEmitMs <= 0 && emitter.elapsedMs <= emitter.durationMs) {
+                const snapshot = getSnapshot(emitter.sprite);
+                this._ghosts.push({
+                    canvas: snapshot.canvas,
+                    layer: snapshot.layer,
+                    ignoreScroll: snapshot.ignoreScroll,
+                    x: snapshot.x,
+                    y: snapshot.y,
+                    rotation: snapshot.rotation,
+                    alpha: snapshot.alpha * emitter.alpha,
+                    flipX: snapshot.flipX,
+                    flipY: snapshot.flipY,
+                    drawWidth: snapshot.drawWidth,
+                    drawHeight: snapshot.drawHeight,
+                    ageMs: 0,
+                    fadeMs: emitter.fadeMs,
+                    startAlpha: snapshot.alpha * emitter.alpha,
+                    baseDrawWidth: snapshot.drawWidth,
+                    baseDrawHeight: snapshot.drawHeight,
+                    scaleTo: emitter.scaleTo,
+                });
+                emitter.timeUntilNextEmitMs += emitter.spacingMs;
+            }
+            if (emitter.elapsedMs >= emitter.durationMs) {
+                toRemove.push(i);
+                emitter.onComplete?.();
+            }
+        }
+        for (let i = toRemove.length - 1; i >= 0; i--) {
+            emitters.splice(toRemove[i], 1);
+        }
+        const ghosts = this._ghosts;
+        for (let i = ghosts.length - 1; i >= 0; i--) {
+            const ghost = ghosts[i];
+            ghost.ageMs += dtMs;
+            const t = Math.min(ghost.ageMs / ghost.fadeMs, 1);
+            const scale = 1 + (ghost.scaleTo - 1) * t;
+            ghost.alpha = ghost.startAlpha * (1 - t);
+            ghost.drawWidth = ghost.baseDrawWidth * scale;
+            ghost.drawHeight = ghost.baseDrawHeight * scale;
+            if (t >= 1) {
+                ghosts.splice(i, 1);
+            }
+        }
+    }
+    getRenderEntries() {
+        return this._ghosts;
+    }
+    clearSpriteTrails(sprite) {
+        this._emitters = this._emitters.filter((entry) => entry.sprite !== sprite);
+    }
+    clearAll() {
+        this._emitters = [];
+        this._ghosts = [];
+    }
+    /** @internal */
+    sanitizeDuration(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return Math.max(1, value);
+    }
+    /** @internal */
+    sanitizeAlpha(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return Math.max(0, Math.min(1, value));
+    }
+    /** @internal */
+    sanitizeScale(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return Math.max(0, value);
+    }
+}

package/dist/internal/TransitionSystem.d.ts

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

package/dist/internal/TransitionSystem.js

@@ -0,0 +1,74 @@
+const DEFAULT_DURATION_MS = 420;
+const DEFAULT_DIRECTION = "left-to-right";
+const DEFAULT_PIXEL_SIZE = 28;
+/** @internal */
+export class TransitionSystem {
+    constructor() {
+        /** @internal */
+        this._active = null;
+    }
+    get isActive() {
+        return this._active !== null;
+    }
+    start(fromCanvas, toCanvas, width, height, options, onComplete) {
+        const type = options.type;
+        const durationMs = this.sanitizeDuration(options.durationMs, DEFAULT_DURATION_MS);
+        const color = typeof options.color === "string" && options.color.trim()
+            ? options.color
+            : type === "flash"
+                ? "#ffffff"
+                : "#000000";
+        const centerX = this.sanitizeCoordinate(options.centerX, width / 2);
+        const centerY = this.sanitizeCoordinate(options.centerY, height / 2);
+        const pixelSize = this.sanitizePixelSize(options.pixelSize, DEFAULT_PIXEL_SIZE);
+        this._active = {
+            fromCanvas,
+            toCanvas,
+            type,
+            progress: 0,
+            color,
+            direction: options.direction ?? DEFAULT_DIRECTION,
+            centerX,
+            centerY,
+            pixelSize,
+            elapsedMs: 0,
+            durationMs,
+            onComplete,
+        };
+    }
+    update(dtMs) {
+        if (!this._active)
+            return;
+        this._active.elapsedMs += dtMs;
+        this._active.progress = Math.max(0, Math.min(1, this._active.elapsedMs / this._active.durationMs));
+        if (this._active.progress >= 1) {
+            const onComplete = this._active.onComplete;
+            this._active = null;
+            onComplete?.();
+        }
+    }
+    getRenderEntry() {
+        return this._active;
+    }
+    clear() {
+        this._active = null;
+    }
+    /** @internal */
+    sanitizeDuration(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return Math.max(1, value);
+    }
+    /** @internal */
+    sanitizeCoordinate(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return value;
+    }
+    /** @internal */
+    sanitizePixelSize(value, fallback) {
+        if (!Number.isFinite(value))
+            return fallback;
+        return Math.max(2, Math.round(value));
+    }
+}

package/dist/internal/arcade-racer/ArcadeRacerCollisionSystem.d.ts

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

package/dist/internal/arcade-racer/ArcadeRacerCollisionSystem.js

@@ -0,0 +1,198 @@
+const AUTO_BODY_WIDTH_VISUAL_RATIO = 0.76;
+const AUTO_BODY_LENGTH_PER_PIXEL = 1.92;
+/** @internal */
+export class ArcadeRacerCollisionSystem {
+    constructor(
+    /** @internal */ engine) {
+        this.engine = engine;
+    }
+    resolveAutoBodyFromVisual(visual, _scale) {
+        try {
+            const surface = this.engine.resolveVisualSurface(visual);
+            return {
+                width: Math.max(1, surface.width * AUTO_BODY_WIDTH_VISUAL_RATIO),
+                length: Math.max(1, surface.height),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    resolveCollisionBodyMetrics(visual, scale, bodyWidth, bodyLength, bodyOffsetX, bodyOffsetY) {
+        return {
+            laneWidth: this.getBodyLaneWidthFromVisual(scale, bodyWidth),
+            distanceLength: this.getBodyLengthFromVisual(scale, bodyLength),
+            laneOffset: this.getBodyLaneOffsetFromVisual(visual, scale, bodyOffsetX),
+            distanceOffset: this.getBodyDistanceOffsetFromVisual(visual, scale, bodyOffsetY),
+        };
+    }
+    getDebugCollisionRectFromVisual(visualRect, visual, bodyWidth, bodyLength, bodyOffsetX, bodyOffsetY) {
+        const surface = this.engine.resolveVisualSurface(visual);
+        const projectedScale = Math.max(0, Math.min(visualRect.width / Math.max(1, surface.width), visualRect.height / Math.max(1, surface.height)));
+        const rectWidth = Math.max(4, bodyWidth * projectedScale);
+        const rectHeight = Math.max(8, bodyLength * projectedScale);
+        const offsetX = bodyOffsetX * projectedScale;
+        const offsetY = bodyOffsetY * projectedScale;
+        return {
+            x: visualRect.x + (visualRect.width - rectWidth) / 2 + offsetX,
+            y: visualRect.y + visualRect.height - rectHeight + offsetY,
+            width: rectWidth,
+            height: rectHeight,
+        };
+    }
+    getRealCollisionRect(current, width, height, ahead, lane, visual, referenceScale, bodyWidth, bodyLength, bodyOffsetX, bodyOffsetY, resolvedBody, anchorCenterX, anchorBottomY) {
+        const metrics = resolvedBody ??
+            this.resolveCollisionBodyMetrics(visual, referenceScale, bodyWidth, bodyLength, bodyOffsetX, bodyOffsetY);
+        const bodyLaneWidth = metrics.laneWidth;
+        const bodyDistanceLength = metrics.distanceLength;
+        const laneCenter = lane + metrics.laneOffset;
+        const bodyDistanceOffset = metrics.distanceOffset;
+        const depthCenter = this.getBodyDistanceCenterFromAnchor(ahead, bodyDistanceLength, bodyDistanceOffset);
+        const center = this.engine.projectTrafficPoint(current, depthCenter, width, height);
+        const far = this.engine.projectTrafficPoint(current, depthCenter + bodyDistanceLength * 0.5, width, height);
+        const near = this.engine.projectTrafficPoint(current, depthCenter - bodyDistanceLength * 0.5, width, height);
+        const laneUnit = center.roadWidth * 0.38;
+        const centerX = Number.isFinite(anchorCenterX)
+            ? anchorCenterX +
+                this.getBodyOffsetXInScreenPixels(visual, referenceScale, bodyOffsetX)
+            : center.x + laneCenter * laneUnit;
+        const rectWidth = Math.max(4, bodyLaneWidth * laneUnit);
+        const rawTop = Math.min(far.y, near.y);
+        const rawBottom = Math.max(far.y, near.y);
+        const rawHeight = Math.max(8, rawBottom - rawTop);
+        const bottom = Number.isFinite(anchorBottomY)
+            ? rawBottom +
+                (anchorBottomY - rawBottom) *
+                    this.engine.realCollisionVerticalShiftBlend
+            : rawBottom;
+        const top = bottom - rawHeight;
+        return {
+            x: centerX - rectWidth / 2,
+            y: top,
+            width: rectWidth,
+            height: rawHeight,
+        };
+    }
+    resolvePlayerTrafficCollisions() {
+        const nextCollisionIds = new Set();
+        const current = this.engine.trackSystem.sampleTrack(this.engine.distanceState);
+        const playerBodyWidth = this.engine.playerResolvedBodyState.laneWidth;
+        const playerBodyLength = this.engine.playerResolvedBodyState.distanceLength;
+        const playerLaneCenter = this.engine.playerLaneState + this.engine.playerResolvedBodyState.laneOffset;
+        const playerBodyDistanceOffset = this.engine.playerResolvedBodyState.distanceOffset;
+        const playerDistanceCenter = this.engine.distanceState +
+            this.getBodyDistanceCenterFromAnchor(this.engine.playerProjectionAheadDistance, playerBodyLength, playerBodyDistanceOffset);
+        const playerRect = this.getRealCollisionRect(current, this.engine.width, this.engine.height, this.engine.playerProjectionAheadDistance, this.engine.playerLaneState, this.engine.playerVisualState, this.engine.playerBaseScaleState, this.engine.playerBodyWidthState, this.engine.playerBodyLengthState, this.engine.playerBodyOffsetXState, this.engine.playerBodyOffsetYState, this.engine.playerResolvedBodyState, this.engine.getPlayerScreenX(), this.engine.playerScreenYState);
+        for (const traffic of this.engine.trafficState) {
+            const trafficBodyWidth = traffic.resolvedBody.laneWidth;
+            const trafficBodyLength = traffic.resolvedBody.distanceLength;
+            const trafficBodyDistanceOffset = traffic.resolvedBody.distanceOffset;
+            const trafficLaneCenter = traffic.lane + traffic.resolvedBody.laneOffset;
+            const trafficDistanceCenter = this.getBodyDistanceCenterFromAnchor(traffic.distance, trafficBodyLength, trafficBodyDistanceOffset);
+            const distanceDelta = trafficDistanceCenter - playerDistanceCenter;
+            const laneDelta = trafficLaneCenter - playerLaneCenter;
+            const hitDepth = Math.abs(distanceDelta) < (playerBodyLength + trafficBodyLength) * 0.5;
+            const hitLane = Math.abs(laneDelta) < (playerBodyWidth + trafficBodyWidth) * 0.5;
+            if (!hitDepth || !hitLane)
+                continue;
+            const trafficVisualBottom = this.engine.projectTrafficPoint(current, traffic.distance - this.engine.distanceState, this.engine.width, this.engine.height).y;
+            const trafficRect = this.getRealCollisionRect(current, this.engine.width, this.engine.height, traffic.distance - this.engine.distanceState, traffic.lane, traffic.visual, traffic.baseScale, traffic.bodyWidth, traffic.bodyLength, traffic.bodyOffsetX, traffic.bodyOffsetY, traffic.resolvedBody, undefined, trafficVisualBottom);
+            if (playerRect &&
+                trafficRect &&
+                !this.rectsOverlap(playerRect, trafficRect)) {
+                continue;
+            }
+            nextCollisionIds.add(traffic.id);
+            if (this.engine.activeCollisionIds.has(traffic.id))
+                continue;
+            const collision = {
+                trafficId: traffic.id,
+                distanceDelta,
+                laneDelta,
+                trafficDistance: traffic.distance,
+                trafficLane: traffic.lane,
+            };
+            for (const handler of this.engine.collisionHandlers) {
+                handler(collision);
+            }
+        }
+        this.engine.activeCollisionIds = nextCollisionIds;
+    }
+    getPlayerScreenLaneUnit() {
+        return this.engine.roadNearWidth * 0.38;
+    }
+    getBodyDistanceCenterFromAnchor(anchorDistance, bodyLength, bodyDistanceOffset) {
+        return anchorDistance + bodyLength * 0.5 - bodyDistanceOffset;
+    }
+    /** @internal */
+    getBodyOffsetXInScreenPixels(visual, scale, bodyOffsetX) {
+        if (!Number.isFinite(bodyOffsetX) || bodyOffsetX === 0)
+            return 0;
+        try {
+            const surface = this.engine.resolveVisualSurface(visual);
+            const safeScale = Number.isFinite(scale) ? Math.max(0, scale) : 1;
+            const visualWidth = Math.max(1, surface.width * safeScale);
+            return Math.max(-visualWidth * 0.5, Math.min(visualWidth * 0.5, bodyOffsetX * safeScale));
+        }
+        catch {
+            return 0;
+        }
+    }
+    /** @internal */
+    getBodyLaneWidthFromVisual(scale, bodyWidth) {
+        if (!Number.isFinite(bodyWidth) || bodyWidth <= 0)
+            return 0;
+        const safeScale = Number.isFinite(scale) ? Math.max(0, scale) : 1;
+        const projectedWidth = Math.max(1, bodyWidth * safeScale);
+        const laneUnit = Math.max(1, this.getPlayerScreenLaneUnit());
+        return Math.max(0.01, projectedWidth / laneUnit);
+    }
+    /** @internal */
+    getBodyLengthFromVisual(scale, bodyLength) {
+        if (!Number.isFinite(bodyLength) || bodyLength <= 0)
+            return 0;
+        const safeScale = Number.isFinite(scale) ? Math.max(0, scale) : 1;
+        const projectedLength = Math.max(1, bodyLength * safeScale);
+        return Math.max(1, projectedLength * AUTO_BODY_LENGTH_PER_PIXEL);
+    }
+    /** @internal */
+    getBodyLaneOffsetFromVisual(visual, scale, bodyOffsetX) {
+        if (!Number.isFinite(bodyOffsetX) || bodyOffsetX === 0)
+            return 0;
+        try {
+            const surface = this.engine.resolveVisualSurface(visual);
+            const safeScale = Number.isFinite(scale) ? Math.max(0, scale) : 1;
+            const projectedOffsetX = bodyOffsetX * safeScale;
+            const laneUnit = Math.max(1, this.getPlayerScreenLaneUnit());
+            const visualWidth = Math.max(1, surface.width * safeScale);
+            const clampedOffsetX = Math.max(-visualWidth * 0.5, Math.min(visualWidth * 0.5, projectedOffsetX));
+            return clampedOffsetX / laneUnit;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /** @internal */
+    getBodyDistanceOffsetFromVisual(visual, scale, bodyOffsetY) {
+        if (!Number.isFinite(bodyOffsetY) || bodyOffsetY === 0)
+            return 0;
+        try {
+            const surface = this.engine.resolveVisualSurface(visual);
+            const safeScale = Number.isFinite(scale) ? Math.max(0, scale) : 1;
+            const projectedOffsetY = bodyOffsetY * safeScale;
+            const visualHeight = Math.max(1, surface.height * safeScale);
+            const clampedOffsetY = Math.max(-visualHeight * 0.5, Math.min(visualHeight * 0.5, projectedOffsetY));
+            return clampedOffsetY * AUTO_BODY_LENGTH_PER_PIXEL;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /** @internal */
+    rectsOverlap(a, b) {
+        return !(a.x + a.width <= b.x ||
+            b.x + b.width <= a.x ||
+            a.y + a.height <= b.y ||
+            b.y + b.height <= a.y);
+    }
+}

package/dist/internal/arcade-racer/ArcadeRacerLaneSystem.d.ts

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

package/dist/internal/arcade-racer/ArcadeRacerLaneSystem.js

@@ -0,0 +1,120 @@
+/** @internal */
+export function sanitizeLaneSpacePositions(values) {
+    if (!Array.isArray(values))
+        return null;
+    const sanitized = [];
+    for (const value of values) {
+        if (!Number.isFinite(value))
+            continue;
+        sanitized.push(Math.max(-1, Math.min(1, value)));
+    }
+    return sanitized;
+}
+/** @internal */
+export class ArcadeRacerLaneSystem {
+    constructor(requestedLaneCount, laneDirections) {
+        const highestConfiguredLaneIndex = this.getHighestConfiguredLaneIndex(laneDirections);
+        this.laneCountState = Math.max(1, Math.round(requestedLaneCount), highestConfiguredLaneIndex + 1);
+        this.lanePositionsState = this.buildLanePositions(this.laneCountState);
+        const laneDirectionGroups = this.resolveLaneDirectionIndices(laneDirections, this.laneCountState);
+        this.sameDirectionLaneIndicesState = laneDirectionGroups.same;
+        this.oncomingLaneIndicesState = laneDirectionGroups.oncoming;
+    }
+    get laneCount() {
+        return this.laneCountState;
+    }
+    getLanePosition(laneIndex) {
+        if (this.lanePositionsState.length === 0)
+            return 0;
+        const safeIndex = Number.isFinite(laneIndex)
+            ? Math.max(0, Math.min(this.laneCountState - 1, Math.round(laneIndex)))
+            : 0;
+        return this.lanePositionsState[safeIndex] ?? 0;
+    }
+    getLanePositions(direction = "all") {
+        if (direction === "all") {
+            return [...this.lanePositionsState];
+        }
+        const indices = direction === "same"
+            ? this.sameDirectionLaneIndicesState
+            : this.oncomingLaneIndicesState;
+        if (indices === null) {
+            return [...this.lanePositionsState];
+        }
+        return indices.map((index) => this.getLanePosition(index));
+    }
+    clampRoadLane(value) {
+        if (!Number.isFinite(value))
+            return 0;
+        return Math.max(-1, Math.min(1, value));
+    }
+    /** @internal */
+    buildLanePositions(laneCount) {
+        const positions = [];
+        for (let index = 0; index < laneCount; index++) {
+            positions.push(((index + 0.5) / laneCount) * 2 - 1);
+        }
+        return positions;
+    }
+    /** @internal */
+    sanitizeLaneIndexList(values, laneCount) {
+        if (!Array.isArray(values))
+            return [];
+        const result = [];
+        const seen = new Set();
+        for (const value of values) {
+            if (!Number.isFinite(value))
+                continue;
+            const index = Math.round(value);
+            if (index < 0 || index >= laneCount || seen.has(index))
+                continue;
+            seen.add(index);
+            result.push(index);
+        }
+        return result.sort((a, b) => a - b);
+    }
+    /** @internal */
+    getHighestConfiguredLaneIndex(config) {
+        let highest = -1;
+        for (const list of [config?.same, config?.oncoming]) {
+            if (!Array.isArray(list))
+                continue;
+            for (const value of list) {
+                if (!Number.isFinite(value))
+                    continue;
+                highest = Math.max(highest, Math.round(value));
+            }
+        }
+        return highest;
+    }
+    /** @internal */
+    resolveLaneDirectionIndices(config, laneCount) {
+        const hasSame = Array.isArray(config?.same);
+        const hasOncoming = Array.isArray(config?.oncoming);
+        if (!hasSame && !hasOncoming) {
+            return { same: null, oncoming: null };
+        }
+        const allLaneIndices = Array.from({ length: laneCount }, (_, index) => index);
+        const same = this.sanitizeLaneIndexList(config?.same, laneCount);
+        const oncoming = this.sanitizeLaneIndexList(config?.oncoming, laneCount);
+        if (hasSame && hasOncoming) {
+            const sameSet = new Set(same);
+            return {
+                same,
+                oncoming: oncoming.filter((index) => !sameSet.has(index)),
+            };
+        }
+        if (hasSame) {
+            const sameSet = new Set(same);
+            return {
+                same,
+                oncoming: allLaneIndices.filter((index) => !sameSet.has(index)),
+            };
+        }
+        const oncomingSet = new Set(oncoming);
+        return {
+            same: allLaneIndices.filter((index) => !oncomingSet.has(index)),
+            oncoming,
+        };
+    }
+}