jp.ms.common.engine 1.0.0

package/src/board-game/base/board-table.ts

@@ -0,0 +1,52 @@
+import { GamePlayer, GameTable } from '../../base';
+import { GameTableConfig } from '../../base/game-table';
+
+import { BoardFigure } from './board-figure';
+import { BoardCell } from './board-cell';
+
+export abstract class BoardTable<
+    GP extends GamePlayer,
+    GM,
+    GSR,
+    BF extends BoardFigure,
+    BC extends BoardCell<BF>,
+> extends GameTable<GP, GM, GSR> {
+    private readonly bar: Array<BoardFigure>;
+
+    constructor (config: GameTableConfig<GP>) {
+        super(config);
+        this.bar = [];
+    }
+
+    abstract initCells ();
+
+    abstract getCell (id: number): BC | null;
+
+    abstract getCellsArray (): Array<BC>;
+
+    getCellsWithFigures (color: number) {
+        return this.getCellsArray().filter((item) => item.hasYoursFigure(color));
+    }
+
+    moveFigure (fromCellId: number, toCellId: number) {
+        const movingFigure = this.getCell(fromCellId)?.popFigure();
+        if (movingFigure) {
+            this.getCell(toCellId)?.addFigure(movingFigure);
+        }
+    }
+
+    getBar () {
+        return this.bar;
+    }
+
+    getFiguresAtBar (color: number) {
+        return this.bar.filter((item) => item.getColor() === color);
+    }
+
+    moveFigureToBar (fromCellId: number) {
+        const movingFigure = this.getCell(fromCellId)?.popFigure();
+        if (movingFigure) {
+            this.bar.push(movingFigure);
+        }
+    }
+}

package/src/board-game/d1-board-game/d1-board-table.ts

@@ -0,0 +1,56 @@
+import { BoardFigure } from '../base/board-figure';
+import { CircleList } from '../../utils/circle-list';
+import { GameTableConfig } from '../../base/game-table';
+import { BoardCell } from '../base/board-cell';
+import { BoardTable } from '../base/board-table';
+import { BoardPlayer } from '../base/board-player';
+
+export abstract class D1BoardTable<
+    GP extends BoardPlayer,
+    GM,
+    GSR,
+    BF extends BoardFigure,
+> extends BoardTable<GP, GM, GSR, BF, BoardCell<BF>> {
+    private cells: CircleList<BoardCell<BF>>;
+    private readonly boardSize: number;
+
+    protected constructor (config: GameTableConfig<GP>, boardSize: number) {
+        super(config);
+        this.boardSize = boardSize;
+        this.initCells();
+    }
+
+    initCells () {
+        const circleList: CircleList<BoardCell<BF>> = new CircleList<BoardCell<BF>>();
+
+        for (let i = 0; i < this.getBoardSize(); i += 1) {
+            circleList.push(new BoardCell(i));
+        }
+
+        this.cells = circleList;
+    }
+
+    getBoardSize (): number {
+        return this.boardSize;
+    }
+
+    getCell (id: number): BoardCell<BF> | null {
+        return this.cells.getData(id) ?? null;
+    }
+
+    getCells (): CircleList<BoardCell<BF>> {
+        return this.cells;
+    }
+
+    getCellsArray (): Array<BoardCell<BF>> {
+        return this.cells.toArray();
+    }
+
+    getCellsChain (id: number): Array<BoardCell<BF>> {
+        return this.cells.getNextChain(id);
+    }
+
+    getCellSlice (start: number, end?: number): Array<BoardCell<BF>> {
+        return this.cells.getSlice(start, end);
+    }
+}

package/src/board-game/d2-board-game/d2-board-cell.ts

@@ -0,0 +1,30 @@
+import { BoardCell } from '../base/board-cell';
+import { BoardFigure } from '../base/board-figure';
+
+import { Coordinate } from './types';
+
+export class D2BoardCell<BF extends BoardFigure> extends BoardCell<BF> {
+    private readonly col: number;
+    private readonly row: number;
+
+    constructor (id: number, col: number, row: number) {
+        super(id);
+        this.col = col;
+        this.row = row;
+    }
+
+    getRow (): number {
+        return this.row;
+    }
+
+    getCol (): number {
+        return this.col;
+    }
+
+    getCoordinate (): Coordinate {
+        return {
+            y: this.row ?? 0,
+            x: this.col ?? 0,
+        };
+    }
+}

