@johnmorrisdotca/houseki 0.0.0-stage → 0.1.0

package/dist/falling-triplets/match.js

@@ -0,0 +1,45 @@
+/** Finds the union of every maximal horizontal, vertical, and diagonal run of at least three. */
+export function findMatches(board, width, height) {
+    const directions = [[1, 0], [0, 1], [1, 1], [1, -1]];
+    const found = new Map();
+    for (let y = 0; y < height; y++)
+        for (let x = 0; x < width; x++) {
+            const index = y * width + x;
+            const gem = board[index];
+            if (!gem)
+                continue;
+            for (const [dx, dy] of directions) {
+                const px = x - dx, py = y - dy;
+                if (px >= 0 && px < width && py >= 0 && py < height && board[py * width + px]?.colour === gem.colour)
+                    continue;
+                const run = [];
+                let cx = x, cy = y;
+                while (cx >= 0 && cx < width && cy >= 0 && cy < height && board[cy * width + cx]?.colour === gem.colour) {
+                    run.push(cy * width + cx);
+                    cx += dx;
+                    cy += dy;
+                }
+                if (run.length >= 3) {
+                    const cells = found.get(gem.colour) ?? new Set();
+                    run.forEach(cell => cells.add(cell));
+                    found.set(gem.colour, cells);
+                }
+            }
+        }
+    return [...found].map(([colour, cells]) => ({ colour, cells: [...cells].sort((a, b) => a - b) }));
+}
+/** Compacts each column downward while preserving the top-to-bottom order of survivors. */
+export function compactBoard(board, width, height) {
+    const result = Array(width * height).fill(null);
+    for (let x = 0; x < width; x++) {
+        const stack = [];
+        for (let y = 0; y < height; y++) {
+            const gem = board[y * width + x];
+            if (gem)
+                stack.push(gem);
+        }
+        const offset = height - stack.length;
+        stack.forEach((gem, i) => { result[(offset + i) * width + x] = gem; });
+    }
+    return result;
+}

package/dist/falling-triplets/random.d.ts

@@ -0,0 +1,9 @@
+import type { Colour } from './types.js';
+/** Hashes a string seed with UTF-8 FNV-1a and returns a nonzero uint32 state. */
+export declare function seedState(seed: string): number;
+/** Advances the reference xorshift32 source. */
+export declare function nextUint32(state: number): readonly [number, number];
+/** Draws an unbiased integer and updated state using rejection sampling. */
+export declare function nextInt(state: number, n: number): readonly [number, number];
+/** Creates a shuffled bag with three of each available colour. */
+export declare function drawBag(bag: readonly Colour[], state: number, count: 4 | 5 | 6): readonly [readonly Colour[], number];

package/dist/falling-triplets/random.js

@@ -0,0 +1,44 @@
+const COLOURS = ['red', 'blue', 'green', 'gold', 'purple', 'teal'];
+/** Hashes a string seed with UTF-8 FNV-1a and returns a nonzero uint32 state. */
+export function seedState(seed) {
+    let hash = 0x811c9dc5;
+    for (const byte of new TextEncoder().encode(seed))
+        hash = Math.imul(hash ^ byte, 0x01000193) >>> 0;
+    return hash || 0x6d2b79f5;
+}
+/** Advances the reference xorshift32 source. */
+export function nextUint32(state) {
+    let next = state >>> 0;
+    next ^= next << 13;
+    next ^= next >>> 17;
+    next ^= next << 5;
+    next >>>= 0;
+    return [next, next];
+}
+/** Draws an unbiased integer and updated state using rejection sampling. */
+export function nextInt(state, n) {
+    if (!Number.isInteger(n) || n < 1 || n > 0x100000000)
+        throw new RangeError('n must be an integer from 1 to 2^32');
+    const limit = Math.floor(0x100000000 / n) * n;
+    let current = state >>> 0;
+    for (;;) {
+        const [value, next] = nextUint32(current);
+        current = next;
+        if (value < limit)
+            return [value % n, current];
+    }
+}
+/** Creates a shuffled bag with three of each available colour. */
+export function drawBag(bag, state, count) {
+    if (bag.length)
+        return [bag, state];
+    const values = COLOURS.slice(0, count);
+    const nextBag = [...values, ...values, ...values];
+    let current = state;
+    for (let i = nextBag.length - 1; i > 0; i--) {
+        const [j, next] = nextInt(current, i + 1);
+        current = next;
+        [nextBag[i], nextBag[j]] = [nextBag[j], nextBag[i]];
+    }
+    return [nextBag, current];
+}

