jp.ms.common.engine 1.0.0

package/src/base-rooms/scheduled-tournament-room.ts

@@ -0,0 +1,181 @@
+import schedule from 'node-schedule';
+import dayjs from 'dayjs';
+import { chunk, sumBy } from 'lodash';
+
+import { GamePlayer } from '../base';
+import { IGameTable } from '../base/game-table';
+
+import { TournamentRoom, TournamentRoomConfig } from './tournament-room';
+
+export abstract class ScheduledTournamentRoom<
+    GT extends IGameTable<GP>,
+    GP extends GamePlayer,
+> extends TournamentRoom<GT, GP> {
+    private readonly startDate: Date | null;
+    private readonly minUserForMergeTables: number;
+    private readonly startJob: Promise<schedule.Job> | null;
+
+    constructor (config: TournamentRoomConfig, minUserForMergeTables, startDate: Date | null) {
+        super(config);
+        this.minUserForMergeTables = minUserForMergeTables;
+        this.startDate = startDate;
+        if (startDate) {
+            this.startJob = this.scheduleTournament();
+        }
+    }
+
+    handleJoinTournament (player: GP) {
+        if (this.getState().isWaiting()) {
+            this.addUserRoomToQueue(player);
+        } else if (this.getState().isInProgress()) {
+            if (this.isParticipant(player.getId())) {
+                // redirect to table
+            } else {
+                // redirect
+            }
+        } else {
+            // redirect to status
+        }
+    }
+
+    handleLeaveTournament (player: GP) {
+        if (this.getState().isWaiting()) {
+            this.removeUserFromQueue(player);
+        } else if (this.getState().isInProgress()) {
+
+        }
+    }
+
+    handleFinishRound () {
+    }
+
+    handleRestartRound = (table: GT) => {
+        if (this.isTournamentFinish()) {
+            this.finishTournament();
+        } else if (this.isTableFinish(table)) {
+            const lastPlayer = table.getLastPlayer();
+            if (lastPlayer) {
+                table.removePlayerFromSeat(lastPlayer);
+                this.removeTable(table);
+                this.processAloneUser(lastPlayer, table);
+            }
+        } else if (this.isMergeTables(table)) {
+            this.mergeTables(table);
+        } else {
+
+        }
+    };
+
+    handleStartTournament = () => {
+        this.startTournament();
+    };
+
+    startTournament () {
+        const onlineQueuers = this.getOnlineQueuers();
+        if (onlineQueuers.length > 1) {
+            this.initTables(onlineQueuers);
+            this.getTables().forEach((table) => table.startNewRound());
+            this.getState().toStart();
+        } else {
+            this.getState().toCancel();
+        }
+    }
+
+    finishTournament () {
+        this.getState().toFinish();
+        this.calculateWinners();
+    }
+
+    async scheduleTournament (): Promise<schedule.Job> {
+        if (this.getState().isWaiting() && dayjs().isBefore(this.startDate)) {
+            return schedule.scheduleJob(this.startDate ?? 0, this.handleStartTournament);
+        }
+    }
+
+    isTournamentFinish (): boolean {
+        return this.remainOneTable() && this.getTables()[0].remainOnePlayer();
+    }
+
+    isTableFinish (table: GT): boolean {
+        return !this.remainOneTable() && table.remainOnePlayer();
+    }
+
+    isMergeTables (table: GT) {
+        const otherTables = this.getTables().filter((item) => item.getId() !== table.getId());
+        const totalSeats = this.getMaxPlayers() * otherTables.length;
+        const playersOnSeats = sumBy(otherTables, (item) => item.getPlayersWithQueue().length);
+        const freeSeats = totalSeats - playersOnSeats;
+
+        return freeSeats >= table.getPlayers().length && table.getPlayers().length <= this.minUserForMergeTables;
+    }
+
+    initTables (players: Array<GP>): Array<GT> {
+        const newTables: Array<GT> = [];
+        const tablesDividedOnTables = chunk<GP>(players, this.getMaxPlayers());
+        tablesDividedOnTables.forEach((tablePlayers) => {
+            if (tablePlayers.length > 1) {
+                const newTable = this.createTable();
+                tablePlayers.forEach((player) => this.movePlayerToAnotherTable(player, null, newTable));
+            } else {
+                this.processAloneUser(tablePlayers[0], null);
+            }
+        });
+
+        return newTables;
+    }
+
+    mergeTables (table: GT) {
+        this.removeTable(table);
+
+        const movingUsers = table.getPlayers();
+        movingUsers.forEach((movingPlayer) => {
+            const freeTable = this.getTableWithFreeSeats();
+            if (freeTable) {
+                table.removePlayerFromSeat(movingPlayer);
+                this.movePlayerToAnotherTable(movingPlayer, table, freeTable);
+            }
+        });
+    }
+
+    movePlayerToAnotherTable (player: GP, fromTable: GT | null, toTable: GT) {
+        if (toTable.isFull()) {
+            toTable.addPlayerToQueue(player);
+        } else {
+            toTable.addPlayerToSeat(player);
+        }
+    }
+
+    processAloneUser (aloneUser: GP, fromTable: GT | null) {
+        const freeTable = this.getTableWithFreeSeats();
+        const redundantPlayers = this.getRedundantPlayers();
+        const firstTable = this.getFirstTable();
+        aloneUser.flush();
+
+        if (freeTable) {
+            this.movePlayerToAnotherTable(aloneUser, fromTable, freeTable);
+        } else if (redundantPlayers.length > 0) {
+            redundantPlayers.forEach((user) => user.flush());
+            this.initTables([...redundantPlayers, aloneUser]);
+        } else if (firstTable) {
+            this.movePlayerToAnotherTable(aloneUser, fromTable, firstTable);
+        }
+    }
+
+    getRedundantPlayers (): Array<GP> {
+        const table = this.getFirstTable();
+        if (table) {
+            const redundantQueuers = table.getRedundantQueuers();
+            redundantQueuers.forEach((user) => {
+                table.removePlayerFromQueue(user);
+            });
+
+            return redundantQueuers;
+        }
+
+        return [];
+    }
+
+    async cancelJob () {
+        return (await this.startJob)?.cancel();
+    }
+}

