@logic-pad/core 0.24.0 → 0.25.0

package/dist/{data → src/data}/rules/musicControlLine.js

@@ -2,6 +2,40 @@ import { ConfigType } from '../config.js';
 import Configurable from '../configurable.js';
 import { Instrument } from '../primitives.js';
 export class Row extends Configurable {
+    note;
+    instrument;
+    velocity;
+    title = 'Music Grid - Row';
+    configExplanation = 'Configure the playback settings from this tile onwards.';
+    static CONFIGS = Object.freeze([
+        {
+            type: ConfigType.NullableNote,
+            default: 'C4',
+            field: 'note',
+            description: 'Note',
+            explanation: 'The musical note or sample to play.',
+            configurable: true,
+        },
+        {
+            type: ConfigType.NullableInstrument,
+            default: Instrument.Piano,
+            field: 'instrument',
+            description: 'Instrument',
+            explanation: 'The musical instrument to use. This has no effect if the current note is a drum sample.',
+            configurable: true,
+        },
+        {
+            type: ConfigType.NullableNumber,
+            default: 0.5,
+            min: 0,
+            max: 1,
+            step: 0.2,
+            field: 'velocity',
+            description: 'Velocity',
+            explanation: 'The volume to play the note at.',
+            configurable: true,
+        },
+    ]);
     constructor(
     /**
      * The note to play at this row, or null to keep the current note from the previous control line.
@@ -20,36 +54,9 @@ export class Row extends Configurable {
      */
     velocity) {
         super();
-        Object.defineProperty(this, "note", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: note
-        });
-        Object.defineProperty(this, "instrument", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: instrument
-        });
-        Object.defineProperty(this, "velocity", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: velocity
-        });
-        Object.defineProperty(this, "title", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'Music Grid - Row'
-        });
-        Object.defineProperty(this, "configExplanation", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'Configure the playback settings from this tile onwards.'
-        });
+        this.note = note;
+        this.instrument = instrument;
+        this.velocity = velocity;
         this.note = note;
         this.instrument = instrument;
         this.velocity = velocity;
@@ -61,41 +68,42 @@ export class Row extends Configurable {
         return new Row(note !== undefined ? note : this.note, instrument !== undefined ? instrument : this.instrument, velocity !== undefined ? velocity : this.velocity);
     }
 }
-Object.defineProperty(Row, "CONFIGS", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: Object.freeze([
+export class ControlLine extends Configurable {
+    column;
+    bpm;
+    pedal;
+    checkpoint;
+    rows;
+    title = 'Music Grid - Control Line';
+    configExplanation = 'Configure the playback settings from this point onwards.';
+    static CONFIGS = Object.freeze([
         {
-            type: ConfigType.NullableNote,
-            default: 'C4',
-            field: 'note',
-            description: 'Note',
-            explanation: 'The musical note or sample to play.',
+            type: ConfigType.NullableNumber,
+            default: 120,
+            min: 20,
+            max: 1000,
+            field: 'bpm',
+            description: 'BPM',
+            explanation: 'Beats per minute for the playback.',
             configurable: true,
         },
         {
-            type: ConfigType.NullableInstrument,
-            default: Instrument.Piano,
-            field: 'instrument',
-            description: 'Instrument',
-            explanation: 'The musical instrument to use. This has no effect if the current note is a drum sample.',
+            type: ConfigType.NullableBoolean,
+            default: false,
+            field: 'pedal',
+            description: 'Pedal',
+            explanation: 'For piano notes, whether the pedal is pressed to sustain the sound.',
             configurable: true,
         },
         {
-            type: ConfigType.NullableNumber,
-            default: 0.5,
-            min: 0,
-            max: 1,
-            step: 0.2,
-            field: 'velocity',
-            description: 'Velocity',
-            explanation: 'The volume to play the note at.',
+            type: ConfigType.Boolean,
+            default: false,
+            field: 'checkpoint',
+            description: 'Checkpoint',
+            explanation: 'Whether players can start playback from this position.',
             configurable: true,
         },
-    ])
-});
-export class ControlLine extends Configurable {
+    ]);
     /**
      * Configure playback settings, taking effect at the given column (inclusive)
      * @param column The column at which the settings take effect
@@ -106,48 +114,11 @@ export class ControlLine extends Configurable {
      */
     constructor(column, bpm, pedal, checkpoint, rows) {
         super();
-        Object.defineProperty(this, "column", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: column
-        });
-        Object.defineProperty(this, "bpm", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: bpm
-        });
-        Object.defineProperty(this, "pedal", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: pedal
-        });
-        Object.defineProperty(this, "checkpoint", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: checkpoint
-        });
-        Object.defineProperty(this, "rows", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: rows
-        });
-        Object.defineProperty(this, "title", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'Music Grid - Control Line'
-        });
-        Object.defineProperty(this, "configExplanation", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'Configure the playback settings from this point onwards.'
-        });
+        this.column = column;
+        this.bpm = bpm;
+        this.pedal = pedal;
+        this.checkpoint = checkpoint;
+        this.rows = rows;
         this.column = Math.floor(column);
         this.bpm = bpm;
         this.pedal = pedal;