package/dist/falling-triplets/types.d.ts

@@ -0,0 +1,134 @@
+/** A gem colour ID. */
+export type Colour = 'red' | 'blue' | 'green' | 'gold' | 'purple' | 'teal';
+/** A settled or active gem with a stable run-local identity. */
+export interface Gem {
+    readonly id: number;
+    readonly colour: Colour;
+    readonly target?: boolean;
+}
+export type Mode = 'relaxed' | 'arcade' | 'daily' | 'challenge';
+export type Phase = 'falling' | 'clear-mark' | 'clear-remove' | 'gravity' | 'paused' | 'won' | 'lost' | 'finished';
+export interface Piece {
+    readonly gems: readonly [Gem, Gem, Gem];
+    readonly x: number;
+    readonly y: number;
+    readonly orientation: 0 | 1 | 2;
+    readonly level: number;
+    readonly descent: number;
+    readonly lockTicks: number;
+    readonly lockResets: number;
+    readonly lockStarted: boolean;
+}
+export interface Settings {
+    readonly mode: Mode;
+    readonly width: number;
+    readonly height: number;
+    readonly colourCount: 4 | 5 | 6;
+    readonly seed: string;
+    readonly pieceLimit?: number;
+    readonly goal?: 'targets' | 'chain' | 'empty';
+    readonly targetIds?: readonly number[];
+    readonly minimumChain?: number;
+    readonly challengeBoard?: readonly (Gem | null)[];
+    readonly challengeQueue?: readonly Triplet[];
+    readonly witness?: readonly ChallengeHint[];
+}
+export type Triplet = readonly [Colour, Colour, Colour];
+export interface ChallengeGoalTargets {
+    readonly type: 'targets';
+    readonly targetIds: readonly number[];
+}
+export interface ChallengeGoalChain {
+    readonly type: 'chain';
+    readonly minimumChain: number;
+}
+export interface ChallengeGoalEmpty {
+    readonly type: 'empty';
+}
+export type ChallengeGoal = ChallengeGoalTargets | ChallengeGoalChain | ChallengeGoalEmpty;
+export interface ChallengeHint {
+    readonly x: number;
+    readonly orientation: 0 | 1 | 2;
+}
+export interface ChallengeSettings extends Settings {
+    readonly mode: 'challenge';
+    readonly goal: ChallengeGoal['type'];
+    readonly challengeBoard: readonly (Gem | null)[];
+    readonly challengeQueue: readonly Triplet[];
+}
+export interface Wave {
+    readonly clearedIds: readonly number[];
+    readonly cells: readonly number[];
+    readonly chain: number;
+    readonly points: number;
+}
+export interface GameState {
+    readonly game: 'falling-triplets';
+    readonly rules: 'triplets-1';
+    readonly settings: Settings;
+    readonly board: readonly (Gem | null)[];
+    readonly phase: Phase;
+    readonly pausedPhase?: Phase;
+    readonly active: Piece | null;
+    readonly next: readonly Triplet[];
+    readonly bag: readonly Colour[];
+    readonly randomState: number;
+    readonly nextId: number;
+    readonly score: number;
+    readonly maxChain: number;
+    readonly completedPieces: number;
+    readonly elapsedTicks: number;
+    readonly pieceTicks: number;
+    readonly resolutionTick: number;
+    readonly waves: readonly Wave[];
+    readonly assisted: boolean;
+    readonly hintsUsed: number;
+    readonly witnessPathMatches: boolean;
+    readonly challengeIndex?: number;
+    readonly pendingClear?: readonly number[];
+    readonly gravityBoard?: readonly (Gem | null)[];
+    readonly resolutionChain?: number;
+    readonly resolutionLevel?: number;
+    readonly recording: readonly RecordedAction[];
+    readonly reason?: string;
+}
+export type Action = {
+    readonly kind: 'left' | 'right' | 'soft-drop' | 'hard-drop' | 'place' | 'cycle-forward' | 'cycle-backward' | 'pause' | 'resume' | 'hint' | 'tick';
+};
+export interface Transition {
+    readonly state: GameState;
+    readonly events: readonly GameEvent[];
+    readonly accepted: boolean;
+    readonly reason?: string;
+}
+/** One accepted canonical action and its logical tick position. */
+export interface RecordedAction {
+    readonly tick: number;
+    readonly ordinal: number;
+    readonly action: Exclude<Action, {
+        readonly kind: 'tick';
+    }>;
+}
+export interface GameEvent {
+    readonly type: string;
+    readonly [key: string]: unknown;
+}
+export interface CreateOptions {
+    readonly mode?: Exclude<Mode, 'challenge'>;
+    readonly seed?: string;
+    readonly preset?: 'compact' | 'narrow' | 'standard' | 'wide' | 'extraWide' | 'tall' | 'deep' | 'large';
+    readonly width?: number;
+    readonly height?: number;
+    readonly colourCount?: 4 | 5 | 6;
+    readonly pieceLimit?: number;
+}
+export interface ChallengeOptions {
+    readonly seed?: string;
+    readonly width?: number;
+    readonly height?: number;
+    readonly colourCount?: 4 | 5 | 6;
+    readonly board: readonly (Gem | null)[];
+    readonly queue: readonly Triplet[];
+    readonly goal: ChallengeGoal;
+    readonly witness?: readonly ChallengeHint[];
+}

