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

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

@@ -0,0 +1,447 @@
+/** @internal */
+export class ArcadeRacerTrackSystem {
+    constructor() {
+        /** @internal */
+        this.segments = [];
+        /** @internal */
+        this.pathPrimitives = [];
+        /** @internal */
+        this.pathPointsCacheVersion = -1;
+        /** @internal */
+        this.pathPointsCache = [];
+        /** @internal */
+        this.totalTrackLengthState = 0;
+        /** @internal */
+        this.trackVersion = 0;
+        /** @internal */
+        this.trackClosureMetricsVersion = -1;
+        /** @internal */
+        this.trackClosureMetrics = null;
+        /** @internal */
+        this.minimapPathCacheVersion = -1;
+        /** @internal */
+        this.minimapPathCache = [];
+        this.resetTrack();
+        this.addLegacyTrackSegment({ length: 4000, curve: 0, hill: 0 });
+    }
+    get totalTrackLength() {
+        return this.totalTrackLengthState;
+    }
+    get hasPathPrimitives() {
+        return this.pathPrimitives.length > 0;
+    }
+    clearTrack() {
+        this.resetTrack();
+    }
+    appendPathLine(length, options = {}) {
+        const safeLength = Math.max(1, Math.abs(length));
+        if (this.pathPrimitives.length === 0 && this.segments.length > 0) {
+            this.resetTrack();
+        }
+        this.pathPrimitives.push({
+            type: "line",
+            length: safeLength,
+            elevationDelta: Number.isFinite(options.elevationDelta)
+                ? options.elevationDelta
+                : 0,
+        });
+        this.totalTrackLengthState += safeLength;
+        this.trackVersion += 1;
+        this.pathPointsCache = [];
+        this.pathPointsCacheVersion = -1;
+    }
+    appendPathArc(radius, degrees, direction, options = {}) {
+        const safeRadius = Math.max(1, Math.abs(radius));
+        const safeDegrees = Math.max(0.1, Math.abs(degrees));
+        if (this.pathPrimitives.length === 0 && this.segments.length > 0) {
+            this.resetTrack();
+        }
+        const angleRad = ((safeDegrees * Math.PI) / 180) * direction;
+        this.pathPrimitives.push({
+            type: "arc",
+            radius: safeRadius,
+            angleRad,
+            elevationDelta: Number.isFinite(options.elevationDelta)
+                ? options.elevationDelta
+                : 0,
+        });
+        this.totalTrackLengthState += Math.abs(safeRadius * angleRad);
+        this.trackVersion += 1;
+        this.pathPointsCache = [];
+        this.pathPointsCacheVersion = -1;
+    }
+    setRoundedRectTrack(circuitWidth, circuitHeight, cornerRadius) {
+        const safeWidth = Math.max(48, Math.abs(circuitWidth));
+        const safeHeight = Math.max(48, Math.abs(circuitHeight));
+        const radius = Math.max(12, Math.min(Math.abs(cornerRadius), safeWidth / 2 - 1, safeHeight / 2 - 1));
+        const horizontal = Math.max(1, safeWidth - radius * 2);
+        const vertical = Math.max(1, safeHeight - radius * 2);
+        const arcAngle = Math.PI / 2;
+        this.resetTrack();
+        this.pathPrimitives = [
+            { type: "line", length: horizontal, elevationDelta: 0 },
+            { type: "arc", radius, angleRad: arcAngle, elevationDelta: 0 },
+            { type: "line", length: vertical, elevationDelta: 0 },
+            { type: "arc", radius, angleRad: arcAngle, elevationDelta: 0 },
+            { type: "line", length: horizontal, elevationDelta: 0 },
+            { type: "arc", radius, angleRad: arcAngle, elevationDelta: 0 },
+            { type: "line", length: vertical, elevationDelta: 0 },
+            { type: "arc", radius, angleRad: arcAngle, elevationDelta: 0 },
+        ];
+        this.totalTrackLengthState =
+            horizontal * 2 + vertical * 2 + radius * Math.PI * 2;
+        this.trackVersion += 1;
+        this.pathPointsCache = [];
+        this.pathPointsCacheVersion = -1;
+    }
+    sampleTrack(distance) {
+        if (this.pathPrimitives.length > 0) {
+            return this.samplePathTrack(distance);
+        }
+        if (this.segments.length === 0 || this.totalTrackLengthState <= 0) {
+            return this.makeZeroSample();
+        }
+        const raw = this.sampleRawTrack(distance);
+        const metrics = this.getTrackClosureMetrics();
+        const wrapped = this.wrapDistance(distance);
+        const t = this.totalTrackLengthState <= 0
+            ? 0
+            : Math.max(0, Math.min(1, wrapped / this.totalTrackLengthState));
+        return {
+            lateralOffset: raw.lateralOffset - metrics.offsetDrift * t,
+            elevation: raw.elevation - metrics.elevationDrift * t,
+            curve: raw.curve - metrics.curveDrift * t,
+            hill: raw.hill - metrics.hillDrift * t,
+            worldX: raw.lateralOffset - metrics.offsetDrift * t,
+            worldY: wrapped,
+            heading: 0,
+        };
+    }
+    getMinimapPathPoints() {
+        if (this.pathPrimitives.length > 0) {
+            const pathPoints = this.getPathTrackPoints();
+            let visiblePathPoints = pathPoints;
+            if (pathPoints.length >= 3) {
+                const first = pathPoints[0];
+                const last = pathPoints[pathPoints.length - 1];
+                const previous = pathPoints[pathPoints.length - 2];
+                const lastMatchesStart = Math.hypot(last.x - first.x, last.y - first.y) <= 0.001;
+                const previousStillOpen = Math.hypot(previous.x - first.x, previous.y - first.y) > 0.001;
+                if (lastMatchesStart && previousStillOpen) {
+                    visiblePathPoints = pathPoints.slice(0, -1);
+                }
+            }
+            return visiblePathPoints.map((point) => ({
+                x: point.x,
+                y: point.y,
+                distance: point.distance,
+            }));
+        }
+        if (this.minimapPathCacheVersion === this.trackVersion) {
+            return this.minimapPathCache;
+        }
+        if (this.totalTrackLengthState <= 0) {
+            this.minimapPathCache = [];
+            this.minimapPathCacheVersion = this.trackVersion;
+            return this.minimapPathCache;
+        }
+        const sampleCount = Math.max(64, Math.round(this.totalTrackLengthState / 80));
+        const points = [{ x: 0, y: 0, distance: 0 }];
+        let x = 0;
+        let y = 0;
+        let heading = -Math.PI / 2;
+        let previousDistance = 0;
+        const turnFactor = 0.0034;
+        for (let i = 1; i <= sampleCount; i++) {
+            const distance = (i / sampleCount) * this.totalTrackLengthState;
+            const delta = distance - previousDistance;
+            const sample = this.sampleTrack(previousDistance + delta * 0.5);
+            heading += sample.curve * delta * turnFactor;
+            x += Math.cos(heading) * delta;
+            y += Math.sin(heading) * delta;
+            points.push({ x, y, distance });
+            previousDistance = distance;
+        }
+        this.minimapPathCache = points;
+        this.minimapPathCacheVersion = this.trackVersion;
+        return this.minimapPathCache;
+    }
+    getLoopingAheadDistance(currentDistance, targetDistance) {
+        if (this.totalTrackLengthState <= 0) {
+            return targetDistance - currentDistance;
+        }
+        const currentWrapped = this.wrapDistance(currentDistance);
+        const targetWrapped = this.wrapDistance(targetDistance);
+        let delta = targetWrapped - currentWrapped;
+        if (delta < 0) {
+            delta += this.totalTrackLengthState;
+        }
+        return delta;
+    }
+    wrapDistance(distance) {
+        if (this.totalTrackLengthState <= 0)
+            return 0;
+        const wrapped = distance % this.totalTrackLengthState;
+        return wrapped < 0 ? wrapped + this.totalTrackLengthState : wrapped;
+    }
+    addLegacyTrackSegment(config) {
+        const length = Math.max(1, Number.isFinite(config.length) ? config.length : 1);
+        const previous = this.segments[this.segments.length - 1];
+        const curveFrom = previous ? previous.curveTo : 0;
+        const hillFrom = previous ? previous.hillTo : 0;
+        const curveTo = Number.isFinite(config.curve)
+            ? config.curve
+            : curveFrom;
+        const hillTo = Number.isFinite(config.hill)
+            ? config.hill
+            : hillFrom;
+        const start = previous ? previous.end : 0;
+        const offsetAtStart = previous
+            ? previous.offsetAtStart +
+                ((previous.curveFrom + previous.curveTo) * 0.5) * previous.length
+            : 0;
+        const elevationAtStart = previous
+            ? previous.elevationAtStart +
+                ((previous.hillFrom + previous.hillTo) * 0.5) * previous.length
+            : 0;
+        this.segments.push({
+            length,
+            curveFrom,
+            curveTo,
+            hillFrom,
+            hillTo,
+            start,
+            end: start + length,
+            offsetAtStart,
+            elevationAtStart,
+        });
+        this.totalTrackLengthState = this.segments[this.segments.length - 1].end;
+        this.trackVersion += 1;
+    }
+    /** @internal */
+    makeZeroSample() {
+        return {
+            lateralOffset: 0,
+            elevation: 0,
+            curve: 0,
+            hill: 0,
+            worldX: 0,
+            worldY: 0,
+            heading: 0,
+        };
+    }
+    /** @internal */
+    sampleRawTrack(distance) {
+        if (this.segments.length === 0 || this.totalTrackLengthState <= 0) {
+            return this.makeZeroSample();
+        }
+        const wrapped = this.wrapDistance(distance);
+        let segment = this.segments[this.segments.length - 1];
+        for (const candidate of this.segments) {
+            if (wrapped >= candidate.start && wrapped <= candidate.end) {
+                segment = candidate;
+                break;
+            }
+        }
+        const local = wrapped - segment.start;
+        const t = segment.length <= 0 ? 0 : Math.max(0, Math.min(1, local / segment.length));
+        const eased = this.easeInOut(t);
+        const curve = this.lerp(segment.curveFrom, segment.curveTo, eased);
+        const hill = this.lerp(segment.hillFrom, segment.hillTo, eased);
+        const localOffset = ((segment.curveFrom + curve) * 0.5) * local;
+        const localElevation = ((segment.hillFrom + hill) * 0.5) * local;
+        return {
+            lateralOffset: segment.offsetAtStart + localOffset,
+            elevation: segment.elevationAtStart + localElevation,
+            curve,
+            hill,
+            worldX: segment.offsetAtStart + localOffset,
+            worldY: wrapped,
+            heading: 0,
+        };
+    }
+    /** @internal */
+    samplePathTrack(distance) {
+        const points = this.getPathTrackPoints();
+        if (points.length === 0 || this.totalTrackLengthState <= 0) {
+            return this.makeZeroSample();
+        }
+        const wrapped = this.wrapDistance(distance);
+        for (let i = 1; i < points.length; i++) {
+            const from = points[i - 1];
+            const to = points[i];
+            if (wrapped > to.distance)
+                continue;
+            const span = Math.max(0.0001, to.distance - from.distance);
+            const t = Math.max(0, Math.min(1, (wrapped - from.distance) / span));
+            const heading = this.lerp(from.heading, to.heading, t);
+            const elevation = this.lerp(from.elevation, to.elevation, t);
+            const curve = this.lerp(from.curve, to.curve, t);
+            const hill = this.lerp(from.hill, to.hill, t);
+            const worldX = this.lerp(from.x, to.x, t);
+            const worldY = this.lerp(from.y, to.y, t);
+            return {
+                lateralOffset: worldX,
+                elevation,
+                curve,
+                hill,
+                worldX,
+                worldY,
+                heading,
+            };
+        }
+        const last = points[points.length - 1];
+        return {
+            lateralOffset: last.x,
+            elevation: last.elevation,
+            curve: last.curve,
+            hill: last.hill,
+            worldX: last.x,
+            worldY: last.y,
+            heading: last.heading,
+        };
+    }
+    /** @internal */
+    getPathTrackPoints() {
+        if (this.pathPointsCacheVersion === this.trackVersion) {
+            return this.pathPointsCache;
+        }
+        const points = [];
+        if (this.pathPrimitives.length === 0) {
+            this.pathPointsCache = points;
+            this.pathPointsCacheVersion = this.trackVersion;
+            return points;
+        }
+        let x = 0;
+        let y = 0;
+        let heading = 0;
+        let distance = 0;
+        let elevation = 0;
+        points.push({
+            distance,
+            x,
+            y,
+            heading,
+            elevation,
+            curve: 0,
+            hill: 0,
+        });
+        for (const primitive of this.pathPrimitives) {
+            if (primitive.type === "line") {
+                const steps = Math.max(1, Math.ceil(primitive.length / 40));
+                const stepLength = primitive.length / steps;
+                const stepElevation = primitive.elevationDelta / steps;
+                const hill = primitive.elevationDelta / Math.max(1, primitive.length);
+                for (let i = 0; i < steps; i++) {
+                    x += Math.cos(heading) * stepLength;
+                    y += Math.sin(heading) * stepLength;
+                    distance += stepLength;
+                    elevation += stepElevation;
+                    points.push({
+                        distance,
+                        x,
+                        y,
+                        heading,
+                        elevation,
+                        curve: 0,
+                        hill,
+                    });
+                }
+                continue;
+            }
+            const arcLength = Math.abs(primitive.radius * primitive.angleRad);
+            const steps = Math.max(4, Math.ceil(arcLength / 32));
+            const stepAngle = primitive.angleRad / steps;
+            const stepLength = arcLength / steps;
+            const curve = primitive.angleRad >= 0 ? 1 / primitive.radius : -1 / primitive.radius;
+            const stepElevation = primitive.elevationDelta / steps;
+            const hill = primitive.elevationDelta / Math.max(1, arcLength);
+            for (let i = 0; i < steps; i++) {
+                const headingMid = heading + stepAngle * 0.5;
+                x += Math.cos(headingMid) * stepLength;
+                y += Math.sin(headingMid) * stepLength;
+                heading += stepAngle;
+                distance += stepLength;
+                elevation += stepElevation;
+                points.push({
+                    distance,
+                    x,
+                    y,
+                    heading,
+                    elevation,
+                    curve,
+                    hill,
+                });
+            }
+        }
+        const start = points[0];
+        const end = points[points.length - 1];
+        if (Math.hypot(end.x - start.x, end.y - start.y) > 0.001) {
+            points.push({
+                distance: this.totalTrackLengthState,
+                x: start.x,
+                y: start.y,
+                heading: start.heading + Math.PI * 2,
+                elevation: start.elevation,
+                curve: 0,
+                hill: 0,
+            });
+        }
+        else {
+            end.x = start.x;
+            end.y = start.y;
+            end.heading = start.heading + Math.PI * 2;
+            end.elevation = start.elevation;
+        }
+        this.pathPointsCache = points;
+        this.pathPointsCacheVersion = this.trackVersion;
+        return this.pathPointsCache;
+    }
+    /** @internal */
+    getTrackClosureMetrics() {
+        if (this.trackClosureMetrics &&
+            this.trackClosureMetricsVersion === this.trackVersion) {
+            return this.trackClosureMetrics;
+        }
+        const start = this.sampleRawTrack(0);
+        const end = this.sampleRawTrack(Math.max(0, this.totalTrackLengthState - 0.0001));
+        this.trackClosureMetrics = {
+            startCurve: start.curve,
+            startHill: start.hill,
+            startOffset: start.lateralOffset,
+            startElevation: start.elevation,
+            endCurve: end.curve,
+            endHill: end.hill,
+            endOffset: end.lateralOffset,
+            endElevation: end.elevation,
+            curveDrift: end.curve - start.curve,
+            hillDrift: end.hill - start.hill,
+            offsetDrift: end.lateralOffset - start.lateralOffset,
+            elevationDrift: end.elevation - start.elevation,
+        };
+        this.trackClosureMetricsVersion = this.trackVersion;
+        return this.trackClosureMetrics;
+    }
+    /** @internal */
+    resetTrack() {
+        this.segments = [];
+        this.pathPrimitives = [];
+        this.pathPointsCache = [];
+        this.pathPointsCacheVersion = -1;
+        this.totalTrackLengthState = 0;
+        this.trackVersion += 1;
+        this.trackClosureMetrics = null;
+        this.trackClosureMetricsVersion = -1;
+        this.minimapPathCache = [];
+        this.minimapPathCacheVersion = -1;
+    }
+    /** @internal */
+    lerp(from, to, t) {
+        return from + (to - from) * t;
+    }
+    /** @internal */
+    easeInOut(t) {
+        const safeT = Math.max(0, Math.min(1, t));
+        return safeT * safeT * (3 - 2 * safeT);
+    }
+}