@@ -193,37 +164,4 @@ export class ControlLine extends Configurable {
             !this.rows.some(row => row.note !== null || row.velocity !== null));
     }
 }
-Object.defineProperty(ControlLine, "CONFIGS", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: Object.freeze([
-        {
-            type: ConfigType.NullableNumber,
-            default: 120,
-            min: 20,
-            max: 1000,
-            field: 'bpm',
-            description: 'BPM',
-            explanation: 'Beats per minute for the playback.',
-            configurable: true,
-        },
-        {
-            type: ConfigType.NullableBoolean,
-            default: false,
-            field: 'pedal',
-            description: 'Pedal',
-            explanation: 'For piano notes, whether the pedal is pressed to sustain the sound.',
-            configurable: true,
-        },
-        {
-            type: ConfigType.Boolean,
-            default: false,
-            field: 'checkpoint',
-            description: 'Checkpoint',
-            explanation: 'Whether players can start playback from this position.',
-            configurable: true,
-        },
-    ])
-});
 export const instance = undefined;

package/dist/{data → src/data}/rules/musicGridRule.js

@@ -15,10 +15,49 @@ const DEFAULT_SCALE = [
     new Row('D4', Instrument.Piano, null),
     new Row('C4', Instrument.Piano, null),
 ];
-class MusicGridRule extends Rule {
+export default class MusicGridRule extends Rule {
+    controlLines;
+    track;
+    normalizeVelocity;
+    title = 'Music Grid';
     get configExplanation() {
         return 'Solve the grid by listening to the solution being played back.';
     }
+    static EXAMPLE_GRID = Object.freeze(GridData.create(['.']).addSymbol(new CustomIconSymbol('', GridData.create([]), 0, 0, 'MdMusicNote')));
+    static CONFIGS = Object.freeze([
+        {
+            type: ConfigType.ControlLines,
+            default: [new ControlLine(0, 120, false, false, DEFAULT_SCALE)],
+            field: 'controlLines',
+            description: 'Control Lines',
+            configurable: false,
+        },
+        {
+            type: ConfigType.NullableGrid,
+            default: null,
+            nonNullDefault: GridData.create([
+                'wwwww',
+                'wwwww',
+                'wwwww',
+                'wwwww',
+            ]).addRule(new MusicGridRule([new ControlLine(0, 120, false, false, DEFAULT_SCALE)], null)),
+            field: 'track',
+            description: 'Track',
+            explanation: 'If set, this grid will be played instead of the solution.',
+            configurable: true,
+        },
+        {
+            type: ConfigType.Boolean,
+            default: true,
+            field: 'normalizeVelocity',
+            description: 'Normalize Velocity',
+            explanation: 'Whether to adjust note velocities by their pitch such that every note has the same perceived loudness.',
+            configurable: true,
+        },
+    ]);
+    static SEARCH_VARIANTS = [
+        new MusicGridRule([new ControlLine(0, 120, false, false, DEFAULT_SCALE)], null).searchVariant(),
+    ];
     /**
      * **Music Grid: Listen to the solution**
      * @param controlLines Denote changes in the playback settings. At least one control line at column 0 should be present to enable playback.
@@ -27,30 +66,9 @@ class MusicGridRule extends Rule {
      */
     constructor(controlLines, track, normalizeVelocity = true) {
         super();
-        Object.defineProperty(this, "controlLines", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: controlLines
-        });
-        Object.defineProperty(this, "track", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: track
-        });
-        Object.defineProperty(this, "normalizeVelocity", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: normalizeVelocity
-        });
-        Object.defineProperty(this, "title", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'Music Grid'
-        });
+        this.controlLines = controlLines;
+        this.track = track;
+        this.normalizeVelocity = normalizeVelocity;
         this.controlLines = MusicGridRule.deduplicateControlLines(controlLines);
         this.track = track;
         this.normalizeVelocity = normalizeVelocity;
