jp.ms.common.engine 1.0.0

package/src/base/game-round.ts

@@ -0,0 +1,62 @@
+import { v4 as uidv4 } from 'uuid';
+
+export type GameRoundHistoryItem = {
+    userId: string;
+    fullName: string;
+    date: Date;
+    action: string;
+    state: string;
+}
+
+export interface IGameRound<GP> {
+    getActivePlayer (): GP;
+
+    setActivePlayer (activePlayer: GP);
+}
+
+export abstract class GameRound<SM, GP> implements IGameRound<GP> {
+    private readonly history: Array<GameRoundHistoryItem>;
+    private id: string;
+    private pot: number;
+    private state: SM;
+    private activePlayer: GP;
+
+    protected constructor () {
+        this.id = uidv4();
+        this.pot = 0;
+        this.history = [];
+    }
+
+    getState (): SM {
+        return this.state;
+    }
+
+    setState (state: SM): void {
+        this.state = state;
+    }
+
+    getHistory (): Array<GameRoundHistoryItem> {
+        return this.history;
+    }
+
+    addToHistory (item: GameRoundHistoryItem): void {
+        this.history.push(item);
+    }
+
+    addToPot (amount: number): void {
+        this.pot += amount;
+    }
+
+    getPot (): number {
+        return this.pot;
+    }
+
+    getActivePlayer () {
+        return this.activePlayer;
+    }
+
+    setActivePlayer (activePlayer: GP) {
+        this.activePlayer = activePlayer;
+    }
+}
+

package/src/base/game-state-machine.ts

@@ -0,0 +1,25 @@
+export type StateMachineConfig = Record<string, { on: Record<string, string> }>
+
+export abstract class GameStateMachine<S, A> {
+    private readonly initialState: S;
+    private currentState: S;
+    private config: StateMachineConfig;
+
+    protected constructor (initialState: S, config: StateMachineConfig) {
+        this.config = config;
+        this.initialState = initialState;
+        this.currentState = this.initialState;
+    }
+
+    getCurrentState (): S {
+        return this.currentState;
+    }
+
+    start () {
+        this.currentState = this.initialState;
+    }
+
+    send (action: A) {
+        this.currentState = this.config[this.currentState as string].on[action as string] as S;
+    }
+}

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

@@ -0,0 +1,37 @@
+import { GamePlayer } from './game-player';
+
+export class GameTableSeat<GP extends GamePlayer> {
+    private player: GP | null = null;
+    private role: string | null;
+
+    constructor (private readonly number: number) {
+    }
+
+    public getRole () {
+        return this.role;
+    }
+
+    public setRole (role: string) {
+        this.role = role;
+    }
+
+    public clearRole () {
+        this.role = null;
+    }
+
+    getNumber (): number {
+        return this.number;
+    }
+
+    getPlayer () {
+        return this.player;
+    }
+
+    addPlayer (player: GP) {
+        this.player = player;
+    }
+
+    removePlayer () {
+        this.player = null;
+    }
+}

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

@@ -0,0 +1,78 @@
+import { compact } from 'lodash';
+
+import { CircleList } from '../utils';
+import { TWO_PLAYER_GAME } from '../const';
+
+import { GameTableSeat } from './game-table-seat';
+import { GamePlayer } from './game-player';
+
+export class GameTableSeats<GP extends GamePlayer> {
+    protected readonly seats: CircleList<GameTableSeat<GP>>;
+
+    constructor (private readonly tableSize: number) {
+        this.seats = new CircleList();
+
+        for (let i = 0; i < this.tableSize; i += 1) {
+            this.seats.push(new GameTableSeat<GP>(i + 1));
+        }
+    }
+
+    getSeats (): Array<GameTableSeat<GP>> {
+        return this.seats.toArray();
+    }
+
+    getSeatsWithPlayers (): Array<GameTableSeat<GP>> {
+        return this.seats.toArray().filter((item) => !!item.getPlayer());
+    }
+
+    getSeat (number: number | null): GameTableSeat<GP> | undefined {
+        return this.seats.toArray().find((item) => item.getNumber() === number);
+    }
+
+    getNextSeat (from: number): GameTableSeat<GP> | undefined {
+        return this.seats.get(from - 1)?.getNext()?.getData();
+    }
+
+    getNextPlayer (from: number): GP | null {
+        const nextSeat = this.getNextSeat(from);
+        const nextPlayer = nextSeat?.getPlayer();
+
+        if (!nextPlayer) {
+            return this.getNextPlayer(nextSeat?.getNumber() ?? 0);
+        }
+
+        return nextPlayer;
+    }
+
+    getPrevSeat (from: number): GameTableSeat<GP> | undefined {
+        return this.seats.get(from - 1)?.getPrev()?.getData();
+    }
+
+    getPrevPlayer (from: number): GP | null {
+        return this.getPrevSeat(from)?.getPlayer() ?? null;
+    }
+
+    getPlayersChain (from: number): Array<GP> {
+        const chain = this.seats.getNextChain(from).map((item) => item.getPlayer());
+
+        return compact(chain);
+    }
+
+    getFirstSeatWithPlayer (): GameTableSeat<GP> | null {
+        return this.getSeatsWithPlayers()[0] ?? null;
+    }
+
+    findFreeSeat (): GameTableSeat<GP> | undefined {
+        return this.seats.toArray().find((seat) => seat.getPlayer() === null);
+    }
+
+    clearAllSeatsRole () {
+        this.seats.toArray().forEach((seat) => {
+            seat.clearRole();
+        });
+    }
+
+    isTwoPlayerGame () {
+        return this.getSeatsWithPlayers().length === TWO_PLAYER_GAME;
+    }
+}

