jp.ms.common.engine 1.0.2 → 1.0.4

package/dist/tests/just-black-jack/tests/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/tests/just-black-jack/tests/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAG9D,eAAO,MAAM,OAAO,iBAKnB,CAAC;AAEF,eAAO,MAAM,OAAO,iBAKnB,CAAC;AAEF,eAAO,MAAM,OAAO,iBAKnB,CAAC;AAEF,eAAO,MAAM,OAAO,iBAKnB,CAAC;AAEF,eAAO,MAAM,OAAO,iBAKnB,CAAC;AAEF,eAAO,MAAM,OAAO,iBAKnB,CAAC;AAEF,eAAO,MAAM,OAAO,iBAKnB,CAAC;AAEF,eAAO,MAAM,OAAO,iBAKnB,CAAC;AAGF,wBAAgB,QAAQ,SAEvB"}

package/dist/tests/just-black-jack/tests/common.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.player8 = exports.player7 = exports.player6 = exports.player5 = exports.player4 = exports.player3 = exports.player2 = exports.player1 = void 0;
+exports.mockDeck = mockDeck;
+const black_jack_player_1 = require("../domain/black-jack-player");
+const shuffle = __importStar(require("../../../utils/shuffle"));
+exports.player1 = new black_jack_player_1.BlackJackPlayer('5ef77417f471c39c885d18f5', 'dima', '', 1000);
+exports.player2 = new black_jack_player_1.BlackJackPlayer('5ef774a71486d104736561a4', 'vova', '', 500);
+exports.player3 = new black_jack_player_1.BlackJackPlayer('5ef774a71486d104736561a5', 'pasha', '', 500);
+exports.player4 = new black_jack_player_1.BlackJackPlayer('5ef774a71486d104736561a7', 'petya', '', 500);
+exports.player5 = new black_jack_player_1.BlackJackPlayer('5ef774a71486d104736561a8', 'dima 2', '', 500);
+exports.player6 = new black_jack_player_1.BlackJackPlayer('5ef774a71486d104736561a9', 'vova 2', '', 500);
+exports.player7 = new black_jack_player_1.BlackJackPlayer('5ef774a71486d104736561a10', 'pasha 2', '', 500);
+exports.player8 = new black_jack_player_1.BlackJackPlayer('5ef774a71486d104736561a11', 'petya 2', '', 500);
+function mockDeck() {
+    jest.spyOn(shuffle, 'superShuffle').mockImplementation((collection) => collection);
+}
+//# sourceMappingURL=common.js.map

package/dist/tests/just-black-jack/tests/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../../src/tests/just-black-jack/tests/common.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,4BAEC;AA9DD,mEAA8D;AAC9D,gEAAkD;AAErC,QAAA,OAAO,GAAG,IAAI,mCAAe,CACxC,0BAA0B,EAC1B,MAAM,EACN,EAAE,EACF,IAAI,CACL,CAAC;AAEW,QAAA,OAAO,GAAG,IAAI,mCAAe,CACxC,0BAA0B,EAC1B,MAAM,EACN,EAAE,EACF,GAAG,CACJ,CAAC;AAEW,QAAA,OAAO,GAAG,IAAI,mCAAe,CACxC,0BAA0B,EAC1B,OAAO,EACP,EAAE,EACF,GAAG,CACJ,CAAC;AAEW,QAAA,OAAO,GAAG,IAAI,mCAAe,CACxC,0BAA0B,EAC1B,OAAO,EACP,EAAE,EACF,GAAG,CACJ,CAAC;AAEW,QAAA,OAAO,GAAG,IAAI,mCAAe,CACxC,0BAA0B,EAC1B,QAAQ,EACR,EAAE,EACF,GAAG,CACJ,CAAC;AAEW,QAAA,OAAO,GAAG,IAAI,mCAAe,CACxC,0BAA0B,EAC1B,QAAQ,EACR,EAAE,EACF,GAAG,CACJ,CAAC;AAEW,QAAA,OAAO,GAAG,IAAI,mCAAe,CACxC,2BAA2B,EAC3B,SAAS,EACT,EAAE,EACF,GAAG,CACJ,CAAC;AAEW,QAAA,OAAO,GAAG,IAAI,mCAAe,CACxC,2BAA2B,EAC3B,SAAS,EACT,EAAE,EACF,GAAG,CACJ,CAAC;AAGF,SAAgB,QAAQ;IACtB,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,kBAAkB,CAAC,CAAC,UAAiB,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC;AAC5F,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jp.ms.common.engine",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,7 +12,7 @@
     "node-schedule": "2.1.1",
     "seedrandom": "3.0.5",
     "shuffle-array": "1.0.1",