@@ -191,55 +209,4 @@ class MusicGridRule extends Rule {
         return Array.from(columns.values()).map(lines => lines.length > 1 ? MusicGridRule.mergeControlLines(...lines) : lines[0]);
     }
 }
-Object.defineProperty(MusicGridRule, "EXAMPLE_GRID", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: Object.freeze(GridData.create(['.']).addSymbol(new CustomIconSymbol('', GridData.create([]), 0, 0, 'MdMusicNote')))
-});
-Object.defineProperty(MusicGridRule, "CONFIGS", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: Object.freeze([
-        {
-            type: ConfigType.ControlLines,
-            default: [new ControlLine(0, 120, false, false, DEFAULT_SCALE)],
-            field: 'controlLines',
-            description: 'Control Lines',
-            configurable: false,
-        },
-        {
-            type: ConfigType.NullableGrid,
-            default: null,
-            nonNullDefault: GridData.create([
-                'wwwww',
-                'wwwww',
-                'wwwww',
-                'wwwww',
-            ]).addRule(new MusicGridRule([new ControlLine(0, 120, false, false, DEFAULT_SCALE)], null)),
-            field: 'track',
-            description: 'Track',
-            explanation: 'If set, this grid will be played instead of the solution.',
-            configurable: true,
-        },
-        {
-            type: ConfigType.Boolean,
-            default: true,
-            field: 'normalizeVelocity',
-            description: 'Normalize Velocity',
-            explanation: 'Whether to adjust note velocities by their pitch such that every note has the same perceived loudness.',
-            configurable: true,
-        },
-    ])
-});
-Object.defineProperty(MusicGridRule, "SEARCH_VARIANTS", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: [
-        new MusicGridRule([new ControlLine(0, 120, false, false, DEFAULT_SCALE)], null).searchVariant(),
-    ]
-});
-export default MusicGridRule;
 export const instance = new MusicGridRule([new ControlLine(0, 120, false, false, DEFAULT_SCALE)], null);

package/dist/{data → src/data}/rules/mysteryRule.js

@@ -4,33 +4,43 @@ import { array } from '../dataHelper.js';
 import { Color, State } from '../primitives.js';
 import CustomTextSymbol from '../symbols/customTextSymbol.js';
 import Rule from './rule.js';