package/src/base/game-table.ts

@@ -0,0 +1,237 @@
+import { compact, first, remove, slice } from 'lodash';
+
+import { GamePlayer } from './game-player';
+import { GameTableSeats } from './game-table-seats';
+
+export interface IGameTable<GP extends GamePlayer> {
+    getId (): string;
+
+    hasInQueue (PlayerId: string): boolean;
+
+    hasInWatchers (PlayerId: string): boolean;
+
+    isFull (): boolean;
+
+    getSeats (): GameTableSeats<GP>;
+
+    hasSeats (): boolean;
+
+    addPlayerToQueue (player: GP);
+
+    addPlayerToSeat (player: GP);
+
+    removePlayerFromSeat (player: GP);
+
+    removePlayerFromQueue (player: GP);
+
+    removePlayerFromWatchers (player: GP);
+
+    addPlayerToWatchers (player: GP);
+
+    getPlayers (): Array<GP>;
+
+    getPlayerByColor (color: number): GP | undefined;
+
+    getPlayersWithQueue (): Array<GP>;
+
+    getEmptyStackPlayers (): Array<GP>;
+
+    remainOnePlayer (): boolean;
+
+    startNewRound (): void;
+
+    getQueue (): Array<GP>;
+
+    getTableSize (): number;
+
+    getRedundantQueuers (): Array<GP>;
+
+    getLastPlayer (): GP | null;
+
+    getTurnTimeout (): number;
+
+    getRestartTimeout (): number;
+}
+
+export type GameTableConfig<GP extends GamePlayer> = {
+    roomId: string;
+    number: number;
+    tableSize: number;
+    bet: number;
+    rulesType: string;
+    turnTimeout: number;
+    restartTimeout: number;
+    onRoomFinishRound: (table: IGameTable<GP>) => void
+    onRoomRestartRound: (table: IGameTable<GP>) => void
+}
+
+export abstract class GameTable<GP extends GamePlayer, GM, GSR> implements IGameTable<GP> {
+    private readonly roomId: string;
+    private readonly number: number;
+    private readonly tableSize: number;
+    private readonly bet: number;
+    private readonly turnTimeout: number;
+    private readonly restartTimeout: number;
+    private readonly queue: Array<GP>;
+    private readonly watchers: Array<GP>;
+    public readonly seats: GameTableSeats<GP>;
+    public master: GM;
+    public onRoomFinishRound: (table: IGameTable<GP>) => void;
+    public onRoomRestartRound: (table: IGameTable<GP>) => void;
+
+    protected constructor (config: GameTableConfig<GP>) {
+        this.queue = [];
+        this.watchers = [];
+        this.onRoomFinishRound = config.onRoomFinishRound;
+        this.onRoomRestartRound = config.onRoomRestartRound;
+        this.roomId = config.roomId;
+        this.number = config.number;
+        this.tableSize = config.tableSize;
+        this.bet = config.bet;
+        this.turnTimeout = config.turnTimeout;
+        this.restartTimeout = config.restartTimeout;
+        this.seats = new GameTableSeats(this.getTableSize());
+    }
+
+    abstract startNewRound (): void
+
+    getRoomId () {
+        return this.roomId;
+    }
+
+    getId () {
+        return String(this.number);
+    }
+
+    getNumber (): number {
+        return this.number;
+    }
+
+    getTableSize (): number {
+        return this.tableSize;
+    }
+
+    getBet () {
+        return this.bet;
+    }
+
+    getHalfBet () {
+        return this.bet / 2;
+    }
+
+    getTurnTimeout () {
+        return this.turnTimeout;
+    }
+
+    getRestartTimeout () {
+        return this.restartTimeout;
+    }
+
+    addPlayerToSeat (player: GP): boolean {
+        const freeSeat = this.seats.findFreeSeat();
+        if (freeSeat) {
+            freeSeat.addPlayer(player);
+            player.seat(this.getRoomId(), this.getId(), freeSeat.getNumber());
+            return true;
+        }
+
+        return false;
+    }
+
+    removePlayerFromSeat (player: GP): void {
+        const seat = this.seats.getSeat(player.getSeatNumber());
+        if (seat) {
+            seat.removePlayer();
+            player.quit();
+        }
+    }
+
+    getPlayers (): Array<GP> {
+        return compact(this.seats.getSeats().map((seat) => seat.getPlayer()));
+    }
+
+    getPlayerByColor (color: number): GP | undefined {
+        return this.getPlayers().find((item) => item.getColor() === color);
+    }
+
+    getPlayersWithQueue (): Array<GP> {
+        return [...this.getPlayers(), ...this.queue];
+    }
+
+    getLastPlayer (): GP | null {
+        return first(this.getPlayers()) ?? null;
+    }
+
+    remainOnePlayer (): boolean {
+        return this.getPlayers().length === 1;
+    }
+
+    hasMinPlayers (): boolean {
+        return this.getPlayers().length > 1;
+    }
+
+    getEmptyStackPlayers (): Array<GP> {
+        return this.getPlayers().filter((player) => player.hasEmptyStack());
+    }
+
+    getQueue (): Array<GP> {
+        return this.queue;
+    }
+
+    getRedundantQueuers (): Array<GP> {
+        return slice(this.queue, this.getTableSize() - this.getPlayers().length - 1);
+    }
+
+    addPlayerToQueue (player: GP): void {
+        this.queue.push(player);
+        player.getInTableQueue(this.getRoomId(), this.getId());
+    }
+
+    removePlayerFromQueue (player: GP): void {
+        remove(this.queue, (queuer) => queuer.getId() === player.getId());
+        player.quit();
+    }
+
+    hasInQueue (PlayerId: string): boolean {
+        return !!this.getQueue().find((queuer) => queuer.getId() === PlayerId);
+    }
+
+    getWatchers (): Array<GP> {
+        return this.watchers;
+    }
+
+    addPlayerToWatchers (player: GP): void {
+        this.watchers.push(player);
+        player.watch(this.getRoomId(), this.getId());
+    }
+
+    removePlayerFromWatchers (player: GP): void {
+        remove(this.watchers, (watcher) => watcher.getId() === player.getId());
+        player.quit();
+    }
+
+    hasInWatchers (PlayerId: string): boolean {
+        return !!this.getWatchers().find((watcher) => watcher.getId() === PlayerId);
+    }
+
+    isFull (): boolean {
+        return !this.seats.findFreeSeat();
+    }
+
+    getSeats (): GameTableSeats<GP> {
+        return this.seats;
+    }
+
+    hasSeats (): boolean {
+        return !!this.seats.findFreeSeat();
+    }
+
+    onFinishRound () {
+        this.onRoomFinishRound(this);
+    }
+
+    onRestartRound () {
+        this.onRoomRestartRound(this);
+    }
+}
+