-    "uuid": "13.0.0"
+    "uuid": "11.1.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
@@ -23,6 +23,7 @@
     "@types/shuffle-array": "1.0.5",
     "jest": "^29.7.0",
     "rimraf": "6.0.1",
+    "socket.io": "4.8.1",
     "ts-jest": "^29.2.5",
     "typescript": "5.9.3"
   },

package/src/base/game-control-player-turn.ts

@@ -2,15 +2,15 @@ import { ONE_SECOND } from '../const';
 
 import { GamePlayer } from './game-player';
 
-export class GameControlPlayerTurn<GP extends GamePlayer> {
+export class GameControlPlayerTurn {
     private readonly playersTurnTimeout: number;
     private playerTurnTimerId?: NodeJS.Timeout;
     private playerTurnTimerDate: Date | null;
-    private readonly handleTurnTimeout: (player: GP) => void;
+    private readonly handleTurnTimeout: (player: GamePlayer) => void;
 
     constructor (
         playersTurnTimeout: number,
-        handleTurnTimeout: (player: GP) => void,
+        handleTurnTimeout: (player: GamePlayer) => void,
     ) {
         this.playersTurnTimeout = playersTurnTimeout;
         this.handleTurnTimeout = handleTurnTimeout;
@@ -20,7 +20,7 @@ export class GameControlPlayerTurn<GP extends GamePlayer> {
         return this.playersTurnTimeout > 0;
     }
 
-    setPlayerTurnTimeout (player: GP | null) {
+    setPlayerTurnTimeout (player: GamePlayer | null) {
         this.playerTurnTimerDate = new Date();
         if (this.isEnableTimer() && player) {
             this.playerTurnTimerId = setTimeout(
@@ -30,7 +30,7 @@ export class GameControlPlayerTurn<GP extends GamePlayer> {
         }
     }
 
-    clearPlayerTurnTimeout (player: GP | null) {
+    clearPlayerTurnTimeout (player: GamePlayer | null) {
         if (this.playerTurnTimerId) {
             clearTimeout(this.playerTurnTimerId);
             this.playerTurnTimerDate = null;

package/src/base/game-master.ts

@@ -1,26 +1,28 @@
 import { GamePlayer } from './game-player';
-import { IGameTable } from './game-table';
 import { GameControlPlayerTurn } from './game-control-player-turn';
 import { GameControlRestart } from './game-control-restart';
-import { IGameRound } from './game-round';
-
-export abstract class GameMaster<GT extends IGameTable<GP>, GR extends IGameRound<GP>, GP extends GamePlayer, GSR> {
-    protected readonly table: GT;
-    protected gameRound: GR | null;
-    public readonly controlTurn: GameControlPlayerTurn<GP>;
+import { GameTable } from './game-table';
+import { GameSummaryResult } from './game-summary-result';
+import { GameRound } from './game-round';
+import { GameRoom } from './game-room';
+
+export abstract class GameMaster {
+    protected readonly table: GameTable;
+    protected gameRound: GameRound | null;
+    public readonly controlTurn: GameControlPlayerTurn;
     public readonly controlRestart: GameControlRestart;
 
-    protected constructor (table: GT) {
-        this.table = table;
+    protected constructor (room: GameRoom) {
+        this.table = new GameTable(room.getConfigForTable());
         this.controlTurn = new GameControlPlayerTurn(this.table.getTurnTimeout(), this.onHandleTurnTimeout);
         this.controlRestart = new GameControlRestart(this.table.getRestartTimeout(), this.onHandleRestartTimeout);
     }
 
-    abstract onHandleTurnTimeout (player: GP);
+    abstract onHandleTurnTimeout (player: GamePlayer);
 
     abstract onHandleRestartTimeout ();
 
-    abstract kickPlayer (player: GP);
+    abstract kickPlayer (player: GamePlayer);
 
     abstract startNewRound ();
 
@@ -28,15 +30,19 @@ export abstract class GameMaster<GT extends IGameTable<GP>, GR extends IGameRoun
 
     abstract changePlayer ();
 
-    abstract getResults (): GSR | null;
+    abstract getResults (): GameSummaryResult | null;
+
+    abstract onHandleMove (player: GamePlayer);
 
-    abstract onHandleMove (player: GP);
+    getId () {
+       return this.table.getId();
+    }
 
-    setGameRound (gameRound: GR): void {
+    setGameRound (gameRound: GameRound): void {
         this.gameRound = gameRound;
     }
 
-    getGameRound (): GR | null {
+    getGameRound (): GameRound | null {
         return this.gameRound;
     }
 
@@ -44,7 +50,7 @@ export abstract class GameMaster<GT extends IGameTable<GP>, GR extends IGameRoun
         return this.table;
     }
 
-    enterTheTable (player: GP) {
+    enterTheTable (player: GamePlayer) {
         if (this.table.isFull()) {
             this.table.addPlayerToQueue(player);
         } else {
@@ -52,7 +58,7 @@ export abstract class GameMaster<GT extends IGameTable<GP>, GR extends IGameRoun
         }
     }
 
-    exitTheTable (player: GP) {
+    exitTheTable (player: GamePlayer) {
         if (player.isPlayer()) {
             this.table.removePlayerFromSeat(player);
         } else if (player.isTableQueuer()) {
@@ -62,7 +68,7 @@ export abstract class GameMaster<GT extends IGameTable<GP>, GR extends IGameRoun
         }
     }
 
-    watchTheTable (player: GP) {
+    watchTheTable (player: GamePlayer) {
         this.table.addPlayerToWatchers(player);
     }
 
@@ -91,7 +97,7 @@ export abstract class GameMaster<GT extends IGameTable<GP>, GR extends IGameRoun
         }
     }
 
-    getActivePlayer (): GP | null {
+    getActivePlayer (): GamePlayer | null {
         return this.getGameRound()?.getActivePlayer() ?? null;
     }
 

package/src/base/game-player-connections-helper.ts

@@ -0,0 +1,40 @@
+import { Socket } from 'socket.io';
+
+export class GamePlayerConnectionsHelper {
+    private readonly connections: Record<string, Socket>;
+
+    constructor () {
+        this.connections = {};
+    }
+
+    public getAllConnections () {
+        return Object.keys(this.connections)
+            .map((key) => ({ key, connection: this.connections[key] }));
+    }
+
+    public addConnection (connection: Socket) {
+        this.connections[connection.id] = connection;
+    }
+
+    public clearConnections () {
+        this.getClosedConnections().forEach((connection) => {
+            delete this.connections[connection.key];
+        });
+    }
+
+    public hasOpenConnection () {
+        return this.getOpenConnections().length > 0;
+    }
+
+    private getOpenConnections () {
+        return this.getAllConnections()
+            .filter((connection) =>
+                connection.connection.connected);
+    }
+
+    private getClosedConnections () {
+        return this.getAllConnections()
+            .filter((connection) =>
+                !connection.connection.connected);
+    }
+}

package/src/base/game-player.ts

@@ -1,4 +1,5 @@
 import { GamePlayerMove } from './game-player-move';
+import { GamePlayerConnectionsHelper } from './game-player-connections-helper';
 
 export enum GamePlayerRole {
     VISITOR = 'VISITOR',
@@ -28,8 +29,9 @@ export abstract class GamePlayer {
     private readonly color: number;
     private bet: number;
     private move: GamePlayerMove | undefined;
+    public readonly connections: GamePlayerConnectionsHelper;
 
-    constructor (
+    protected constructor (
         id: string,
         fullName: string,
         avatarUrl: string,
@@ -43,6 +45,7 @@ export abstract class GamePlayer {
         this.stack = 0;
         this.color = color ?? 0;
         this.bet = 0;
+        this.connections = new GamePlayerConnectionsHelper();
     }
 
     getId (): string {
@@ -159,7 +162,7 @@ export abstract class GamePlayer {
     }
 
     hasOpenConnection () {
-        return true;
+        return this.connections.hasOpenConnection();
     }
 
     flush () {

package/src/base/game-room.ts

@@ -1,8 +1,7 @@
-import { first } from 'lodash';
-import { remove } from 'lodash';
+import { first, remove } from 'lodash';
 
-import { GameTableConfig, IGameTable } from './game-table';
-import { GamePlayer } from './game-player';
+import { GameTable, GameTableConfig } from './game-table';
+import { GameMaster } from './game-master';
 
 export type GameRoomConfig = {
     id: string;
@@ -15,20 +14,20 @@ export type GameRoomConfig = {
     restartTimeout: number;
 }
 
-export abstract class GameRoom<GT extends IGameTable<GP>, GP extends GamePlayer> {
+export abstract class GameRoom {
     private readonly id: string;
     private readonly gameType: string;
     private readonly roomType: string;
     private readonly rulesType: string;
     private readonly maxPlayers: number;
     private readonly bet: number;
-    private readonly tables: Array<GT>;
     private readonly turnTimeout: number;
     private readonly restartTimeout: number;
     private createdTableCount: number;
+    private readonly masters: Array<GameMaster>;
 
     constructor (config: GameRoomConfig) {
-        this.tables = [];
+        this.masters = [];
         this.createdTableCount = 0;
         this.id = config.id;
         this.roomType = config.roomType;
@@ -40,15 +39,11 @@ export abstract class GameRoom<GT extends IGameTable<GP>, GP extends GamePlayer>
         this.restartTimeout = config.restartTimeout;
     }
 
-    abstract createTable (): GT;
+    abstract createMaster (): GameMaster;
 
-    abstract handleWatchTheTable (player: GP, tableId: string);
+    abstract handleFinishRound (table: GameTable): void;
 
-    abstract handleMove (player: GP, tableId: string);
-
-    abstract handleFinishRound (table: IGameTable<GP>);
-
-    abstract handleRestartRound (table: IGameTable<GP>);
+    abstract handleRestartRound (table: GameTable): void;
 
     getId () {
         return this.id;
@@ -70,24 +65,25 @@ export abstract class GameRoom<GT extends IGameTable<GP>, GP extends GamePlayer>
         return this.maxPlayers;
     }
 
-    getTables (): Array<GT> {
-        return this.tables;
+    getMasters (): Array<GameMaster> {
+        return this.masters;
     }
 
-    getFirstTable (): GT | undefined {
-        return first(this.getTables());
+    getFirstMaster (): GameMaster | undefined {
+        return first(this.getMasters());
     }
 
-    getTableWithFreeSeats (): GT | undefined {
-        return this.tables.find((table) => table.getPlayers().length + table.getQueue().length < table.getTableSize());
+    getMasterWithFreeSeats (): GameTable | undefined {
+        return this.masters.find((master) =>
+            master.getTable().getPlayers().length + master.getTable().getQueue().length < master.getTable().getTableSize()).getTable();
     }
 
-    remainOneTable (): boolean {
-        return this.tables.length === 1;
+    remainOneMaster (): boolean {
+        return this.masters.length === 1;
     }
 
-    getTableById (id: string): GT | undefined {
-        return this.tables.find((item) => item.getId() === id);
+    getMasterById (id: string): GameMaster | undefined {
+        return this.masters.find((item) => item.getId() === id);
     }
 
     getFreeTableNumber (): number {
@@ -98,30 +94,30 @@ export abstract class GameRoom<GT extends IGameTable<GP>, GP extends GamePlayer>
         return this.createdTableCount;
     }
 
-    addTable (newTable: GT): void {
-        this.tables.push(newTable);
+    addMaster (): void {
+        this.masters.push(this.createMaster());
         this.createdTableCount += 1;
     }
 
-    removeTable (removingTable: GT): void {
-        remove(this.tables, (table) => table.getId() === removingTable.getId());
+    removeMaster (masterId: string): void {
+        remove(this.masters, (master) => master.getId() === masterId);
     }
 
     getBet () {
         return this.bet;
     }
 
-    getConfigForTable (): GameTableConfig<GP> {
+    getConfigForTable (): GameTableConfig {
         return {
             roomId: this.getId(),
             number: this.getFreeTableNumber(),
             tableSize: this.getMaxPlayers(),
             bet: this.getBet(),
+            rulesType: this.getRulesType(),
             turnTimeout: this.turnTimeout,
             restartTimeout: this.restartTimeout,
             onRoomFinishRound: this.handleFinishRound,
             onRoomRestartRound: this.handleRestartRound,
-            rulesType: this.getRulesType(),
         };
     }
 }

package/src/base/game-round.ts

@@ -1,5 +1,8 @@
 import { v4 as uidv4 } from 'uuid';
 
+import { GamePlayer } from './game-player';
+import { GameStateMachine } from './game-state-machine';
+
 export type GameRoundHistoryItem = {
     userId: string;
     fullName: string;
@@ -8,33 +11,24 @@ export type GameRoundHistoryItem = {
     state: string;
 }
 
-export interface IGameRound<GP> {
-    getActivePlayer (): GP;
-
-    setActivePlayer (activePlayer: GP);
-}
-
-export abstract class GameRound<SM, GP> implements IGameRound<GP> {
+export class GameRound {
     private readonly history: Array<GameRoundHistoryItem>;
     private id: string;
     private pot: number;
-    private state: SM;
-    private activePlayer: GP;
+    private state: GameStateMachine;
+    private activePlayer: GamePlayer;
 
-    protected constructor () {
+    constructor (state: GameStateMachine) {
         this.id = uidv4();
         this.pot = 0;
         this.history = [];
+        this.state = state;
     }
 
-    getState (): SM {
+    getState (): GameStateMachine {
         return this.state;
     }
 
-    setState (state: SM): void {
-        this.state = state;
-    }
-
     getHistory (): Array<GameRoundHistoryItem> {
         return this.history;
     }
@@ -55,7 +49,7 @@ export abstract class GameRound<SM, GP> implements IGameRound<GP> {
         return this.activePlayer;
     }
 
-    setActivePlayer (activePlayer: GP) {
+    setActivePlayer (activePlayer: GamePlayer) {
         this.activePlayer = activePlayer;
     }
 }

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

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

package/src/base/game-summary-result.ts

@@ -0,0 +1,3 @@
+export class GameSummaryResult {
+
+}

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

@@ -1,7 +1,7 @@
 import { GamePlayer } from './game-player';
 
-export class GameTableSeat<GP extends GamePlayer> {
-    private player: GP | null = null;
+export class GameTableSeat {
+    private player: GamePlayer | null = null;
     private role: string | null;
 
     constructor (private readonly number: number) {
@@ -27,7 +27,7 @@ export class GameTableSeat<GP extends GamePlayer> {
         return this.player;
     }
 
-    addPlayer (player: GP) {
+    addPlayer (player: GamePlayer) {
         this.player = player;
     }
 

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

@@ -6,34 +6,34 @@ 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>>;
+export class GameTableSeats {
+    protected readonly seats: CircleList<GameTableSeat>;
 
     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));
+            this.seats.push(new GameTableSeat(i + 1));
         }
     }
 
-    getSeats (): Array<GameTableSeat<GP>> {
+    getSeats (): Array<GameTableSeat> {
         return this.seats.toArray();
     }
 
-    getSeatsWithPlayers (): Array<GameTableSeat<GP>> {
+    getSeatsWithPlayers (): Array<GameTableSeat> {
         return this.seats.toArray().filter((item) => !!item.getPlayer());
     }
 
-    getSeat (number: number | null): GameTableSeat<GP> | undefined {
+    getSeat (number: number | null): GameTableSeat | undefined {
         return this.seats.toArray().find((item) => item.getNumber() === number);
     }
 
-    getNextSeat (from: number): GameTableSeat<GP> | undefined {
+    getNextSeat (from: number): GameTableSeat | undefined {
         return this.seats.get(from - 1)?.getNext()?.getData();
     }
 
-    getNextPlayer (from: number): GP | null {
+    getNextPlayer (from: number): GamePlayer | null {
         const nextSeat = this.getNextSeat(from);
         const nextPlayer = nextSeat?.getPlayer();
 
@@ -44,25 +44,25 @@ export class GameTableSeats<GP extends GamePlayer> {
         return nextPlayer;
     }
 
-    getPrevSeat (from: number): GameTableSeat<GP> | undefined {
+    getPrevSeat (from: number): GameTableSeat | undefined {
         return this.seats.get(from - 1)?.getPrev()?.getData();
     }
 
-    getPrevPlayer (from: number): GP | null {
+    getPrevPlayer (from: number): GamePlayer | null {
         return this.getPrevSeat(from)?.getPlayer() ?? null;
     }
 
-    getPlayersChain (from: number): Array<GP> {
+    getPlayersChain (from: number): Array<GamePlayer> {
         const chain = this.seats.getNextChain(from).map((item) => item.getPlayer());
 
         return compact(chain);
     }
 
-    getFirstSeatWithPlayer (): GameTableSeat<GP> | null {
+    getFirstSeatWithPlayer (): GameTableSeat | null {
         return this.getSeatsWithPlayers()[0] ?? null;
     }
 
-    findFreeSeat (): GameTableSeat<GP> | undefined {
+    findFreeSeat (): GameTableSeat | undefined {
         return this.seats.toArray().find((seat) => seat.getPlayer() === null);
     }