scrabble-solver 2.8.8 → 2.8.9

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

@@ -1,70 +0,0 @@
-import { literaki } from '@scrabble-solver/configs';
-import { Board, Cell, HorizontalPattern, Locale, Pattern, Tile, VerticalPattern } from '@scrabble-solver/types';
-
-import ScoresCalculator from './ScoresCalculator';
-
-const config = literaki[Locale.PL_PL];
-const scoresCalculator = new ScoresCalculator(config);
-const board = Board.fromStringArray([
-  ' kasom         ',
-  '     i         ',
-  '     napiją    ',
-  '  w  i         ',
-  ' krabim        ',
-  '  z            ',
-  '  ę  eh        ',
-  'f s srać       ',
-  'i z t       s  ',
-  'knebel      e  ',
-  'a  ew     warcz',
-  'ł  żyło  wody  ',
-  'o     pecyj chu',
-  '            y  ',
-  '            t  ',
-]);
-
-describe('ScoresCalculator', () => {
-  it('gives proper score without collisions', () => {
-    const pattern = new Pattern({
-      board,
-      cells: [
-        new Cell({ x: 0, y: 0, tile: new Tile({ character: 'ź' }), isEmpty: true }),
-        new Cell({ x: 1, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
-        new Cell({ x: 2, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
-        new Cell({ x: 3, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
-        new Cell({ x: 4, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
-        new Cell({ x: 5, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
-        new Cell({ x: 6, y: 0, tile: new Tile({ character: 'a' }), isEmpty: true }),
-        new Cell({ x: 7, y: 0, tile: new Tile({ character: 'ź' }), isEmpty: false }),
-      ],
-    });
-    const score = scoresCalculator.calculate(pattern);
-    expect(score).toBe(128);
-  });
-
-  it('gives proper score with collisions', () => {
-    const pattern = new VerticalPattern({
-      board,
-      cells: [
-        new Cell({ x: 2, y: 11, tile: new Tile({ character: 'l' }), isEmpty: true }),
-        new Cell({ x: 2, y: 12, tile: new Tile({ character: 'i' }), isEmpty: true }),
-        new Cell({ x: 2, y: 13, tile: new Tile({ character: 'n' }), isEmpty: true }),
-        new Cell({ x: 2, y: 14, tile: new Tile({ character: 'o' }), isEmpty: true }),
-      ],
-    });
-    const score = scoresCalculator.calculate(pattern);
-    expect(score).toBe(44);
-  });
-
-  it('gives proper score for blank', () => {
-    const pattern = new HorizontalPattern({
-      board,
-      cells: [
-        new Cell({ x: 13, y: 14, tile: new Tile({ character: 'o', isBlank: true }), isEmpty: true }),
-        new Cell({ x: 12, y: 14, tile: new Tile({ character: 't' }), isEmpty: false }),
-      ],
-    });
-    const score = scoresCalculator.calculate(pattern);
-    expect(score).toBe(2);
-  });
-});

package/packages/solver/src/ScoresCalculator.ts

@@ -1,52 +0,0 @@
-import { NO_BONUS } from '@scrabble-solver/constants';
-import { Cell, Config, Pattern } from '@scrabble-solver/types';
-
-class ScoresCalculator {
-  private readonly config: Config;
-
-  constructor(config: Config) {
-    this.config = config;
-  }
-
-  public calculate(pattern: Pattern): number {
-    return this.calculatePatternScoreWithCollisions(pattern) + this.calculateBonusScore(pattern);
-  }
-
-  public calculateBonusScore(pattern: Pattern): number {
-    const areAllTilesUsed = pattern.getEmptyCellsCount() === this.config.maximumCharactersCount;
-    return areAllTilesUsed ? this.config.allTilesBonusScore : 0;
-  }
-
-  public calculatePatternScoreWithCollisions(pattern: Pattern): number {
-    return pattern
-      .getCollisions()
-      .reduce(
-        (patternsScore, collisionPattern) => patternsScore + this.calculatePatternScore(collisionPattern),
-        this.calculatePatternScore(pattern),
-      );
-  }
-
-  public calculatePatternScore(pattern: Pattern): number {
-    const { multiplier, score } = pattern.cells.reduce(this.reduceCellScore, {
-      multiplier: 1,
-      score: 0,
-    });
-    return score * multiplier;
-  }
-
-  public reduceCellScore = (
-    { multiplier, score }: { multiplier: number; score: number },
-    cell: Cell,
-  ): { multiplier: number; score: number } => {
-    const bonus = this.config.getCellBonus(cell);
-    const { characterMultiplier, wordMultiplier } = bonus && bonus.canApply(this.config, cell) ? bonus.value : NO_BONUS;
-    const characterScore = cell.tile.isBlank ? this.config.blankScore : this.config.pointsMap[cell.tile.character];
-
-    return {
-      multiplier: multiplier * wordMultiplier,
-      score: score + characterScore * characterMultiplier,
-    };
-  };
-}
-
-export default ScoresCalculator;

package/packages/solver/src/Solver.ts

@@ -1,39 +0,0 @@
-import { Trie } from '@kamilmielnik/trie';
-import { Board, Config, Result, Tile } from '@scrabble-solver/types';
-
-import getUniquePatterns from './getUniquePatterns';
-import PatternsFiller from './PatternsFiller';
-import PatternsGenerator from './PatternsGenerator';
-import ScoresCalculator from './ScoresCalculator';
-
-class Solver {
-  private readonly patternsFiller: PatternsFiller;
-
-  private readonly patternsGenerator: PatternsGenerator;
-
-  private readonly scoresCalculator: ScoresCalculator;
-
-  constructor(config: Config, trie: Trie) {
-    this.patternsFiller = new PatternsFiller(config, trie);
-    this.patternsGenerator = new PatternsGenerator(config);
-    this.scoresCalculator = new ScoresCalculator(config);
-  }
-
-  public solve(board: Board, tiles: Tile[]): Result[] {
-    const patterns = this.patternsGenerator.generate(board);
-    const filledPatterns = patterns.flatMap((pattern) => this.patternsFiller.fill(pattern, tiles));
-    const uniquePatterns = getUniquePatterns(filledPatterns);
-    const results = uniquePatterns.map(
-      (pattern, index) =>
-        new Result({
-          cells: pattern.cells,
-          collisions: pattern.getCollisions().map((collision) => collision.cells),
-          id: index,
-          points: this.scoresCalculator.calculate(pattern),
-        }),
-    );
-    return results;
-  }
-}
-
-export default Solver;