package/src/base/index.ts

@@ -0,0 +1,25 @@
+import { GameControlPlayerTurn } from './game-control-player-turn';
+import { GameControlRestart } from './game-control-restart';
+import { GameMaster } from './game-master';
+import { GamePlayer } from './game-player';
+import { GamePlayerMove } from './game-player-move';
+import { GameRoom } from './game-room';
+import { GameRound } from './game-round';
+import { GameStateMachine } from './game-state-machine';
+import { GameTable } from './game-table';
+import { GameTableSeat } from './game-table-seat';
+import { GameTableSeats } from './game-table-seats';
+
+export {
+    GameControlPlayerTurn,
+    GameControlRestart,
+    GameMaster,
+    GamePlayer,
+    GamePlayerMove,
+    GameRoom,
+    GameRound,
+    GameStateMachine,
+    GameTable,
+    GameTableSeat,
+    GameTableSeats,
+}

package/src/base/standard-game-state.ts

@@ -0,0 +1,69 @@
+import { GameStateMachine, StateMachineConfig } from './game-state-machine';
+
+export enum StandardStateMachineStates {
+    STATE_WAITING_FOR_PLAYERS = 'STATE_WAITING_FOR_PLAYERS',
+    STATE_IN_PROGRESS = 'STATE_IN_PROGRESS',
+    STATE_END = 'STATE_END',
+}
+
+export enum StandardStateMachineActions {
+    ACTION_TO_END = 'ACTION_TO_END',
+    ACTION_START = 'ACTION_START',
+    ACTION_RESTART = 'ACTION_RESTART',
+}
+
+const {
+    STATE_WAITING_FOR_PLAYERS,
+    STATE_IN_PROGRESS,
+    STATE_END,
+} = StandardStateMachineStates;
+
+const {
+    ACTION_TO_END,
+    ACTION_START,
+    ACTION_RESTART,
+} = StandardStateMachineActions;
+
+const config: StateMachineConfig = {
+    [STATE_WAITING_FOR_PLAYERS]: {
+        on: {
+            [ACTION_START]: STATE_IN_PROGRESS,
+        },
+    },
+    [STATE_IN_PROGRESS]: {
+        on: {
+            [ACTION_TO_END]: STATE_END,
+        },
+    },
+    [STATE_END]: {
+        on: {
+            [ACTION_RESTART]: STATE_WAITING_FOR_PLAYERS,
+        },
+    },
+};
+
+export class StandardGameState extends GameStateMachine<StandardStateMachineStates, StandardStateMachineActions> {
+    constructor () {
+        super(StandardStateMachineStates.STATE_WAITING_FOR_PLAYERS, config);
+    }
+
+    isWaiting () {
+        return this.getCurrentState() === StandardStateMachineStates.STATE_WAITING_FOR_PLAYERS;
+    }
+
+    isInProgress () {
+        return this.getCurrentState() === StandardStateMachineStates.STATE_IN_PROGRESS;
+    }
+
+    isEnd () {
+        return this.getCurrentState() === StandardStateMachineStates.STATE_END;
+    }
+
+    toStart () {
+        this.send(StandardStateMachineActions.ACTION_START);
+    }
+
+    toFinish () {
+        this.send(StandardStateMachineActions.ACTION_TO_END);
+    }
+}

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