package/src/base-rooms/simple-room.ts

@@ -0,0 +1,15 @@
+import { GamePlayer, GameRoom } from '../base';
+import { IGameTable } from '../base/game-table';
+
+export abstract class SimpleRoom<GT extends IGameTable<GP>, GP extends GamePlayer> extends GameRoom<GT, GP> {
+  abstract handleEnterTheTable (player: GP, tableId: string);
+
+  abstract handleExitTheTable (player: GP, tableId: string);
+
+  handleFinishRound () {
+    // save users balances
+  }
+
+  handleRestartRound () {
+  }
+}

package/src/base-rooms/tournament-participant.ts

@@ -0,0 +1,5 @@
+export interface ITournamentParticipant {
+    userId: string;
+    userName: string;
+    userAvatarUrl: string;
+}

package/src/base-rooms/tournament-prize.ts

@@ -0,0 +1,7 @@
+export type TournamentPrize = {
+    minPlayers: number;
+    maxPlayers: number;
+    prizes: Record<string, number | undefined>;
+}
+
+export type TournamentPrizes = Array<TournamentPrize>;

package/src/base-rooms/tournament-room.ts

@@ -0,0 +1,169 @@
+import { first, remove, reverse } from 'lodash';
+
+import { GamePlayer, GameRoom } from '../base';
+import { IGameTable } from '../base/game-table';
+import { GameRoomConfig } from '../base/game-room';
+
+import { TournamentState } from './tournament-state';
+import { ITournamentWinner } from './tournament-winner';
+import { ITournamentParticipant } from './tournament-participant';
+import { TournamentPrizes } from './tournament-prize';
+
+export type TournamentRoomConfig = {
+    ticketPrice: number;
+    prizeTable: TournamentPrizes;
+} & GameRoomConfig
+
+export abstract class TournamentRoom<
+    GT extends IGameTable<GP>,
+    GP extends GamePlayer,
+> extends GameRoom<GT, GP> {
+    private readonly state: TournamentState;
+    private readonly prizeTable: TournamentPrizes;
+    private queue: Array<GP>;
+    private readonly userRating: Array<ITournamentWinner>;
+    private winners: Array<ITournamentWinner>;
+    private readonly participants: Array<ITournamentParticipant>;
+    private readonly ticketPrice: number;
+
+    constructor (config: TournamentRoomConfig) {
+        super(config);
+        this.state = new TournamentState();
+        this.ticketPrice = config.ticketPrice;
+        this.prizeTable = config.prizeTable;
+        this.queue = [];
+        this.userRating = [];
+        this.winners = [];
+        this.participants = [];
+    }
+
+    abstract handleJoinTournament (player: GP);
+
+    abstract handleLeaveTournament (player: GP);
+
+    abstract startTournament ();
+
+    abstract finishTournament ();
+
+    abstract isTournamentFinish (): boolean;
+
+    getParticipants () {
+        return this.participants;
+    }
+
+    addParticipant (participant: GP) {
+        return this.participants.push({
+            userId: participant.getId(),
+            userName: participant.getFullName(),
+            userAvatarUrl: participant.getAvatarUrl(),
+        });
+    }
+
+    getParticipant (userId: string) {
+        return this.participants.find((item) => item.userId === userId);
+    }
+
+    isParticipant (userId: string): boolean {
+        return !!this.participants.find((item) => item.userId === userId);
+    }
+
+    getQueue () {
+        return this.queue;
+    }
+
+    getOnlineQueuers () {
+        return this.queue.filter((item) => item.hasOpenConnection());
+    }
+
+    addUserRoomToQueue (player: GP) {
+        const hasThisUser = this.queue.find((queuer) => queuer.getId() === player.getId());
+        if (!hasThisUser) {
+            player.getInTournamentQueue(this.getId());
+            this.queue.push(player);
+        }
+    }
+
+    removeUserFromQueue (player: GP) {
+        player.quit();
+        remove(this.queue, (queuer) => queuer.getId() === player.getId());
+    }
+
+    clearQueue () {
+        this.queue.forEach((player) => player.quit());
+        this.queue = [];
+    }
+
+    getRatingList () {
+        return this.userRating;
+    }
+
+    addPlayerToRating (player: GP) {
+        remove(this.userRating, (user) => player.getId() === user.userId);
+
+        this.userRating.push({
+            userId: player.getId(),
+            userName: player.getFullName(),
+            userAvatarUrl: player.getAvatarUrl() ?? '',
+            prize: 0,
+            rank: 0,
+        });
+    }
+
+    getWinner (): ITournamentWinner | undefined {
+        return first(this.winners);
+    }
+
+    getWinners () {
+        return this.winners;
+    }
+
+    setWinners (winners: Array<ITournamentWinner>) {
+        this.winners = winners;
+    }
+
+    getState (): TournamentState {
+        return this.state;
+    }
+
+    isTournament (): boolean {
+        return true;
+    }
+
+    calculateWinners () {
+        const firstTen = this.getSortedRatingList();
+        const winners: Array<ITournamentWinner> = [];
+
+        for (let i = 0; i < firstTen.length; i += 1) {
+            const ratingUser = firstTen[i];
+            const rank = i + 1;
+            const prize = this.getPrize(rank);
+
+            winners.push({
+                ...ratingUser,
+                prize,
+                rank,
+            });
+        }
+
+        this.setWinners(winners);
+    }
+
+    getSortedRatingList (): Array<ITournamentWinner> {
+        return reverse(this.getRatingList());
+    }
+
+    getTournamentFund (): number {
+        return this.participants.length * this.ticketPrice;
+    }
+
+    getPrize (rank: number): number {
+        const allPlayersCount = this.getRatingList().length;
+
+        const prize = this.prizeTable.find((item) =>
+            allPlayersCount >= item.minPlayers && allPlayersCount <= item.maxPlayers);
+
+        const rankPrize = prize?.prizes[rank] ?? 0;
+
+        return rankPrize * this.getTournamentFund() / 100;
+    }
+}

