jp.ms.common.engine 1.0.20 → 2.0.0

package/src/base/game-room.ts

@@ -1,19 +1,34 @@
-import { first, remove } from 'lodash';
+import { findIndex, first, remove } from 'lodash';
+
+import { IStartStrategy } from '../strategies';
+import { BaseGameEvent } from '../events';
+import { GameRoomRoomCreatedEvent } from '../events';
 
 import { GameTable, GameTableConfig } from './game-table';
 import { GameMaster } from './game-master';
+import { GamePlayer } from './game-player';
+
+export interface LocalService {
+    t (key: string, options: object): string;
+}
 
-export type GameRoomConfig = {
+export interface GameRoomConfig {
     id: string;
     gameType: string;
     roomType: string;
     rulesType: string;
+    deckType?: string;
     maxPlayers: number;
     bet: number;
+    ticketPrice: number;
     title: Record<string, string>;
     subtitle: Record<string, string>;
     turnTimeout: number;
     restartTimeout: number;
+    localeService: LocalService;
+    startStrategy: IStartStrategy;
+    onRoomEvent?: (event: BaseGameEvent) => void;
+    onRoomTableGameFinished?: (master: GameMaster) => void;
 }
 
 export abstract class GameRoom {
@@ -21,35 +36,51 @@ export abstract class GameRoom {
     private readonly gameType: string;
     private readonly roomType: string;
     private readonly rulesType: string;
+    private readonly deckType?: string;
     private readonly maxPlayers: number;
     private readonly bet: number;
+    private readonly ticketPrice: number;
     private readonly title: Record<string, string>;
     private readonly subtitle: Record<string, string>;
     private readonly turnTimeout: number;
     private readonly restartTimeout: number;
     private createdTableCount: number;
     private readonly masters: Array<GameMaster>;
+    private readonly localeService: LocalService;
+    readonly startStrategy: IStartStrategy;
+    private techBreak: boolean;
+    private roomQueue: Map<string, GamePlayer>;
+    onRoomEvent: (event: BaseGameEvent) => void;
+    onRoomTableGameFinished: (master: GameMaster) => void;
 
     constructor (config: GameRoomConfig) {
         this.masters = [];
         this.createdTableCount = 0;
+        this.roomQueue = new Map();
+        this.techBreak = false;
         this.id = config.id;
         this.roomType = config.roomType;
         this.rulesType = config.rulesType;
         this.maxPlayers = config.maxPlayers;
         this.gameType = config.gameType;
+        this.deckType = config.deckType;
         this.bet = config.bet;
+        this.ticketPrice = config.ticketPrice;
         this.title = config.title;
         this.subtitle = config.subtitle;
         this.turnTimeout = config.turnTimeout;
         this.restartTimeout = config.restartTimeout;
-    }
-
-    abstract createMaster (): GameMaster;
+        this.localeService = config.localeService;
+        this.startStrategy = config.startStrategy;
+        this.onRoomEvent = config.onRoomEvent ?? function () {
+        };
+        this.onRoomTableGameFinished = config.onRoomTableGameFinished ?? function () {
+        };
 
-    abstract handleFinishRound (table: GameTable): void;
+        this.onRoomEvent(new GameRoomRoomCreatedEvent(this));
+    }
 
-    abstract handleRestartRound (table: GameTable): void;
+    abstract createMaster (room: GameRoom): GameMaster;
 
     getId () {
         return this.id;
@@ -60,13 +91,17 @@ export abstract class GameRoom {
     }
 
     getGameType () {
-        return this.roomType;
+        return this.gameType;
     }
 
     getRulesType () {
         return this.rulesType;
     }
 
+    getDeckType () {
+        return this.deckType;
+    }
+
     getMaxPlayers () {
         return this.maxPlayers;
     }
@@ -75,17 +110,17 @@ export abstract class GameRoom {
         return this.masters;
     }
 
-    getTables (): Array<GameTable> {
-        return this.masters.map(((item) => item.getTable()));
-    }
-
     getFirstMaster (): GameMaster | undefined {
         return first(this.getMasters());
     }
 
-    getMasterWithFreeSeats (): GameTable | undefined {
+    getTables (): Array<GameTable> {
+        return this.masters.map(((item) => item.getTable()));
+    }
+
+    getTableWithFreeSeats (): GameTable | undefined {
         return this.masters.find((master) =>
-            master.getTable().getPlayers().length + master.getTable().getQueue().length < master.getTable().getTableSize()).getTable();
+            master.getTable().getPlayersWithQueue().length < master.getTable().getTableSize())?.getTable();
     }
 
     remainOneMaster (): boolean {
@@ -105,7 +140,7 @@ export abstract class GameRoom {
     }
 
     addMaster (): void {
-        this.masters.push(this.createMaster());
+        this.masters.push(this.createMaster(this));
         this.createdTableCount += 1;
     }
 
@@ -113,13 +148,67 @@ export abstract class GameRoom {
         remove(this.masters, (master) => master.getId() === masterId);
     }
 
+    restartTable (masterId: string): void {
+        const index = findIndex(this.masters, (item) => item.getId() === masterId);
+        if (index !== -1) {
+            this.masters.splice(index, 1, this.createMaster(this));
+        }
+    }
+
     getBet () {
         return this.bet;
     }
 
+    getTicketPrice () {
+        return this.ticketPrice;
+    }
+
+    getRoomQueue () {
+        return Array.from(this.roomQueue.values());
+    }
+
+    getRoomQueuerById (playerId: string) {
+        return this.roomQueue.get(playerId);
+    }
+
+    getOnlineQueuers () {
+        return this.getRoomQueue().filter((item) => item.hasOpenConnection());
+    }
+
+    addUserRoomToQueue (player: GamePlayer) {
+        this.roomQueue.set(player.id, player);
+        player.becomeRoomQueuer(this);
+    }
+
+    removeUserFromQueue (player: GamePlayer) {
+        this.roomQueue.delete(player.id);
+        player.quit();
+    }
+
+    clearRoomQueue () {
+        this.roomQueue.forEach((player) => player.quit());
+        this.roomQueue.clear();
+    }
+
+    isTechBreak () {
+        return this.techBreak;
+    }
+
+    techBreakOn () {
+        this.techBreak = true;
+    }
+
+    techBreakOff () {
+        this.techBreak = false;
+    }
+
+    getLocaleService () {
+        return this.localeService;
+    }
+
     getConfigForTable (): GameTableConfig {
         return {
-            roomId: this.getId(),
+            room: this,
             number: this.getFreeTableNumber(),
             tableSize: this.getMaxPlayers(),
             bet: this.getBet(),
@@ -128,8 +217,6 @@ export abstract class GameRoom {
             subtitle: this.subtitle,
             turnTimeout: this.turnTimeout,
             restartTimeout: this.restartTimeout,
-            onRoomFinishRound: this.handleFinishRound,
-            onRoomRestartRound: this.handleRestartRound,
         };
     }
 }

package/src/base/game-round-history-item.enum.ts

@@ -0,0 +1,6 @@
+export enum GameRoundHistoryItemEnum {
+    MASTER_TAKE_BET = 'MASTER_TAKE_BET',
+    MASTER_MOVE = 'MASTER_MOVE',
+    MASTER_GIVES_FIGURES = 'MASTER_GIVES_FIGURES',
+    PLAYER_MOVE = 'PLAYER_MOVE',
+}

package/src/base/game-round-history-item.ts

@@ -0,0 +1,110 @@
+import { BaseMoveData } from './base-move-data';
+import { BaseFigure } from './base-figure';
+import { GameRoundHistoryItemEnum } from './game-round-history-item.enum';
+
+const MASTER_ID = 'GAME_MASTER';
+
+export class GameRoundHistoryItem {
+    private readonly _userId: string;
+    private readonly _fullName: string;
+    private readonly _date: Date;
+    private readonly _actionType: string;
+    private readonly _state: string;
+    private readonly _turnNumber: number;
+    private readonly _move?: BaseMoveData | null;
+    private readonly _figures?: Array<BaseFigure> | null;
+
+    constructor (
+        userId: string,
+        fullName: string,
+        state: string,
+        actionType: string,
+        turnNumber: number,
+        move: BaseMoveData | null,
+        figures: Array<BaseFigure> | null,
+    ) {
+        this._userId = userId;
+        this._fullName = fullName;
+        this._date = new Date();
+        this._actionType = actionType;
+        this._turnNumber = turnNumber;
+        this._state = state;
+        this._move = move;
+        this._figures = figures;
+    }
+
+    get userId () {
+        return this._userId;
+    }
+
+    get fullName () {
+        return this._fullName;
+    }
+
+    get date () {
+        return this._date;
+    }
+
+    get state () {
+        return this._state;
+    }
+
+    get actionType () {
+        return this._actionType;
+    }
+
+    get turnNumber () {
+        return this._turnNumber;
+    }
+
+    get move () {
+        return this._move;
+    }
+
+    get figures () {
+        return this._figures;
+    }
+
+    static createMasterItem (
+        state: string,
+        actionType: string,
+        turnNumber: number,
+        figures: Array<BaseFigure>,
+    ) {
+        return new GameRoundHistoryItem(
+            MASTER_ID,
+            MASTER_ID,
+            state,
+            actionType,
+            turnNumber,
+            null,
+            figures,
+        );
+    }
+
+    static createMasterGivesFigureItem (
+        state: string,
+        turnNumber: number,
+        figures: Array<BaseFigure>,
+    ) {
+        return GameRoundHistoryItem.createMasterItem(state, GameRoundHistoryItemEnum.MASTER_GIVES_FIGURES, turnNumber, figures);
+    }
+
+    static createPlayerMove (
+        userId: string,
+        fullName: string,
+        state: string,
+        turnNumber: number,
+        move: BaseMoveData
+    ) {
+        return new GameRoundHistoryItem(
+            userId,
+            fullName,
+            state,
+            GameRoundHistoryItemEnum.PLAYER_MOVE,
+            turnNumber,
+            move,
+            null,
+        );
+    }
+}

package/src/base/game-round.ts

@@ -2,13 +2,13 @@ import { v4 as uidv4 } from 'uuid';
 
 import { GamePlayer } from './game-player';
 import { GameStateMachine } from './game-state-machine';
+import { GameRoundHistoryItem } from './game-round-history-item';
+import { GamePlayerExited } from './game-player-exited';
+import { differenceWith } from 'lodash';
 
-export type GameRoundHistoryItem = {
-    userId: string;
-    fullName: string;
-    date: Date;
-    action: string;
-    state: string;
+interface PlayerRank {
+    rank: number;
+    player: GamePlayerExited;
 }
 
 export class GameRound {
@@ -16,21 +16,23 @@ export class GameRound {
     private id: string;
     private pot: number;
     private state: GameStateMachine;
-    private activePlayer: GamePlayer;
+    private activePlayer: GamePlayer | null = null;
+    private rating: Array<Array<GamePlayerExited>>;
 
     constructor (state: GameStateMachine) {
         this.id = uidv4();
         this.pot = 0;
         this.history = [];
         this.state = state;
+        this.rating = [];
     }
 
     getId (): string {
         return this.id;
     }
 
-    getState (): GameStateMachine {
-        return this.state;
+    getState<T extends GameStateMachine> (): T {
+        return this.state as T;
     }
 
     getHistory (): Array<GameRoundHistoryItem> {
@@ -49,12 +51,56 @@ export class GameRound {
         return this.pot;
     }
 
-    getActivePlayer () {
+    getActivePlayer (): GamePlayer | null {
         return this.activePlayer;
     }
 
     setActivePlayer (activePlayer: GamePlayer) {
         this.activePlayer = activePlayer;
     }
+
+    clearActivePlayer () {
+        this.activePlayer = null;
+    }
+
+    getRating () {
+        return this.rating;
+    }
+
+    addPlayersToRating (newPlayers: Array<GamePlayer>) {
+        const onlyNewPlayers = differenceWith(
+            newPlayers,
+            this.getRatingPlayers(),
+            (newPlayer, ratingPlayer) => newPlayer.id === ratingPlayer.id,
+        )
+
+        if (onlyNewPlayers.length > 0) {
+            this.rating.push(onlyNewPlayers.map((item) => new GamePlayerExited(item)));
+        }
+    }
+
+    getPlayerRankGroup () {
+        return this.rating.reduce<Array<PlayerRank>>(
+            (accumulator, currentPack, index) => {
+                currentPack.forEach((item) => {
+                    accumulator.push({
+                        rank: index + 1,
+                        player: item,
+                    })
+                })
+
+                return accumulator;
+            },
+            [],
+        );
+    }
+
+    getRatingPlayers () {
+        return this.getPlayerRankGroup().map((item) => item.player);
+    }
+
+    getPlayerRank (player: GamePlayer): number {
+        return this.getPlayerRankGroup().find((item) => item.player.id === player.id)?.rank ?? 0;
+    }
 }
 

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

@@ -5,6 +5,16 @@ export abstract class GameStateMachine {
     private currentState: string;
     private config: StateMachineConfig;
 
+    abstract toStart ();
+
+    abstract toFinish ();
+
+    abstract isWaiting ();
+
+    abstract isInProgress ();
+
+    abstract isFinish ();
+
     protected constructor (initialState: string, config: StateMachineConfig) {
         this.config = config;
         this.initialState = initialState;

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

@@ -1,21 +1,26 @@
+import { CircleListNode } from '../utils';
+
 import { GamePlayer } from './game-player';
 
-export class GameTableSeat {
+export class GameTableSeat extends CircleListNode {
+    private readonly number: number
     private player: GamePlayer | null = null;
-    private role: string | null;
+    private role: string | null = null;
 
-    constructor (private readonly number: number) {
+    constructor (number: number) {
+        super();
+        this.number = number;
     }
 
-    public getRole () {
+    getRole () {
         return this.role;
     }
 
-    public setRole (role: string) {
+    setRole (role: string) {
         this.role = role;
     }
 
-    public clearRole () {
+    clearRole () {
         this.role = null;
     }
 
@@ -34,4 +39,50 @@ export class GameTableSeat {
     removePlayer () {
         this.player = null;
     }
+
+    getNextSeat (): GameTableSeat | null {
+        return this.getNext<GameTableSeat>();
+    }
+
+    getNextSeatWithPlayer (): GameTableSeat | null {
+        let firstNode = this;
+        let nextNode = this.getNextSeat();
+
+        while (firstNode !== nextNode) {
+            if (nextNode?.getPlayer()) {
+                return nextNode;
+            }
+
+            nextNode = nextNode?.getNextSeat() ?? null;
+        }
+
+        return null;
+    }
+
+    getNextPlayer<T> (): T | null {
+        return this.getNextSeatWithPlayer()?.getPlayer() as T | null;
+    }
+
+    getPrevSeat (): GameTableSeat | null {
+        return this.getPrev<GameTableSeat>();
+    }
+
+    getPrevSeatWithPlayer (): GameTableSeat | null {
+        let firstNode = this;
+        let preNode = this.getPrevSeat();
+
+        while (firstNode !== preNode) {
+            if (preNode?.getPlayer()) {
+                return preNode;
+            }
+
+            preNode = preNode?.getPrevSeat() ?? null;
+        }
+
+        return null;
+    }
+
+    getPrevPlayer<T> (): T | null {
+        return this.getPrevSeatWithPlayer()?.getPlayer() as T | null;
+    }
 }

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

@@ -1,4 +1,4 @@
-import { compact } from 'lodash';
+import { compact, first } from 'lodash';
 
 import { CircleList } from '../utils';
 import { TWO_PLAYER_GAME } from '../const';
@@ -13,7 +13,7 @@ export class GameTableSeats {
         this.seats = new CircleList();
 
         for (let i = 0; i < this.tableSize; i += 1) {
-            this.seats.push(new GameTableSeat(i + 1));
+            this.seats.push(new GameTableSeat(i));
         }
     }
 
@@ -25,45 +25,30 @@ export class GameTableSeats {
         return this.seats.toArray().filter((item) => !!item.getPlayer());
     }
 
-    getSeat (number: number | null): GameTableSeat | undefined {
-        return this.seats.toArray().find((item) => item.getNumber() === number);
+    getFirstSeat (): GameTableSeat | null {
+        return first(this.getSeats()) ?? null;
     }
 
-    getNextSeat (from: number): GameTableSeat | undefined {
-        return this.seats.get(from - 1)?.getNext()?.getData();
+    getFirstSeatWithPlayer (): GameTableSeat | null {
+        return first(this.getSeatsWithPlayers()) ?? null;
     }
 
-    getNextPlayer (from: number): GamePlayer | null {
-        const nextSeat = this.getNextSeat(from);
-        const nextPlayer = nextSeat?.getPlayer();
-
-        if (!nextPlayer) {
-            return this.getNextPlayer(nextSeat?.getNumber() ?? 0);
-        }
-
-        return nextPlayer;
+    findFreeSeat (): GameTableSeat | undefined {
+        return this.seats.toArray().find((seat) => seat.getPlayer() === null);
     }
 
-    getPrevSeat (from: number): GameTableSeat | undefined {
-        return this.seats.get(from - 1)?.getPrev()?.getData();
+    getSeatByRole (role: string) {
+        return this.seats.toArray().find((item) => item.getRole() === role);
     }
 
-    getPrevPlayer (from: number): GamePlayer | null {
-        return this.getPrevSeat(from)?.getPlayer() ?? null;
+    getSeatByNumber (number: number | null): GameTableSeat | undefined {
+        return this.seats.toArray().find((item) => item.getNumber() === number);
     }
 
-    getPlayersChain (from: number): Array<GamePlayer> {
+    getPlayersChain<T extends GamePlayer> (from: number): Array<T> {
         const chain = this.seats.getNextChain(from).map((item) => item.getPlayer());
 
-        return compact(chain);
-    }
-
-    getFirstSeatWithPlayer (): GameTableSeat | null {
-        return this.getSeatsWithPlayers()[0] ?? null;
-    }
-
-    findFreeSeat (): GameTableSeat | undefined {
-        return this.seats.toArray().find((seat) => seat.getPlayer() === null);
+        return compact(chain) as Array<T>;
     }
 
     clearAllSeatsRole () {