package/dist/falling-triplets/types.js

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

package/dist/falling-triplets.d.ts

@@ -0,0 +1,7 @@
+export * from './falling-triplets/types.js';
+export { findMatches, compactBoard } from './falling-triplets/match.js';
+export { nextUint32, nextInt, seedState } from './falling-triplets/random.js';
+export { createInputScheduler, setHeldAction, queueInputEdge, actionsForTick, releaseAllActions } from './falling-triplets/input.js';
+export { createGame, createChallenge, restartGame, applyAction, advanceTicks, legalActions, statusOf, encodeGame, decodeGame, landingY } from './falling-triplets/engine.js';
+export { campaignManifest, levelManifest, tutorialManifest, getLevel, createLevel, getTutorial } from './falling-triplets/content.js';
+export type { CampaignLevel, CampaignManifest, DifficultyMetrics, LocalizedText, TutorialDefinition, TutorialStep } from './falling-triplets/content-types.js';

package/dist/falling-triplets.js

@@ -0,0 +1,6 @@
+export * from './falling-triplets/types.js';
+export { findMatches, compactBoard } from './falling-triplets/match.js';
+export { nextUint32, nextInt, seedState } from './falling-triplets/random.js';
+export { createInputScheduler, setHeldAction, queueInputEdge, actionsForTick, releaseAllActions } from './falling-triplets/input.js';
+export { createGame, createChallenge, restartGame, applyAction, advanceTicks, legalActions, statusOf, encodeGame, decodeGame, landingY } from './falling-triplets/engine.js';
+export { campaignManifest, levelManifest, tutorialManifest, getLevel, createLevel, getTutorial } from './falling-triplets/content.js';

package/dist/gem-swap/black-hole.d.ts

@@ -0,0 +1,7 @@
+import type { BlackHolePortal, GameState } from './types.js';
+/** Lists the placement gem and first edge-contact wave in deterministic cell order. */
+export declare function placementCells(state: GameState, target: number): readonly number[];
+/** Finds the next bounded orthogonal contact wave without activating swallowed powers. */
+export declare function contactCells(state: GameState, portal: BlackHolePortal): readonly number[];
+/** Accounts for one portal contact wave and closes the portal exactly at zero capacity. */
+export declare function consumePortal(state: GameState, cells: readonly number[]): BlackHolePortal | null;

package/dist/gem-swap/black-hole.js

