scrabble-solver 2.18.9 → 2.18.10-alpha.0

package/packages/solver/src/ReferenceSolver.ts

@@ -1,401 +0,0 @@
-/* eslint-disable max-lines */
-
-import { type Gaddag } from '@kamilmielnik/gaddag';
-import { BONUS_CHARACTER, BONUS_WORD } from '@scrabble-solver/constants';
-import {
-  type Board,
-  type Bonus,
-  type Cell,
-  type Config,
-  isMultiplierBingo,
-  isScoreBingo,
-  type Tile,
-} from '@scrabble-solver/types';
-
-interface ReferencePlacement {
-  alpha: number;
-  isBlank: boolean;
-}
-
-/**
- * Brute-force oracle: enumerates every span and rack assignment, validating and
- * scoring moves with the same semantics as MoveGenerator.
- */
-export class ReferenceSolver {
-  private readonly gaddag: Gaddag;
-  private readonly config: Config;
-  private readonly width: number;
-  private readonly height: number;
-  private readonly filled: boolean[] = [];
-  private readonly boardCharacters: string[] = [];
-  private readonly boardScores: number[] = [];
-  private readonly boardIsEmpty: boolean;
-  private readonly alphabet: string[];
-  private readonly rackCounts: number[];
-  private blanksLeft = 0;
-
-  private horizontal = true;
-  private line = 0;
-  private start = 0;
-  private end = 0;
-  private emptyPositions: number[] = [];
-  private placements: ReferencePlacement[] = [];
-  private readonly moves = new Set<string>();
-
-  constructor(gaddag: Gaddag, config: Config, board: Board, tiles: Tile[]) {
-    this.gaddag = gaddag;
-    this.config = config;
-    this.width = board.columnsCount;
-    this.height = board.rowsCount;
-
-    for (const row of board.rows) {
-      for (const cell of row) {
-        const hasTile = !cell.isEmpty && cell.hasTile();
-        this.filled.push(hasTile);
-        this.boardCharacters.push(hasTile ? cell.tile.character : '');
-        this.boardScores.push(this.boardTileScore(cell, hasTile));
-      }
-    }
-
-    this.boardIsEmpty = this.filled.every((isFilled) => !isFilled);
-    this.alphabet = config.alphabet;
-    this.rackCounts = this.alphabet.map(() => 0);
-
-    for (const tile of tiles) {
-      if (tile.isBlank) {
-        ++this.blanksLeft;
-        continue;
-      }
-
-      const alpha = this.alphabet.indexOf(tile.character);
-
-      if (alpha !== -1) {
-        ++this.rackCounts[alpha];
-      }
-    }
-  }
-
-  public solve(): string[] {
-    for (const horizontal of [true, false]) {
-      this.horizontal = horizontal;
-      this.enumerateSpans();
-    }
-
-    return [...this.moves].sort();
-  }
-
-  private enumerateSpans(): void {
-    const rackTotal = this.rackCounts.reduce((sum, count) => sum + count, this.blanksLeft);
-
-    for (let line = 0; line < this.linesCount; ++line) {
-      for (let start = 0; start < this.lineLength; ++start) {
-        for (let end = start + 1; end < this.lineLength; ++end) {
-          this.line = line;
-          this.start = start;
-          this.end = end;
-          this.trySpan(rackTotal);
-        }
-      }
-    }
-  }
-
-  private trySpan(rackTotal: number): void {
-    if (!this.isSpanMaximal()) {
-      return;
-    }
-
-    this.emptyPositions = this.spanPositions().filter((position) => !this.isFilled(position));
-
-    if (this.emptyPositions.length === 0 || this.emptyPositions.length > rackTotal) {
-      return;
-    }
-
-    this.placements = this.emptyPositions.map(() => ({ alpha: -1, isBlank: false }));
-    this.tryPlacements(0);
-  }
-
-  private isSpanMaximal(): boolean {
-    const beforeFilled = this.start > 0 && this.isFilled(this.start - 1);
-    const afterFilled = this.end < this.lineLength - 1 && this.isFilled(this.end + 1);
-    return !beforeFilled && !afterFilled;
-  }
-
-  private tryPlacements(index: number): void {
-    if (!this.gaddag.hasPrefix(this.prefixBefore(index))) {
-      return;
-    }
-
-    if (index === this.emptyPositions.length) {
-      this.tryMove();
-      return;
-    }
-
-    for (let alpha = 0; alpha < this.alphabet.length; ++alpha) {
-      if (this.rackCounts[alpha] > 0) {
-        --this.rackCounts[alpha];
-        this.placements[index] = { alpha, isBlank: false };
-        this.tryPlacements(index + 1);
-        ++this.rackCounts[alpha];
-      }
-
-      if (this.blanksLeft > 0) {
-        --this.blanksLeft;
-        this.placements[index] = { alpha, isBlank: true };
-        this.tryPlacements(index + 1);
-        ++this.blanksLeft;
-      }
-    }
-  }
-
-  private prefixBefore(index: number): string {
-    const limit = index < this.emptyPositions.length ? this.emptyPositions[index] : this.end + 1;
-    let prefix = '';
-
-    for (let position = this.start; position < limit; ++position) {
-      prefix += this.characterAt(position);
-    }
-
-    return prefix;
-  }
-
-  private tryMove(): void {
-    const characters = this.spanPositions().map((position) => this.characterAt(position));
-
-    if (!this.gaddag.has(characters.join(''))) {
-      return;
-    }
-
-    if (this.hasAdjacentDigraph(characters)) {
-      return;
-    }
-
-    if (!this.isConnected()) {
-      return;
-    }
-
-    const crossWords: string[] = [];
-
-    for (const position of this.emptyPositions) {
-      const cross = this.crossAt(position);
-
-      if (!cross) {
-        continue;
-      }
-
-      const crossWord = cross.characters.join('');
-
-      if (!this.gaddag.has(crossWord) || this.hasAdjacentDigraph(cross.characters)) {
-        return;
-      }
-
-      crossWords.push(crossWord);
-    }
-
-    this.moves.add(this.createSignature(characters.join(''), crossWords));
-  }
-
-  private hasAdjacentDigraph(characters: string[]): boolean {
-    const digraphs = this.config.twoCharacterTiles;
-    return characters.some((character, index) => index > 0 && digraphs.includes(characters[index - 1] + character));
-  }
-
-  private isConnected(): boolean {
-    if (this.boardIsEmpty) {
-      const centerLine = Math.floor((this.horizontal ? this.height : this.width) / 2);
-      const centerPosition = Math.floor((this.horizontal ? this.width : this.height) / 2);
-      return this.line === centerLine && this.start <= centerPosition && centerPosition <= this.end;
-    }
-
-    return this.emptyPositions.some((position) => this.touchesBoardTile(position));
-  }
-
-  private touchesBoardTile(position: number): boolean {
-    const x = this.xOf(position);
-    const y = this.yOf(position);
-    return (
-      this.isFilledAt(x - 1, y) || this.isFilledAt(x + 1, y) || this.isFilledAt(x, y - 1) || this.isFilledAt(x, y + 1)
-    );
-  }
-
-  private createSignature(mainWord: string, crossWords: string[]): string {
-    const placed = this.emptyPositions
-      .map((position, index) => {
-        const { alpha, isBlank } = this.placements[index];
-        return `${this.xOf(position)},${this.yOf(position)},${this.alphabet[alpha]},${isBlank ? 1 : 0}`;
-      })
-      .sort()
-      .join(' ');
-    const words = [mainWord, ...crossWords].sort().join(' ');
-    return `${placed} | ${words} | ${this.score()}`;
-  }
-
-  private score(): number {
-    let collisionsScore = 0;
-    let mainScore = 0;
-    let wordMultiplier = 1;
-
-    for (const position of this.spanPositions()) {
-      if (this.isFilled(position)) {
-        mainScore += this.boardScores[this.globalIndex(position)];
-        continue;
-      }
-
-      const placement = this.placementAt(position);
-      const bonus = this.bonusAt(position);
-      const cellWordMultiplier = bonus?.type === BONUS_WORD ? bonus.multiplier : 1;
-      const tileScore = this.tileScore(placement) * this.characterMultiplier(placement, bonus);
-      mainScore += tileScore;
-      wordMultiplier *= cellWordMultiplier;
-      const cross = this.crossAt(position);
-
-      if (cross) {
-        collisionsScore += (cross.baseScore + tileScore) * cellWordMultiplier;
-      }
-    }
-
-    return this.applyBingo(mainScore * wordMultiplier, collisionsScore);
-  }
-
-  private applyBingo(wordsScore: number, collisionsScore: number): number {
-    if (this.emptyPositions.length !== this.config.rackSize) {
-      return wordsScore + collisionsScore;
-    }
-
-    const { bingo } = this.config;
-
-    if (isScoreBingo(bingo)) {
-      return wordsScore + collisionsScore + bingo.score;
-    }
-
-    if (isMultiplierBingo(bingo)) {
-      return wordsScore * bingo.multiplier + collisionsScore;
-    }
-
-    return wordsScore + collisionsScore;
-  }
-
-  private characterMultiplier(placement: ReferencePlacement, bonus: Bonus | undefined): number {
-    if (bonus?.type !== BONUS_CHARACTER) {
-      return 1;
-    }
-
-    const characterScore = this.config.pointsMap[this.alphabet[placement.alpha]] || 0;
-
-    if (typeof bonus.score === 'number' && bonus.score !== characterScore) {
-      return 1;
-    }
-
-    return bonus.multiplier;
-  }
-
-  private tileScore({ alpha, isBlank }: ReferencePlacement): number {
-    return isBlank ? this.config.blankScore : this.config.pointsMap[this.alphabet[alpha]] || 0;
-  }
-
-  private bonusAt(position: number): Bonus | undefined {
-    const x = this.xOf(position);
-    const y = this.yOf(position);
-    return this.config.bonuses.find((bonus) => bonus.x === x && bonus.y === y);
-  }
-
-  private crossAt(position: number): { baseScore: number; characters: string[] } | undefined {
-    const dx = this.horizontal ? 0 : 1;
-    const dy = this.horizontal ? 1 : 0;
-    const [startX, startY] = this.crossRunEnd(position, -dx, -dy);
-    const [endX, endY] = this.crossRunEnd(position, dx, dy);
-
-    if (startX === endX && startY === endY) {
-      return undefined;
-    }
-
-    const characters: string[] = [];
-    let baseScore = 0;
-
-    for (let x = startX, y = startY; x <= endX && y <= endY; x += dx, y += dy) {
-      if (x === this.xOf(position) && y === this.yOf(position)) {
-        characters.push(this.characterAt(position));
-        continue;
-      }
-
-      const cellIndex = y * this.width + x;
-      baseScore += this.boardScores[cellIndex];
-      characters.push(this.boardCharacters[cellIndex]);
-    }
-
-    return { baseScore, characters };
-  }
-
-  private crossRunEnd(position: number, dx: number, dy: number): [number, number] {
-    let x = this.xOf(position);
-    let y = this.yOf(position);
-
-    while (this.isFilledAt(x + dx, y + dy)) {
-      x += dx;
-      y += dy;
-    }
-
-    return [x, y];
-  }
-
-  private boardTileScore(cell: Cell, hasTile: boolean): number {
-    if (!hasTile) {
-      return 0;
-    }
-
-    if (cell.tile.isBlank) {
-      return this.config.blankScore;
-    }
-
-    return this.config.pointsMap[cell.tile.character] || 0;
-  }
-
-  private characterAt(position: number): string {
-    if (this.isFilled(position)) {
-      return this.boardCharacters[this.globalIndex(position)];
-    }
-
-    return this.alphabet[this.placementAt(position).alpha];
-  }
-
-  private placementAt(position: number): ReferencePlacement {
-    return this.placements[this.emptyPositions.indexOf(position)];
-  }
-
-  private spanPositions(): number[] {
-    const positions: number[] = [];
-
-    for (let position = this.start; position <= this.end; ++position) {
-      positions.push(position);
-    }
-
-    return positions;
-  }
-
-  private isFilled(position: number): boolean {
-    return this.filled[this.globalIndex(position)];
-  }
-
-  private isFilledAt(x: number, y: number): boolean {
-    return x >= 0 && x < this.width && y >= 0 && y < this.height && this.filled[y * this.width + x];
-  }
-
-  private globalIndex(position: number): number {
-    return this.yOf(position) * this.width + this.xOf(position);
-  }
-
-  private get linesCount(): number {
-    return this.horizontal ? this.height : this.width;
-  }
-
-  private get lineLength(): number {
-    return this.horizontal ? this.width : this.height;
-  }
-
-  private xOf(position: number): number {
-    return this.horizontal ? position : this.line;
-  }
-
-  private yOf(position: number): number {
-    return this.horizontal ? this.line : position;
-  }
-}

