/** * Freecell solitaire app worker. One singleton window holds a standard * 52-card Freecell game: 8 cascades, 4 free cells, 4 foundations. Red suits * have a bright marker beside their label, since the display has no color. * * Controls: scroll moves a cursor through the 16 locations (free cells, * foundations, then cascades, wrapping). Click selects a source, then click * on a destination moves there; cascade-to-cascade moves take the longest * legal run that fits (supermoves via empty cells/columns). Double-click * sends the card at the cursor to its foundation, or cancels a pending * selection. Tap-then-hold opens the window menu (undo, new game, restart). * Watch swipes move the cursor spatially: left/right within the row, up/down * between the top row (cells + foundations) and the cascades. * The cursor skips locations that can't take part in the move being built: * with nothing selected, empty spots and the foundations (never a source); * with a source selected, filled free cells and foundations that can't * accept the card (see isCursorEligible). * Safe cards auto-play to the foundations after every move. */ import "@nativescript/core/globals"; import { finishWorkerShutdown } from "../../ui/shell/worker-lifecycle"; import { GrayImage } from "../../graphics/image"; import { flattenPlanesWithDraws, planesFingerprint, singlePlane, type Plane } from "../../graphics/plane"; import { prepareFrameDraws } from "../../graphics/glyph-wire"; import { getFont } from "../../graphics/bdffont"; import { ensurePreinstalledFonts, installedFontPath } from "../../graphics/installed-fonts"; import { TtfFont } from "../../graphics/ttf-font"; import * as frameTimings from "../../native/frame-timings"; import { playWorkerBuzzerSequence } from "../../native/worker-buzzer"; import { getActiveDisplay } from "../../native/active-display"; import { buildSoundSequencePayload, type Step } from "../../ui/sound-effects"; import { loadSoundEnabled, saveSoundEnabled } from "../../ui/sound-setting"; import { WindowMenu } from "../../ui/window-menu"; import type { MenuItem } from "../../ui/menu"; import type { WorkerAppMessage, WorkerAppReply } from "../../ui/shell/worker-window"; import { directionalFallback, GESTURE_CLICK, GESTURE_DOUBLE_CLICK, GESTURE_LONG_PRESS, type InputEvent } from "../../ui/gestures"; declare const global: any; ensurePreinstalledFonts(); const fontPath = installedFontPath("Roboto-Regular.ttf"); const largeFont = TtfFont.load(fontPath, 28) ?? getFont("terminus32"); const mediumFont = TtfFont.load(fontPath, 18) ?? getFont("terminus24"); const labelFont = TtfFont.load(fontPath, 14) ?? getFont("terminus16"); const suitFont = TtfFont.load(fontPath, 10) ?? getFont("terminus16"); const smallFont = TtfFont.load(fontPath, 12) ?? getFont("terminus12"); /** Cards are 0..51: suit = card % 4 (♠♥♣♦, alternating colors), rank 1..13. */ const SUIT_CHARS = ["♠", "♥", "♣", "♦"] as const; const RANK_CHARS = ["", "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"] as const; function suitOf(card: number): number { return card % 4; } function rankOf(card: number): number { return Math.floor(card / 4) + 1; } function isRed(card: number): boolean { return (card & 1) === 1; } const CARD_W = 60; const CARD_H = 36; const TOP_Y = 4; const CASCADE_Y = 48; /** * Cursor locations, in scroll order: free cells 0-3, foundations 0-3 (the * top row left to right), then cascades 0-7. */ const LOC_CELL0 = 0; const LOC_FOUNDATION0 = 4; const LOC_CASCADE0 = 8; const LOC_COUNT = 16; /** Buzzer effects, tuned soft like the other games' (shared piezo). */ const SFX_SELECT: Step[] = [{ freq: 880, duty: 40, ms: 20 }]; const SFX_MOVE: Step[] = [{ freq: 660, duty: 40, ms: 15 }]; const SFX_FOUNDATION: Step[] = [{ freq: 1047, duty: 40, ms: 25 }]; const SFX_ERROR: Step[] = [{ freq: 220, duty: 45, ms: 60 }]; const SFX_UNDO: Step[] = [{ freq: 550, duty: 40, ms: 30 }]; /** Also the new-game and sound-toggled-on confirmation. */ const SFX_NEW_GAME: Step[] = [ { freq: 880, duty: 40, ms: 60 }, { freq: 1319, duty: 40, ms: 110 }, ]; const SFX_WIN: Step[] = [ { freq: 1047, ms: 55 }, { freq: 1319, ms: 55 }, { freq: 1568, ms: 55 }, { freq: 2093, ms: 70 }, { freq: 1, duty: 0, ms: 30 }, { freq: 2093, ms: 160 }, ]; type Snapshot = { cascades: number[][]; cells: Array; foundations: Array; moves: number; }; type FreecellWindow = { windowId: string; surfaceId: string; title: string; viewportWidth: number; viewportHeight: number; foreground: boolean; /** Whether this window is the shell's input target (pushed with each message). */ focused: boolean; /** Tap-then-hold window menu; created on first open. */ menu: WindowMenu | null; phase: "playing" | "won"; cascades: number[][]; cells: Array; /** Top card of each foundation pile, or null while empty. */ foundations: Array; /** The shuffle behind the current game, kept so a deal can be restarted. */ dealOrder: number[]; undoStack: Snapshot[]; moves: number; cursor: number; /** Location of the pending source selection, if any. */ selected: number | null; soundOn: boolean; lastSubmittedFingerprint: string; }; const windows = new Map(); function post(message: WorkerAppReply): void { global.postMessage(message); } // The host queues messages until this arrives: posts to a worker whose bundle // is still evaluating can be silently dropped (see WorkerAppHost). Top-level // evaluation is synchronous, so the handler below is installed before any // queued message can be delivered. post({ type: "worker-ready" }); global.onmessage = (event: { data: WorkerAppMessage }) => { const message = event.data; switch (message.type) { case "check-idle": post({ type: "worker-idle" }); break; case "shutdown": finishWorkerShutdown(); break; case "open-window": { const window: FreecellWindow = { windowId: message.windowId, surfaceId: message.surfaceId, title: message.title, viewportWidth: message.viewport.width, viewportHeight: message.viewport.height, foreground: false, focused: false, menu: null, phase: "playing", cascades: [], cells: [null, null, null, null], foundations: [null, null, null, null], dealOrder: [], undoStack: [], moves: 0, cursor: LOC_CASCADE0, selected: null, soundOn: loadSoundEnabled("freecell"), lastSubmittedFingerprint: "", }; newGame(window, false); windows.set(message.windowId, window); break; } case "close-window": windows.delete(message.windowId); break; case "input": { const window = windows.get(message.windowId); if (!window) { frameTimings.finishFrame(message.frameId, "discarded: unknown freecell window"); break; } window.focused = message.focused; // Marks the main-thread -> worker hop, which is otherwise an // unexplained gap inside the shell's handle-input span. frameTimings.logFrame(message.frameId, `input received in ${message.windowId} worker`); handleInput(window, message.event as InputEvent, message.frameId); break; } case "render": { const window = windows.get(message.windowId); if (!window) break; window.focused = message.focused; renderAndSubmit(window, 0); break; } case "foreground": { const window = windows.get(message.windowId); if (!window) break; window.foreground = message.foreground; window.focused = message.focused; if (window.foreground) renderAndSubmit(window, 0); break; } case "resize-window": { const window = windows.get(message.windowId); if (!window) break; window.viewportWidth = message.viewport.width; window.viewportHeight = message.viewport.height; window.menu?.resize({ width: window.viewportWidth, height: window.viewportHeight }); window.lastSubmittedFingerprint = ""; if (window.foreground) renderAndSubmit(window, 0); break; } case "input-focus": case "navigation-sensors": case "screen": case "text-input": case "tool-call": break; } }; /** * Fire a buzzer effect. Non-blocking: the firmware's sequencer plays the * steps on its own timer; the platform bridge routes it from the worker. */ function playSfx(window: FreecellWindow, steps: Step[]): void { if (!window.soundOn || steps.length === 0) return; try { playWorkerBuzzerSequence(buildSoundSequencePayload(steps)); } catch (error) { console.warn(`freecell sfx failed: ${error}`); } } /** The window's context menu (game actions). */ function windowMenuItems(window: FreecellWindow): MenuItem[] { const items: MenuItem[] = []; if (window.undoStack.length > 0 && window.phase === "playing") { items.push({ label: `Undo (${window.undoStack.length})`, onSelect: (ctx) => { ctx.stack.pop(); undoMove(window); }, }); } items.push( { label: "New game", onSelect: (ctx) => { ctx.stack.pop(); newGame(window, false); playSfx(window, SFX_NEW_GAME); }, }, { label: "Restart this deal", onSelect: (ctx) => { ctx.stack.pop(); newGame(window, true); playSfx(window, SFX_NEW_GAME); }, }, { label: window.soundOn ? "Sound: on" : "Sound: off", onSelect: (ctx) => { ctx.stack.pop(); window.soundOn = !window.soundOn; saveSoundEnabled("freecell", window.soundOn); if (window.soundOn) playSfx(window, SFX_NEW_GAME); }, }, ); return items; } function windowMenu(window: FreecellWindow): WindowMenu { if (!window.menu) { window.menu = new WindowMenu({ windowId: window.windowId, post, title: () => window.title, items: () => windowMenuItems(window), size: { width: window.viewportWidth, height: window.viewportHeight }, paintBase: () => paintContent(window), isFocused: () => window.focused, }); } return window.menu; } function handleInput(window: FreecellWindow, event: InputEvent, frameId: number): void { // An open window menu owns all input (it closes itself via pop); menus are // list UIs, so watch swipes take their standard fallback meanings there. if (window.menu?.isOpen()) { void window.menu .handleInput(directionalFallback(event)) .catch((error) => console.error(`freecell menu input failed: ${error}`)) .then(() => renderAndSubmit(window, frameId)); return; } if (window.phase === "playing") { handlePlayingInput(window, event, frameId); } else { handleWonInput(window, event, frameId); } } function handlePlayingInput(window: FreecellWindow, event: InputEvent, frameId: number): void { switch (event.type) { case "scroll-up": moveCursor(window, -1); break; case "scroll-down": moveCursor(window, 1); break; // Watch swipes are spatial over the two rows of eight columns: up/down // switch between the top row (free cells + foundations) and the cascades // landing on the nearest usable column, left/right move within the row. case "swipe-up": if (window.cursor >= LOC_CASCADE0) moveCursorToRow(window, LOC_CELL0); break; case "swipe-down": if (window.cursor < LOC_CASCADE0) moveCursorToRow(window, LOC_CASCADE0); break; case "swipe-left": moveCursorInRow(window, -1); break; case "swipe-right": moveCursorInRow(window, 1); break; case "click": if (window.selected === null) { if (locationHasCard(window, window.cursor)) { window.selected = window.cursor; playSfx(window, SFX_SELECT); } else { playSfx(window, SFX_ERROR); } } else if (window.selected === window.cursor) { window.selected = null; } else { performMove(window, window.selected, window.cursor); } break; case "double-click": if (window.selected !== null) { window.selected = null; } else { sendToFoundation(window, window.cursor); } break; case "short-then-long-press": windowMenu(window).open(); break; default: frameTimings.finishFrame(frameId, "discarded: freecell ignored input"); return; } renderAndSubmit(window, frameId); } function handleWonInput(window: FreecellWindow, event: InputEvent, frameId: number): void { switch (directionalFallback(event).type) { case "click": newGame(window, false); playSfx(window, SFX_NEW_GAME); break; case "double-click": frameTimings.finishFrame(frameId, "discarded: freecell yielded focus"); post({ type: "yield-focus", windowId: window.windowId }); return; case "short-then-long-press": windowMenu(window).open(); break; default: frameTimings.finishFrame(frameId, "discarded: freecell ignored input"); return; } renderAndSubmit(window, frameId); } function newGame(window: FreecellWindow, keepDeal: boolean): void { if (!keepDeal || window.dealOrder.length !== 52) { const order = Array.from({ length: 52 }, (_, i) => i); for (let i = order.length - 1; i > 0; i--) { const j = Math.floor(Math.random() * (i + 1)); [order[i], order[j]] = [order[j]!, order[i]!]; } window.dealOrder = order; } window.cascades = Array.from({ length: 8 }, () => []); for (let i = 0; i < 52; i++) { window.cascades[i % 8]!.push(window.dealOrder[i]!); } window.cells = [null, null, null, null]; window.foundations = [null, null, null, null]; window.undoStack = []; window.moves = 0; window.cursor = LOC_CASCADE0; window.selected = null; window.phase = "playing"; } function snapshot(window: FreecellWindow): Snapshot { return { cascades: window.cascades.map((cascade) => [...cascade]), cells: [...window.cells], foundations: [...window.foundations], moves: window.moves, }; } function undoMove(window: FreecellWindow): void { const previous = window.undoStack.pop(); if (!previous) return; window.cascades = previous.cascades; window.cells = previous.cells; window.foundations = previous.foundations; window.moves = previous.moves; window.selected = null; playSfx(window, SFX_UNDO); } function locationHasCard(window: FreecellWindow, location: number): boolean { if (location < LOC_FOUNDATION0) return window.cells[location] !== null; if (location < LOC_CASCADE0) return window.foundations[location - LOC_FOUNDATION0] !== null; return window.cascades[location - LOC_CASCADE0]!.length > 0; } function isFoundation(location: number): boolean { return location >= LOC_FOUNDATION0 && location < LOC_CASCADE0; } /** * Whether the cursor should stop at a location, given the move being built. * Picking a source: it must hold a card, and foundations are never a source. * Picking a destination: an empty free cell, a foundation that accepts the * selected card, any cascade (a full legality check would hide the * cascades the player wants to compare), or the source itself (clicking it * again cancels the selection). */ function isCursorEligible(window: FreecellWindow, location: number): boolean { if (window.selected === null) { return !isFoundation(location) && locationHasCard(window, location); } if (location === window.selected) return true; if (location < LOC_FOUNDATION0) return window.cells[location] === null; if (isFoundation(location)) { const card = topCardAt(window, window.selected); return card !== null && foundationCanAccept(window.foundations[location - LOC_FOUNDATION0]!, card); } return true; } /** Step the cursor through the location list (wrapping), skipping ineligible spots. */ function moveCursor(window: FreecellWindow, step: 1 | -1): void { let location = window.cursor; for (let i = 0; i < LOC_COUNT; i++) { location = (location + step + LOC_COUNT) % LOC_COUNT; if (isCursorEligible(window, location)) { window.cursor = location; return; } } } /** Step the cursor within its row (no wrapping), skipping ineligible spots. */ function moveCursorInRow(window: FreecellWindow, step: 1 | -1): void { const rowStart = window.cursor < LOC_CASCADE0 ? LOC_CELL0 : LOC_CASCADE0; for (let location = window.cursor + step; location >= rowStart && location < rowStart + 8; location += step) { if (isCursorEligible(window, location)) { window.cursor = location; return; } } } /** * Jump to the other row, keeping the column when it is eligible and * otherwise taking the nearest eligible column; stays put when the row has * none. */ function moveCursorToRow(window: FreecellWindow, rowStart: number): void { const column = window.cursor % 8; for (let distance = 0; distance < 8; distance++) { for (const candidate of [column - distance, column + distance]) { if (candidate < 0 || candidate >= 8) continue; if (isCursorEligible(window, rowStart + candidate)) { window.cursor = rowStart + candidate; return; } } } } /** True if `card` can go on `onto` in a cascade (descending, alternating color). */ function canStack(card: number, onto: number): boolean { return rankOf(onto) === rankOf(card) + 1 && isRed(onto) !== isRed(card); } function foundationCanAccept(pileTop: number | null, card: number): boolean { if (pileTop === null) return rankOf(card) === 1; return suitOf(pileTop) === suitOf(card) && rankOf(card) === rankOf(pileTop) + 1; } /** The foundation pile this card can legally go to right now, or -1. */ function foundationIndexFor(window: FreecellWindow, card: number): number { for (let i = 0; i < 4; i++) { const top = window.foundations[i]!; if (top !== null && suitOf(top) === suitOf(card)) { return rankOf(card) === rankOf(top) + 1 ? i : -1; } } if (rankOf(card) === 1) { return window.foundations.indexOf(null); } return -1; } /** Length of the movable tail run (descending, alternating colors). */ function tailRunLength(cascade: number[]): number { let length = Math.min(1, cascade.length); while (length < cascade.length && canStack(cascade[cascade.length - length]!, cascade[cascade.length - length - 1]!)) { length++; } return length; } /** * Supermove capacity: (empty free cells + 1) doubled per empty cascade. A * move into an empty cascade can't count that cascade as a waypoint. */ function moveCapacity(window: FreecellWindow, excludeCascade: number): number { const freeCells = window.cells.filter((cell) => cell === null).length; let capacity = freeCells + 1; for (let i = 0; i < 8; i++) { if (i !== excludeCascade && window.cascades[i]!.length === 0) capacity *= 2; } return capacity; } /** The card a location would give up right now (cascade top), or null. */ function topCardAt(window: FreecellWindow, location: number): number | null { if (location < LOC_FOUNDATION0) return window.cells[location]!; if (location < LOC_CASCADE0) return window.foundations[location - LOC_FOUNDATION0]!; const cascade = window.cascades[location - LOC_CASCADE0]!; return cascade.length > 0 ? cascade[cascade.length - 1]! : null; } /** Remove the card `topCardAt` reported (single-card sources only). */ function takeCardFrom(window: FreecellWindow, location: number): void { if (location < LOC_FOUNDATION0) { window.cells[location] = null; } else if (location < LOC_CASCADE0) { const pile = location - LOC_FOUNDATION0; const top = window.foundations[pile]!; window.foundations[pile] = rankOf(top!) > 1 ? top! - 4 : null; } else { window.cascades[location - LOC_CASCADE0]!.pop(); } } /** * Attempt a user move between two locations; on success commit it as one * undoable step (including any safe auto-plays it unlocks). */ function performMove(window: FreecellWindow, src: number, dst: number): void { const before = snapshot(window); const result = attemptMove(window, src, dst); if (!result.moved) { playSfx(window, SFX_ERROR); return; } window.undoStack.push(before); if (window.undoStack.length > 200) window.undoStack.shift(); window.moves++; window.selected = null; playSfx(window, result.toFoundation ? SFX_FOUNDATION : SFX_MOVE); autoSafeMoves(window); checkWin(window); } function attemptMove(window: FreecellWindow, src: number, dst: number): { moved: boolean; toFoundation: boolean } { const failed = { moved: false, toFoundation: false }; const srcIsCascade = src >= LOC_CASCADE0; const dstIsCell = dst < LOC_FOUNDATION0; const dstIsFoundation = !dstIsCell && dst < LOC_CASCADE0; if (dstIsFoundation) { if (src >= LOC_FOUNDATION0 && src < LOC_CASCADE0) return failed; const card = topCardAt(window, src); const pile = dst - LOC_FOUNDATION0; if (card === null || !foundationCanAccept(window.foundations[pile]!, card)) return failed; takeCardFrom(window, src); window.foundations[pile] = card; return { moved: true, toFoundation: true }; } if (dstIsCell) { if (window.cells[dst] !== null) return failed; const card = topCardAt(window, src); if (card === null) return failed; takeCardFrom(window, src); window.cells[dst] = card; return { moved: true, toFoundation: false }; } // Destination is a cascade. const dstCascade = window.cascades[dst - LOC_CASCADE0]!; const dstTop = dstCascade.length > 0 ? dstCascade[dstCascade.length - 1]! : null; if (!srcIsCascade) { const card = topCardAt(window, src); if (card === null) return failed; if (dstTop !== null && !canStack(card, dstTop)) return failed; takeCardFrom(window, src); dstCascade.push(card); return { moved: true, toFoundation: false }; } const srcCascade = window.cascades[src - LOC_CASCADE0]!; if (srcCascade.length === 0) return failed; const capacity = moveCapacity(window, dstTop === null ? dst - LOC_CASCADE0 : -1); const maxRun = Math.min(tailRunLength(srcCascade), capacity); // Take the longest legal run; onto an empty cascade any run length works. for (let n = maxRun; n >= 1; n--) { const bottom = srcCascade[srcCascade.length - n]!; if (dstTop === null || canStack(bottom, dstTop)) { dstCascade.push(...srcCascade.splice(srcCascade.length - n, n)); return { moved: true, toFoundation: false }; } } return failed; } /** Double-click convenience: the card at `location` goes to its foundation. */ function sendToFoundation(window: FreecellWindow, location: number): void { if (location >= LOC_FOUNDATION0 && location < LOC_CASCADE0) { playSfx(window, SFX_ERROR); return; } const card = topCardAt(window, location); const pile = card === null ? -1 : foundationIndexFor(window, card); if (pile < 0) { playSfx(window, SFX_ERROR); return; } performMove(window, location, LOC_FOUNDATION0 + pile); } /** Foundation rank per suit (0 while that suit has no pile). */ function foundationRankBySuit(window: FreecellWindow): number[] { const ranks = [0, 0, 0, 0]; for (const top of window.foundations) { if (top !== null) ranks[suitOf(top)] = rankOf(top); } return ranks; } /** * A card is safe to auto-play when no cascade card could still need it: * rank 2 or less, or both opposite-color foundations at rank-1 or higher. */ function isSafeAutoPlay(window: FreecellWindow, card: number): boolean { const rank = rankOf(card); if (rank <= 2) return true; const ranks = foundationRankBySuit(window); const oppositeMin = isRed(card) ? Math.min(ranks[0]!, ranks[2]!) : Math.min(ranks[1]!, ranks[3]!); return oppositeMin >= rank - 1; } /** Repeatedly move safe cards (cell or cascade top) to the foundations. */ function autoSafeMoves(window: FreecellWindow): void { let moved = true; while (moved) { moved = false; for (let location = 0; location < LOC_COUNT; location++) { if (location >= LOC_FOUNDATION0 && location < LOC_CASCADE0) continue; const card = topCardAt(window, location); if (card === null || !isSafeAutoPlay(window, card)) continue; const pile = foundationIndexFor(window, card); if (pile < 0) continue; takeCardFrom(window, location); window.foundations[pile] = card; moved = true; } } } function checkWin(window: FreecellWindow): void { const done = window.foundations.every((top) => top !== null && rankOf(top) === 13); if (!done) return; window.phase = "won"; window.selected = null; playSfx(window, SFX_WIN); } // --------------------------------------------------------------------------- // Painting type Layout = { pitch: number; marginX: number; /** Vertical pixels per buried cascade card (its visible label strip). */ strip: (cascadeLength: number) => number; }; function layoutFor(window: FreecellWindow): Layout { const pitch = Math.floor((window.viewportWidth - 12) / 8); const marginX = Math.floor((window.viewportWidth - (pitch * 8 - (pitch - CARD_W))) / 2); const available = window.viewportHeight - CASCADE_Y - 2; return { pitch, marginX, strip: (cascadeLength: number) => cascadeLength <= 1 ? 0 : Math.min(16, Math.floor((available - CARD_H) / (cascadeLength - 1))), }; } function paint(window: FreecellWindow): Plane[] { return windowMenu(window).paint(() => { const planes = singlePlane(paintContent(window)); if (window.phase === "won") { // The win box goes on its own plane: card labels are deferred glyphs // that render above their own image's raster, so an overlay drawn into // the board image could not cover them. const overlay = new GrayImage(window.viewportWidth, window.viewportHeight, 0); paintWinOverlay(overlay, window); planes.push({ image: overlay, x: 0, y: 0 }); } return planes; }); } function paintContent(window: FreecellWindow): GrayImage { const image = new GrayImage(window.viewportWidth, window.viewportHeight, 0); const layout = layoutFor(window); const colX = (i: number) => layout.marginX + i * layout.pitch; // Top row: free cells then foundations, with a divider between the groups. for (let i = 0; i < 4; i++) { const card = window.cells[i]!; if (card === null) { image.drawRoundedRect(colX(i), TOP_Y, CARD_W, CARD_H, 70, 4); } else { paintCard(image, colX(i), TOP_Y, card, window.selected === LOC_CELL0 + i, true); } } image.drawLine(colX(4) - 4, TOP_Y + 4, colX(4) - 4, TOP_Y + CARD_H - 4, 70); for (let i = 0; i < 4; i++) { const x = colX(4 + i); const card = window.foundations[i]!; if (card === null) { image.drawRoundedRect(x, TOP_Y, CARD_W, CARD_H, 70, 4); image.drawText(labelFont, x + Math.round((CARD_W - labelFont.measureText("A")) / 2), TOP_Y + 10, "A", 70); } else { paintCard(image, x, TOP_Y, card, window.selected === LOC_FOUNDATION0 + i, true); } } for (let i = 0; i < 8; i++) { paintCascade(image, window, layout, i); } paintCursor(image, window, layout); // The win overlay is painted onto its own plane by paint(), not here. return image; } function paintCascade(image: GrayImage, window: FreecellWindow, layout: Layout, index: number): void { const x = layout.marginX + index * layout.pitch; const cascade = window.cascades[index]!; if (cascade.length === 0) { image.drawRoundedRect(x, CASCADE_Y, CARD_W, CARD_H, 45, 4); return; } const strip = layout.strip(cascade.length); // How many tail cards the pending selection would move (highlighted). let highlightFrom = cascade.length; if (window.selected === LOC_CASCADE0 + index) { const run = Math.min(tailRunLength(cascade), moveCapacity(window, -1)); highlightFrom = cascade.length - run; } for (let i = 0; i < cascade.length; i++) { paintCard(image, x, CASCADE_Y + i * strip, cascade[i]!, i >= highlightFrom, i === cascade.length - 1); } } function paintCard( image: GrayImage, x: number, y: number, card: number, selected: boolean, fullyVisible: boolean, ): void { image.fillRoundedRect(x, y, CARD_W, CARD_H, 0, 4); image.drawRoundedRect(x, y, CARD_W, CARD_H, selected ? 255 : 160, 4); if (selected) image.drawRoundedRect(x + 1, y + 1, CARD_W - 2, CARD_H - 2, 255, 3); const rankText: string = RANK_CHARS[rankOf(card)]! const suitText: string = SUIT_CHARS[suitOf(card)]!; image.drawText(labelFont, x + 5, y, rankText, 255); image.drawText(suitFont, x + 5 + labelFont.measureText(rankText), y + 3, suitText, 150); if (isRed(card)) { // Keep the marker within the top strip, clear of even a two-digit rank. const markerX = x + 28; image.fillRect(markerX, y + 1, Math.max(0, x + CARD_W - 4 - markerX), 13, 10); } if (fullyVisible) { image.drawText( mediumFont, x + CARD_W - 4 - Math.ceil(mediumFont.measureText(suitText)), y + CARD_H - mediumFont.lineHeight - 2, suitText, 100, ); } } /** Bright double outline around the cursor's location, minesweeper-style. */ function paintCursor(image: GrayImage, window: FreecellWindow, layout: Layout): void { if (window.phase !== "playing") return; let x: number; let y: number; let height: number; if (window.cursor < LOC_CASCADE0) { x = layout.marginX + (window.cursor % 8) * layout.pitch; y = TOP_Y; height = CARD_H; } else { const index = window.cursor - LOC_CASCADE0; const cascade = window.cascades[index]!; x = layout.marginX + index * layout.pitch; y = CASCADE_Y; height = cascade.length === 0 ? CARD_H : (cascade.length - 1) * layout.strip(cascade.length) + CARD_H; } image.drawRect(x - 3, y - 3, CARD_W + 6, height + 6, 255); image.drawRect(x - 2, y - 2, CARD_W + 4, height + 4, 255); } function paintWinOverlay(image: GrayImage, window: FreecellWindow): void { const width = 320; const height = 120; const x = Math.round((window.viewportWidth - width) / 2); const y = Math.round((window.viewportHeight - height) / 2); // Fill 1, not 0: identical after 4bpp quantization, but 0 is transparent // when this overlay composites as its own plane over the board. image.fillRoundedRect(x, y, width, height, 1, 8); image.drawRoundedRect(x, y, width, height, 200, 8); drawCenteredIn(image, largeFont, x, width, y + 14, "You win!", 255); drawCenteredIn(image, smallFont, x, width, y + 56, `${window.moves} moves`, 170); drawCenteredIn(image, smallFont, x, width, y + 80, `${GESTURE_CLICK} new game ${GESTURE_DOUBLE_CLICK} leave`, 150); drawCenteredIn(image, smallFont, x, width, y + 98, `${GESTURE_LONG_PRESS} menu`, 150); } function drawCenteredIn( image: GrayImage, font: typeof smallFont, x: number, width: number, y: number, text: string, value: number, ): void { image.drawText(font, Math.round(x + (width - font.measureText(text)) / 2), y, text, value); } function renderAndSubmit(window: FreecellWindow, inputFrameId: number): void { const frameId = inputFrameId > 0 ? inputFrameId : frameTimings.startFrame(`render:${window.windowId}`); try { const paintStartedAtMs = Date.now(); const planes = frameTimings.span(frameId, "paint", () => frameTimings.runWithFrame(frameId, () => paint(window)), ); const paintMs = Date.now() - paintStartedAtMs; const fingerprint = planesFingerprint(planes); if (fingerprint === window.lastSubmittedFingerprint) { frameTimings.finishFrame(frameId, "discarded: freecell content unchanged"); return; } const communicator = getActiveDisplay(); if (!communicator) { frameTimings.finishFrame(frameId, "discarded: no active display"); return; } const { image, draws } = frameTimings.span(frameId, "flatten", () => flattenPlanesWithDraws(planes)); const buffer = frameTimings.span(frameId, "to8bpp", () => image.to8bppBuffer()); communicator.submitSurfaceFrame( buffer.buffer, window.surfaceId, 0, 0, image.width, image.height, fingerprint, paintMs, frameId, frameTimings.span(frameId, "prepareFrameDraws", () => prepareFrameDraws(draws)), ); window.lastSubmittedFingerprint = fingerprint; } catch (error) { frameTimings.finishFrame(frameId, "discarded: freecell render failed"); console.error(`freecell worker render failed: ${error}`); } }