@@ -0,0 +1,54 @@
+import { neighbors } from './board.js';
+/** Lists the placement gem and first edge-contact wave in deterministic cell order. */
+export function placementCells(state, target) {
+    if (!Number.isInteger(target) || target < 0 || target >= state.board.length || !state.settings.mask[target] || !state.board[target])
+        return Object.freeze([]);
+    const cells = [target];
+    const ids = new Set([state.board[target].id]);
+    for (const cell of neighbors(target, state.settings.width, state.settings.height, state.settings.mask).sort((a, b) => a - b)) {
+        const id = state.board[cell]?.id;
+        if (id === undefined || ids.has(id))
+            continue;
+        ids.add(id);
+        cells.push(cell);
+        if (cells.length === 8)
+            break;
+    }
+    return Object.freeze(cells.sort((a, b) => a - b));
+}
+/** Finds the next bounded orthogonal contact wave without activating swallowed powers. */
+export function contactCells(state, portal) {
+    if (portal.capacityRemaining <= 0)
+        return Object.freeze([]);
+    const consumed = new Set(portal.consumedIds);
+    const candidates = neighbors(portal.cell, state.settings.width, state.settings.height, state.settings.mask).sort((a, b) => a - b);
+    const cells = [];
+    for (const cell of candidates) {
+        const id = state.board[cell]?.id;
+        if (id === undefined || consumed.has(id))
+            continue;
+        consumed.add(id);
+        cells.push(cell);
+        if (cells.length === portal.capacityRemaining)
+            break;
+    }
+    return Object.freeze(cells);
+}
+/** Accounts for one portal contact wave and closes the portal exactly at zero capacity. */
+export function consumePortal(state, cells) {
+    const portal = state.blackHole;
+    if (!portal)
+        return null;
+    const seen = new Set(portal.consumedIds);
+    const ids = cells.flatMap(cell => {
+        const id = state.board[cell]?.id;
+        if (id === undefined || seen.has(id))
+            return [];
+        seen.add(id);
+        return [id];
+    });
+    const capacityRemaining = Math.max(0, portal.capacityRemaining - ids.length);
+    if (!capacityRemaining)
+        return null;
+    return Object.freeze({ ...portal, capacityRemaining, consumedIds: Object.freeze([...portal.consumedIds, ...ids]) });
+}

package/dist/gem-swap/board.d.ts

@@ -0,0 +1,25 @@
+import type { Gem, GemColour, GameState, Settings } from './types.js';
+export declare const COLOURS: readonly GemColour[];
+export declare const PRESETS: {
+    readonly compact: readonly [6, 6];
+    readonly standard: readonly [8, 8];
+    readonly wide: readonly [10, 6];
+    readonly tall: readonly [6, 10];
+    readonly extraWide: readonly [16, 10];
+    readonly deep: readonly [8, 32];
+    readonly large: readonly [12, 32];
+};
+/** Returns active orthogonal neighbours in row-major order. */
+export declare function neighbors(index: number, width: number, height: number, mask: readonly boolean[]): number[];
+/** Finds every cell participating in a horizontal or vertical run of at least three. */
+export declare function findMatches(board: readonly (Gem | null)[], settings: Settings): readonly number[];
+/** Tests an adjacent swap without changing either the board or random stream. */
+export declare function matchesAfterSwap(state: GameState, from: number, to: number): readonly number[];
+/** Enumerates legal normal-gem swaps in stable source/destination order. */
+export declare function listLegalSwaps(state: GameState): readonly {
+    readonly kind: 'swap';
+    readonly from: number;
+    readonly to: number;
+}[];
+/** Checks whether a partially filled row-major board already contains a run. */
+export declare function hasMatch(board: readonly (Gem | null)[], settings: Settings): boolean;

package/dist/gem-swap/board.js

@@ -0,0 +1,89 @@
+export const COLOURS = ['red', 'blue', 'green', 'gold', 'purple', 'teal'];
+export const PRESETS = { compact: [6, 6], standard: [8, 8], wide: [10, 6], tall: [6, 10], extraWide: [16, 10], deep: [8, 32], large: [12, 32] };
+/** Returns active orthogonal neighbours in row-major order. */
+export function neighbors(index, width, height, mask) {
+    const x = index % width;
+    const y = Math.floor(index / width);
+    const out = [];
+    if (x > 0 && mask[index - 1])
+        out.push(index - 1);
+    if (x + 1 < width && mask[index + 1])
+        out.push(index + 1);
+    if (y > 0 && mask[index - width])
+        out.push(index - width);
+    if (y + 1 < height && mask[index + width])
+        out.push(index + width);
+    return out;
+}
+/** Finds every cell participating in a horizontal or vertical run of at least three. */
+export function findMatches(board, settings) {
+    const found = new Set();
+    const { width, height, mask } = settings;
+    const scan = (cells) => {
+        let start = 0;
+        while (start < cells.length) {
+            const first = board[cells[start]];
+            if (!first) {
+                start++;
+                continue;
+            }
+            let end = start + 1;
+            while (end < cells.length && board[cells[end]]?.colour === first.colour)
+                end++;
+            if (end - start >= 3)
+                for (let i = start; i < end; i++)
+                    found.add(cells[i]);
+            start = end;
+        }
+    };
+    for (let y = 0; y < height; y++) {
+        let segment = [];
+        for (let x = 0; x <= width; x++) {
+            const index = y * width + x;
+            if (x < width && mask[index])
+                segment.push(index);
+            else {
+                scan(segment);
+                segment = [];
+            }
+        }
+    }
+    for (let x = 0; x < width; x++) {
+        let segment = [];
+        for (let y = 0; y <= height; y++) {
+            const index = y * width + x;
+            if (y < height && mask[index])
+                segment.push(index);
+            else {
+                scan(segment);
+                segment = [];
+            }
+        }
+    }
+    return [...found].sort((a, b) => a - b);
+}
+/** Tests an adjacent swap without changing either the board or random stream. */
+export function matchesAfterSwap(state, from, to) {
+    const board = [...state.board];
+    [board[from], board[to]] = [board[to], board[from]];
+    return findMatches(board, state.settings);
+}
+/** Enumerates legal normal-gem swaps in stable source/destination order. */
+export function listLegalSwaps(state) {
+    if (state.phase !== 'ready' || findMatches(state.board, state.settings).length)
+        return [];
+    const moves = [];
+    for (let from = 0; from < state.board.length; from++) {
+        if (!state.board[from])
+            continue;
+        for (const to of neighbors(from, state.settings.width, state.settings.height, state.settings.mask)) {
+            if (to <= from || !state.board[to] || state.board[from].colour === state.board[to].colour)
+                continue;
+            if (matchesAfterSwap(state, from, to).length)
+                moves.push({ kind: 'swap', from, to });
+        }
+    }
+    return moves;
+}
+/** Checks whether a partially filled row-major board already contains a run. */
+export function hasMatch(board, settings) { return findMatches(board, settings).length > 0; }

