scrabble-solver 2.15.10 → 2.15.11

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

@@ -3,68 +3,154 @@ import { Board, Cell, Game, HorizontalPattern, Locale, Pattern, Tile, VerticalPa
 
 import { getPatternScore } from './getPatternScore';
 
-const locale = Locale.PL_PL;
-const config = getConfig(Game.Literaki, locale);
-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('getPatternScore', () => {
-  it('gives proper score without collisions', () => {
-    const pattern = new Pattern(board, [
-      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 }),
+  describe('Literaki - PL_PL', () => {
+    const config = getConfig(Game.Literaki, Locale.PL_PL);
+    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  ',
     ]);
 
-    expect(getPatternScore(config, pattern)).toBe(128);
-  });
+    it('gives proper score without collisions (źaaaaaaź)', () => {
+      const pattern = new Pattern(board, [
+        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 }),
+      ]);
 
-  it('gives proper score with collisions', () => {
-    const pattern = new VerticalPattern(board, [
-      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 }),
-    ]);
+      expect(getPatternScore(config, pattern)).toBe(128);
+    });
 
-    expect(getPatternScore(config, pattern)).toBe(44);
-  });
+    it('gives proper score with collisions (źaaaaaaź)', () => {
+      const pattern = new HorizontalPattern(board, [
+        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 }),
+      ]);
 
-  it('gives proper score for blank', () => {
-    const pattern = new HorizontalPattern(board, [
-      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 }),
-    ]);
+      expect(getPatternScore(config, pattern)).toBe(133);
+    });
+
+    it('gives proper score with collisions (lino)', () => {
+      const pattern = new VerticalPattern(board, [
+        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 }),
+      ]);
+
+      expect(getPatternScore(config, pattern)).toBe(44);
+    });
+
+    it('gives proper score for blank', () => {
+      const pattern = new HorizontalPattern(board, [
+        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 }),
+      ]);
+
+      expect(getPatternScore(config, pattern)).toBe(2);
+    });
 
-    expect(getPatternScore(config, pattern)).toBe(2);
+    it('gives 0 score for unknown characters', () => {
+      const pattern = new HorizontalPattern(board, [
+        new Cell({ x: 13, y: 14, tile: new Tile({ character: '?', isBlank: false }), isEmpty: true }),
+        new Cell({ x: 12, y: 14, tile: new Tile({ character: 't' }), isEmpty: false }),
+      ]);
+
+      expect(getPatternScore(config, pattern)).toBe(2);
+    });
+
+    it('gives 50 points bonus for bingo', () => {
+      const pattern = new HorizontalPattern(board, [
+        new Cell({ x: 6, y: 14, tile: new Tile({ character: 'p' }), isEmpty: true }),
+        new Cell({ x: 7, y: 14, tile: new Tile({ character: 'o' }), isEmpty: true }),
+        new Cell({ x: 8, y: 14, tile: new Tile({ character: 'r' }), isEmpty: true }),
+        new Cell({ x: 9, y: 14, tile: new Tile({ character: 'o' }), isEmpty: true }),
+        new Cell({ x: 10, y: 14, tile: new Tile({ character: 'w' }), isEmpty: true }),
+        new Cell({ x: 11, y: 14, tile: new Tile({ character: 'a', isBlank: true }), isEmpty: true }),
+        new Cell({ x: 11, y: 14, tile: new Tile({ character: 't' }), isEmpty: false }),
+        new Cell({ x: 13, y: 14, tile: new Tile({ character: 'e' }), isEmpty: true }),
+      ]);
+
+      expect(getPatternScore(config, pattern)).toBe(59);
+    });
   });
 