package/src/base-rooms/tournament-state.ts

@@ -0,0 +1,78 @@
+import { GameStateMachine, StateMachineConfig } from '../base/game-state-machine';
+
+export enum TournamentStateMachineStates {
+    STATE_WAITING_FOR_START = 'STATE_WAITING_FOR_START',
+    STATE_IN_PROGRESS = 'STATE_IN_PROGRESS',
+    STATE_FINISHED = 'STATE_FINISHED',
+    STATE_CANCELLED = 'STATE_CANCELLED',
+}
+
+export enum TournamentStateMachineActions {
+    ACTION_START = 'ACTION_START',
+    ACTION_FINISH = 'ACTION_FINISH',
+    ACTION_CANCEL = 'ACTION_CANCEL',
+}
+
+const {
+    STATE_WAITING_FOR_START,
+    STATE_CANCELLED,
+    STATE_FINISHED,
+    STATE_IN_PROGRESS,
+} = TournamentStateMachineStates;
+
+const {
+    ACTION_CANCEL,
+    ACTION_FINISH,
+    ACTION_START
+} = TournamentStateMachineActions;
+
+const config: StateMachineConfig = {
+    [STATE_WAITING_FOR_START]: {
+        on: {
+            [ACTION_START]: STATE_IN_PROGRESS,
+            [ACTION_CANCEL]: STATE_CANCELLED,
+        },
+    },
+    [STATE_IN_PROGRESS]: {
+        on: {
+            [ACTION_FINISH]: STATE_FINISHED,
+            [ACTION_CANCEL]: STATE_CANCELLED,
+        },
+    },
+    [STATE_FINISHED]: { on: {} },
+    [STATE_CANCELLED]: { on: {} },
+};
+
+export class TournamentState extends GameStateMachine<TournamentStateMachineStates, TournamentStateMachineActions> {
+    constructor () {
+        super(TournamentStateMachineStates.STATE_WAITING_FOR_START, config);
+    }
+
+    isWaiting () {
+        return this.getCurrentState() === TournamentStateMachineStates.STATE_WAITING_FOR_START;
+    }
+
+    isCancelled () {
+        return this.getCurrentState() === TournamentStateMachineStates.STATE_CANCELLED;
+    }
+
+    isInProgress () {
+        return this.getCurrentState() === TournamentStateMachineStates.STATE_IN_PROGRESS;
+    }
+
+    isFinished () {
+        return this.getCurrentState() === TournamentStateMachineStates.STATE_FINISHED;
+    }
+
+    toStart () {
+        this.send(TournamentStateMachineActions.ACTION_START);
+    }
+
+    toFinish () {
+        this.send(TournamentStateMachineActions.ACTION_FINISH);
+    }
+
+    toCancel () {
+        this.send(TournamentStateMachineActions.ACTION_CANCEL);
+    }
+}