package/dist/gem-swap/content.d.ts

@@ -0,0 +1,75 @@
+import type { Action, CreateOptions, ReplayOperation } from './types.js';
+export type GemSwapReviewStatus = 'human-review-pending';
+export interface GemSwapCampaignLevel {
+    readonly id: string;
+    readonly number: number;
+    readonly title: {
+        readonly en: string;
+        readonly ja: string;
+    };
+    readonly options: CreateOptions;
+    readonly width: number;
+    readonly height: number;
+    readonly colourCount: number;
+    readonly seed: number;
+    readonly challenge: NonNullable<CreateOptions['challenge']>;
+    readonly witness: readonly ReplayOperation[];
+    readonly canonicalKeyHash: string;
+    readonly tags: readonly string[];
+    readonly rawMetrics: Readonly<Record<string, number>>;
+    readonly difficultyScore: number;
+    readonly difficultyMarks: number;
+    readonly gradingVersion: string;
+    readonly proofStatus: 'engine-witness-verified';
+    readonly reviewStatus: GemSwapReviewStatus;
+}
+export type GemSwapLessonStep = {
+    readonly kind: 'action';
+    readonly id: string;
+    readonly action: Action;
+    readonly accepted: boolean;
+    readonly reason?: string;
+    readonly event?: string;
+    readonly cell?: number;
+    readonly text: {
+        readonly en: string;
+        readonly ja: string;
+    };
+} | {
+    readonly kind: 'ticks';
+    readonly id: string;
+    readonly count: number;
+    readonly event?: string;
+    readonly outcome?: string;
+    readonly cell?: number;
+    readonly text: {
+        readonly en: string;
+        readonly ja: string;
+    };
+};
+export interface GemSwapLesson {
+    readonly id: string;
+    readonly title: {
+        readonly en: string;
+        readonly ja: string;
+    };
+    readonly initial: CreateOptions;
+    readonly steps: readonly GemSwapLessonStep[];
+    readonly witness: readonly ReplayOperation[];
+    readonly reviewStatus: GemSwapReviewStatus;
+}
+export declare const GENERATION_REVISION = "gem-swap-campaign-1.3.0";
+export declare const GRADING_VERSION = "swap-choice-forgiveness-1";
+export declare const SAMPLE_BUDGET = 24;
+export declare const GRADING_WEIGHTS: {
+    seededPlayoutDifficulty: number;
+    choiceDifficulty: number;
+    objectiveCoordination: number;
+    chainDepth: number;
+    witnessLength: number;
+    specialCombination: number;
+};
+export declare const CAMPAIGN_CHECKSUM = "eb7c54a583db428d596b8fbdab0d63a9ad39ad5b9e39948dc4ccab84ba1196aa";
+export declare const CAMPAIGN_COUNT = 50;
+export declare const GEM_SWAP_CAMPAIGN: readonly GemSwapCampaignLevel[];
+export declare const GEM_SWAP_LESSONS: readonly GemSwapLesson[];