-class MysteryRule extends Rule {
+export default class MysteryRule extends Rule {
+    solution;
+    visible;
+    title = 'Alternate Solution';
     get configExplanation() {
         return 'You may use multiple instances of this rule to provide multiple alternate solutions.';
     }
+    static EXAMPLE_GRID = Object.freeze(GridData.create(['.']).addSymbol(new CustomTextSymbol('', GridData.create([]), 0, 0, '?')));
+    static CONFIGS = Object.freeze([
+        {
+            type: ConfigType.Tile,
+            default: MysteryRule.EXAMPLE_GRID,
+            resizable: false,
+            field: 'solution',
+            description: 'Solution',
+            explanation: 'The alternate solution to the puzzle. Does not need to satisfy puzzle rules / symbols.',
+            configurable: true,
+        },
+        {
+            type: ConfigType.Boolean,
+            default: true,
+            field: 'visible',
+            description: 'Visible',
+            explanation: 'Display this rule to the player.',
+            configurable: true,
+        },
+    ]);
+    static SEARCH_VARIANTS = [
+        new MysteryRule(MysteryRule.EXAMPLE_GRID, true).searchVariant(),
+    ];
     /**
      * **Mystery: alternate solution**
      */
     constructor(solution, visible) {
         super();
-        Object.defineProperty(this, "solution", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: solution
-        });
-        Object.defineProperty(this, "visible", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: visible
-        });
-        Object.defineProperty(this, "title", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'Alternate Solution'
-        });
+        this.solution = solution;
+        this.visible = visible;
         this.solution = MysteryRule.cleanSolution(solution);
         this.visible = visible;
     }
@@ -133,43 +143,4 @@ class MysteryRule extends Rule {
         return GridData.create(baseGrid?.width ?? solution.width, baseGrid?.height ?? solution.height, tiles);
     }
 }
-Object.defineProperty(MysteryRule, "EXAMPLE_GRID", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: Object.freeze(GridData.create(['.']).addSymbol(new CustomTextSymbol('', GridData.create([]), 0, 0, '?')))
-});
-Object.defineProperty(MysteryRule, "CONFIGS", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: Object.freeze([
-        {
-            type: ConfigType.Tile,
-            default: MysteryRule.EXAMPLE_GRID,
-            resizable: false,
-            field: 'solution',
-            description: 'Solution',
-            explanation: 'The alternate solution to the puzzle. Does not need to satisfy puzzle rules / symbols.',
-            configurable: true,
-        },
-        {
-            type: ConfigType.Boolean,
-            default: true,
-            field: 'visible',
-            description: 'Visible',
-            explanation: 'Display this rule to the player.',
-            configurable: true,
-        },
-    ])
-});
-Object.defineProperty(MysteryRule, "SEARCH_VARIANTS", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: [
-        new MysteryRule(MysteryRule.EXAMPLE_GRID, true).searchVariant(),
-    ]
-});
-export default MysteryRule;
 export const instance = new MysteryRule(GridData.create([]), true);

package/dist/src/data/rules/noLoopsRule.d.ts

@@ -0,0 +1,29 @@
+import { AnyConfig } from '../config.js';
+import GridData from '../grid.js';
+import { Color, RuleState } from '../primitives.js';
+import Rule, { SearchVariant } from './rule.js';
+export default class NoLoopsRule extends Rule {
+    readonly color: Color;
+    readonly title = "No Loops";
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID_LIGHT;
+    private static readonly EXAMPLE_GRID_DARK;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **No loops in <color> cells**
+     *
+     * @param color - The color of the cells to check.
+     */
+    constructor(color: Color);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    copyWith({ color }: {
+        color?: Color;
+    }): this;
+    withColor(color: Color): this;
+}
+export declare const instance: NoLoopsRule;

package/dist/src/data/rules/noLoopsRule.js