package/src/board-game/d2-board-game/d2-board-pattern-move-figure.ts

@@ -0,0 +1,79 @@
+import { BoardFigure } from '../base/board-figure';
+import { BoardCell } from '../base/board-cell';
+
+import { Coordinate } from './types';
+import { ID2BoardTable } from './d2-board-table';
+
+export type KillingMove = {
+    cellId: number;
+    figureId: number;
+    killingCellId?: number;
+    killingFigureId?: number;
+    targetCells: Array<number>;
+}
+
+export type KillingMoveResult = {
+    cellId: number;
+    figureId: number;
+    paths: Array<KillingMove>;
+}
+
+export abstract class D2BoardPatternMoveFigure extends BoardFigure {
+    abstract getMovePatterns (table: ID2BoardTable<BoardFigure>, center: Coordinate): Array<Array<BoardCell<D2BoardPatternMoveFigure>>>;
+
+    abstract getMove (path: Array<BoardCell<D2BoardPatternMoveFigure>>): KillingMove | null;
+
+    abstract getKill (path: Array<BoardCell<D2BoardPatternMoveFigure>>): KillingMove | null;
+
+    private getMovePaths (table: ID2BoardTable<BoardFigure>, center: Coordinate): Array<KillingMove> {
+        const list: Array<KillingMove> = [];
+        this.getMovePatterns(table, center).forEach((path) => {
+            const move = this.getMove(path);
+            if (this.getMove(path) && move) {
+                list.push(move);
+            }
+        });
+
+        return list;
+    }
+
+    getResultMoves (table: ID2BoardTable<BoardFigure>, center: Coordinate): KillingMoveResult | null {
+        return this.toResult(this.getMoves(table, center));
+    }
+
+    getMoves (table: ID2BoardTable<BoardFigure>, center: Coordinate): Array<KillingMove> {
+        return this.getMovePaths(table, center);
+    }
+
+    getKillPatterns (table: ID2BoardTable<BoardFigure>, center: Coordinate): Array<Array<BoardCell<D2BoardPatternMoveFigure>>> {
+        return this.getMovePatterns(table, center);
+    }
+
+    getKillPaths (table: ID2BoardTable<BoardFigure>, center: Coordinate): Array<KillingMove> {
+        const list: Array<KillingMove> = [];
+        this.getKillPatterns(table, center).forEach((path) => {
+            const kill = this.getKill(path);
+            if (this.getKill(path) && kill) {
+                list.push(kill);
+            }
+        });
+
+        return list;
+    }
+
+    getKillMoves (table: ID2BoardTable<BoardFigure>, center: Coordinate): Array<KillingMove> {
+        return this.getKillPaths(table, center);
+    }
+
+    protected toResult (list: Array<KillingMove>): KillingMoveResult | null {
+        if (list.length > 0) {
+            return {
+                cellId: list[0].cellId ?? 0,
+                figureId: list[0].figureId ?? 0,
+                paths: list,
+            }
+        }
+
+        return null;
+    }
+}

package/src/board-game/d2-board-game/d2-board-table.ts