-  it('gives 0 score for unknown characters', () => {
-    const pattern = new HorizontalPattern(board, [
-      new Cell({ x: 13, y: 14, tile: new Tile({ character: '?', isBlank: false }), isEmpty: true }),
-      new Cell({ x: 12, y: 14, tile: new Tile({ character: 't' }), isEmpty: false }),
-    ]);
+  describe('Letter League - EN_US', () => {
+    const config = getConfig(Game.LetterLeague, Locale.EN_US);
+
+    it('gives double multiplier bonus for bingo without collisions', () => {
+      const board = Board.create(config.boardWidth, config.boardHeight);
+      const pattern = new HorizontalPattern(board, [
+        new Cell({ x: 13, y: 6, tile: new Tile({ character: 'r' }), isEmpty: true }),
+        new Cell({ x: 13, y: 7, tile: new Tile({ character: 'o' }), isEmpty: true }),
+        new Cell({ x: 13, y: 8, tile: new Tile({ character: 'm' }), isEmpty: true }),
+        new Cell({ x: 13, y: 9, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 13, y: 10, tile: new Tile({ character: 'i' }), isEmpty: true }),
+        new Cell({ x: 13, y: 11, tile: new Tile({ character: 'n' }), isEmpty: true }),
+        new Cell({ x: 13, y: 12, tile: new Tile({ character: 'e' }), isEmpty: true }),
+      ]);
+
+      expect(getPatternScore(config, pattern)).toBe(18);
+    });
+
+    it('gives double multiplier bonus for bingo with collisions', () => {
+      const board = Board.fromStringArray([
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '           on              ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+        '                           ',
+      ]);
+
+      const pattern = new VerticalPattern(board, [
+        new Cell({ x: 13, y: 6, tile: new Tile({ character: 'r' }), isEmpty: true }),
+        new Cell({ x: 13, y: 7, tile: new Tile({ character: 'o' }), isEmpty: true }),
+        new Cell({ x: 13, y: 8, tile: new Tile({ character: 'm' }), isEmpty: true }),
+        new Cell({ x: 13, y: 9, tile: new Tile({ character: 'a' }), isEmpty: true }),
+        new Cell({ x: 13, y: 10, tile: new Tile({ character: 'i' }), isEmpty: true }),
+        new Cell({ x: 13, y: 11, tile: new Tile({ character: 'n' }), isEmpty: true }),
+        new Cell({ x: 13, y: 12, tile: new Tile({ character: 'e' }), isEmpty: true }),
+      ]);
 
-    expect(getPatternScore(config, pattern)).toBe(2);
+      expect(getPatternScore(config, pattern)).toBe(21);
+    });
   });
 });

package/packages/solver/src/getPatternScore.ts

@@ -1,13 +1,23 @@
-import { Config, Pattern } from '@scrabble-solver/types';
+import { Config, isMultiplierBingo, isScoreBingo, Pattern } from '@scrabble-solver/types';
 
 import { getCellsScore } from './getCellsScore';
 
 export const getPatternScore = (config: Config, pattern: Pattern) => {
   const areAllTilesUsed = pattern.getEmptyCellsCount() === config.rackSize;
-  const bonusScore = areAllTilesUsed ? config.bingoScore : 0;
-  const score = pattern
+  const baseScore = getCellsScore(config, pattern.cells);
+  const collisionsScore = pattern
     .getCollisions()
-    .reduce((sum, collision) => sum + getCellsScore(config, collision.cells), getCellsScore(config, pattern.cells));
+    .reduce((sum, collision) => sum + getCellsScore(config, collision.cells), 0);
 
-  return score + bonusScore;
+  if (areAllTilesUsed) {
+    if (isScoreBingo(config.bingo)) {
+      return baseScore + collisionsScore + config.bingo.score;
+    }
+
+    if (isMultiplierBingo(config.bingo)) {
+      return baseScore * config.bingo.multiplier + collisionsScore;
+    }
+  }
+
+  return baseScore + collisionsScore;
 };

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

@@ -0,0 +1,10 @@
+export type MultiplierBingo = {
+    multiplier: number;
+};
+export type ScoreBingo = {
+    score: number;
+};
+export type Bingo = MultiplierBingo | ScoreBingo;
+export declare const isBingo: (value: unknown) => value is Bingo;
+export declare const isScoreBingo: (value: unknown) => value is ScoreBingo;
+export declare const isMultiplierBingo: (value: unknown) => value is MultiplierBingo;

package/packages/types/build/Bingo.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMultiplierBingo = exports.isScoreBingo = exports.isBingo = void 0;
+const isObject_1 = require("./isObject");
+const isBingo = (value) => {
+    return (0, exports.isScoreBingo)(value) || (0, exports.isMultiplierBingo)(value);
+};
+exports.isBingo = isBingo;
+const isScoreBingo = (value) => {
+    return (0, isObject_1.isObject)(value) && 'score' in value && typeof value.score === 'number';
+};
+exports.isScoreBingo = isScoreBingo;
+const isMultiplierBingo = (value) => {
+    return (0, isObject_1.isObject)(value) && 'multiplier' in value && typeof value.multiplier === 'number';
+};
+exports.isMultiplierBingo = isMultiplierBingo;

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

@@ -1,3 +1,4 @@
+import { Bingo } from './Bingo';
 import { Bonus } from './Bonus';
 import { BonusValue } from './BonusValue';
 import { Cell } from './Cell';