@@ -0,0 +1,111 @@
+import { ConfigType } from '../config.js';
+import GridData, { NEIGHBOR_OFFSETS } from '../grid.js';
+import { array } from '../dataHelper.js';
+import { Color, State } from '../primitives.js';
+import Rule from './rule.js';
+import CustomIconSymbol from '../symbols/customIconSymbol.js';
+export default class NoLoopsRule extends Rule {
+    color;
+    title = 'No Loops';
+    static CONFIGS = Object.freeze([
+        {
+            type: ConfigType.Color,
+            default: Color.Light,
+            allowGray: false,
+            field: 'color',
+            description: 'Color',
+            configurable: true,
+        },
+    ]);
+    static EXAMPLE_GRID_LIGHT = Object.freeze(GridData.create(['bwwwb', 'bwbww', 'wwwwb', 'wbbww']).withSymbols([
+        new CustomIconSymbol('', GridData.create([]), 1, 0, 'MdClear'),
+        new CustomIconSymbol('', GridData.create([]), 2, 0, 'MdClear'),
+        new CustomIconSymbol('', GridData.create([]), 3, 0, 'MdClear'),
+        new CustomIconSymbol('', GridData.create([]), 3, 1, 'MdClear'),
+        new CustomIconSymbol('', GridData.create([]), 3, 2, 'MdClear'),
+        new CustomIconSymbol('', GridData.create([]), 2, 2, 'MdClear'),
+        new CustomIconSymbol('', GridData.create([]), 1, 2, 'MdClear'),
+        new CustomIconSymbol('', GridData.create([]), 1, 1, 'MdClear'),
+    ]));
+    static EXAMPLE_GRID_DARK = Object.freeze(NoLoopsRule.EXAMPLE_GRID_LIGHT.withTiles(tiles => tiles.map(row => row.map(tile => tile.withColor(tile.color === Color.Dark ? Color.Light : Color.Dark)))));
+    static SEARCH_VARIANTS = [
+        new NoLoopsRule(Color.Light).searchVariant(),
+        new NoLoopsRule(Color.Dark).searchVariant(),
+    ];
+    /**
+     * **No loops in <color> cells**
+     *
+     * @param color - The color of the cells to check.
+     */
+    constructor(color) {
+        super();
+        this.color = color;
+        this.color = color;
+    }
+    get id() {
+        return `no_loops`;
+    }
+    get explanation() {
+        return `*No loops* in ${this.color} cells`;
+    }
+    get configs() {
+        return NoLoopsRule.CONFIGS;
+    }
+    createExampleGrid() {
+        return this.color === Color.Light
+            ? NoLoopsRule.EXAMPLE_GRID_LIGHT
+            : NoLoopsRule.EXAMPLE_GRID_DARK;
+    }
+    get searchVariants() {
+        return NoLoopsRule.SEARCH_VARIANTS;
+    }
+    validateGrid(grid) {
+        const visited = array(grid.width, grid.height, (i, j) => !grid.getTile(i, j).exists);
+        while (true) {
+            const seed = grid.find((tile, x, y) => !visited[y][x] && tile.color === this.color);
+            if (!seed)
+                break;
+            let invalid = false;
+            const positions = [];
+            const stack = [[seed, null]];
+            while (stack.length > 0) {
+                const [{ x, y }, from] = stack.pop();
+                const { x: arrX, y: arrY } = grid.toArrayCoordinates(x, y);
+                positions.push({ x, y });
+                if (visited[arrY][arrX]) {
+                    invalid = true;
+                    continue;
+                }
+                visited[arrY][arrX] = true;
+                for (const offset of NEIGHBOR_OFFSETS) {
+                    if (-offset.x === from?.x && -offset.y === from?.y)
+                        continue;
+                    const next = { x: x + offset.x, y: y + offset.y };
+                    if (grid.isPositionValid(next.x, next.y)) {
+                        const nextTile = grid.getTile(next.x, next.y);
+                        if (nextTile.exists && nextTile.color === this.color)
+                            stack.push([next, offset]);
+                    }
+                }
+            }
+            if (invalid) {
+                return {
+                    state: State.Error,
+                    positions,
+                };
+            }
+        }
+        return {
+            state: visited.some(row => row.some(v => !v))
+                ? State.Incomplete
+                : State.Satisfied,
+        };
+    }
+    copyWith({ color }) {
+        return new NoLoopsRule(color ?? this.color);
+    }
+    withColor(color) {
+        return this.copyWith({ color });
+    }
+}
+export const instance = new NoLoopsRule(Color.Dark);