@@ -0,0 +1,262 @@
+import { flatten, last, take, uniqBy } from 'lodash';
+
+import { GamePlayer } from '../../base';
+import { GameTableConfig } from '../../base/game-table';
+import { BoardFigure } from '../base/board-figure';
+import { BoardTable } from '../base/board-table';
+
+import { D2BoardCell } from './d2-board-cell';
+import { Coordinate } from './types';
+
+export interface ID2BoardTable<BF extends BoardFigure> {
+    getUpLeftDiagonal (center: Coordinate): Array<D2BoardCell<BF>>;
+
+    getUpRightDiagonal (center: Coordinate): Array<D2BoardCell<BF>>;
+
+    getDownLeftDiagonal (center: Coordinate): Array<D2BoardCell<BF>>;
+
+    getDownRightDiagonal (center: Coordinate): Array<D2BoardCell<BF>>;
+
+    getUpVertical (center: Coordinate): Array<D2BoardCell<BF>>;
+
+    getDownVertical (center: Coordinate): Array<D2BoardCell<BF>>;
+
+    getLeftHorizontal (center: Coordinate): Array<D2BoardCell<BF>>;
+
+    getRightHorizontal (center: Coordinate): Array<D2BoardCell<BF>>;
+}
+
+export abstract class D2BoardTable<
+    GP extends GamePlayer,
+    GM,
+    GSR,
+    BF extends BoardFigure,
+> extends BoardTable<GP, GM, GSR, BF, D2BoardCell<BF>> implements ID2BoardTable<BF> {
+    cells: Array<Array<D2BoardCell<BF>>>;
+    readonly height: number;
+    readonly width: number;
+
+    protected constructor (config: GameTableConfig<GP>, height: number, width: number) {
+        super(config);
+        this.height = height;
+        this.width = width;
+        this.initCells();
+    }
+
+    initCells () {
+        const cells: Array<Array<D2BoardCell<BF>>> = [];
+        let id = 0;
+        for (let i = 0; i < this.getHeight(); i += 1) {
+            cells.push([]);
+            for (let j = 0; j < this.getWidth(); j += 1) {
+                cells[i].push(new D2BoardCell(id, j, i));
+                id += 1;
+            }
+        }
+
+        this.cells = cells;
+    }
+
+    getHeight () {
+        return this.height;
+    }
+
+    getWidth () {
+        return this.width;
+    }
+
+    getCell (id: number): D2BoardCell<BF> | null {
+        return this.getCellsArray().find((item) => item.getId() === id) ?? null;
+    }
+
+    getCellByCoordinate (y: number, x: number): D2BoardCell<BF> | null {
+        return this.cells[y]?.[x] ?? null;
+    }
+
+    getCells (): Array<Array<D2BoardCell<BF>>> {
+        return this.cells;
+    }
+
+    getCellsArray (): Array<D2BoardCell<BF>> {
+        return flatten(this.cells);
+    }
+
+    getUpLeftDiagonal (center: Coordinate): Array<D2BoardCell<BF>> {
+        const cells: Array<D2BoardCell<BF>> = [];
+
+        for (let row = center.y, col = center.x; row >= 0 && col >= 0; row -= 1, col -= 1) {
+            const foundCell = this.getCellByCoordinate(row, col);
+            if (foundCell) {
+                cells.push(foundCell);
+            }
+        }
+
+        return cells;
+    }
+
+    getUpRightDiagonal (center: Coordinate): Array<D2BoardCell<BF>> {
+        const cells: Array<D2BoardCell<BF>> = [];
+
+        for (let row = center.y, col = center.x; row >= 0 && col < this.cells.length; row -= 1, col += 1) {
+            const foundCell = this.getCellByCoordinate(row, col);
+            if (foundCell) {
+                cells.push(foundCell);
+            }
+        }
+
+        return cells;
+    }
+
+    getDownLeftDiagonal (center: Coordinate) {
+        const cells: Array<D2BoardCell<BF>> = [];
+
+        for (let row = center.y, col = center.x; row < 8 && col >= 0; row += 1, col -= 1) {
+            const foundCell = this.getCellByCoordinate(row, col);
+            if (foundCell) {
+                cells.push(foundCell);
+            }
+        }
+
+        return cells;
+    }
+
+    getDownRightDiagonal (center: Coordinate) {
+        const cells: Array<D2BoardCell<BF>> = [];
+
+        for (let row = center.y, col = center.x; row < 8 && col < this.cells.length; row += 1, col += 1) {
+            const foundCell = this.getCellByCoordinate(row, col);
+            if (foundCell) {
+                cells.push(foundCell);
+            }
+        }
+
+        return cells;
+    }
+
+    getUpVertical (center: Coordinate): Array<D2BoardCell<BF>> {
+        const cells: Array<D2BoardCell<BF>> = [];
+
+        for (let row = center.y, col = center.x; row >= 0; row -= 1) {
+            const foundCell = this.getCellByCoordinate(row, col);
+            if (foundCell) {
+                cells.push(foundCell);
+            }
+        }
+
+        return cells;
+    }
+
+    getDownVertical (center: Coordinate): Array<D2BoardCell<BF>> {
+        const cells: Array<D2BoardCell<BF>> = [];
+
+        for (let row = center.y, col = center.x; row < this.cells.length; row += 1) {
+            const foundCell = this.getCellByCoordinate(row, col);
+            if (foundCell) {
+                cells.push(foundCell);
+            }
+        }
+
+        return cells;
+    }
+
+    getLeftHorizontal (center: Coordinate): Array<D2BoardCell<BF>> {
+        const cells: Array<D2BoardCell<BF>> = [];
+
+        for (let row = center.y, col = center.x; col >= 0; col -= 1) {
+            const foundCell = this.getCellByCoordinate(row, col);
+            if (foundCell) {
+                cells.push(foundCell);
+            }
+        }
+
+        return cells;
+    }
+
+    getRightHorizontal (center: Coordinate): Array<D2BoardCell<BF>> {
+        const cells: Array<D2BoardCell<BF>> = [];
+
+        for (let row = center.y, col = center.x; col < this.cells.length; col += 1) {
+            const foundCell = this.getCellByCoordinate(row, col);
+            if (foundCell) {
+                cells.push(foundCell);
+            }
+        }
+
+        return cells;
+    }
+
+    getEdgedCells (center: Coordinate): Array<D2BoardCell<BF>> {
+        const length = 3;
+        const shift = 2;
+
+        const first: Coordinate = { x: center.x - 1, y: center.y - 1 };
+        const second: Coordinate = { x: first.x + shift, y: first.y };
+        const third: Coordinate = { x: second.x, y: second.y + shift };
+        const fourth: Coordinate = { x: second.x - shift, y: second.y };
+
+        const list = [
+            take(this.getRightHorizontal(first), length),
+            take(this.getDownVertical(second), length),
+            take(this.getLeftHorizontal(third), length),
+            take(this.getUpVertical(fourth), length),
+        ];
+
+        return uniqBy(flatten(list), (item) => item.getId());
+    }
+
+    getEdgedRectangleCells (list: Array<Coordinate>): Array<D2BoardCell<BF>> {
+        let cells: Array<Array<D2BoardCell<BF>>> = [];
+
+        list.forEach((center) => {
+            cells.push(this.getEdgedCells(center));
+        });
+
+        return uniqBy(flatten(cells), (item) => item.getId());
+    }
+
+    getPistolUpVerticalLeftCells (center: Coordinate): Array<D2BoardCell<BF>> {
+        return this.getPistolCells(this.getUpVertical(center), this.getLeftHorizontal);
+    }
+
+    getPistolUpVerticalRightCells (center: Coordinate): Array<D2BoardCell<BF>> {
+        return this.getPistolCells(this.getUpVertical(center), this.getRightHorizontal);
+    }
+
+    getPistolDownVerticalLeftCells (center: Coordinate): Array<D2BoardCell<BF>> {
+        return this.getPistolCells(this.getDownVertical(center), this.getLeftHorizontal);
+    }
+
+    getPistolDownVerticalRightCells (center: Coordinate): Array<D2BoardCell<BF>> {
+        return this.getPistolCells(this.getDownVertical(center), this.getRightHorizontal);
+    }
+
+    getPistolLeftHorizontalUpCells (center: Coordinate): Array<D2BoardCell<BF>> {
+        return this.getPistolCells(this.getLeftHorizontal(center), this.getUpVertical);
+    }
+
+    getPistolLeftHorizontalDownCells (center: Coordinate): Array<D2BoardCell<BF>> {
+        return this.getPistolCells(this.getLeftHorizontal(center), this.getDownVertical);
+    }
+
+    getPistolRightHorizontalUpCells (center: Coordinate): Array<D2BoardCell<BF>> {
+        return this.getPistolCells(this.getRightHorizontal(center), this.getUpVertical);
+    }
+
+    getPistolRightHorizontalDownCells (center: Coordinate): Array<D2BoardCell<BF>> {
+        return this.getPistolCells(this.getRightHorizontal(center), this.getDownVertical);
+    }
+
+    private getPistolCells (directPath: Array<D2BoardCell<BF>>, sidePath: (center: Coordinate) => Array<D2BoardCell<BF>>): Array<D2BoardCell<BF>> {
+        const KNIGHT_UP_MOVE = 3;
+        const KNIGHT_SIDE_MOVE = 2;
+
+        const lastDirectCell = last(take(directPath, KNIGHT_UP_MOVE));
+        if (lastDirectCell) {
+            const sideCells = take(sidePath(lastDirectCell.getCoordinate()), KNIGHT_SIDE_MOVE);
+
+            return uniqBy([...directPath, ...sideCells], (item) => item.getId());
+        }
+
+        return [];
+    }
+}

