@johnmorrisdotca/houseki 0.1.0 → 0.2.0

package/dist/colour-chains/content-types.d.ts

@@ -10,11 +10,17 @@ export interface ChainDifficultyMetrics {
     readonly forcedPlacementShare: number;
     readonly seededPlayoutSamples: number;
     readonly seededPlayoutQueueDepth: number;
+    /** Number of pair placements randomized in each seeded playout. */
+    readonly seededPlayoutVariablePrefixLength?: number;
+    /** Number of later witnessed placements held fixed in each seeded playout. */
+    readonly seededPlayoutFixedSuffixLength?: number;
     readonly seededPlayoutSuccesses: number;
     readonly seededPlayoutSuccessRate: number;
     readonly setupPairsBeforePayoff: number;
     readonly requiredSetupPairs: number;
     readonly verifiedSetupDependencies: number;
+    /** Number of pre-payoff steps checked by exhaustive single-step deviations. */
+    readonly setupDependencyProbeSteps?: number;
     readonly requiredChainDepth: number;
     readonly requiredRotations: number;
     readonly requiredWallKicks: number;
@@ -26,6 +32,10 @@ export interface ChainCampaignLevel {
     readonly id: string;
     readonly number: number;
     readonly title: LocalizedText;
+    readonly objective?: LocalizedText;
+    readonly nature?: true;
+    readonly weather?: 'frequent';
+    readonly magneticQueue?: readonly (readonly [boolean, boolean])[];
     readonly canonicalKeyHash: string;
     readonly width: number;
     readonly height: number;
@@ -43,6 +53,12 @@ export interface ChainCampaignLevel {
     readonly proofStatus: 'engine-witness-verified';
     readonly reviewStatus: 'human-review-pending' | 'human-reviewed';
 }
+export interface NatureChainCampaignLevel extends ChainCampaignLevel {
+    readonly objective: LocalizedText;
+    readonly nature: true;
+    readonly weather?: 'frequent';
+    readonly magneticQueue?: readonly (readonly [boolean, boolean])[];
+}
 export interface ChainCampaignManifest {
     readonly count: number;
     readonly candidatePoolCount: number;
@@ -56,6 +72,9 @@ export interface ChainCampaignManifest {
     readonly checksum: string;
     readonly levels: readonly ChainCampaignLevel[];
 }
+export interface NatureChainCampaignManifest extends Omit<ChainCampaignManifest, 'levels'> {
+    readonly levels: readonly NatureChainCampaignLevel[];
+}
 export interface ChainTutorialStep {
     readonly instruction: LocalizedText;
     readonly action: string;
@@ -76,5 +95,7 @@ export interface ChainTutorialDefinition {
 export interface ChainContentData {
     readonly campaign: ChainCampaignManifest;
     readonly tutorials: readonly ChainTutorialDefinition[];
+    readonly shizen?: NatureChainCampaignManifest;
+    readonly arashi?: NatureChainCampaignManifest;
 }
 export type { Colour, Orientation, WitnessStep, ChallengeGoal };

package/dist/colour-chains/content.d.ts

@@ -1,11 +1,19 @@
-import type { ChainCampaignLevel, ChainCampaignManifest, ChainTutorialDefinition } from './content-types.js';
+import type { ChainCampaignLevel, ChainCampaignManifest, ChainTutorialDefinition, NatureChainCampaignLevel, NatureChainCampaignManifest } from './content-types.js';
 import type { GameState } from './types.js';
 export declare const campaignManifest: ChainCampaignManifest;
 export declare const levelManifest: readonly ChainCampaignLevel[];
 export declare const tutorialManifest: readonly ChainTutorialDefinition[];
+export declare const shizenCampaignManifest: NatureChainCampaignManifest;
+export declare const shizenLevelManifest: readonly NatureChainCampaignLevel[];
+export declare const arashiCampaignManifest: NatureChainCampaignManifest;
+export declare const arashiLevelManifest: readonly NatureChainCampaignLevel[];
 /** Find a campaign challenge by stable content ID or its current one-based number. */
 export declare function getLevel(id: string | number): ChainCampaignLevel | undefined;
 /** Create a fresh engine-validated challenge from a stable content ID or display number. */
 export declare function createLevel(id: string | number): GameState;
+export declare function getShizenLevel(id: string | number): NatureChainCampaignLevel | undefined;
+export declare function createShizenLevel(id: string | number): GameState;
+export declare function getArashiLevel(id: string | number): NatureChainCampaignLevel | undefined;
+export declare function createArashiLevel(id: string | number): GameState;
 /** Find a persistent interactive lesson by its stable ID. */
 export declare function getTutorial(id: string): ChainTutorialDefinition | undefined;

package/dist/colour-chains/content.js

@@ -11,6 +11,10 @@ function deepFreeze(value) {
 export const campaignManifest = deepFreeze(contentData.campaign);
 export const levelManifest = campaignManifest.levels;
 export const tutorialManifest = deepFreeze(contentData.tutorials);
+export const shizenCampaignManifest = deepFreeze((contentData.shizen ?? { ...contentData.campaign, count: 0, levels: [], checksum: '' }));
+export const shizenLevelManifest = shizenCampaignManifest.levels;
+export const arashiCampaignManifest = deepFreeze((contentData.arashi ?? { ...contentData.campaign, count: 0, levels: [], checksum: '' }));
+export const arashiLevelManifest = arashiCampaignManifest.levels;
 /** Find a campaign challenge by stable content ID or its current one-based number. */
 export function getLevel(id) {
     if (typeof id === 'number')
@@ -24,5 +28,14 @@ export function createLevel(id) {
         throw new RangeError(`Unknown Colour Chains level: ${String(id)}`);
     return createChallenge({ id: level.id, seed: level.seed, width: level.width, height: level.height, colourCount: level.colourCount, board: level.board, queue: level.queue, goal: level.goal, witness: level.witness });
 }
+function createNatureLevel(level) {
+    return createChallenge({ id: level.id, seed: level.seed, width: level.width, height: level.height, colourCount: level.colourCount, board: level.board, queue: level.queue, goal: level.goal, witness: level.witness, nature: true, ...(level.weather ? { weather: level.weather } : {}), ...(level.magneticQueue ? { magneticQueue: level.magneticQueue } : {}) });
+}
+export function getShizenLevel(id) { return typeof id === 'number' ? shizenLevelManifest.find(level => level.number === id) : shizenLevelManifest.find(level => level.id === id); }
+export function createShizenLevel(id) { const level = getShizenLevel(id); if (!level)
+    throw new RangeError(`Unknown Shizen Colour Chains level: ${String(id)}`); return createNatureLevel(level); }
+export function getArashiLevel(id) { return typeof id === 'number' ? arashiLevelManifest.find(level => level.number === id) : arashiLevelManifest.find(level => level.id === id); }
+export function createArashiLevel(id) { const level = getArashiLevel(id); if (!level)
+    throw new RangeError(`Unknown Arashi Colour Chains level: ${String(id)}`); return createNatureLevel(level); }
 /** Find a persistent interactive lesson by its stable ID. */
 export function getTutorial(id) { return tutorialManifest.find(tutorial => tutorial.id === id); }

package/dist/colour-chains/engine.js

@@ -136,6 +136,8 @@ function terminalAfterResolution(state) {
             if (movement.length)
                 return [{ ...current, phase: 'gravity', active: null, gravityBoard: settled, resolutionTick: 0 }, [...weatherEvents, { type: 'cells-fell', cells: movement, before: current.board, after: settled }]];
             current = { ...current, board: settled };
+            if (current.settings.mode === 'challenge' && satisfied(current))
+                return [{ ...current, phase: 'won', active: null, reason: 'goal-complete' }, [...weatherEvents, { type: 'run-ended', reason: 'goal-complete', score: current.score }]];
         }
     }
     if (current.settings.mode === 'challenge') {
@@ -144,8 +146,9 @@ function terminalAfterResolution(state) {
             return [{ ...current, phase: 'lost', active: null, reason: 'challenge-queue-exhausted' }, [...weatherEvents, { type: 'run-ended', reason: 'challenge-queue-exhausted' }]];
         const queue = current.settings.queue;
         const colours = queue[nextIndex];
-        const pair = makePair(current, colours);
-        const next = { ...current, active: pair, next: queue.slice(nextIndex + 1, nextIndex + 4), nextId: current.nextId + 2 };
+        const pair = makePair(current, colours, current.settings.magneticQueue?.[nextIndex]);
+        const nextMagnetic = current.settings.nature ? queue.slice(nextIndex + 1, nextIndex + 4).map((_, index) => current.settings.magneticQueue?.[nextIndex + index + 1] ?? [false, false]) : undefined;
+        const next = { ...current, active: pair, next: queue.slice(nextIndex + 1, nextIndex + 4), ...(nextMagnetic ? { nextMagnetic: Object.freeze(nextMagnetic) } : {}), nextId: current.nextId + 2 };
         if (!pairFits(next, pair))
             return [{ ...next, active: null, phase: 'lost', reason: 'spawn-collision' }, [...weatherEvents, { type: 'run-ended', reason: 'spawn-collision' }]];
         return [next, [...weatherEvents, { type: 'pair-spawned', ids: pair.gems.map(gem => gem.id), colours }]];
@@ -469,8 +472,9 @@ export function initialChallengeState(settings, visibleBoard, queue) {
         board[i + settings.width * HIDDEN] = visibleBoard[i];
     const maxId = Math.max(0, ...visibleBoard.flatMap(gem => gem ? [gem.id] : []));
     const base = { game: 'colour-chains', rules: RULES, settings, board: Object.freeze(board), phase: 'falling', active: null, next: Object.freeze(queue.slice(1, 4)), bag: [], randomState: seedState(`colour-chains|${RULES}|${settings.seed}`), nextId: maxId + 1, score: 0, maxChain: 0, allClears: 0, completedPairs: 0, resolutionTick: 0, waves: [], clearCells: [], gravityBoard: null, resolutionHadClear: false, elapsedTicks: 0, assisted: false, witnessIndex: 0, recording: [] };
-    const active = makePair(base, queue[0]);
-    return { ...base, active, nextId: maxId + 3 };
+    const active = makePair(base, queue[0], settings.magneticQueue?.[0]);
+    const nextMagnetic = settings.nature ? queue.slice(1, 4).map((_, index) => settings.magneticQueue?.[index + 1] ?? [false, false]) : undefined;
+    return { ...base, active, ...(nextMagnetic ? { nextMagnetic: Object.freeze(nextMagnetic) } : {}), nextId: maxId + 3 };
 }
 /** Creates a deterministic seeded game with one active pair and three previews. */
 export function createGame(options = {}) {

package/dist/colour-chains/input.js

@@ -14,6 +14,7 @@ export function setHeldInput(state, control, pressed) {
 /** Queues a one-shot rotation, drop, Place, pause or resume edge for the next logical tick. */
 export function queueInputEdge(state, action) { return { ...state, queued: Object.freeze([...state.queued, action]) }; }
 /** Releases every held or queued control after focus loss, lock, resolution or pause. */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- the public signature takes the state a caller holds, though nothing of it is kept
 export function releaseAllInput(state) { return createInputScheduler(); }
 /** Resolves this tick's inputs in lateral, rotation, drop, soft-drop, pause order. */
 export function actionsForTick(game, input) {

package/dist/colour-chains/persistence.js

@@ -17,7 +17,7 @@ function stable(value, depth = 0) {
 function challengeOptions(settings) {
     if (settings.mode !== 'challenge' || !settings.challengeId || !settings.goal || !settings.initialBoard || !settings.queue || !settings.witness)
         throw new TypeError('Challenge settings are incomplete');
-    return { id: settings.challengeId, width: settings.width, height: settings.height, colourCount: settings.colourCount, seed: settings.seed, board: settings.initialBoard, queue: settings.queue, goal: settings.goal, witness: settings.witness };
+    return { id: settings.challengeId, width: settings.width, height: settings.height, colourCount: settings.colourCount, seed: settings.seed, board: settings.initialBoard, queue: settings.queue, ...(settings.magneticQueue ? { magneticQueue: settings.magneticQueue } : {}), ...(settings.nature ? { nature: true } : {}), ...(settings.weather ? { weather: settings.weather } : {}), goal: settings.goal, witness: settings.witness };
 }
 function createFromSettings(settings) {
     if (!settings || typeof settings !== 'object' || Array.isArray(settings))

package/dist/colour-chains/types.d.ts

@@ -6,8 +6,8 @@ export interface Gem {
     readonly colour: Colour;
     readonly magnetic?: true;
 }
-/** Authored Challenge layouts do not permit Shizen-marked stones. */
-export type ChallengeGem = Omit<Gem, 'magnetic'>;
+/** Authored challenge layouts can include explicit Shizen-marked stones. */
+export type ChallengeGem = Gem;
 /** The pivot-to-satellite direction, in clockwise order. */
 export type Orientation = 'up' | 'right' | 'down' | 'left';
 /** A visible or hidden board coordinate. */
@@ -57,6 +57,7 @@ export interface Settings {
     readonly goal?: ChallengeGoal;
     readonly initialBoard?: readonly (ChallengeGem | null)[];
     readonly queue?: readonly (readonly [Colour, Colour])[];
+    readonly magneticQueue?: readonly (readonly [boolean, boolean])[];
     readonly witness?: readonly WitnessStep[];
 }
 /** Challenge objective; target IDs refer to the visible starting board. */
@@ -81,6 +82,9 @@ export interface ChallengeOptions {
     readonly seed?: string;
     readonly board: readonly (ChallengeGem | null)[];
     readonly queue: readonly (readonly [Colour, Colour])[];
+    readonly magneticQueue?: readonly (readonly [boolean, boolean])[];
+    readonly nature?: boolean;
+    readonly weather?: WeatherSchedule;
     readonly goal: ChallengeGoal;
     readonly witness?: readonly WitnessStep[];
 }

package/dist/colour-chains.d.ts

@@ -4,5 +4,5 @@ export { createGame, applyAction, advanceTicks, legalActions, statusOf, landingC
 export { createChallenge } from './colour-chains/challenge.js';
 export { restartGame, encodeGame, decodeGame } from './colour-chains/persistence.js';
 export { createInputScheduler, setHeldInput, queueInputEdge, releaseAllInput, actionsForTick, applyScheduledActions, processInputTick } from './colour-chains/input.js';
-export { campaignManifest, levelManifest, tutorialManifest, getLevel, createLevel, getTutorial } from './colour-chains/content.js';
-export type { LocalizedText, ChainDifficultyMetrics, ChainCampaignLevel, ChainCampaignManifest, ChainTutorialStep, ChainTutorialDefinition, ChainContentData } from './colour-chains/content-types.js';
+export { campaignManifest, levelManifest, tutorialManifest, getLevel, createLevel, getTutorial, shizenCampaignManifest, shizenLevelManifest, getShizenLevel, createShizenLevel, arashiCampaignManifest, arashiLevelManifest, getArashiLevel, createArashiLevel } from './colour-chains/content.js';
+export type { LocalizedText, ChainDifficultyMetrics, ChainCampaignLevel, ChainCampaignManifest, NatureChainCampaignLevel, NatureChainCampaignManifest, ChainTutorialStep, ChainTutorialDefinition, ChainContentData } from './colour-chains/content-types.js';

package/dist/colour-chains.js

@@ -4,4 +4,4 @@ export { createGame, applyAction, advanceTicks, legalActions, statusOf, landingC
 export { createChallenge } from './colour-chains/challenge.js';
 export { restartGame, encodeGame, decodeGame } from './colour-chains/persistence.js';
 export { createInputScheduler, setHeldInput, queueInputEdge, releaseAllInput, actionsForTick, applyScheduledActions, processInputTick } from './colour-chains/input.js';
-export { campaignManifest, levelManifest, tutorialManifest, getLevel, createLevel, getTutorial } from './colour-chains/content.js';
+export { campaignManifest, levelManifest, tutorialManifest, getLevel, createLevel, getTutorial, shizenCampaignManifest, shizenLevelManifest, getShizenLevel, createShizenLevel, arashiCampaignManifest, arashiLevelManifest, getArashiLevel, createArashiLevel } from './colour-chains/content.js';

package/dist/falling-triplets/engine.js

@@ -79,7 +79,7 @@ export function createGame(options = {}) {
     const settings = { mode, width, height, colourCount, seed, ...(pieceLimit === undefined ? {} : { pieceLimit }) };
     if (![4, 5, 6].includes(settings.colourCount))
         throw new RangeError('Colour count must be 4, 5, or 6');
-    let randomState = seedState(`falling-triplets|${RULES}|${seed}`);
+    const randomState = seedState(`falling-triplets|${RULES}|${seed}`);
     const initial = { game: 'falling-triplets', rules: RULES, settings, board: Array(width * (height + HIDDEN)).fill(null), phase: 'falling', active: null, next: [], bag: [], randomState, nextId: 1, score: 0, maxChain: 0, completedPieces: 0, elapsedTicks: 0, pieceTicks: 0, resolutionTick: 0, waves: [], assisted: false, hintsUsed: 0, witnessPathMatches: true, recording: [] };
     const first = drawTriplet(initial);
     let state = { ...initial, bag: first.bag, randomState: first.randomState, hintsUsed: 0 };

package/dist/falling-triplets/input.js

@@ -38,4 +38,5 @@ export function actionsForTick(state) {
     return [actions, { held, queued: [] }];
 }
 /** Releases every held action after blur, pause, or pointer cancellation. */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- the public signature takes the state a caller holds, though nothing of it is kept
 export function releaseAllActions(state) { return { held: {}, queued: [] }; }

package/dist/gem-swap/engine.js

@@ -418,7 +418,7 @@ function awardTools(state, removed) {
         return { inventory: state.inventory, progress: state.toolProgress, cursor: state.toolAwardCursor, events: Object.freeze([]) };
     let progress = state.toolProgress + removed;
     let cursor = state.toolAwardCursor;
-    let inventory = { ...state.inventory };
+    const inventory = { ...state.inventory };
     const events = [];
     while (progress >= 12) {
         progress -= 12;

package/dist/gem-swap/specials.js

@@ -211,7 +211,7 @@ function comboPlan(state, p, q, protectedCells, pairIds) {
     return null;
 }
 function effectCells(state, cell, kind) {
-    const { width, height } = state.settings;
+    const { width } = state.settings;
     const x = cell % width;
     const y = Math.floor(cell / width);
     if (kind === 'row-beam')

package/dist/gem-swap/tools.js

@@ -1,7 +1,7 @@
 import { planWave } from './specials.js';
 /** Computes the occupied cells affected by a tool and all special activations it causes. */
 export function previewTool(state, tool, target) {
-    const { width, height, mask } = state.settings;
+    const { width, mask } = state.settings;
     if (!Number.isInteger(target) || target < 0 || target >= state.board.length || !mask[target] || !state.board[target])
         return Object.freeze([]);
     const x = target % width;

package/dist/magnetic-blocks/content-data.d.ts

@@ -0,0 +1,3 @@
+import type { MagneticContentData } from './content-types.js';
+/** Generated by scripts/magnetic-blocks-levels.mjs. */
+export declare const contentData: MagneticContentData;