@@ -0,0 +1,59 @@
+import { GamePlayer } from '../base';
+import { IGameTable } from '../base/game-table';
+
+import { TournamentRoom, TournamentRoomConfig } from './tournament-room';
+
+export abstract class FastTournamentRoom<
+    GT extends IGameTable<GP>,
+    GP extends GamePlayer,
+> extends TournamentRoom<GT, GP> {
+    constructor (config: TournamentRoomConfig) {
+        super(config);
+        this.createTable();
+    }
+
+    handleJoinTournament (player: GP) {
+        const onlyTable = this.getFirstTable();
+        if (this.getState().isWaiting() && onlyTable && onlyTable.hasSeats()) {
+            onlyTable.addPlayerToSeat(player);
+            if (onlyTable.isFull()) {
+                this.startTournament();
+            }
+        }
+    }
+
+    handleLeaveTournament (player: GP) {
+        const onlyTable = this.getFirstTable();
+        if (onlyTable) {
+            if (player.isPlayer()) {
+                onlyTable.removePlayerFromSeat(player);
+            } else {
+                onlyTable.removePlayerFromWatchers(player);
+            }
+        }
+    }
+
+    handleFinishRound = () => {
+    };
+
+    handleRestartRound = () => {
+        if (this.isTournamentFinish()) {
+            this.finishTournament();
+        }
+    };
+
+    startTournament () {
+        this.getFirstTable()?.getPlayers().forEach((player) => this.addParticipant(player));
+        this.getState().toStart();
+        this.getFirstTable()?.startNewRound();
+    }
+
+    finishTournament () {
+        this.getState().toFinish();
+        this.calculateWinners();
+    }
+
+    isTournamentFinish (): boolean {
+        return this.getFirstTable()?.remainOnePlayer() ?? false;
+    }
+}

package/src/base-rooms/index.ts

@@ -0,0 +1,19 @@
+import { FastTournamentRoom } from './fast-tournament-room';
+import { ScheduledTournamentRoom } from './scheduled-tournament-room';
+import { SimpleRoom } from './simple-room';
+import { ITournamentParticipant } from './tournament-participant';
+import { TournamentPrizes } from './tournament-prize';
+import { TournamentRoom } from './tournament-room';
+import { TournamentState } from './tournament-state';
+import { ITournamentWinner } from './tournament-winner';
+
+export {
+    FastTournamentRoom,
+    SimpleRoom,
+    ITournamentParticipant,
+    TournamentPrizes,
+    ScheduledTournamentRoom,
+    TournamentRoom,
+    TournamentState,
+    ITournamentWinner,
+}