package/src/board-game/d2-board-game/types.ts

@@ -0,0 +1,4 @@
+export type Coordinate = {
+  x: number;
+  y: number;
+}

package/src/board-game/dice.ts

@@ -0,0 +1,9 @@
+import { superShuffle } from '../utils/shuffle';
+
+export class Dice {
+    private readonly sides = [1, 2, 3, 4, 5, 6];
+
+    roll (): number {
+        return superShuffle(this.sides)[0];
+    }
+}

package/src/board-game/index.ts

@@ -0,0 +1,28 @@
+import { BoardCell } from './base/board-cell';
+import { BoardFigure } from './base/board-figure';
+import { BoardGameMaster } from './base/board-game-master';
+import { BoardPlayer } from './base/board-player';
+import { BoardPlayerMove } from './base/board-player-move';
+import { BoardTable } from './base/board-table';
+import { D1BoardTable } from './d1-board-game/d1-board-table';
+import { D2BoardCell } from './d2-board-game/d2-board-cell';
+import { D2BoardPatternMoveFigure } from './d2-board-game/d2-board-pattern-move-figure';
+import { D2BoardTable } from './d2-board-game/d2-board-table';
+import { Dice } from './dice';
+
+export {
+    BoardCell,
+    BoardFigure,
+    BoardGameMaster,
+    BoardPlayer,
+    BoardPlayerMove,
+    BoardTable,
+    D1BoardTable,
+    D2BoardCell,
+    D2BoardPatternMoveFigure,
+    D2BoardTable,
+    Dice,
+}
+
+
+

