51:I[707087,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/1o6_421saitt-.js","/_next/static/immutable/chunks/31nn7jwsjvqii.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"RegistryDependencies"] 52:I[314491,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/1o6_421saitt-.js","/_next/static/immutable/chunks/31nn7jwsjvqii.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"FilesView"] 53:T529d,/** biome-ignore-all lint/a11y/noNoninteractiveElementInteractions: The focus-scoped game fieldset intentionally owns keyboard input. */ /** biome-ignore-all lint/a11y/noNoninteractiveTabindex: The game fieldset must receive focus without a global listener. */ "use client"; import Link from "next/link"; import { type ComponentPropsWithoutRef, type KeyboardEvent as ReactKeyboardEvent, useId, useMemo, useReducer, useRef, useState, } from "react"; import { Badge } from "@/components/ui/8bit/badge"; import { Button } from "@/components/ui/8bit/button"; import { Card, CardContent, CardFooter, CardHeader, } from "@/components/ui/8bit/card"; import { Kbd, KbdGroup } from "@/components/ui/8bit/kbd"; import { type CratePusherState, createCratePusherState, type Direction, moveCratePusher, type ParsedCratePusherLevel, type PositionKey, parseCratePusherLevel, resetCratePusher, startCratePusher, undoCratePusher, } from "@/lib/games/crate-pusher"; import { CRATE_PUSHER_LEVELS, type CratePusherLevelDefinition, type CratePusherShuffleBag, createCratePusherShuffleBag, drawCratePusherShuffleBag, } from "@/lib/games/crate-pusher-levels"; import { cn } from "@/lib/utils"; import "@/components/ui/8bit/styles/retro.css"; export interface NotFoundCratePusherProps extends ComponentPropsWithoutRef<"section"> { badge?: string; cta?: string; description?: string; href?: string; level?: readonly string[]; seed?: number; title?: string; } interface CratePusherGameProps extends Omit { readonly catalogMode: boolean; readonly initialLevel: ParsedCratePusherLevel; readonly seed?: number; } interface BoardTileProps { readonly column: number; readonly row: number; readonly state: CratePusherState; } type CratePusherAction = | { readonly announcement: string; readonly level: ParsedCratePusherLevel; readonly type: "load"; } | { readonly type: "move"; readonly direction: Direction } | { readonly type: "restart" } | { readonly type: "start" } | { readonly type: "undo" }; const KEY_DIRECTIONS: Readonly> = { a: "left", arrowdown: "down", arrowleft: "left", arrowright: "right", arrowup: "up", d: "right", s: "down", w: "up", }; const INTERACTIVE_SELECTOR = "a, button, input, textarea, select, [contenteditable=''], [contenteditable='true']"; const PARSED_CRATE_PUSHER_LEVELS = Object.freeze( CRATE_PUSHER_LEVELS.map((level) => parseCratePusherLevel(level.lines)) ); function createPositionKey(row: number, column: number): PositionKey { return `${row}:${column}`; } function cratePusherReducer( state: CratePusherState, action: CratePusherAction ): CratePusherState { switch (action.type) { case "load": { const startedState = startCratePusher(resetCratePusher(action.level)); return { ...startedState, announcement: `${action.announcement} ${startedState.announcement}`, }; } case "move": return moveCratePusher(state, action.direction); case "restart": return startCratePusher(resetCratePusher(state.level)); case "start": return startCratePusher(state); case "undo": return undoCratePusher(state); default: return state; } } function createInitialGameState({ catalogMode, initialLevel, }: { readonly catalogMode: boolean; readonly initialLevel: ParsedCratePusherLevel; }): CratePusherState { const state = createCratePusherState(initialLevel); if (!catalogMode) { return state; } return { ...state, announcement: `${CRATE_PUSHER_LEVELS.length} puzzles ready. Select Start Shift to load a random route.`, }; } function createRuntimeSeed(): number { const randomValue = new Uint32Array(1); if (typeof globalThis.crypto?.getRandomValues === "function") { globalThis.crypto.getRandomValues(randomValue); return randomValue[0] ?? 0; } return Math.floor(Math.random() * 4_294_967_296); } function getCatalogLevel(levelIndex: number): { readonly definition: CratePusherLevelDefinition; readonly parsedLevel: ParsedCratePusherLevel; } { const definition = CRATE_PUSHER_LEVELS[levelIndex]; const parsedLevel = PARSED_CRATE_PUSHER_LEVELS[levelIndex]; if (!(definition && parsedLevel)) { throw new Error(`Crate Pusher puzzle ${levelIndex + 1} was not found.`); } return { definition, parsedLevel }; } function createPuzzleAnnouncement( definition: CratePusherLevelDefinition, levelIndex: number ): string { return `${definition.name}. Puzzle ${levelIndex + 1} of ${CRATE_PUSHER_LEVELS.length}. ${definition.difficulty} route loaded.`; } function getPuzzleDisplayMetadata( catalogMode: boolean, activeLevelIndex: number | null ): { readonly boardLabel: string; readonly difficultyLabel: string; readonly puzzleLabel: string; } { if (!catalogMode) { return { boardLabel: "Crate Pusher custom game board", difficultyLabel: "CUSTOM", puzzleLabel: "PUZZLE CUSTOM", }; } if (activeLevelIndex === null) { return { boardLabel: `Crate Pusher random puzzle preview, ${CRATE_PUSHER_LEVELS.length} routes available`, difficultyLabel: "RANDOM", puzzleLabel: `PUZZLES ${CRATE_PUSHER_LEVELS.length}`, }; } const { definition } = getCatalogLevel(activeLevelIndex); const puzzleNumber = activeLevelIndex + 1; return { boardLabel: `Crate Pusher puzzle ${puzzleNumber} of ${CRATE_PUSHER_LEVELS.length}, ${definition.difficulty} game board`, difficultyLabel: definition.difficulty.toUpperCase(), puzzleLabel: `PUZZLE ${puzzleNumber}/${CRATE_PUSHER_LEVELS.length}`, }; } function isInteractiveTarget(target: EventTarget | null): boolean { return ( target instanceof Element && target.closest(INTERACTIVE_SELECTOR) !== null ); } function getPhaseLabel(state: CratePusherState): string { switch (state.phase) { case "idle": return "IDLE"; case "playing": return "PLAYING"; case "won": return "WON"; default: return "IDLE"; } } function getTerminalStatus(state: CratePusherState): string { switch (state.phase) { case "idle": return "AWAITING SHIFT"; case "playing": return "SHIFT ACTIVE"; case "won": return "ROUTE RESTORED"; default: return "AWAITING SHIFT"; } } function countFilledPortals(state: CratePusherState): number { let filledPortals = 0; for (const portal of state.level.portals) { if (state.crates.has(portal)) { filledPortals += 1; } } return filledPortals; } function getBoardTileKind( isWall: boolean, isCrate: boolean, isPortal: boolean ): string { if (isWall) { return "wall"; } if (isCrate && isPortal) { return "crate-on-portal"; } if (isCrate) { return "crate"; } if (isPortal) { return "portal"; } return "floor"; } function BoardTile({ column, row, state }: BoardTileProps) { const position = createPositionKey(row, column); const isWall = state.level.walls.has(position); const isPortal = state.level.portals.has(position); const isCrate = state.crates.has(position); const isPlayer = state.player === position; const tileKind = getBoardTileKind(isWall, isCrate, isPortal); return (

{isWall && ( )} {isPortal && !isWall && ( <> )} {isCrate && !isWall && ( )} {isPlayer && !isWall && !isCrate && ( )}

); } function CratePusherBoard({ state }: { readonly state: CratePusherState }) { return ( ); } function CratePusherGame({ badge = "ROUTE LOST", catalogMode, className, cta = "RETURN HOME", description, href = "/", initialLevel, seed, title = "404: CRATE RESCUE", ...sectionProps }: CratePusherGameProps) { const [state, dispatch] = useReducer( cratePusherReducer, { catalogMode, initialLevel }, createInitialGameState ); const [activeLevelIndex, setActiveLevelIndex] = useState(null); const boardReference = useRef(null); const shuffleBagReference = useRef(null); const componentId = useId(); const headingId = `${componentId}-heading`; const instructionsId = `${componentId}-instructions`; const resolvedDescription = description ?? (catalogMode ? "Push every lost crate onto a portal across 20 randomized routes, or return home now." : "Push every lost crate onto a portal, or return home now."); const filledPortals = countFilledPortals(state); const movementIsActive = state.phase === "playing"; const { boardLabel, difficultyLabel, puzzleLabel } = getPuzzleDisplayMetadata( catalogMode, activeLevelIndex ); const focusBoard = () => { boardReference.current?.focus(); }; const loadNextRandomPuzzle = () => { const shuffleBag = shuffleBagReference.current ?? createCratePusherShuffleBag(seed ?? createRuntimeSeed()); const draw = drawCratePusherShuffleBag(shuffleBag); const nextLevel = getCatalogLevel(draw.levelIndex); shuffleBagReference.current = draw.shuffleBag; setActiveLevelIndex(draw.levelIndex); dispatch({ announcement: createPuzzleAnnouncement( nextLevel.definition, draw.levelIndex ), level: nextLevel.parsedLevel, type: "load", }); focusBoard(); }; const handleStart = () => { if (catalogMode && activeLevelIndex === null) { loadNextRandomPuzzle(); return; } dispatch({ type: "start" }); focusBoard(); }; const handleRestart = () => { dispatch({ type: "restart" }); focusBoard(); }; const handleMove = (direction: Direction) => { dispatch({ direction, type: "move" }); }; const handleKeyDown = (event: ReactKeyboardEvent) => { if ( event.altKey || event.ctrlKey || event.metaKey || event.shiftKey || event.repeat || event.currentTarget !== event.target || isInteractiveTarget(event.target) ) { return; } const key = event.key.toLowerCase(); const direction = KEY_DIRECTIONS[key]; if (direction) { if (!movementIsActive) { return; } event.preventDefault(); handleMove(direction); return; } if (key === "u" && state.phase !== "idle") { event.preventDefault(); dispatch({ type: "undo" }); return; } if (key === "r" && state.phase !== "idle") { event.preventDefault(); handleRestart(); } }; return (

{badge}

{title}

{resolvedDescription}

MOVES {state.moves} PUSHES {state.pushes} PORTALS {filledPortals}/{state.level.portals.size} {puzzleLabel} LEVEL {difficultyLabel} PHASE {getPhaseLabel(state)}

Start the shift, then use Arrow keys or WASD to move. Push every crate onto a portal. Press U to undo or R to restart. Random routes can be skipped without losing the rest of the queue.

ARROWS OR WASD MOVE U UNDO R RESTART

ROUTE TERMINAL {getTerminalStatus(state)}

{state.announcement}

{state.phase === "idle" && ( )} {state.phase === "playing" && ( <> {catalogMode && ( )} )} {state.phase === "won" && ( <> {catalogMode && ( )} )}

); } export function NotFoundCratePusher({ level, seed, ...props }: NotFoundCratePusherProps) { const levelSignature = level?.join("\n") ?? null; const parsedLevel = useMemo( () => levelSignature === null ? getCatalogLevel(0).parsedLevel : parseLevelSignature(levelSignature), [levelSignature] ); const componentKey = levelSignature === null ? `catalog:${seed ?? "random"}` : `custom:${levelSignature}`; return ( ); } function parseLevelSignature(levelSignature: string): ParsedCratePusherLevel { return parseCratePusherLevel(levelSignature.split("\n")); } export default NotFoundCratePusher; 54:T2b17,export type Direction = "up" | "down" | "left" | "right"; export type PositionKey = `${number}:${number}`; export type CratePusherPhase = "idle" | "playing" | "won"; export interface ParsedCratePusherLevel { readonly columns: number; readonly initialCrates: ReadonlySet; readonly initialPlayer: PositionKey; readonly portals: ReadonlySet; readonly rows: number; readonly walls: ReadonlySet; } export interface CratePusherSnapshot { readonly crates: ReadonlySet; readonly moves: number; readonly player: PositionKey; readonly pushes: number; } export interface CratePusherState extends CratePusherSnapshot { readonly announcement: string; readonly history: readonly CratePusherSnapshot[]; readonly level: ParsedCratePusherLevel; readonly phase: CratePusherPhase; } const MAX_BOARD_SIZE = 16; const MAX_HISTORY_LENGTH = 128; const MIN_BOARD_SIZE = 4; const POSITION_PATTERN = /^(-?\d+):(-?\d+)$/; const SUPPORTED_TILES: ReadonlySet = new Set([ " ", "#", "$", "*", "+", ".", "@", ]); const DIRECTION_DELTAS: Readonly< Record > = { down: [1, 0], left: [0, -1], right: [0, 1], up: [-1, 0], }; interface Coordinates { readonly column: number; readonly row: number; } function createPositionKey(row: number, column: number): PositionKey { return `${row}:${column}`; } function parsePositionKey(position: PositionKey): Coordinates { const match = POSITION_PATTERN.exec(position); if (!match) { throw new Error(`Invalid crate pusher position: "${position}".`); } return { column: Number(match[2]), row: Number(match[1]), }; } function isPerimeterPosition( row: number, column: number, rows: number, columns: number ): boolean { return ( row === 0 || column === 0 || row === rows - 1 || column === columns - 1 ); } function validateLevelPerimeter( lines: readonly string[], columns: number ): void { for (const [row, line] of lines.entries()) { for (const [column, tile] of [...line].entries()) { if ( isPerimeterPosition(row, column, lines.length, columns) && tile !== "#" ) { throw new Error( `Crate pusher level perimeter must be walls; found "${tile}" at row ${row + 1}, column ${column + 1}.` ); } } } } function validateSupportedTiles(lines: readonly string[]): void { for (const [row, line] of lines.entries()) { for (const [column, tile] of [...line].entries()) { if (!SUPPORTED_TILES.has(tile)) { throw new Error( `Unsupported crate pusher tile "${tile}" at row ${row + 1}, column ${column + 1}.` ); } } } } function isInsideLevel( position: Coordinates, level: ParsedCratePusherLevel ): boolean { return ( position.row >= 0 && position.row < level.rows && position.column >= 0 && position.column < level.columns ); } function countFilledPortals( crates: ReadonlySet, level: ParsedCratePusherLevel ): number { let filledPortals = 0; for (const portal of level.portals) { if (crates.has(portal)) { filledPortals += 1; } } return filledPortals; } function createSnapshot(state: CratePusherState): CratePusherSnapshot { return Object.freeze({ crates: state.crates, moves: state.moves, player: state.player, pushes: state.pushes, }); } function appendHistory( history: readonly CratePusherSnapshot[], snapshot: CratePusherSnapshot ): readonly CratePusherSnapshot[] { const nextHistory = [...history, snapshot]; if (nextHistory.length <= MAX_HISTORY_LENGTH) { return Object.freeze(nextHistory); } return Object.freeze(nextHistory.slice(-MAX_HISTORY_LENGTH)); } function createMoveAnnouncement( direction: Direction, player: PositionKey, crates: ReadonlySet, level: ParsedCratePusherLevel, pushedCrate: boolean ): string { const action = pushedCrate ? "Pushed a crate" : "Moved"; const filledPortals = countFilledPortals(crates, level); return `${action} ${direction}. Player ${formatCratePusherPosition(player)}. Portals ${filledPortals} of ${level.portals.size}.`; } export function parseCratePusherLevel( lines: readonly string[] ): ParsedCratePusherLevel { if (lines.length < MIN_BOARD_SIZE || lines.length > MAX_BOARD_SIZE) { throw new Error( `Crate pusher levels must have between ${MIN_BOARD_SIZE} and ${MAX_BOARD_SIZE} rows.` ); } const columns = lines[0]?.length ?? 0; if (columns < MIN_BOARD_SIZE || columns > MAX_BOARD_SIZE) { throw new Error( `Crate pusher levels must have between ${MIN_BOARD_SIZE} and ${MAX_BOARD_SIZE} columns.` ); } if (lines.some((line) => line.length !== columns)) { throw new Error("Every crate pusher level row must have the same length."); } validateSupportedTiles(lines); validateLevelPerimeter(lines, columns); const walls = new Set(); const portals = new Set(); const crates = new Set(); let player: PositionKey | undefined; let playerCount = 0; for (const [row, line] of lines.entries()) { for (const [column, tile] of [...line].entries()) { const position = createPositionKey(row, column); switch (tile) { case " ": break; case "#": walls.add(position); break; case ".": portals.add(position); break; case "$": crates.add(position); break; case "*": crates.add(position); portals.add(position); break; case "+": player = position; playerCount += 1; portals.add(position); break; case "@": player = position; playerCount += 1; break; default: throw new Error( `Unsupported crate pusher tile "${tile}" at row ${row + 1}, column ${column + 1}.` ); } } } if (playerCount === 0 || !player) { throw new Error("Crate pusher levels must contain exactly one player."); } if (playerCount > 1) { throw new Error("Crate pusher levels must contain exactly one player."); } if (crates.size === 0) { throw new Error("Crate pusher levels must contain at least one crate."); } if (crates.size !== portals.size) { throw new Error( `Crate pusher levels must contain equal crate and portal counts; found ${crates.size} crates and ${portals.size} portals.` ); } return Object.freeze({ columns, initialCrates: crates, initialPlayer: player, portals, rows: lines.length, walls, }); } export function createCratePusherState( level: ParsedCratePusherLevel ): CratePusherState { return { announcement: "Ready. Select Start Shift to move.", crates: new Set(level.initialCrates), history: Object.freeze([]), level, moves: 0, phase: "idle", player: level.initialPlayer, pushes: 0, }; } export function startCratePusher(state: CratePusherState): CratePusherState { if (state.phase !== "idle") { return state; } if (isCratePusherSolved(state, state.level)) { return { ...state, announcement: "Route restored in 0 moves and 0 pushes.", phase: "won", }; } return { ...state, announcement: `Shift started. Player ${formatCratePusherPosition(state.player)}.`, phase: "playing", }; } export function moveCratePusher( state: CratePusherState, direction: Direction ): CratePusherState { if (state.phase !== "playing") { return state; } const current = parsePositionKey(state.player); const [rowDelta, columnDelta] = DIRECTION_DELTAS[direction]; const targetCoordinates = { column: current.column + columnDelta, row: current.row + rowDelta, }; if (!isInsideLevel(targetCoordinates, state.level)) { return { ...state, announcement: "Blocked by the edge of the board.", }; } const target = createPositionKey( targetCoordinates.row, targetCoordinates.column ); if (state.level.walls.has(target)) { return { ...state, announcement: "Blocked by a wall.", }; } let nextCrates = state.crates; let pushedCrate = false; if (state.crates.has(target)) { const crateDestinationCoordinates = { column: targetCoordinates.column + columnDelta, row: targetCoordinates.row + rowDelta, }; if (!isInsideLevel(crateDestinationCoordinates, state.level)) { return { ...state, announcement: "That crate cannot be pushed.", }; } const crateDestination = createPositionKey( crateDestinationCoordinates.row, crateDestinationCoordinates.column ); const crateIsBlocked = state.level.walls.has(crateDestination) || state.crates.has(crateDestination); if (crateIsBlocked) { return { ...state, announcement: "That crate cannot be pushed.", }; } const movedCrates = new Set(state.crates); movedCrates.delete(target); movedCrates.add(crateDestination); nextCrates = movedCrates; pushedCrate = true; } const nextState: CratePusherState = { ...state, announcement: "", crates: nextCrates, history: appendHistory(state.history, createSnapshot(state)), moves: state.moves + 1, phase: "playing", player: target, pushes: state.pushes + (pushedCrate ? 1 : 0), }; if (isCratePusherSolved(nextState, state.level)) { return { ...nextState, announcement: `Route restored in ${nextState.moves} moves and ${nextState.pushes} pushes.`, phase: "won", }; } return { ...nextState, announcement: createMoveAnnouncement( direction, nextState.player, nextState.crates, state.level, pushedCrate ), }; } export function undoCratePusher(state: CratePusherState): CratePusherState { const previous = state.history.at(-1); if (!previous) { return { ...state, announcement: "Nothing to undo.", }; } return { ...state, announcement: "Move undone.", crates: new Set(previous.crates), history: Object.freeze(state.history.slice(0, -1)), moves: previous.moves, phase: "playing", player: previous.player, pushes: previous.pushes, }; } export function resetCratePusher( level: ParsedCratePusherLevel ): CratePusherState { return createCratePusherState(level); } export function isCratePusherSolved( state: Pick, level: ParsedCratePusherLevel ): boolean { for (const portal of level.portals) { if (!state.crates.has(portal)) { return false; } } return true; } export function formatCratePusherPosition(position: PositionKey): string { const { column, row } = parsePositionKey(position); return `row ${row + 1} column ${column + 1}`; } 55:T2501,export type CratePusherDifficulty = "intermediate" | "advanced" | "expert"; export interface CratePusherLevelDefinition { readonly difficulty: CratePusherDifficulty; readonly id: string; readonly lines: readonly string[]; readonly name: string; } export interface CratePusherShuffleBag { readonly cursor: number; readonly lastLevelIndex: number | null; readonly levelCount: number; readonly order: readonly number[]; readonly randomState: number; } export interface CratePusherShuffleDraw { readonly levelIndex: number; readonly shuffleBag: CratePusherShuffleBag; } const UINT32_RANGE = 4_294_967_296; function defineLevel( definition: CratePusherLevelDefinition ): CratePusherLevelDefinition { return Object.freeze({ ...definition, lines: Object.freeze([...definition.lines]), }); } export const CRATE_PUSHER_LEVELS = Object.freeze([ defineLevel({ difficulty: "intermediate", id: "warm-circuit", lines: [ "#######", "# # #", "# .#", "# $$ #", "# #@. #", "# # #", "#######", ], name: "Warm Circuit", }), defineLevel({ difficulty: "intermediate", id: "side-step", lines: [ "#######", "# #", "# # $@#", "# $ # #", "#. . #", "# # # #", "#######", ], name: "Side Step", }), defineLevel({ difficulty: "intermediate", id: "relay-room", lines: [ "########", "# .. #", "# # #", "# $ #", "#@$ ##", "# # #", "########", ], name: "Relay Room", }), defineLevel({ difficulty: "intermediate", id: "corner-signal", lines: [ "########", "# # #", "# $ #@ #", "# # $ #", "# .# #", "# #", "# . # #", "########", ], name: "Corner Signal", }), defineLevel({ difficulty: "advanced", id: "split-shift", lines: [ "########", "## ##", "# #$ #", "# # .#", "##@$ # #", "# # $ #", "# .. #", "########", ], name: "Split Shift", }), defineLevel({ difficulty: "advanced", id: "long-detour", lines: [ "########", "# #", "# .# $ #", "# # $ #", "# # .#", "# $ #.#", "# @# #", "########", ], name: "Long Detour", }), defineLevel({ difficulty: "advanced", id: "cross-current", lines: [ "#########", "# # #", "# @$ #", "## #", "# .# # #", "# .$* #", "# #", "#########", ], name: "Cross Current", }), defineLevel({ difficulty: "advanced", id: "crate-relay", lines: [ "#########", "# ## + #", "# $$ #", "# $ #", "## #", "## .#.#", "# # # #", "## #", "#########", ], name: "Crate Relay", }), defineLevel({ difficulty: "advanced", id: "switchback", lines: [ "#########", "# . #", "# # .#", "# $ #", "# #@.#", "# $ #", "# # $ #", "# # #", "#########", ], name: "Switchback", }), defineLevel({ difficulty: "advanced", id: "deep-storage", lines: [ "#########", "# # #", "# # #", "## # #", "# .#$ * #", "# .#@ $ #", "# # # #", "# # #", "#########", ], name: "Deep Storage", }), defineLevel({ difficulty: "advanced", id: "backtrack-bay", lines: [ "########", "# #", "# # $ #", "# $@#", "#. #", "# $ #", "# . . #", "########", ], name: "Backtrack Bay", }), defineLevel({ difficulty: "advanced", id: "narrow-orbit", lines: [ "########", "## #", "# #", "#. $##", "# # $@ #", "#.. $ #", "# # ##", "########", ], name: "Narrow Orbit", }), defineLevel({ difficulty: "advanced", id: "forklift-loop", lines: [ "#########", "# @ #", "# *$ ###", "# # # #", "# $ # #", "# ## #", "# . . #", "#########", ], name: "Forklift Loop", }), defineLevel({ difficulty: "advanced", id: "wall-circuit", lines: [ "#########", "# . #", "# .#", "# ## #", "#. @$ #", "# $# $ #", "# #", "#########", ], name: "Wall Circuit", }), defineLevel({ difficulty: "advanced", id: "long-haul", lines: [ "#########", "# # # ##", "# $ * #", "# # #", "#. # .##", "# # #", "# $@#", "# # #", "#########", ], name: "Long Haul", }), defineLevel({ difficulty: "expert", id: "fourfold-gate", lines: [ "########", "# .. #", "# $.#", "## # #", "##$ $. #", "#@$ #", "# # # #", "########", ], name: "Fourfold Gate", }), defineLevel({ difficulty: "expert", id: "packed-route", lines: [ "########", "# #", "# .* ###", "# . $@#", "# $ #", "# $ # #", "### . #", "########", ], name: "Packed Route", }), defineLevel({ difficulty: "expert", id: "signal-stack", lines: [ "#########", "# # #", "# $ #", "# $ $ #", "#.# . #", "# .$@#", "# # . ##", "#########", ], name: "Signal Stack", }), defineLevel({ difficulty: "expert", id: "cargo-spiral", lines: [ "#########", "# # @ #", "# . $ $ #", "## $## ##", "# . #", "# . $ #", "# . #", "#########", ], name: "Cargo Spiral", }), defineLevel({ difficulty: "expert", id: "final-dispatch", lines: [ "########", "# #", "## $@$.#", "### *# #", "# # $ #", "# .. #", "# ## #", "########", ], name: "Final Dispatch", }), ]); export const DEFAULT_CRATE_PUSHER_LEVEL = CRATE_PUSHER_LEVELS[0].lines; function normalizeSeed(seed: number): number { if (!Number.isSafeInteger(seed)) { throw new Error("Crate Pusher shuffle seeds must be safe integers."); } return wrapUint32(seed); } function validateLevelCount(levelCount: number): void { if (!Number.isInteger(levelCount) || levelCount < 1) { throw new Error("Crate Pusher shuffle bags require at least one level."); } } function nextRandom(randomState: number): { readonly randomState: number; readonly value: number; } { const nextState = wrapUint32( Math.imul(randomState, 1_664_525) + 1_013_904_223 ); return { randomState: nextState, value: nextState / UINT32_RANGE, }; } function wrapUint32(value: number): number { return ((value % UINT32_RANGE) + UINT32_RANGE) % UINT32_RANGE; } function shuffledOrder( levelCount: number, randomState: number, excludedFirstIndex: number | null ): { readonly order: readonly number[]; readonly randomState: number; } { const order = Array.from({ length: levelCount }, (_, index) => index); let nextRandomState = randomState; for (let index = order.length - 1; index > 0; index -= 1) { const random = nextRandom(nextRandomState); const swapIndex = Math.floor(random.value * (index + 1)); nextRandomState = random.randomState; const currentValue = order[index]; order[index] = order[swapIndex] as number; order[swapIndex] = currentValue as number; } if ( excludedFirstIndex !== null && order.length > 1 && order[0] === excludedFirstIndex ) { [order[0], order[1]] = [order[1] as number, order[0] as number]; } return { order: Object.freeze(order), randomState: nextRandomState, }; } function createFrozenShuffleBag( shuffleBag: CratePusherShuffleBag ): CratePusherShuffleBag { return Object.freeze(shuffleBag); } export function createCratePusherShuffleBag( seed: number, levelCount: number = CRATE_PUSHER_LEVELS.length ): CratePusherShuffleBag { validateLevelCount(levelCount); const shuffled = shuffledOrder(levelCount, normalizeSeed(seed), null); return createFrozenShuffleBag({ cursor: 0, lastLevelIndex: null, levelCount, order: shuffled.order, randomState: shuffled.randomState, }); } export function drawCratePusherShuffleBag( shuffleBag: CratePusherShuffleBag ): CratePusherShuffleDraw { let activeBag = shuffleBag; if (shuffleBag.cursor >= shuffleBag.order.length) { const shuffled = shuffledOrder( shuffleBag.levelCount, shuffleBag.randomState, shuffleBag.lastLevelIndex ); activeBag = createFrozenShuffleBag({ cursor: 0, lastLevelIndex: shuffleBag.lastLevelIndex, levelCount: shuffleBag.levelCount, order: shuffled.order, randomState: shuffled.randomState, }); } const levelIndex = activeBag.order[activeBag.cursor]; if (levelIndex === undefined) { throw new Error("Crate Pusher shuffle bag could not draw a level."); } return Object.freeze({ levelIndex, shuffleBag: createFrozenShuffleBag({ ...activeBag, cursor: activeBag.cursor + 1, lastLevelIndex: levelIndex, }), }); } 56:T88b,import { type VariantProps, cva } from "class-variance-authority"; import { cn } from "@/lib/utils"; import { Badge as ShadcnBadge } from "@/components/ui/badge"; export const badgeVariants = cva("", { variants: { font: { normal: "", retro: "retro", }, variant: { default: "border-primary bg-primary", destructive: "border-destructive bg-destructive", outline: "border-background bg-background", secondary: "border-secondary bg-secondary", }, }, defaultVariants: { variant: "default", }, }); export interface BitButtonProps extends React.ButtonHTMLAttributes, VariantProps { asChild?: boolean; } function Badge({ children, className = "", font, variant, ...props }: BitButtonProps) { const color = badgeVariants({ variant, font }); const classes = className.split(" "); // visual classes for badge and sidebars const visualClasses = classes.filter( (c) => c.startsWith("bg-") || c.startsWith("border-") || c.startsWith("text-") || c.startsWith("rounded-") ); // Container should accept all non-visual utility classes (e.g., size, spacing, layout) const containerClasses = classes.filter( (c) => !( c.startsWith("bg-") || c.startsWith("border-") || c.startsWith("text-") || c.startsWith("rounded-") ) ); return (

{children} {/* Left pixel bar */}

{/* Right pixel bar */}

); } export { Badge }; 57:T116b,import { type VariantProps, cva } from "class-variance-authority"; import { Slot } from "radix-ui"; import type { ButtonHTMLAttributes, Ref } from "react"; import { Button as ShadcnButton } from "@/components/ui/button"; import { cn } from "@/lib/utils"; import "@/components/ui/8bit/styles/retro.css"; export const buttonVariants = cva("", { variants: { font: { normal: "", retro: "retro", }, variant: { default: "bg-foreground", destructive: "bg-foreground", outline: "bg-foreground", secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80", ghost: "hover:bg-accent hover:text-accent-foreground", link: "text-primary underline-offset-4 hover:underline", }, size: { default: "", sm: "", lg: "", icon: "", }, }, defaultVariants: { variant: "default", size: "default", }, }); export interface BitButtonProps extends ButtonHTMLAttributes, VariantProps { asChild?: boolean; ref?: Ref; } interface ButtonDecorationsProps { size: BitButtonProps["size"]; variant: BitButtonProps["variant"]; } function ButtonDecorations({ size, variant }: ButtonDecorationsProps) { return ( {variant !== "ghost" && variant !== "link" && size !== "icon" && ( <> {/* Pixelated border */} {variant !== "outline" && ( <> {/* Top shadow */} {/* Bottom shadow */} )} )} {size === "icon" && ( <> )} ); } function Button({ asChild = false, children, className, font, size, variant, ...props }: BitButtonProps) { const decorations = ; return ( {asChild ? {children} : children} {decorations} ); } export { Button }; 58:Tb05,import { type VariantProps, cva } from "class-variance-authority"; import { cn } from "@/lib/utils"; import { Card as ShadcnCard, CardAction as ShadcnCardAction, CardContent as ShadcnCardContent, CardDescription as ShadcnCardDescription, CardFooter as ShadcnCardFooter, CardHeader as ShadcnCardHeader, CardTitle as ShadcnCardTitle, } from "@/components/ui/card"; import "@/components/ui/8bit/styles/retro.css"; export const cardVariants = cva("", { variants: { font: { normal: "", retro: "retro", }, }, defaultVariants: { font: "retro", }, }); export interface BitCardProps extends React.ComponentProps<"div">, VariantProps { asChild?: boolean; } function Card({ className, font, ...props }: BitCardProps) { return (

); } function CardHeader({ ...props }: BitCardProps) { const { className, font } = props; return ( ); } function CardTitle({ ...props }: BitCardProps) { const { className, font } = props; return ( ); } function CardDescription({ ...props }: BitCardProps) { const { className, font } = props; return ( ); } function CardAction({ ...props }: BitCardProps) { const { className, font } = props; return ( ); } function CardContent({ ...props }: BitCardProps) { const { className, font } = props; return ( ); } function CardFooter({ ...props }: BitCardProps) { const { className, font } = props; return ( ); } export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent, }; 50:["$","div",null,{"className":"mt-3 flex min-h-0 min-w-0 flex-1 flex-col gap-3","children":[["$","div",null,{"className":"flex shrink-0 items-start gap-3","children":[["$","div",null,{"className":"flex max-h-28 min-w-0 flex-1 flex-wrap items-center gap-2 overflow-y-auto","children":[null,["$","$L51",null,{"namespace":"@catalogs","registryDependencies":["badge","button","card"]}]]}],null]}],["$","$L52",null,{"files":[{"path":"components/ui/8bit/blocks/not-found-crate-pusher.tsx","content":"$53","type":"registry:block","target":"components/ui/8bit/blocks/not-found-crate-pusher.tsx"},{"path":"lib/games/crate-pusher.ts","content":"$54","type":"registry:lib","target":"lib/games/crate-pusher.ts"},{"path":"lib/games/crate-pusher-levels.ts","content":"$55","type":"registry:lib","target":"lib/games/crate-pusher-levels.ts"},{"path":"components/ui/8bit/styles/retro.css","content":"@import url(\"https://fonts.googleapis.com/css2?family=Press+Start+2P&display=swap\");\n\n.retro {\n font-family:\n \"Press Start 2P\",\n system-ui,\n -apple-system,\n sans-serif;\n line-height: 1.5;\n letter-spacing: 0.5px;\n}\n\n.pixelated {\n image-rendering: pixelated;\n image-rendering: crisp-edges;\n}","type":"registry:component","target":"components/ui/8bit/styles/retro.css"},{"path":"components/ui/8bit/badge.tsx","content":"$56","type":"registry:component","target":"components/ui/8bit/badge.tsx"},{"path":"components/ui/8bit/button.tsx","content":"$57","type":"registry:component","target":"components/ui/8bit/button.tsx"},{"path":"components/ui/8bit/card.tsx","content":"$58","type":"registry:component","target":"components/ui/8bit/card.tsx"},{"path":"components/ui/8bit/kbd.tsx","content":"import { cn } from \"@/lib/utils\";\n\nimport \"@/components/ui/8bit/styles/retro.css\";\n\nfunction Kbd({ className, ...props }: React.ComponentProps<\"kbd\">) {\n return (\n \n );\n}\n\nfunction KbdGroup({ className, ...props }: React.ComponentProps<\"div\">) {\n return (\n \n );\n}\n\nexport { Kbd, KbdGroup };\n","type":"registry:component","target":"components/ui/8bit/kbd.tsx"}],"className":"h-[70svh] min-h-80"}]]}]