package/src/base-rooms/tournament-winner.ts

@@ -0,0 +1,7 @@
+export interface ITournamentWinner {
+    userId: string;
+    userName: string;
+    userAvatarUrl: string;
+    prize: number;
+    rank: number;
+}

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

@@ -0,0 +1,50 @@
+import { last } from 'lodash';
+
+import { BoardFigure } from './board-figure';
+
+export class BoardCell<BF extends BoardFigure> {
+    private readonly id: number;
+    private readonly figures: Array<BF>;
+
+    constructor (id: number) {
+        this.id = id;
+        this.figures = [];
+    }
+
+    getId (): number {
+        return this.id;
+    }
+
+    getFigures (): Array<BF> {
+        return this.figures;
+    }
+
+    getFigure (): BF | null {
+        return last(this.figures) ?? null;
+    }
+
+    addFigure (figure: BF): void {
+        this.figures.push(figure);
+        figure.addCell(this.getId());
+    }
+
+    hasFigure (): boolean {
+        return this.figures.length > 0;
+    }
+
+    popFigure (): BF | undefined {
+        return this.figures.pop();
+    }
+
+    isFree () {
+        return this.figures.length === 0;
+    }
+
+    hasYoursFigure (color: number) {
+        return this.getFigure()?.getColor() === color;
+    }
+
+    hasEnemiesFigure (color: number) {
+        return this.hasFigure() && !this.hasYoursFigure(color);
+    }
+}

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

@@ -0,0 +1,49 @@
+import { last } from 'lodash';
+
+import { GamePlayerColor } from '../../base/game-player';
+
+export abstract class BoardFigure {
+    private readonly id: number;
+    private readonly color: number;
+    private readonly cells: Array<number>;
+
+    constructor (id: number, color: number) {
+        this.id = id;
+        this.color = color;
+        this.cells = [];
+    }
+
+    abstract getType (): number;
+
+    getId () {
+        return this.id;
+    }
+
+    getColor () {
+        return this.color;
+    }
+
+    getCells () {
+        return this.cells;
+    }
+
+    getCell () {
+        return last(this.cells);
+    }
+
+    getState () {
+        return 0;
+    }
+
+    addCell (cellId: number) {
+        this.cells.push(cellId);
+    }
+
+    isWhite () {
+        return this.color === GamePlayerColor.WHITE;
+    }
+
+    isBlack () {
+        return this.color === GamePlayerColor.BLACK;
+    }
+}

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