package/packages/solver/src/index.ts

@@ -1 +0,0 @@
-export { solve } from './solve';

package/packages/solver/src/solve.test.ts

@@ -1,225 +0,0 @@
-/* eslint-disable max-lines */
-
-import { type Gaddag } from '@kamilmielnik/gaddag';
-import { getConfig } from '@scrabble-solver/configs';
-import { dictionaries } from '@scrabble-solver/dictionaries';
-import { Board, Game, Locale, Result, Tile } from '@scrabble-solver/types';
-
-import { solve } from './solve';
-
-const generateTiles = (characters: string[]): Tile[] => {
-  return characters.map((character) => new Tile({ character, isBlank: false }));
-};
-
-const getBestResult = ([firstResult, ...results]: Result[]): Result => {
-  return results.reduce(
-    (bestResultCandidate, result) => (result.points > bestResultCandidate.points ? result : bestResultCandidate),
-    firstResult,
-  );
-};
-
-describe('solve - pl-PL', () => {
-  const locale = Locale.PL_PL;
-  const config = getConfig(Game.Literaki, locale);
-  let gaddag: Gaddag | undefined;
-
-  beforeAll(() => {
-    return dictionaries.get(locale).then((loadedGaddag) => {
-      gaddag = loadedGaddag;
-    });
-  });
-
-  it('żyło', () => {
-    const board = Board.fromStringArray([
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '   żyło        ',
-      '               ',
-      '               ',
-      '               ',
-    ]);
-    const tiles = generateTiles(['l', 'i', 'n', 'o']);
-    const results = solve(gaddag!, config, board, tiles);
-    expect(results.length).toBe(60);
-  });
-
-  it('zmartwychwstałą x9', () => {
-    const board = Board.fromStringArray([
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '       n       ',
-      '       armia   ',
-      '       p   miot',
-      '       ośka   r',
-      '     boi  n   w',
-      ' deski   po  da',
-      ' or o    in fał',
-      ' m  twych s  ł ',
-      '               ',
-      '               ',
-    ]);
-    const tiles = generateTiles(['a', 'a', 'ą', 'r', 't', 'w', 'z']);
-    const results = solve(gaddag!, config, board, tiles);
-    const bestResult = getBestResult(results.map((result) => Result.fromJson(result, board)));
-    expect(bestResult.word).toBe('zmartwychwstałą');
-    expect(bestResult.points).toBe(682);
-  });
-
-  it('zmartwychwstałą x24', () => {
-    const board = Board.fromStringArray([
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '       ś   miot',
-      '     s piska  r',
-      '     p i      w',
-      'j  fiolę j   da',
-      'as o iw  au  ał',
-      ' mar  y   stał ',
-      'da do    ot    ',
-      'ar  ń    m     ',
-    ]);
-    const tiles = generateTiles(['ą', 'c', 'h', 't', 'w', 'w', 'z']);
-    const results = solve(gaddag!, config, board, tiles);
-    const bestResult = getBestResult(results.map((result) => Result.fromJson(result, board)));
-    expect(bestResult.word).toBe('zmartwychwstałą');
-    expect(bestResult.points).toBe(1157);
-  });
-
-  it('does not duplicate results', () => {
-    const board = Board.fromStringArray([
-      '             a ',
-      '              a',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-    ]);
-    const tiles = generateTiles(['d']);
-    const results = solve(gaddag!, config, board, tiles);
-    expect(results.length).toBe(4);
-  });
-});
-
-describe('solve - es-ES', () => {
-  const locale = Locale.ES_ES;
-  const config = getConfig(Game.Scrabble, locale);
-  let gaddag: Gaddag | undefined;
-
-  beforeAll(() => {
-    return dictionaries.get(locale).then((loadedGaddag) => {
-      gaddag = loadedGaddag;
-    });
-  });
-
-  it('llana', () => {
-    const board = Board.fromStringArray([
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-    ]);
-    const tiles = generateTiles(['ll', 'a', 'n', 'a']);
-    const results = solve(gaddag!, config, board, tiles);
-    const bestResult = getBestResult(results.map((result) => Result.fromJson(result, board)));
-    expect(results.length).toBe(24);
-    expect(bestResult.points).toBe(22);
-  });
-
-  it('chooho - does not use C + H to imitate CH', () => {
-    const board = Board.fromStringArray([
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-    ]);
-    const tiles = generateTiles(['ch', 'o', 'o', 'c', 'h']);
-    const results = solve(gaddag!, config, board, tiles);
-    const words = results.map((result) => Result.fromJson(result, board).word);
-    expect(words).not.toContain('chocho');
-  });
-});
-
-describe('solve - en-GB', () => {
-  const locale = Locale.EN_GB;
-  const config = getConfig(Game.Scrabble, locale);
-  let gaddag: Gaddag | undefined;
-
-  beforeAll(() => {
-    return dictionaries.get(locale).then((loadedGaddag) => {
-      gaddag = loadedGaddag;
-    });
-  });
-
-  it('no', () => {
-    const board = Board.fromStringArray([
-      '               ',
-      '             ko',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-      '               ',
-    ]);
-    const tiles = generateTiles(['n']);
-    const results = solve(gaddag!, config, board, tiles).map((json) => Result.fromJson(json, board));
-    expect(results.some((result) => result.word === 'no')).toBe(true);
-    expect(results.some((result) => result.word === 'on')).toBe(true);
-    expect(results.length).toBe(2);
-  });
-});