@@ -13,7 +14,7 @@ export declare class Config {
     readonly pointsMap: Record<string, number>;
     constructor(config: ConfigJson);
     get alphabet(): string[];
-    get bingoScore(): number;
+    get bingo(): Bingo;
     get blankScore(): number;
     get blanksCount(): number;
     get boardHeight(): number;
@@ -29,6 +30,7 @@ export declare class Config {
     hasCharacter(character: string): boolean;
     isTwoCharacterTilePrefix(character: string): boolean;
     get rackSize(): number;
+    get supportsRemainingTiles(): boolean;
     get tiles(): TileConfig[];
     toJson(): ConfigJson;
 }

package/packages/types/build/Config.js

@@ -13,8 +13,8 @@ class Config {
     get alphabet() {
         return getAlphabet(this.config);
     }
-    get bingoScore() {
-        return this.config.bingoScore;
+    get bingo() {
+        return this.config.bingo;
     }
     get blankScore() {
         return this.config.blankScore;
@@ -73,6 +73,9 @@ class Config {
     get rackSize() {
         return this.config.rackSize;
     }
+    get supportsRemainingTiles() {
+        return this.tiles.every((tile) => typeof tile.count === 'number');
+    }
     get tiles() {
         return this.config.tiles;
     }

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

@@ -1,9 +1,10 @@
+import { Bingo } from './Bingo';
 import { BonusJson } from './BonusJson';
 import { Game } from './Game';
 import { Locale } from './Locale';
 import { TileConfig } from './TileConfig';
 export interface ConfigJson {
-    bingoScore: number;
+    bingo: Bingo;
     blankScore: number;
     blanksCount: number;
     boardHeight: number;

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

@@ -1,5 +1,6 @@
 export declare enum Game {
     Kelimelik = "kelimelik",
+    LetterLeague = "letter-league",
     Literaki = "literaki",
     Scrabble = "scrabble",
     ScrabbleDuel = "scrabble-duel",

package/packages/types/build/Game.js

@@ -4,6 +4,7 @@ exports.isGame = exports.Game = void 0;
 var Game;
 (function (Game) {
     Game["Kelimelik"] = "kelimelik";
+    Game["LetterLeague"] = "letter-league";
     Game["Literaki"] = "literaki";
     Game["Scrabble"] = "scrabble";
     Game["ScrabbleDuel"] = "scrabble-duel";

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

@@ -1,5 +1,5 @@
 export interface TileConfig {
     character: string;
-    count: number;
+    count?: number;
     score: number;
 }

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

@@ -1,3 +1,4 @@
+export { Bingo, isBingo, isMultiplierBingo, isScoreBingo } from './Bingo';
 export { Board } from './Board';
 export { BoardJson, isBoardJson } from './BoardJson';
 export { Bonus } from './Bonus';

package/packages/types/build/index.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WordDefinition = exports.WordBonus = exports.VerticalPattern = exports.isTileJson = exports.Tile = exports.Result = exports.Pattern = exports.Locale = exports.isLocale = exports.isObject = exports.isError = exports.HorizontalPattern = exports.isGame = exports.Game = exports.FinalPattern = exports.Config = exports.CharacterBonus = exports.isCellJson = exports.Cell = exports.Bonus = exports.isBoardJson = exports.Board = void 0;
+exports.WordDefinition = exports.WordBonus = exports.VerticalPattern = exports.isTileJson = exports.Tile = exports.Result = exports.Pattern = exports.Locale = exports.isLocale = exports.isObject = exports.isError = exports.HorizontalPattern = exports.isGame = exports.Game = exports.FinalPattern = exports.Config = exports.CharacterBonus = exports.isCellJson = exports.Cell = exports.Bonus = exports.isBoardJson = exports.Board = exports.isScoreBingo = exports.isMultiplierBingo = exports.isBingo = void 0;
+var Bingo_1 = require("./Bingo");
+Object.defineProperty(exports, "isBingo", { enumerable: true, get: function () { return Bingo_1.isBingo; } });
+Object.defineProperty(exports, "isMultiplierBingo", { enumerable: true, get: function () { return Bingo_1.isMultiplierBingo; } });
+Object.defineProperty(exports, "isScoreBingo", { enumerable: true, get: function () { return Bingo_1.isScoreBingo; } });
 var Board_1 = require("./Board");
 Object.defineProperty(exports, "Board", { enumerable: true, get: function () { return Board_1.Board; } });
 var BoardJson_1 = require("./BoardJson");

package/packages/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/types",
-  "version": "2.15.10",
+  "version": "2.15.11",
   "description": "Scrabble Solver 2 - Types",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -23,7 +23,7 @@
     "clean": "rimraf build/"
   },
   "dependencies": {
-    "@scrabble-solver/constants": "^2.15.10"
+    "@scrabble-solver/constants": "^2.15.11"
   },
   "gitHead": "1e2d1ad49a288d4a44196d8e3336740da132c637"
 }

package/packages/types/src/Bingo.ts

@@ -0,0 +1,19 @@
+import { isObject } from './isObject';
+
+export type MultiplierBingo = { multiplier: number };
+
+export type ScoreBingo = { score: number };
+
+export type Bingo = MultiplierBingo | ScoreBingo;
+
+export const isBingo = (value: unknown): value is Bingo => {
+  return isScoreBingo(value) || isMultiplierBingo(value);
+};
+
+export const isScoreBingo = (value: unknown): value is ScoreBingo => {
+  return isObject(value) && 'score' in value && typeof value.score === 'number';
+};
+
+export const isMultiplierBingo = (value: unknown): value is MultiplierBingo => {
+  return isObject(value) && 'multiplier' in value && typeof value.multiplier === 'number';
+};

package/packages/types/src/Config.ts

@@ -1,5 +1,6 @@
 import { BLANK, BONUS_CHARACTER, BONUS_WORD, NO_BONUS } from '@scrabble-solver/constants';
 
+import { Bingo } from './Bingo';
 import { Bonus } from './Bonus';
 import { BonusValue } from './BonusValue';
 import { Cell } from './Cell';
@@ -32,8 +33,8 @@ export class Config {
     return getAlphabet(this.config);
   }
 
-  public get bingoScore(): number {
-    return this.config.bingoScore;
+  public get bingo(): Bingo {
+    return this.config.bingo;
   }
 
   public get blankScore(): number {
@@ -112,6 +113,10 @@ export class Config {
     return this.config.rackSize;
   }
 
+  public get supportsRemainingTiles(): boolean {
+    return this.tiles.every((tile) => typeof tile.count === 'number');
+  }
+
   public get tiles(): TileConfig[] {
     return this.config.tiles;
   }

package/packages/types/src/ConfigJson.ts

@@ -1,10 +1,11 @@
+import { Bingo } from './Bingo';
 import { BonusJson } from './BonusJson';
 import { Game } from './Game';
 import { Locale } from './Locale';
 import { TileConfig } from './TileConfig';
 
 export interface ConfigJson {
-  bingoScore: number;
+  bingo: Bingo;
   blankScore: number;
   blanksCount: number;
   boardHeight: number;

package/packages/types/src/Game.ts

@@ -1,5 +1,6 @@
 export enum Game {
   Kelimelik = 'kelimelik',
+  LetterLeague = 'letter-league',
   Literaki = 'literaki',
   Scrabble = 'scrabble',
   ScrabbleDuel = 'scrabble-duel',

package/packages/types/src/TileConfig.ts

@@ -1,5 +1,5 @@
 export interface TileConfig {
   character: string;
-  count: number;
+  count?: number;
   score: number;
 }

package/packages/types/src/index.ts

@@ -1,3 +1,4 @@
+export { Bingo, isBingo, isMultiplierBingo, isScoreBingo } from './Bingo';
 export { Board } from './Board';
 export { BoardJson, isBoardJson } from './BoardJson';
 export { Bonus } from './Bonus';

package/packages/word-definitions/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/word-definitions",
-  "version": "2.15.10",
+  "version": "2.15.11",
   "description": "Scrabble Solver 2 - Word definitions",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -23,7 +23,7 @@
     "clean": "rimraf build/"
   },
   "dependencies": {
-    "@scrabble-solver/types": "^2.15.10",
+    "@scrabble-solver/types": "^2.15.11",
     "cheerio": "^1.0.0",
     "follow-redirects": "^1.15.9",
     "striptags": "^3.2.0"

package/packages/word-lists/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrabble-solver/word-lists",
-  "version": "2.15.10",
+  "version": "2.15.11",
   "description": "Scrabble Solver 2 - Word lists",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -23,7 +23,7 @@
     "clean": "rimraf build/"
   },
   "dependencies": {
-    "@scrabble-solver/types": "^2.15.10",
+    "@scrabble-solver/types": "^2.15.11",
     "cheerio": "^1.0.0",
     "follow-redirects": "^1.15.9",
     "transliteration": "^2.3.5",