@@ -0,0 +1,56 @@
+import { GameMaster } from '../../base';
+import { IGameRound } from '../../base/game-round';
+import { BoardPlayer } from './board-player';
+import { IGameTable } from '../../base/game-table';
+
+import { KillingMove, KillingMoveResult } from '../d2-board-game/d2-board-pattern-move-figure';
+import { BoardCell } from './board-cell';
+import { BoardFigure } from './board-figure';
+
+export abstract class BoardGameMaster<
+    GT extends IGameTable<GP>,
+    GR extends IGameRound<GP>,
+    GP extends BoardPlayer,
+    GSR,
+> extends GameMaster<GT, GR, GP, GSR> {
+    private figuresCount: number = 0;
+
+    abstract initStartFigures ();
+
+    abstract figuresStartPositions: Array<Array<number>>;
+
+    setFiguresStartPositions (figures: Array<Array<number>>) {
+        this.figuresStartPositions = figures;
+    }
+
+    findPath (
+        possibleMoves: Array<KillingMoveResult>,
+        movingFigureId: number | undefined,
+        movingFigureNewPosition: number | undefined,
+    ): KillingMove | undefined {
+        const foundMove = possibleMoves.find((item) => item.figureId === movingFigureId);
+
+        if (foundMove) {
+            return foundMove.paths.find((path) => path.targetCells.find((targetCell) => targetCell === movingFigureNewPosition));
+        }
+    }
+
+    killFigure (cell: BoardCell<BoardFigure> | null) {
+        const killedFigure = cell?.popFigure();
+        const rival = this.table.getPlayerByColor(killedFigure?.getColor() ?? 0);
+        rival?.popFigure(killedFigure?.getId() ?? 0);
+    }
+
+    isFinish () {
+        return this.table.getPlayers().filter((item) => item.hasNoFigures()).length > 0;
+    }
+
+    getFiguresCount () {
+        return this.figuresCount;
+    }
+
+    increaseFiguresCount () {
+        this.figuresCount += 1;
+    }
+}
+

package/src/board-game/base/board-player-move.ts

@@ -0,0 +1,29 @@
+import { GamePlayerMove } from '../../base/game-player-move';
+
+export class BoardPlayerMove {
+    private readonly move?: GamePlayerMove;
+
+    constructor (move: GamePlayerMove | undefined) {
+        this.move = move;
+    }
+
+    getRoomId () {
+        return this.move?.getRoomId();
+    }
+
+    getTableId () {
+        return this.move?.getTableId();
+    }
+
+    getAction () {
+        return this.move?.getAction();
+    }
+
+    getFigureId (): number | undefined {
+        return parseInt(this.move?.getAttr('figureId') ?? '', 10);
+    }
+
+    getFigureNewPosition (): number | undefined {
+        return parseInt(this.move?.getAttr('figureNewPosition') ?? '', 10);
+    }
+}

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

@@ -0,0 +1,43 @@
+import { remove } from 'lodash';
+
+import { GamePlayer } from '../../base';
+import { BoardFigure } from './board-figure';
+
+export abstract class BoardPlayer extends GamePlayer {
+    private readonly figures: Array<BoardFigure>;
+
+    constructor (
+        id: string,
+        fullName: string,
+        avatarUrl: string,
+        balance: number,
+        color: number,
+    ) {
+        super(id, fullName, avatarUrl, balance, color);
+        this.figures = [];
+    }
+
+    getFigures (): Array<BoardFigure> {
+        return this.figures;
+    }
+
+    hasNoFigures (): boolean {
+        return this.figures.length === 0;
+    }
+
+    addFigure (figure: BoardFigure): void {
+        this.figures.push(figure);
+    }
+
+    popFigure (figureId: number) {
+        remove(this.figures, (item) => item.getId() === figureId);
+    }
+
+    findFigure (figureId: number) {
+        return this.figures.find((item) => item.getId() === figureId);
+    }
+
+    hasFigure (figureId: number) {
+        return !!this.findFigure(figureId);
+    }
+}