package/packages/solver/src/solve.ts

@@ -1,8 +0,0 @@
-import { type Gaddag } from '@kamilmielnik/gaddag';
-import { type Board, type Config, type ResultJson, type Tile } from '@scrabble-solver/types';
-
-import { MoveGenerator } from './MoveGenerator';
-
-export const solve = (gaddag: Gaddag, config: Config, board: Board, tiles: Tile[]): ResultJson[] => {
-  return new MoveGenerator(gaddag, config, board, tiles).run();
-};

package/packages/solver/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-
-  "compilerOptions": {
-    "outDir": "./build",
-    "rootDir": "./src"
-  },
-  "exclude": ["node_modules", "**/*.test.ts", "src/ReferenceSolver.ts"],
-  "include": ["./src", "index.ts"]
-}

package/packages/types/README.md

@@ -1,3 +0,0 @@
-# @scrabble-solver/types
-
-Types, classes, interfaces, etc. of data used throughout the Scrabble Solver.

package/packages/types/build/Bingo.d.ts

@@ -1,7 +0,0 @@
-export type MultiplierBingo = {
-    multiplier: number;
-};
-export type ScoreBingo = {
-    score: number;
-};
-export type Bingo = MultiplierBingo | ScoreBingo;

package/packages/types/build/Bingo.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/packages/types/build/Board.d.ts

