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

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

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

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

@@ -0,0 +1,599 @@
+/** @internal */
+export class ArcadeRacerRenderSystem {
+    constructor(
+    /** @internal */ engine) {
+        this.engine = engine;
+    }
+    renderFrame(ctx, width, height) {
+        const render = {
+            ctx,
+            width,
+            height,
+            current: this.engine.trackSystem.sampleTrack(this.engine.distanceState),
+            horizonY: this.engine.horizonY,
+            stripCount: this.engine.stripCount,
+            drawDistance: this.engine.drawDistance,
+            roadBandSpan: this.engine.roadBandSpan,
+            shoulderBandSpan: this.engine.shoulderBandSpan,
+            grassBandSpan: this.engine.grassBandSpan,
+            laneCount: this.engine.laneCount,
+            trafficBehindVisibilityDistance: this.engine.trafficBehindVisibilityDistance,
+            playerProjectionAheadDistance: this.engine.playerProjectionAheadDistance,
+            distanceState: this.engine.distanceState,
+            headingState: this.engine.headingState,
+            playerLane: this.engine.playerLaneState,
+            playerScreenY: this.engine.playerScreenYState,
+            playerBaseScale: this.engine.playerBaseScaleState,
+            playerVisual: this.engine.playerVisualState,
+            playerBodyWidth: this.engine.playerBodyWidthState,
+            playerBodyLength: this.engine.playerBodyLengthState,
+            playerBodyOffsetX: this.engine.playerBodyOffsetXState,
+            playerBodyOffsetY: this.engine.playerBodyOffsetYState,
+            playerResolvedBody: this.engine.playerResolvedBodyState,
+            theme: this.engine.themeState,
+            groundFill: this.engine.groundFillState,
+            horizon: this.engine.horizonState,
+            minimap: this.engine.minimapState,
+            debug: this.engine.debugState,
+            billboards: this.engine.billboardsState,
+            traffic: this.engine.trafficState,
+            horizonMarkers: this.engine.horizonMarkersState,
+            backgroundLayers: this.engine.backgroundLayersState,
+            minimapPoints: this.engine.trackSystem.getMinimapPathPoints(),
+            resolveVisualSurface: this.engine.resolveVisualSurface.bind(this.engine),
+            projectRoadPoint: this.engine.projectRoadPoint.bind(this.engine),
+            projectTrafficPoint: this.engine.projectTrafficPoint.bind(this.engine),
+            projectObject: (current, ahead, billboard, renderWidth, renderHeight) => this.engine.projectObject(current, ahead, billboard, renderWidth, renderHeight),
+            sampleMinimapPoint: (points, distance) => this.engine.sampleMinimapPoint(points, distance),
+            getPlayerScreenX: this.engine.getPlayerScreenX.bind(this.engine),
+            getDebugCollisionRectFromVisual: this.engine.getDebugCollisionRectFromVisual.bind(this.engine),
+            getRealCollisionRect: this.engine.getRealCollisionRect.bind(this.engine),
+            clamp01: this.engine.clamp01.bind(this.engine),
+            easeInOut: this.engine.easeInOut.bind(this.engine),
+            getShortestAngleDelta: this.engine.getShortestAngleDelta.bind(this.engine),
+        };
+        this.renderResolvedFrame(render);
+    }
+    /** @internal */
+    renderResolvedFrame(render) {
+        this.drawBackground(render);
+        this.drawRoad(render);
+        this.drawSceneObjects(render);
+        this.drawMinimap(render);
+    }
+    /** @internal */
+    drawBackground(render) {
+        if (render.backgroundLayers.length > 0) {
+            this.drawImageBackground(render);
+            return;
+        }
+        this.drawFallbackBackground(render);
+    }
+    /** @internal */
+    drawFallbackBackground(render) {
+        const { ctx, width, height, horizonY, theme } = render;
+        const sky = ctx.createLinearGradient(0, 0, 0, horizonY + 80);
+        sky.addColorStop(0, theme.skyTop);
+        sky.addColorStop(0.55, theme.skyBottom);
+        sky.addColorStop(1, theme.skyBottom);
+        ctx.fillStyle = sky;
+        ctx.fillRect(0, 0, width, horizonY + 80);
+        ctx.fillStyle = theme.horizonGlow;
+        ctx.fillRect(0, horizonY - 8, width, 18);
+        const sunX = width * 0.74;
+        const sunY = Math.max(40, horizonY * 0.54);
+        const sun = ctx.createRadialGradient(sunX, sunY, 8, sunX, sunY, 56);
+        sun.addColorStop(0, theme.sunInner);
+        sun.addColorStop(0.45, "rgba(255, 205, 113, 0.75)");
+        sun.addColorStop(1, theme.sunOuter);
+        ctx.fillStyle = sun;
+        ctx.beginPath();
+        ctx.arc(sunX, sunY, 56, 0, Math.PI * 2);
+        ctx.fill();
+        ctx.fillStyle = theme.mountainBack;
+        ctx.beginPath();
+        ctx.moveTo(0, horizonY + 18);
+        for (let x = 0; x <= width; x += 8) {
+            const y = horizonY +
+                24 +
+                Math.sin(x * 0.012 + render.distanceState * 0.00015) * 22 +
+                Math.sin(x * 0.021 - render.distanceState * 0.00008) * 11;
+            ctx.lineTo(x, y);
+        }
+        ctx.lineTo(width, horizonY + 90);
+        ctx.lineTo(0, horizonY + 90);
+        ctx.closePath();
+        ctx.fill();
+        ctx.fillStyle = theme.mountainFront;
+        ctx.beginPath();
+        ctx.moveTo(0, horizonY + 34);
+        for (let x = 0; x <= width; x += 7) {
+            const y = horizonY +
+                42 +
+                Math.sin(x * 0.01 + render.distanceState * 0.00019 + 1.1) * 30 +
+                Math.sin(x * 0.018 - render.distanceState * 0.0001 - 0.7) * 16;
+            ctx.lineTo(x, y);
+        }
+        ctx.lineTo(width, horizonY + 115);
+        ctx.lineTo(0, horizonY + 115);
+        ctx.closePath();
+        ctx.fill();
+        this.drawDirectionalHorizon(render);
+        if (render.groundFill.enabled) {
+            ctx.fillStyle = render.groundFill.color ?? theme.grassA;
+            ctx.fillRect(0, horizonY, width, height - horizonY);
+        }
+    }
+    /** @internal */
+    drawImageBackground(render) {
+        const { ctx, width, height, horizonY, theme } = render;
+        ctx.fillStyle = theme.skyBottom;
+        ctx.fillRect(0, 0, width, horizonY + 80);
+        for (const layer of render.backgroundLayers) {
+            const surface = render.resolveVisualSurface(layer.visual);
+            const drawWidth = Math.max(1, surface.width * layer.baseScale);
+            const drawHeight = Math.max(1, surface.height * layer.baseScale);
+            const distanceOffset = render.distanceState * layer.parallaxDistance;
+            const headingOffset = (render.headingState / 90) * width * layer.parallaxHeading;
+            const stride = drawWidth + layer.spacing;
+            const y = layer.y;
+            ctx.save();
+            ctx.globalAlpha = layer.alpha;
+            if (layer.repeat) {
+                let startX = layer.xOffset - distanceOffset - headingOffset;
+                startX = ((startX % stride) + stride) % stride - stride;
+                for (let x = startX; x < width + stride; x += stride) {
+                    ctx.drawImage(surface.source, Math.round(x), Math.round(y), drawWidth, drawHeight);
+                }
+            }
+            else {
+                const x = width / 2 -
+                    drawWidth / 2 +
+                    layer.xOffset -
+                    distanceOffset -
+                    headingOffset;
+                ctx.drawImage(surface.source, Math.round(x), Math.round(y), drawWidth, drawHeight);
+            }
+            ctx.restore();
+        }
+        this.drawDirectionalHorizon(render);
+        if (render.groundFill.enabled) {
+            ctx.fillStyle = render.groundFill.color ?? theme.grassA;
+            ctx.fillRect(0, horizonY, width, height - horizonY);
+        }
+    }
+    /** @internal */
+    drawDirectionalHorizon(render) {
+        if (render.horizonMarkers.length === 0) {
+            return;
+        }
+        const visible = render.horizonMarkers
+            .map((marker) => {
+            const influenceAngle = marker.influenceAngle ?? render.horizon.influenceAngle;
+            const signedDelta = render.getShortestAngleDelta(render.headingState, marker.angle);
+            const absDelta = Math.abs(signedDelta);
+            if (absDelta > influenceAngle) {
+                return null;
+            }
+            const weight = 1 - absDelta / influenceAngle;
+            const easedWeight = render.easeInOut(weight);
+            const parallaxFactor = marker.parallaxFactor ?? render.horizon.parallaxFactor;
+            const x = render.width / 2 +
+                (signedDelta / 90) * render.width * parallaxFactor;
+            return {
+                marker,
+                absDelta,
+                alpha: marker.alpha * easedWeight,
+                x,
+                y: render.horizonY +
+                    render.horizon.baseYOffset +
+                    marker.yOffset,
+            };
+        })
+            .filter((entry) => entry !== null && entry.alpha > 0.001)
+            .sort((a, b) => a.absDelta - b.absDelta)
+            .slice(0, render.horizon.maxVisibleMarkers)
+            .sort((a, b) => a.alpha - b.alpha);
+        for (const entry of visible) {
+            this.drawVisual(render, entry.marker.visual, entry.x, entry.y, entry.marker.baseScale, entry.alpha, 0.5, 1);
+        }
+    }
+    /** @internal */
+    drawMinimap(render) {
+        if (!render.minimap.visible || render.minimapPoints.length < 2) {
+            return;
+        }
+        const { ctx } = render;
+        const points = render.minimapPoints;
+        const x = render.minimap.x;
+        const y = render.minimap.y;
+        const width = render.minimap.width;
+        const height = render.minimap.height;
+        const padding = render.minimap.padding;
+        let minX = Number.POSITIVE_INFINITY;
+        let maxX = Number.NEGATIVE_INFINITY;
+        let minY = Number.POSITIVE_INFINITY;
+        let maxY = Number.NEGATIVE_INFINITY;
+        for (const point of points) {
+            if (point.x < minX)
+                minX = point.x;
+            if (point.x > maxX)
+                maxX = point.x;
+            if (point.y < minY)
+                minY = point.y;
+            if (point.y > maxY)
+                maxY = point.y;
+        }
+        const innerWidth = Math.max(1, width - padding * 2);
+        const innerHeight = Math.max(1, height - padding * 2);
+        const boundsWidth = Math.max(1, maxX - minX);
+        const boundsHeight = Math.max(1, maxY - minY);
+        const scale = Math.min(innerWidth / boundsWidth, innerHeight / boundsHeight);
+        const offsetX = x + padding + (innerWidth - boundsWidth * scale) / 2 - minX * scale;
+        const offsetY = y + padding + (innerHeight - boundsHeight * scale) / 2 - minY * scale;
+        ctx.save();
+        ctx.globalAlpha = render.clamp01(render.minimap.alpha);
+        ctx.fillStyle = render.minimap.backgroundColor;
+        this.fillRoundedRect(ctx, x, y, width, height, 12);
+        if (render.minimap.borderWidth > 0) {
+            ctx.strokeStyle = render.minimap.borderColor;
+            ctx.lineWidth = render.minimap.borderWidth;
+            this.strokeRoundedRect(ctx, x, y, width, height, 12);
+        }
+        ctx.beginPath();
+        ctx.lineJoin = "round";
+        ctx.lineCap = "round";
+        ctx.lineWidth = render.minimap.trackLineWidth;
+        ctx.strokeStyle = render.minimap.trackColor;
+        ctx.moveTo(offsetX + points[0].x * scale, offsetY + points[0].y * scale);
+        for (let i = 1; i < points.length; i++) {
+            ctx.lineTo(offsetX + points[i].x * scale, offsetY + points[i].y * scale);
+        }
+        const startPoint = points[0];
+        const endPoint = points[points.length - 1];
+        const closureDistance = Math.hypot(endPoint.x - startPoint.x, endPoint.y - startPoint.y);
+        const closureTolerance = Math.max(boundsWidth, boundsHeight) * 0.08;
+        if (closureDistance <= closureTolerance) {
+            ctx.closePath();
+        }
+        ctx.stroke();
+        const playerPoint = render.sampleMinimapPoint(points, render.distanceState);
+        const playerX = offsetX + playerPoint.x * scale;
+        const playerY = offsetY + playerPoint.y * scale;
+        const radius = render.minimap.playerRadius;
+        ctx.beginPath();
+        ctx.arc(playerX, playerY, radius, 0, Math.PI * 2);
+        ctx.fillStyle = render.minimap.playerColor;
+        ctx.fill();
+        ctx.lineWidth = Math.max(1, render.minimap.borderWidth * 0.75);
+        ctx.strokeStyle = render.minimap.playerStrokeColor;
+        ctx.stroke();
+        ctx.restore();
+    }
+    /** @internal */
+    drawRoad(render) {
+        const frame = this.buildRoadDrawFrame(render);
+        for (const strip of frame.strips) {
+            this.engine.resolveRoadDrawer(strip.trackDistance).drawStrip(render.ctx, frame, strip);
+        }
+        this.engine.roadDrawerState.drawOverlay?.(render.ctx, frame);
+    }
+    /** @internal */
+    buildRoadDrawFrame(render) {
+        const strips = [];
+        const { width, height, current } = render;
+        for (let i = 0; i < render.stripCount; i++) {
+            const tFar = i / render.stripCount;
+            const tNear = (i + 1) / render.stripCount;
+            const aheadFar = (1 - tFar) * render.drawDistance;
+            const aheadNear = (1 - tNear) * render.drawDistance;
+            const absoluteFarDistance = render.distanceState + aheadFar;
+            const absoluteNearDistance = render.distanceState + aheadNear;
+            const far = render.projectRoadPoint(current, aheadFar, width, height);
+            const near = render.projectRoadPoint(current, aheadNear, width, height);
+            const farY = Math.floor(far.y);
+            const nearY = Math.ceil(near.y) + 1;
+            if (nearY <= farY)
+                continue;
+            const stripeIndex = Math.floor(render.distanceState * 0.05 + i);
+            const grassBandIndex = Math.floor(stripeIndex / render.grassBandSpan);
+            const shoulderBandIndex = Math.floor(stripeIndex / render.shoulderBandSpan);
+            const roadBandIndex = Math.floor(stripeIndex / render.roadBandSpan);
+            const shoulderFar = far.roadWidth * 0.12;
+            const shoulderNear = near.roadWidth * 0.12;
+            const leftOuterFar = far.x - far.roadWidth / 2 - shoulderFar;
+            const rightOuterFar = far.x + far.roadWidth / 2 + shoulderFar;
+            const leftOuterNear = near.x - near.roadWidth / 2 - shoulderNear;
+            const rightOuterNear = near.x + near.roadWidth / 2 + shoulderNear;
+            const leftRoadFar = far.x - far.roadWidth / 2;
+            const rightRoadFar = far.x + far.roadWidth / 2;
+            const leftRoadNear = near.x - near.roadWidth / 2;
+            const rightRoadNear = near.x + near.roadWidth / 2;
+            const laneMarkers = this.buildLaneMarkerStrips(render, stripeIndex, far, near, leftRoadFar, rightRoadFar, leftRoadNear, rightRoadNear);
+            const absoluteDistance = render.distanceState + (aheadFar + aheadNear) * 0.5;
+            strips.push({
+                index: strips.length,
+                stripeIndex,
+                absoluteDistance,
+                trackDistance: this.engine.trackSystem.wrapDistance(absoluteDistance),
+                farDistance: absoluteFarDistance,
+                nearDistance: absoluteNearDistance,
+                farProjection: this.toPublicProjection(far),
+                nearProjection: this.toPublicProjection(near),
+                farSample: this.toPublicSample(this.engine.trackSystem.sampleTrack(absoluteFarDistance)),
+                nearSample: this.toPublicSample(this.engine.trackSystem.sampleTrack(absoluteNearDistance)),
+                farY,
+                nearY,
+                grassBandIndex,
+                shoulderBandIndex,
+                roadBandIndex,
+                shoulderFar,
+                shoulderNear,
+                leftOuterFar,
+                rightOuterFar,
+                leftOuterNear,
+                rightOuterNear,
+                leftRoadFar,
+                rightRoadFar,
+                leftRoadNear,
+                rightRoadNear,
+                laneMarkers,
+            });
+        }
+        return {
+            width: render.width,
+            height: render.height,
+            horizonY: render.horizonY,
+            distanceState: render.distanceState,
+            drawDistance: render.drawDistance,
+            stripCount: render.stripCount,
+            laneCount: render.laneCount,
+            currentSample: this.toPublicSample(render.current),
+            theme: render.theme,
+            strips,
+            projectDistance: (absoluteDistance) => this.projectRoadSurfaceAtDistance(render, absoluteDistance),
+        };
+    }
+    /** @internal */
+    projectRoadSurfaceAtDistance(render, absoluteDistance) {
+        const ahead = absoluteDistance - render.distanceState;
+        const projection = render.projectRoadPoint(render.current, ahead, render.width, render.height);
+        const shoulderWidth = projection.roadWidth * 0.12;
+        return {
+            trackDistance: this.engine.trackSystem.wrapDistance(absoluteDistance),
+            absoluteDistance,
+            projection: this.toPublicProjection(projection),
+            shoulderWidth,
+            leftRoadX: projection.x - projection.roadWidth / 2,
+            rightRoadX: projection.x + projection.roadWidth / 2,
+            leftOuterX: projection.x - projection.roadWidth / 2 - shoulderWidth,
+            rightOuterX: projection.x + projection.roadWidth / 2 + shoulderWidth,
+        };
+    }
+    /** @internal */
+    buildLaneMarkerStrips(render, stripeIndex, far, near, leftRoadFar, rightRoadFar, leftRoadNear, rightRoadNear) {
+        const laneSeparators = Math.max(0, render.laneCount - 1);
+        if (!(laneSeparators > 0 && near.roadWidth > 90 && stripeIndex % 7 < 3)) {
+            return [];
+        }
+        const markers = [];
+        for (let laneIndex = 1; laneIndex < render.laneCount; laneIndex++) {
+            const laneT = laneIndex / render.laneCount;
+            const markerFarX = leftRoadFar + laneT * (rightRoadFar - leftRoadFar);
+            const markerNearX = leftRoadNear + laneT * (rightRoadNear - leftRoadNear);
+            markers.push({
+                farX: markerFarX,
+                nearX: markerNearX,
+                farWidth: Math.max(2, far.roadWidth * 0.028),
+                nearWidth: Math.max(2, near.roadWidth * 0.028),
+            });
+        }
+        return markers;
+    }
+    /** @internal */
+    toPublicProjection(projection) {
+        return {
+            x: projection.x,
+            y: projection.y,
+            roadWidth: projection.roadWidth,
+            scale: projection.scale,
+            t: projection.t,
+        };
+    }
+    /** @internal */
+    toPublicSample(sample) {
+        return {
+            lateralOffset: sample.lateralOffset,
+            elevation: sample.elevation,
+            curve: sample.curve,
+            hill: sample.hill,
+            worldX: sample.worldX,
+            worldY: sample.worldY,
+            heading: sample.heading,
+        };
+    }
+    /** @internal */
+    drawSceneObjects(render) {
+        const visible = [];
+        for (const billboard of render.billboards) {
+            const ahead = billboard.distance - render.distanceState;
+            if (ahead <= 0 || ahead > render.drawDistance)
+                continue;
+            const projection = render.projectObject(render.current, ahead, billboard, render.width, render.height);
+            if (!projection)
+                continue;
+            visible.push({
+                depth: ahead,
+                x: projection.x,
+                y: projection.y,
+                bottom: this.getVisualBottom(render, billboard.visual, projection.x, projection.y, projection.scale * billboard.baseScale, billboard.anchorX, billboard.anchorY),
+                scale: projection.scale * billboard.baseScale,
+                alpha: billboard.alpha,
+                visual: billboard.visual,
+                kind: "billboard",
+                anchorX: billboard.anchorX,
+                anchorY: billboard.anchorY,
+            });
+        }
+        for (const traffic of render.traffic) {
+            const ahead = traffic.distance - render.distanceState;
+            if (ahead <= -render.trafficBehindVisibilityDistance ||
+                ahead > render.drawDistance) {
+                continue;
+            }
+            const projection = render.projectTrafficPoint(render.current, ahead, render.width, render.height);
+            const x = projection.x + traffic.lane * projection.roadWidth * 0.38;
+            visible.push({
+                depth: ahead,
+                x,
+                y: projection.y,
+                bottom: this.getVisualBottom(render, traffic.visual, x, projection.y, projection.scale * traffic.baseScale, 0.5, 1),
+                scale: projection.scale * traffic.baseScale,
+                alpha: traffic.alpha,
+                visual: traffic.visual,
+                kind: "traffic",
+                anchorX: 0.5,
+                anchorY: 1,
+                bodyWidth: traffic.bodyWidth,
+                bodyLength: traffic.bodyLength,
+                bodyReferenceScale: traffic.baseScale,
+                bodyOffsetX: traffic.bodyOffsetX,
+                bodyOffsetY: traffic.bodyOffsetY,
+                resolvedBody: traffic.resolvedBody,
+                collisionAhead: ahead,
+                collisionLane: traffic.lane,
+                collisionCenterX: x,
+            });
+        }
+        const playerProjection = render.projectTrafficPoint(render.current, render.playerProjectionAheadDistance, render.width, render.height);
+        const playerCenterX = render.getPlayerScreenX();
+        visible.push({
+            depth: render.playerProjectionAheadDistance,
+            x: playerCenterX,
+            y: render.playerScreenY,
+            bottom: this.getVisualBottom(render, render.playerVisual, playerCenterX, render.playerScreenY, playerProjection.scale * render.playerBaseScale, 0.5, 1),
+            scale: playerProjection.scale * render.playerBaseScale,
+            alpha: 1,
+            visual: render.playerVisual,
+            kind: "player",
+            anchorX: 0.5,
+            anchorY: 1,
+            bodyWidth: render.playerBodyWidth,
+            bodyLength: render.playerBodyLength,
+            bodyReferenceScale: render.playerBaseScale,
+            bodyOffsetX: render.playerBodyOffsetX,
+            bodyOffsetY: render.playerBodyOffsetY,
+            resolvedBody: render.playerResolvedBody,
+            collisionAhead: render.playerProjectionAheadDistance,
+            collisionLane: render.playerLane,
+            collisionCenterX: playerCenterX,
+        });
+        visible.sort((a, b) => {
+            if (a.bottom !== b.bottom) {
+                return a.bottom - b.bottom;
+            }
+            return b.depth - a.depth;
+        });
+        for (const entry of visible) {
+            const visualRect = this.drawVisual(render, entry.visual, entry.x, entry.y, entry.scale, entry.alpha, entry.anchorX, entry.anchorY);
+            if (entry.kind !== "billboard") {
+                this.drawCarDebugBounds(render, entry.kind, visualRect, entry);
+            }
+        }
+    }
+    /** @internal */
+    drawVisual(render, visual, x, y, scale, alpha, anchorX, anchorY) {
+        const surface = render.resolveVisualSurface(visual);
+        const rect = this.getVisualRect(surface, x, y, scale, anchorX, anchorY);
+        render.ctx.save();
+        render.ctx.globalAlpha = render.clamp01(alpha);
+        render.ctx.drawImage(surface.source, rect.x, rect.y, rect.width, rect.height);
+        render.ctx.restore();
+        return rect;
+    }
+    /** @internal */
+    getVisualRect(surface, x, y, scale, anchorX, anchorY) {
+        const drawWidth = Math.max(1, surface.width * Math.max(0, scale));
+        const drawHeight = Math.max(1, surface.height * Math.max(0, scale));
+        const anchorOffsetX = drawWidth * Math.max(0, Math.min(1, anchorX));
+        const anchorOffsetY = drawHeight * Math.max(0, Math.min(1, anchorY));
+        return {
+            x: Math.round(x - anchorOffsetX),
+            y: Math.round(y - anchorOffsetY),
+            width: drawWidth,
+            height: drawHeight,
+        };
+    }
+    /** @internal */
+    getVisualBottom(render, visual, x, y, scale, anchorX, anchorY) {
+        const surface = render.resolveVisualSurface(visual);
+        const rect = this.getVisualRect(surface, x, y, scale, anchorX, anchorY);
+        return rect.y + rect.height;
+    }
+    /** @internal */
+    drawCarDebugBounds(render, kind, visualRect, entry) {
+        if (!render.debug.enabled)
+            return;
+        const { ctx } = render;
+        ctx.save();
+        ctx.lineWidth = render.debug.lineWidth;
+        ctx.setLineDash([]);
+        if (render.debug.visualBounds) {
+            ctx.strokeStyle = render.debug.visualBoundsColor;
+            ctx.strokeRect(visualRect.x, visualRect.y, visualRect.width, visualRect.height);
+        }
+        const collisionRect = render.debug.collisionBounds &&
+            Number.isFinite(entry.bodyWidth) &&
+            Number.isFinite(entry.bodyLength)
+            ? render.getDebugCollisionRectFromVisual(visualRect, entry.visual, entry.bodyReferenceScale ?? 1, entry.bodyWidth, entry.bodyLength, entry.bodyOffsetX ?? 0, entry.bodyOffsetY ?? 0)
+            : null;
+        if (render.debug.collisionBounds && collisionRect) {
+            ctx.strokeStyle =
+                kind === "player"
+                    ? render.debug.playerCollisionBoundsColor
+                    : render.debug.trafficCollisionBoundsColor;
+            ctx.setLineDash([6, 4]);
+            ctx.strokeRect(collisionRect.x, collisionRect.y, collisionRect.width, collisionRect.height);
+        }
+        const realCollisionRect = render.debug.realCollisionBounds &&
+            Number.isFinite(entry.bodyWidth) &&
+            Number.isFinite(entry.bodyLength) &&
+            Number.isFinite(entry.collisionAhead) &&
+            Number.isFinite(entry.collisionLane)
+            ? render.getRealCollisionRect(render.current, render.width, render.height, entry.collisionAhead, entry.collisionLane, entry.visual, entry.bodyReferenceScale ?? 1, entry.bodyWidth, entry.bodyLength, entry.bodyOffsetX ?? 0, entry.bodyOffsetY ?? 0, entry.resolvedBody, visualRect.x + visualRect.width / 2, visualRect.y + visualRect.height)
+            : null;
+        if (render.debug.realCollisionBounds && realCollisionRect) {
+            ctx.strokeStyle =
+                kind === "player"
+                    ? render.debug.playerRealCollisionBoundsColor
+                    : render.debug.trafficRealCollisionBoundsColor;
+            ctx.setLineDash([2, 4]);
+            ctx.strokeRect(realCollisionRect.x, realCollisionRect.y, realCollisionRect.width, realCollisionRect.height);
+        }
+        ctx.restore();
+    }
+    /** @internal */
+    fillRoundedRect(ctx, x, y, width, height, radius) {
+        const r = Math.max(0, Math.min(radius, width / 2, height / 2));
+        ctx.beginPath();
+        ctx.moveTo(x + r, y);
+        ctx.arcTo(x + width, y, x + width, y + height, r);
+        ctx.arcTo(x + width, y + height, x, y + height, r);
+        ctx.arcTo(x, y + height, x, y, r);
+        ctx.arcTo(x, y, x + width, y, r);
+        ctx.closePath();
+        ctx.fill();
+    }
+    /** @internal */
+    strokeRoundedRect(ctx, x, y, width, height, radius) {
+        const r = Math.max(0, Math.min(radius, width / 2, height / 2));
+        ctx.beginPath();
+        ctx.moveTo(x + r, y);
+        ctx.arcTo(x + width, y, x + width, y + height, r);
+        ctx.arcTo(x + width, y + height, x, y + height, r);
+        ctx.arcTo(x, y + height, x, y, r);
+        ctx.arcTo(x, y, x + width, y, r);
+        ctx.closePath();
+        ctx.stroke();
+    }
+}

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

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

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

@@ -0,0 +1,13 @@
+import { DrawSprite } from "../../minimo.js";
+/** @internal */
+export class ArcadeRacerRoadSprite extends DrawSprite {
+    constructor(width, height, 
+    /** @internal */
+    redrawFrame) {
+        super(width, height);
+        this.redrawFrame = redrawFrame;
+    }
+    redraw(ctx) {
+        this.redrawFrame(ctx, this.width, this.height);
+    }
+}

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

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