package/src/cards-game/cards/card.ts

@@ -0,0 +1,60 @@
+export type ClientCard = {
+    id: number;
+    rank: number;
+    suit: string;
+    isDisable: boolean;
+}
+
+export class Card {
+    private readonly _id: number;
+    private readonly _rank: number;
+    private readonly _suit: string;
+    private _isDisable: boolean;
+
+    constructor (id: number, rank: number, suit: string) {
+        this._id = id;
+        this._rank = rank;
+        this._suit = suit;
+        this._isDisable = false;
+    }
+
+    public getId () {
+        return this._id;
+    }
+
+    public getRank () {
+        return this._rank;
+    }
+
+    public getSuit () {
+        return this._suit;
+    }
+
+    public getIsDisable () {
+        return this._isDisable;
+    }
+
+    public disable () {
+        this._isDisable = true;
+    }
+
+    public enable () {
+        this._isDisable = false;
+    }
+
+    public toClient (): ClientCard {
+        return {
+            id: this._id,
+            rank: this._rank,
+            suit: this._suit,
+            isDisable: this._isDisable,
+        };
+    }
+
+    public toLogCard (): { rank: number; suit: string; } {
+        return {
+            rank: this.getRank(),
+            suit: this.getSuit(),
+        }
+    }
+}

package/src/cards-game/cards/cards.ts