@@ -1,33 +0,0 @@
-import { type BoardJson } from './BoardJson';
-import { type BoardWord } from './BoardWord';
-import { Cell } from './Cell';
-export declare class Board {
-    static create: (width: number, height: number) => Board;
-    static fromJson: (json: BoardJson) => Board;
-    static fromStringArray(stringArray: string[]): Board;
-    readonly columnsCount: number;
-    readonly rows: Cell[][];
-    readonly rowsCount: number;
-    constructor({ rows }: {
-        rows: Cell[][];
-    });
-    get center(): Cell;
-    clone(): Board;
-    collides(cell: Cell): boolean;
-    collidesDown({ x, y }: Cell): boolean;
-    collidesLeft({ x, y }: Cell): boolean;
-    collidesRight({ x, y }: Cell): boolean;
-    collidesUp({ x, y }: Cell): boolean;
-    equals(other: Board): boolean;
-    getBlanksCount(): number;
-    getCollidingWords(word: BoardWord): BoardWord[];
-    getColumn(index: number): Cell[];
-    getRow(index: number): Cell[];
-    getTilesCount(): number;
-    getWords(): BoardWord[];
-    isEmpty(): boolean;
-    toJson(): BoardJson;
-    toString(): string;
-    updateCell(x: number, y: number, updateCell: (cell: Cell) => Cell): void;
-    updateRow(y: number, updateRow: (cells: Cell[]) => Cell[]): void;
-}