@logic-pad/core 0.6.1 → 0.9.0

package/assets/logic-core.global.d.ts

@@ -29,6 +29,7 @@ declare global {
     MusicGrid = 'music',
     CompletePattern = 'complete_pattern',
     Underclued = 'underclued',
+    WrapAround = 'wrap_around',
   }
   export declare enum State {
     /**
@@ -81,6 +82,13 @@ declare global {
     AtMost = 'le',
   }
   export declare const COMPARISONS: readonly Comparison[];
+  export declare enum Wrapping {
+    None = 'none',
+    Wrap = 'wrap',
+    WrapReverse = 'wrap-reverse',
+    ReflectReverse = 'reflect-reverse',
+  }
+  export declare const WRAPPINGS: readonly Wrapping[];
   export declare enum Direction {
     Up = 'up',
     Down = 'down',
@@ -632,6 +640,43 @@ declare global {
     get validateWithSolution(): boolean;
     get isSingleton(): boolean;
   }
+  export interface GetTileHandler {
+    onGetTile(x: number, y: number, grid: GridData): Position$1;
+  }
+  export declare function handlesGetTile<T extends Instruction>(
+    val: T
+  ): val is T & GetTileHandler;
+  export declare class WrapAroundRule extends Rule implements GetTileHandler {
+    readonly horizontal: Wrapping;
+    readonly vertical: Wrapping;
+    private static readonly EXAMPLE_GRID_NONE;
+    private static readonly EXAMPLE_GRID_HORIZONTAL;
+    private static readonly EXAMPLE_GRID_VERTICAL;
+    private static readonly SEARCH_VARIANTS;
+    private static readonly CONFIGS;
+    /**
+     * **The left and right edges are connected (in reverse)**
+     *
+     * @param horizontal - The horizontal wrapping.
+     * @param vertical - The vertical wrapping.
+     */
+    constructor(horizontal: Wrapping, vertical: Wrapping);
+    onGetTile(x: number, y: number, grid: GridData): Position$1;
+    get id(): string;
+    get explanation(): string;
+    createExampleGrid(): GridData;
+    get configs(): readonly AnyConfig[] | null;
+    get searchVariants(): SearchVariant[];
+    validateGrid(grid: GridData): RuleState;
+    copyWith({
+      horizontal,
+      vertical,
+    }: {
+      horizontal?: Wrapping;
+      vertical?: Wrapping;
+    }): this;
+    get isSingleton(): boolean;
+  }
   export declare const NEIGHBOR_OFFSETS: Position$1[];
   export declare class GridData {
     readonly width: number;
@@ -644,6 +689,7 @@ declare global {
     readonly musicGrid: CachedAccess<MusicGridRule | undefined>;
     readonly completePattern: CachedAccess<CompletePatternRule | undefined>;
     readonly underclued: CachedAccess<UndercluedRule | undefined>;
+    readonly wrapAround: CachedAccess<WrapAroundRule | undefined>;
     /**
      * Create a new grid with tiles, connections, symbols and rules.
      *
@@ -742,6 +788,7 @@ declare global {
       symbols?: ReadonlyMap<string, readonly Symbol$1[]>;
       rules?: readonly Rule[];
     }): GridData;
+    toArrayCoordinates(x: number, y: number): Position$1;
     isPositionValid(x: number, y: number): boolean;
     /**
      * Safely get the tile at the given position.
@@ -934,12 +981,20 @@ declare global {
      * @param position The position to start the iteration from. This position is included in the iteration.
      * @param predicate The predicate to test each tile with. The callback is only called for tiles that satisfy this predicate.
      * @param callback The callback to call for each tile that satisfies the predicate. The iteration stops when this callback returns a value that is not undefined.
+     * @param visited A 2D array to keep track of visited tiles. This array is modified by the function.
      * @returns The value returned by the callback that stopped the iteration, or undefined if the iteration completed.
      */
     iterateArea<T>(
       position: Position$1,
       predicate: (tile: TileData) => boolean,
-      callback: (tile: TileData, x: number, y: number) => undefined | T
+      callback: (
+        tile: TileData,
+        x: number,
+        y: number,
+        logicalX: number,
+        logicalY: number
+      ) => undefined | T,
+      visited?: boolean[][]
     ): T | undefined;
     /**
      * Iterate over all tiles in a straight line from the given position in the given direction that satisfy the predicate.
@@ -950,13 +1005,21 @@ declare global {
      * @param direction The direction to iterate in.
      * @param predicate The predicate to test each tile with. The callback is only called for tiles that satisfy this predicate.
      * @param callback The callback to call for each tile that satisfies the predicate. The iteration stops when this callback returns a value that is not undefined.
+     * @param visited A 2D array to keep track of visited tiles. This array is modified by the function.
      * @returns The value returned by the callback that stopped the iteration, or undefined if the iteration completed.
      */
     iterateDirection<T>(
       position: Position$1,
       direction: Direction | Orientation,
       predicate: (tile: TileData) => boolean,
-      callback: (tile: TileData, x: number, y: number) => T | undefined
+      callback: (
+        tile: TileData,
+        x: number,
+        y: number,
+        logicalX: number,
+        logicalY: number
+      ) => T | undefined,
+      visited?: boolean[][]
     ): T | undefined;
     /**
      * Iterate over all tiles in a straight line from the given position in the given direction that satisfy the predicate.
@@ -967,13 +1030,21 @@ declare global {
      * @param direction The direction to iterate in.
      * @param predicate The predicate to test each tile with. The callback is only called for tiles that satisfy this predicate.
      * @param callback The callback to call for each tile that satisfies the predicate. The iteration stops when this callback returns a value that is not undefined.
+     * @param visited A 2D array to keep track of visited tiles. This array is modified by the function.
      * @returns The value returned by the callback that stopped the iteration, or undefined if the iteration completed.
      */
     iterateDirectionAll<T>(
       position: Position$1,
       direction: Direction | Orientation,
       predicate: (tile: TileData) => boolean,
-      callback: (tile: TileData, x: number, y: number) => T | undefined
+      callback: (
+        tile: TileData,
+        x: number,
+        y: number,
+        logicalX: number,
+        logicalY: number
+      ) => T | undefined,
+      visited?: boolean[][]
     ): T | undefined;
     /**
      * Check if every tile in the grid is filled with a color other than gray.
@@ -1125,6 +1196,7 @@ declare global {
     String = 'string',
     Color = 'color',
     Comparison = 'comparison',
+    Wrapping = 'wrapping',
     Direction = 'direction',
     DirectionToggle = 'directionToggle',
     Orientation = 'orientation',
@@ -1174,6 +1246,9 @@ declare global {
   export interface ComparisonConfig extends Config<Comparison> {
     readonly type: ConfigType.Comparison;
   }
+  export interface WrappingConfig extends Config<Wrapping> {
+    readonly type: ConfigType.Wrapping;
+  }
   export interface DirectionConfig extends Config<Direction> {
     readonly type: ConfigType.Direction;
   }
@@ -1217,6 +1292,7 @@ declare global {
     | StringConfig
     | ColorConfig
     | ComparisonConfig
+    | WrappingConfig
     | DirectionConfig
     | DirectionToggleConfig
     | OrientationConfig
@@ -1957,9 +2033,6 @@ declare global {
     stringifyPuzzle(puzzle: Puzzle): string;
     parsePuzzle(input: string): Puzzle;
   }
-  export interface CancelRef {
-    cancel?: () => void;
-  }
   /**
    * Base class that all solvers must extend.
    */
@@ -1970,10 +2043,18 @@ declare global {
      * This is also displayed to the user when selecting a solver.
      */
     abstract get id(): string;
+    /**
+     * The author(s) of the solver.
+     */
+    abstract get author(): string;
     /**
      * A short paragraph describing when the user should use this solver.
      */
     abstract get description(): string;
+    /**
+     * Whether the solver supports cancellation. If `true`, the solver must respond to the abort signal if it is provided.
+     */
+    abstract get supportsCancellation(): boolean;
     /**
      * Solve the given grid. The implementation should delegate long-running tasks to a worker thread and yield solutions
      * asynchronously.
@@ -1989,12 +2070,12 @@ declare global {
      *
      * @param grid The grid to solve. The provided grid is guaranteed to be supported by the solver. Some tiles in the
      * grid may already be filled by the user. It is up to the solver to decide whether to respect these tiles or not.
-     * @param cancelRef A reference to a function that can be called to cancel the solver. If cancellation is supported,
-     * the solver can assign a function to `cancelRef.cancel` that will stop the solver when called.
+     * @param abortSignal An optional signal that the solver should subscribe to in order to cancel the operation. If the
+     * solver does not support cancellation, it should ignore this parameter.
      */
     abstract solve(
       grid: GridData,
-      cancelRef: CancelRef
+      abortSignal?: AbortSignal
     ): AsyncGenerator<GridData | null>;
     /**
      * Check if the solver supports the current browser environment. This method is called once when the user first clicks
@@ -2027,15 +2108,17 @@ declare global {
   }
   export declare const allSolvers: Map<string, Solver>;
   export declare abstract class EventIteratingSolver extends Solver {
+    readonly supportsCancellation = true;
     protected abstract createWorker(): Worker;
     solve(
       grid: GridData,
-      cancelRef: CancelRef
+      abortSignal?: AbortSignal
     ): AsyncGenerator<GridData | null>;
   }
   export declare class BacktrackSolver extends EventIteratingSolver {
     private static readonly supportedInstrs;
     readonly id = 'backtrack';
+    readonly author = 'ALaggyDev';
     readonly description =
       'Solves puzzles using backtracking with optimizations (blazingly fast). Support most rules and symbols (including underclued).';
     protected createWorker(): Worker;
@@ -2280,6 +2363,43 @@ declare global {
       y: number
     ): Position$1 | null;
   }
+  export declare class FocusSymbol extends NumberSymbol {
+    private static readonly CONFIGS;
+    private static readonly EXAMPLE_GRID;
+    /**
+     * **Focus Numbers count directly adjacent cells of the same color**
+     * @param x - The x-coordinate of the symbol.
+     * @param y - The y-coordinate of the symbol.
+     * @param number - The focus number.
+     */
+    constructor(x: number, y: number, number: number);
+    get id(): string;
+    get placementStep(): number;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    countTiles(grid: GridData): {
+      completed: number;
+      possible: number;
+    };
+    copyWith({
+      x,
+      y,
+      number,
+    }: {
+      x?: number;
+      y?: number;
+      number?: number;
+    }): this;
+    withNumber(number: number): this;
+  }
+  export declare class FocusBTModule extends BTModule {
+    instr: FocusSymbol;
+    private cachedCheckResult?;
+    constructor(instr: FocusSymbol);
+    checkGlobal(grid: BTGridData): CheckResult | false;
+    private buildCheckAndRating;
+  }
   export declare class GalaxySymbol extends DirectionLinkerSymbol {
     readonly x: number;
     readonly y: number;
@@ -2387,7 +2507,7 @@ declare global {
     private static readonly CONFIGS;
     private static readonly EXAMPLE_GRID;
     /**
-     * **Minesweeper numbers count opposite cells in 8 adjacent spaces**
+     * **Minesweeper Numbers count opposite cells in 8 adjacent spaces**
      *
      * @param x - The x-coordinate of the symbol.
      * @param y - The y-coordinate of the symbol.
@@ -2511,6 +2631,7 @@ declare global {
   }
   export declare class UniversalSolver extends EventIteratingSolver {
     readonly id = 'universal';
+    readonly author = 'romain22222, Lysine';
     readonly description =
       'A backtracking solver that supports all rules and symbols (including underclued) but is less optimized.';
     protected createWorker(): Worker;
@@ -2601,8 +2722,10 @@ declare global {
   ): import('grilops').Direction;
   export declare class Z3Solver extends Solver {
     readonly id = 'z3';
+    readonly author = 'Lysine';
     readonly description =
       'Good for confirming that a solution is unique, especially for larger puzzles. It is otherwise slower than most solvers in small to medium-sized puzzles.';
+    readonly supportsCancellation = false;
     isEnvironmentSupported(): Promise<boolean>;
     solve(grid: GridData): AsyncGenerator<GridData | null>;
     isInstructionSupported(instructionId: string): boolean;

package/dist/data/config.d.ts

@@ -1,5 +1,5 @@
 import GridData from './grid.js';
-import { Color, Comparison, Direction, DirectionToggle, Orientation, OrientationToggle, Position } from './primitives.js';
+import { Color, Comparison, Direction, DirectionToggle, Orientation, OrientationToggle, Position, Wrapping } from './primitives.js';
 import { ControlLine } from './rules/musicControlLine.js';
 export declare enum ConfigType {
     Boolean = "boolean",
@@ -9,6 +9,7 @@ export declare enum ConfigType {
     String = "string",
     Color = "color",
     Comparison = "comparison",
+    Wrapping = "wrapping",
     Direction = "direction",
     DirectionToggle = "directionToggle",
     Orientation = "orientation",
@@ -58,6 +59,9 @@ export interface ColorConfig extends Config<Color> {
 export interface ComparisonConfig extends Config<Comparison> {
     readonly type: ConfigType.Comparison;
 }
+export interface WrappingConfig extends Config<Wrapping> {
+    readonly type: ConfigType.Wrapping;
+}
 export interface DirectionConfig extends Config<Direction> {
     readonly type: ConfigType.Direction;
 }
@@ -93,7 +97,7 @@ export interface NullableNoteConfig extends Config<string | null> {
 export interface SolvePathConfig extends Config<Position[]> {
     readonly type: ConfigType.SolvePath;
 }
-export type AnyConfig = BooleanConfig | NullableBooleanConfig | NumberConfig | NullableNumberConfig | StringConfig | ColorConfig | ComparisonConfig | DirectionConfig | DirectionToggleConfig | OrientationConfig | OrientationToggleConfig | TileConfig | GridConfig | NullableGridConfig | IconConfig | ControlLinesConfig | NullableNoteConfig | SolvePathConfig;
+export type AnyConfig = BooleanConfig | NullableBooleanConfig | NumberConfig | NullableNumberConfig | StringConfig | ColorConfig | ComparisonConfig | WrappingConfig | DirectionConfig | DirectionToggleConfig | OrientationConfig | OrientationToggleConfig | TileConfig | GridConfig | NullableGridConfig | IconConfig | ControlLinesConfig | NullableNoteConfig | SolvePathConfig;
 /**
  * Compare two config values for equality, using an appropriate method for the config type.
  *

package/dist/data/config.js

@@ -8,6 +8,7 @@ export var ConfigType;
     ConfigType["String"] = "string";
     ConfigType["Color"] = "color";
     ConfigType["Comparison"] = "comparison";
+    ConfigType["Wrapping"] = "wrapping";
     ConfigType["Direction"] = "direction";
     ConfigType["DirectionToggle"] = "directionToggle";
     ConfigType["Orientation"] = "orientation";

package/dist/data/events/onGetTile.d.ts

@@ -0,0 +1,7 @@
+import Instruction from '../instruction.js';
+import { Position } from '../primitives.js';
+import GridData from '../grid.js';
+export interface GetTileHandler {
+    onGetTile(x: number, y: number, grid: GridData): Position;
+}
+export declare function handlesGetTile<T extends Instruction>(val: T): val is T & GetTileHandler;

package/dist/data/events/onGetTile.js

@@ -0,0 +1,4 @@
+import { isEventHandler } from './eventHelper.js';
+export function handlesGetTile(val) {
+    return isEventHandler(val, 'onGetTile');
+}

package/dist/data/grid.d.ts

@@ -8,6 +8,7 @@ import MusicGridRule from './rules/musicGridRule.js';
 import CompletePatternRule from './rules/completePatternRule.js';
 import UndercluedRule from './rules/undercluedRule.js';
 import GridZones from './gridZones.js';
+import WrapAroundRule from './rules/wrapAroundRule.js';
 export declare const NEIGHBOR_OFFSETS: Position[];
 export default class GridData {
     readonly width: number;
@@ -20,6 +21,7 @@ export default class GridData {
     readonly musicGrid: CachedAccess<MusicGridRule | undefined>;
     readonly completePattern: CachedAccess<CompletePatternRule | undefined>;
     readonly underclued: CachedAccess<UndercluedRule | undefined>;
+    readonly wrapAround: CachedAccess<WrapAroundRule | undefined>;
     /**
      * Create a new grid with tiles, connections, symbols and rules.
      *
@@ -86,6 +88,7 @@ export default class GridData {
         symbols?: ReadonlyMap<string, readonly Symbol[]>;
         rules?: readonly Rule[];
     }): GridData;
+    toArrayCoordinates(x: number, y: number): Position;
     isPositionValid(x: number, y: number): boolean;
     /**
      * Safely get the tile at the given position.
@@ -255,9 +258,10 @@ export default class GridData {
      * @param position The position to start the iteration from. This position is included in the iteration.
      * @param predicate The predicate to test each tile with. The callback is only called for tiles that satisfy this predicate.
      * @param callback The callback to call for each tile that satisfies the predicate. The iteration stops when this callback returns a value that is not undefined.
+     * @param visited A 2D array to keep track of visited tiles. This array is modified by the function.
      * @returns The value returned by the callback that stopped the iteration, or undefined if the iteration completed.
      */
-    iterateArea<T>(position: Position, predicate: (tile: TileData) => boolean, callback: (tile: TileData, x: number, y: number) => undefined | T): T | undefined;
+    iterateArea<T>(position: Position, predicate: (tile: TileData) => boolean, callback: (tile: TileData, x: number, y: number, logicalX: number, logicalY: number) => undefined | T, visited?: boolean[][]): T | undefined;
     /**
      * Iterate over all tiles in a straight line from the given position in the given direction that satisfy the predicate.
      * The iteration stops when the callback returns a value that is not undefined.
@@ -267,9 +271,10 @@ export default class GridData {
      * @param direction The direction to iterate in.
      * @param predicate The predicate to test each tile with. The callback is only called for tiles that satisfy this predicate.
      * @param callback The callback to call for each tile that satisfies the predicate. The iteration stops when this callback returns a value that is not undefined.
+     * @param visited A 2D array to keep track of visited tiles. This array is modified by the function.
      * @returns The value returned by the callback that stopped the iteration, or undefined if the iteration completed.
      */
-    iterateDirection<T>(position: Position, direction: Direction | Orientation, predicate: (tile: TileData) => boolean, callback: (tile: TileData, x: number, y: number) => T | undefined): T | undefined;
+    iterateDirection<T>(position: Position, direction: Direction | Orientation, predicate: (tile: TileData) => boolean, callback: (tile: TileData, x: number, y: number, logicalX: number, logicalY: number) => T | undefined, visited?: boolean[][]): T | undefined;
     /**
      * Iterate over all tiles in a straight line from the given position in the given direction that satisfy the predicate.
      * The iteration stops when the callback returns a value that is not undefined.
@@ -279,9 +284,10 @@ export default class GridData {
      * @param direction The direction to iterate in.
      * @param predicate The predicate to test each tile with. The callback is only called for tiles that satisfy this predicate.
      * @param callback The callback to call for each tile that satisfies the predicate. The iteration stops when this callback returns a value that is not undefined.
+     * @param visited A 2D array to keep track of visited tiles. This array is modified by the function.
      * @returns The value returned by the callback that stopped the iteration, or undefined if the iteration completed.
      */
-    iterateDirectionAll<T>(position: Position, direction: Direction | Orientation, predicate: (tile: TileData) => boolean, callback: (tile: TileData, x: number, y: number) => T | undefined): T | undefined;
+    iterateDirectionAll<T>(position: Position, direction: Direction | Orientation, predicate: (tile: TileData) => boolean, callback: (tile: TileData, x: number, y: number, logicalX: number, logicalY: number) => T | undefined, visited?: boolean[][]): T | undefined;
     /**
      * Check if every tile in the grid is filled with a color other than gray.
      *

package/dist/data/grid.js

@@ -88,6 +88,12 @@ export default class GridData {
             writable: true,
             value: CachedAccess.of(() => this.findRule(rule => rule.id === MajorRule.Underclued))
         });
+        Object.defineProperty(this, "wrapAround", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: CachedAccess.of(() => this.findRule(rule => rule.id === MajorRule.WrapAround))
+        });
         this.width = width;
         this.height = height;
         this.tiles = tiles ?? array(width, height, () => TileData.empty());
@@ -141,7 +147,30 @@ export default class GridData {
     fastCopyWith({ width, height, tiles, connections, zones, symbols, rules, }) {
         return new GridData(width ?? this.width, height ?? this.height, tiles ?? this.tiles, connections ?? this.connections, zones ?? this.zones, symbols ?? this.symbols, rules ?? this.rules);
     }
+    toArrayCoordinates(x, y) {
+        // // This is the preferred way to compute tile coordinates, but for performance reasons we will just access the
+        // // wrap-around rule directly.
+        // this.rules.forEach(rule => {
+        //   if (handlesGetTile(rule)) {
+        //     ({ x, y } = rule.onGetTile(x, y));
+        //   }
+        // });
+        // this.symbols.forEach(list =>
+        //   list.forEach(symbol => {
+        //     if (handlesGetTile(symbol)) {
+        //       ({ x, y } = symbol.onGetTile(x, y));
+        //     }
+        //   })
+        // );
+        if (this.wrapAround.value) {
+            return this.wrapAround.value.onGetTile(x, y, this);
+        }
+        else {
+            return { x, y };
+        }
+    }
     isPositionValid(x, y) {
+        ({ x, y } = this.toArrayCoordinates(x, y));
         return x >= 0 && x < this.width && y >= 0 && y < this.height;
     }
     /**
@@ -151,7 +180,8 @@ export default class GridData {
      * @returns The tile at the given position, or a non-existent tile if the position is invalid.
      */
     getTile(x, y) {
-        if (!this.isPositionValid(x, y))
+        ({ x, y } = this.toArrayCoordinates(x, y));
+        if (x < 0 || x >= this.width || y < 0 || y >= this.height)
             return TileData.doesNotExist();
         return this.tiles[y][x];
     }
@@ -166,6 +196,7 @@ export default class GridData {
      * @returns The new tile array with updated tiles.
      */
     setTile(x, y, tile) {
+        ({ x, y } = this.toArrayCoordinates(x, y));
         if (x < 0 || x >= this.width || y < 0 || y >= this.height) {
             return this.tiles;
         }
@@ -173,6 +204,7 @@ export default class GridData {
         const tiles = this.tiles.map(row => [...row]);
         const newTile = typeof tile === 'function' ? tile(tiles[y][x]) : tile;
         changing.forEach(({ x, y }) => {
+            ({ x, y } = this.toArrayCoordinates(x, y));
             tiles[y][x] = tiles[y][x].withColor(newTile.color);
         });
         tiles[y][x] = newTile;
@@ -587,22 +619,23 @@ export default class GridData {
      * @param position The position to start the iteration from. This position is included in the iteration.
      * @param predicate The predicate to test each tile with. The callback is only called for tiles that satisfy this predicate.
      * @param callback The callback to call for each tile that satisfies the predicate. The iteration stops when this callback returns a value that is not undefined.
+     * @param visited A 2D array to keep track of visited tiles. This array is modified by the function.
      * @returns The value returned by the callback that stopped the iteration, or undefined if the iteration completed.
      */
-    iterateArea(position, predicate, callback) {
+    iterateArea(position, predicate, callback, visited = array(this.width, this.height, () => false)) {
         const tile = this.getTile(position.x, position.y);
         if (!tile.exists || !predicate(tile)) {
             return;
         }
-        const visited = array(this.width, this.height, () => false);
         const stack = [position];
         while (stack.length > 0) {
             const { x, y } = stack.pop();
-            if (visited[y][x]) {
+            const { x: arrX, y: arrY } = this.toArrayCoordinates(x, y);
+            if (visited[arrY][arrX]) {
                 continue;
             }
-            visited[y][x] = true;
-            const ret = callback(this.getTile(x, y), x, y);
+            visited[arrY][arrX] = true;
+            const ret = callback(this.getTile(x, y), arrX, arrY, x, y);
             if (ret !== undefined)
                 return ret;
             for (const offset of NEIGHBOR_OFFSETS) {
@@ -624,10 +657,11 @@ export default class GridData {
      * @param direction The direction to iterate in.
      * @param predicate The predicate to test each tile with. The callback is only called for tiles that satisfy this predicate.
      * @param callback The callback to call for each tile that satisfies the predicate. The iteration stops when this callback returns a value that is not undefined.
+     * @param visited A 2D array to keep track of visited tiles. This array is modified by the function.
      * @returns The value returned by the callback that stopped the iteration, or undefined if the iteration completed.
      */
-    iterateDirection(position, direction, predicate, callback) {
-        return this.iterateDirectionAll(position, direction, tile => tile.exists && predicate(tile), callback);
+    iterateDirection(position, direction, predicate, callback, visited = array(this.width, this.height, () => false)) {
+        return this.iterateDirectionAll(position, direction, tile => tile.exists && predicate(tile), callback, visited);
     }
     /**
      * Iterate over all tiles in a straight line from the given position in the given direction that satisfy the predicate.
@@ -638,16 +672,22 @@ export default class GridData {
      * @param direction The direction to iterate in.
      * @param predicate The predicate to test each tile with. The callback is only called for tiles that satisfy this predicate.
      * @param callback The callback to call for each tile that satisfies the predicate. The iteration stops when this callback returns a value that is not undefined.
+     * @param visited A 2D array to keep track of visited tiles. This array is modified by the function.
      * @returns The value returned by the callback that stopped the iteration, or undefined if the iteration completed.
      */
-    iterateDirectionAll(position, direction, predicate, callback) {
+    iterateDirectionAll(position, direction, predicate, callback, visited = array(this.width, this.height, () => false)) {
         let current = position;
         while (this.isPositionValid(current.x, current.y)) {
+            const arrPos = this.toArrayCoordinates(current.x, current.y);
+            if (visited[arrPos.y][arrPos.x]) {
+                break;
+            }
+            visited[arrPos.y][arrPos.x] = true;
             const tile = this.getTile(current.x, current.y);
             if (!predicate(tile)) {
                 break;
             }
-            const ret = callback(tile, current.x, current.y);
+            const ret = callback(tile, arrPos.x, arrPos.y, current.x, current.y);
             if (ret !== undefined)
                 return ret;
             current = move(current, direction);

package/dist/data/primitives.d.ts

@@ -14,7 +14,8 @@ export interface Edge {
 export declare enum MajorRule {
     MusicGrid = "music",
     CompletePattern = "complete_pattern",
-    Underclued = "underclued"
+    Underclued = "underclued",
+    WrapAround = "wrap_around"
 }
 export declare enum State {
     /**
@@ -63,6 +64,13 @@ export declare enum Comparison {
     AtMost = "le"
 }
 export declare const COMPARISONS: readonly Comparison[];
+export declare enum Wrapping {
+    None = "none",
+    Wrap = "wrap",
+    WrapReverse = "wrap-reverse",
+    ReflectReverse = "reflect-reverse"
+}
+export declare const WRAPPINGS: readonly Wrapping[];
 export declare enum Direction {
     Up = "up",
     Down = "down",

package/dist/data/primitives.js

@@ -6,6 +6,7 @@ export var MajorRule;
     MajorRule["MusicGrid"] = "music";
     MajorRule["CompletePattern"] = "complete_pattern";
     MajorRule["Underclued"] = "underclued";
+    MajorRule["WrapAround"] = "wrap_around";
 })(MajorRule || (MajorRule = {}));
 export var State;
 (function (State) {
@@ -50,6 +51,19 @@ export const COMPARISONS = [
     Comparison.AtLeast,
     Comparison.AtMost,
 ];
+export var Wrapping;
+(function (Wrapping) {
+    Wrapping["None"] = "none";
+    Wrapping["Wrap"] = "wrap";
+    Wrapping["WrapReverse"] = "wrap-reverse";
+    Wrapping["ReflectReverse"] = "reflect-reverse";
+})(Wrapping || (Wrapping = {}));
+export const WRAPPINGS = [
+    Wrapping.None,
+    Wrapping.Wrap,
+    Wrapping.WrapReverse,
+    Wrapping.ReflectReverse,
+];
 export var Direction;
 (function (Direction) {
     Direction["Up"] = "up";

package/dist/data/rules/banPatternRule.js

@@ -71,10 +71,18 @@ class BanPatternRule extends Rule {
     }
     validateGrid(grid) {
         for (const pattern of this.cache) {
-            for (let y = 0; y <= grid.height - pattern.height; y++) {
-                for (let x = 0; x <= grid.width - pattern.width; x++) {
+            for (let y = 0; y <= grid.height - 1; y++) {
+                for (let x = 0; x <= grid.width - 1; x++) {
                     let match = true;
+                    const visited = [];
                     for (const tile of pattern.elements) {
+                        const pos = grid.toArrayCoordinates(x + tile.x, y + tile.y);
+                        if (grid.wrapAround.value && // optimization: not need to check visited if wrapAround is disabled
+                            visited.some(p => p.x === pos.x && p.y === pos.y)) {
+                            match = false;
+                            break;
+                        }
+                        visited.push(pos);
                         const t = grid.getTile(x + tile.x, y + tile.y);
                         if (!t.exists || t.color !== tile.color) {
                             match = false;
@@ -84,10 +92,7 @@ class BanPatternRule extends Rule {
                     if (match) {
                         return {
                             state: State.Error,
-                            positions: pattern.elements.map(tile => ({
-                                x: x + tile.x,
-                                y: y + tile.y,
-                            })),
+                            positions: pattern.elements.map(tile => grid.toArrayCoordinates(x + tile.x, y + tile.y)),
                         };
                     }
                 }