@@ -0,0 +1,86 @@
+import { Card } from './card';
+import { Ranks } from './ranks';
+import { Suits } from './suits';
+
+const {
+    TWO,
+    THREE,
+    FOUR,
+    FIVE,
+    SIX,
+    SEVEN,
+    EIGHT,
+    NINE,
+    TEN,
+    JACK,
+    QUEEN,
+    KING,
+    ACE,
+    UNKNOWN_RANK,
+} = Ranks;
+
+const {
+    HEART,
+    DIAMOND,
+    CLUB,
+    SPADE,
+    UNKNOWN_SUIT,
+} = Suits;
+
+export const heart_2 = new Card(1, TWO, HEART);
+export const heart_3 = new Card(2, THREE, HEART);
+export const heart_4 = new Card(3, FOUR, HEART);
+export const heart_5 = new Card(4, FIVE, HEART);
+export const heart_6 = new Card(5, SIX, HEART);
+export const heart_7 = new Card(6, SEVEN, HEART);
+export const heart_8 = new Card(7, EIGHT, HEART);
+export const heart_9 = new Card(8, NINE, HEART);
+export const heart_10 = new Card(9, TEN, HEART);
+export const heart_jack = new Card(10, JACK, HEART);
+export const heart_queen = new Card(11, QUEEN, HEART);
+export const heart_king = new Card(12, KING, HEART);
+export const heart_ace = new Card(13, ACE, HEART);
+
+export const diamond_2 = new Card(14, TWO, DIAMOND);
+export const diamond_3 = new Card(15, THREE, DIAMOND);
+export const diamond_4 = new Card(16, FOUR, DIAMOND);
+export const diamond_5 = new Card(17, FIVE, DIAMOND);
+export const diamond_6 = new Card(18, SIX, DIAMOND);
+export const diamond_7 = new Card(19, SEVEN, DIAMOND);
+export const diamond_8 = new Card(20, EIGHT, DIAMOND);
+export const diamond_9 = new Card(21, NINE, DIAMOND);
+export const diamond_10 = new Card(22, TEN, DIAMOND);
+export const diamond_jack = new Card(23, JACK, DIAMOND);
+export const diamond_queen = new Card(24, QUEEN, DIAMOND);
+export const diamond_king = new Card(25, KING, DIAMOND);
+export const diamond_ace = new Card(26, ACE, DIAMOND);
+
+export const club_2 = new Card(27, TWO, CLUB);
+export const club_3 = new Card(28, THREE, CLUB);
+export const club_4 = new Card(29, FOUR, CLUB);
+export const club_5 = new Card(30, FIVE, CLUB);
+export const club_6 = new Card(31, SIX, CLUB);
+export const club_7 = new Card(32, SEVEN, CLUB);
+export const club_8 = new Card(33, EIGHT, CLUB);
+export const club_9 = new Card(34, NINE, CLUB);
+export const club_10 = new Card(35, TEN, CLUB);
+export const club_jack = new Card(36, JACK, CLUB);
+export const club_queen = new Card(37, QUEEN, CLUB);
+export const club_king = new Card(38, KING, CLUB);
+export const club_ace = new Card(39, ACE, CLUB);
+
+export const spade_2 = new Card(40, TWO, SPADE);
+export const spade_3 = new Card(41, THREE, SPADE);
+export const spade_4 = new Card(42, FOUR, SPADE);
+export const spade_5 = new Card(43, FIVE, SPADE);
+export const spade_6 = new Card(44, SIX, SPADE);
+export const spade_7 = new Card(45, SEVEN, SPADE);
+export const spade_8 = new Card(46, EIGHT, SPADE);
+export const spade_9 = new Card(47, NINE, SPADE);
+export const spade_10 = new Card(48, TEN, SPADE);
+export const spade_jack = new Card(49, JACK, SPADE);
+export const spade_queen = new Card(50, QUEEN, SPADE);
+export const spade_king = new Card(51, KING, SPADE);
+export const spade_ace = new Card(52, ACE, SPADE);
+
+export const stub_card = new Card(0, UNKNOWN_RANK, UNKNOWN_SUIT);