jp.ms.common.engine 1.0.20 → 2.0.0

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

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

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

@@ -0,0 +1,37 @@
+import { GamePlayer } from './game-player';
+
+export class GamePlayerExited {
+    private readonly _id;
+    private readonly _fullName;
+    private readonly _balance;
+    private readonly _stack;
+    private readonly _totalBet;
+
+    constructor (player: GamePlayer) {
+        this._id = player.id;
+        this._fullName = player.fullName;
+        this._balance = player.balance;
+        this._stack = player.stack;
+        this._totalBet = player.totalBet;
+    }
+
+    get id () {
+        return this._id;
+    }
+
+    get fullName () {
+        return this._fullName;
+    }
+
+    get balance () {
+        return this._balance;
+    }
+
+    get stack () {
+        return this._stack;
+    }
+
+    get totalBet () {
+        return this._totalBet;
+    }
+}

package/src/base/game-player.ts

@@ -1,13 +1,8 @@
-import { GamePlayerMove } from './game-player-move';
 import { GamePlayerConnectionsHelper } from './game-player-connections-helper';
-
-export enum GamePlayerRole {
-    VISITOR = 'VISITOR',
-    WATCHER = 'WATCHER',
-    TABLE_QUEUER = 'TABLE_QUEUER',
-    PLAYER = 'PLAYER',
-    TOURNAMENT_QUEUER = 'TOURNAMENT_QUEUER',
-}
+import { GameRoom } from './game-room';
+import { GameTable } from './game-table';
+import { GameTableSeat } from './game-table-seat';
+import { BaseMoveData } from './base-move-data';
 
 export enum GamePlayerColor {
     NO_COLOR = 0,
@@ -15,179 +10,292 @@ export enum GamePlayerColor {
     BLACK = -1,
 }
 
+export interface IGamePlayerConfig {
+    id: string,
+    fullName: string,
+    avatarUrl: string,
+    balance: number,
+    experience: number,
+    level: number,
+    language: string,
+    color?: number,
+}
+
 export abstract class GamePlayer {
-    private readonly id: string;
-    private readonly fullName: string;
-    private readonly avatarUrl: string;
-    private balance: number;
-    private gameId: string | null = null;
-    private roomId: string | null = null;
-    private tableId: string | null = null;
-    private seatNumber: number | null = null;
-    private role: string | null = null;
-    protected stack: number;
-    private readonly color: number;
-    private bet: number;
-    private move: GamePlayerMove | undefined;
-    public readonly connections: GamePlayerConnectionsHelper;
-
-    protected constructor (
-        id: string,
-        fullName: string,
-        avatarUrl: string,
-        balance: number,
-        color?: number,
-    ) {
-        this.id = id;
-        this.fullName = fullName;
-        this.avatarUrl = avatarUrl;
-        this.balance = balance;
-        this.stack = 0;
-        this.color = color ?? 0;
-        this.bet = 0;
-        this.connections = new GamePlayerConnectionsHelper();
-    }
-
-    getId (): string {
-        return this.id;
-    }
-
-    getFullName (): string {
-        return this.fullName;
-    }
-
-    getAvatarUrl (): string {
-        return this.avatarUrl;
-    }
-
-    getBalance (): number {
-        return this.balance;
+    private readonly _id: string;
+    private readonly _fullName: string;
+    private readonly _avatarUrl: string;
+    private readonly _color: number;
+    private _experience: number;
+    private _level: number;
+    private readonly _language: string;
+
+    private _balance: number;
+    private _stack: number;
+    private _room?: GameRoom | null;
+    private _table?: GameTable | null;
+    private _tableSeat?: GameTableSeat | null;
+
+    private _bet: number;
+    private _totalBet: number;
+    private _profit: number;
+    private _lastMove?: BaseMoveData | null;
+    private _isWinner: boolean;
+    private _isLoser: boolean;
+    private _disconnectedDate: Date | null;
+
+    private readonly _connections: GamePlayerConnectionsHelper;
+
+    protected constructor (config: IGamePlayerConfig) {
+        const {
+            id,
+            fullName,
+            avatarUrl,
+            balance,
+            experience,
+            level,
+            color,
+            language,
+        } = config;
+
+        this._id = id;
+        this._fullName = fullName;
+        this._avatarUrl = avatarUrl;
+        this._balance = balance;
+        this._experience = experience;
+        this._level = level;
+        this._language = language;
+        this._stack = 0;
+        this._color = color ?? 0;
+        this._bet = 0;
+        this._totalBet = 0;
+        this._profit = 0;
+        this._lastMove = null;
+        this._isWinner = false;
+        this._isLoser = false;
+        this._connections = new GamePlayerConnectionsHelper();
+        this._disconnectedDate = null;
+    }
+
+    get id (): string {
+        return this._id;
+    }
+
+    get fullName (): string {
+        return this._fullName;
+    }
+
+    get avatarUrl (): string {
+        return this._avatarUrl;
+    }
+
+    get balance (): number {
+        return this._balance;
+    }
+
+    get language (): string {
+        return this._language;
     }
 
     increaseBalance (amount: number): void {
-        this.balance += amount;
+        this._balance += amount;
     }
 
     decreaseBalance (amount: number): void {
-        this.balance -= amount;
+        this._balance -= amount;
+    }
+
+    hasEnoughMoneyForTheGame (price: number) {
+        return this.balance >= price;
+    }
+
+    get experience (): number {
+        return this._experience;
+    }
+
+    addExperience (amount: number) {
+        this._experience += amount;
+    }
+
+    get level (): number {
+        return this._level;
+    }
+
+    levelUp (): number {
+        return this._level += 1;
+    }
+
+    get stack () {
+        return this._stack;
     }
 
-    makeBet (bet: number) {
-        this.stack -= bet;
-        this.bet = bet;
+    set stack (amount: number) {
+        this._stack = amount;
     }
 
-    getBet () {
-        return this.bet;
+    get bet () {
+        return this._bet;
+    }
+
+    get totalBet () {
+        return this._totalBet;
     }
 
     increaseBet (bet: number) {
-        this.bet += bet;
-        this.stack -= bet;
+        this._stack -= bet;
+        this._bet += bet;
+        this._totalBet += bet;
     }
 
-    getColor () {
-        return this.color;
+    get profit () {
+        return this._profit;
     }
 
-    getRoomId () {
-        return this.roomId;
+    get color () {
+        return this._color;
     }
 
-    getTableId () {
-        return this.tableId;
+    isWhite () {
+        return this._color === GamePlayerColor.WHITE;
     }
 
-    getSeatNumber () {
-        return this.seatNumber;
+    isBlack () {
+        return this._color === GamePlayerColor.BLACK;
     }
 
-    watch (roomId: string, tableId: string) {
-        this.roomId = roomId;
-        this.tableId = tableId;
-        this.role = GamePlayerRole.WATCHER;
+    get room () {
+        return this._room;
     }
 
-    seat (roomId: string, tableId: string, seatNumber: number) {
-        this.roomId = roomId;
-        this.tableId = tableId;
-        this.seatNumber = seatNumber;
-        this.role = GamePlayerRole.PLAYER;
+    get roomId () {
+        return this._room?.getId();
     }
 
-    getInTableQueue (roomId: string, tableId: string) {
-        this.roomId = roomId;
-        this.tableId = tableId;
-        this.role = GamePlayerRole.TABLE_QUEUER;
+    get table () {
+        return this._table;
     }
 
-    getInTournamentQueue (roomId: string) {
-        this.roomId = roomId;
-        this.role = GamePlayerRole.TOURNAMENT_QUEUER;
+    get tableId () {
+        return this._table?.getId();
     }
 
-    isWatcher (): boolean {
-        return this.role === GamePlayerRole.WATCHER;
+    set lastMove (move: BaseMoveData) {
+        this._lastMove = move;
     }
 
-    isPlayer (): boolean {
-        return this.role === GamePlayerRole.PLAYER;
+    getLastMove<T extends BaseMoveData> (): T | undefined {
+        return this._lastMove as T | undefined;
     }
 
-    isTableQueuer (): boolean {
-        return this.role === GamePlayerRole.TABLE_QUEUER;
+    clearLastMove () {
+        this._lastMove = undefined;
     }
 
-    isTournamentQueuer (): boolean {
-        return this.role === GamePlayerRole.TOURNAMENT_QUEUER;
+    get isWinner (): boolean {
+        return this._isWinner;
     }
 
-    quit () {
-        this.roomId = null;
-        this.tableId = null;
-        this.seatNumber = null;
-        this.role = null;
+    win (amount: number) {
+        this._isWinner = true;
+        this._profit = amount;
     }
 
-    getStack () {
-        return this.stack;
+    get isLoser (): boolean {
+        return this._isLoser;
     }
 
-    setStack (stack: number) {
-        this.stack = stack;
+    loose (amount: number) {
+        this._isLoser = true;
+        this._profit = -amount;
     }
 
-    hasEmptyStack () {
-        return this.getStack() === 0;
+    get seatNumber () {
+        return this._tableSeat?.getNumber() ?? 0;
     }
 
-    hasOpenConnection () {
-        return this.connections.hasOpenConnection();
+    getSeat () {
+        return this._tableSeat;
     }
 
-    sendMessage (message: string) {
-        this.connections.getAllOpenConnections().forEach((connection) => {
-            connection.send(message);
-        });
+    isActivePlayer () {
+        return this.table?.getMaster()?.isActivePlayer(this._id) ?? false;
     }
 
-    flush () {
+    becomeWatcher (room: GameRoom, table: GameTable) {
+        this._room = room;
+        this._table = table;
+    }
 
+    becomePlayer (room: GameRoom, table: GameTable, seat: GameTableSeat) {
+        this._room = room;
+        this._table = table;
+        this._tableSeat = seat;
     }
 
-    getMove () {
-        return this.move;
+    becomeTableQueuer (room: GameRoom, table: GameTable) {
+        this._room = room;
+        this._table = table;
     }
 
-    setMove (move: GamePlayerMove) {
-        this.move = move;
+    becomeRoomQueuer (room: GameRoom) {
+        this._room = room;
     }
 
-    isWhite () {
-        return this.color === GamePlayerColor.WHITE;
+    isNew (): boolean {
+        return !this.isPlayer() && !this.isTableQueuer() && !this.isRoomQueuer();
     }
 
-    isBlack () {
-        return this.color === GamePlayerColor.BLACK;
+    isWatcher (): boolean {
+        return !!this._table?.getWatcherById(this._id);
+    }
+
+    isPlayer (): boolean {
+        return !!this._table?.getPlayerById(this._id);
+    }
+
+    isTableQueuer (): boolean {
+        return !!this._table?.getTableQueuerById(this._id);
+    }
+
+    isRoomQueuer (): boolean {
+        return !!this._room?.getRoomQueuerById(this._id);
+    }
+
+    quit () {
+        this._room = null;
+        this._table = null;
+        this._tableSeat = null
+    }
+
+    hasEmptyStack () {
+        return this._stack === 0;
+    }
+
+    get connections () {
+        return this._connections;
+    }
+
+    hasOpenConnection () {
+        return this._connections.hasOpenConnection();
+    }
+
+    sendMessage (message: object) {
+        this._connections.getAllOpenConnections().forEach((connection) => {
+            connection.send(message);
+        });
+    }
+
+    flush () {
+        this._bet = 0;
+        this._totalBet = 0;
+        this._profit = 0;
+        this._isWinner = false;
+        this._isLoser = false;
+        this._lastMove = null;
+    }
+
+    disconnect () {
+        this._disconnectedDate = new Date();
+        this.connections.clearConnections();
     }
 }

package/src/base/game-result-equal-helper.ts

@@ -0,0 +1,17 @@
+import { GameResultHelper } from './game-result-helper';
+
+export abstract class GameResultEqualHelper extends GameResultHelper {
+    calcResult () {
+        this.getWinners().forEach((player) => {
+            player.win(this.getProfitEqual());
+        });
+
+        this.getLosers().forEach((player) => {
+            player.loose(player.totalBet);
+        });
+    }
+
+    getProfitEqual () {
+        return this.getPot() / this.getWinners().length;
+    }
+}

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

@@ -0,0 +1,36 @@
+import { differenceWith } from 'lodash';
+
+import { GamePlayer } from './game-player';
+import { GameMaster } from './game-master';
+
+export abstract class GameResultHelper {
+    protected readonly _master: GameMaster;
+
+    constructor (master: GameMaster) {
+        this._master = master;
+    }
+
+    abstract getWinners (): Array<GamePlayer>;
+
+    abstract calcResult (): void;
+
+    getMaster<T extends GameMaster> (): T {
+        return this._master as T;
+    }
+
+    getPot () {
+        return this._master.getGameRound()?.getPot() ?? 0;
+    }
+
+    getLosers (): Array<GamePlayer> {
+        return differenceWith(
+            this._master.getTable().getPlayers(),
+            this.getWinners(),
+            (all, losers) => all.id === losers.id,
+        );
+    }
+
+    getWinnersName (): string {
+        return this.getWinners().map((winner) => winner.fullName).join(', ');
+    }
+}

package/src/base/game-result-rating-helper.ts

@@ -0,0 +1,44 @@
+import { GameResultHelper } from './game-result-helper';
+import { GameMaster } from './game-master';
+import { GamePlayer } from './game-player';
+
+export interface PrizeTableItem {
+    min: number;
+    max: number;
+    prizes: Record<string, number | undefined>;
+}
+
+export interface PrizeTable extends Array<PrizeTableItem> {
+}
+
+export abstract class GameResultRatingHelper extends GameResultHelper {
+    private readonly _prizeTable: PrizeTable;
+
+    constructor (master: GameMaster, prizeTable: PrizeTable) {
+        super(master);
+        this._prizeTable = prizeTable;
+    }
+
+    calcResult () {
+        this.getWinners().forEach((player) => {
+            player.win(this.getProfitByRank(this.getRankByPlayer(player)));
+        });
+
+        this.getLosers().forEach((player) => {
+            player.loose(player.totalBet);
+        });
+    }
+
+    getProfitByRank (rank: number) {
+        const winnerLength = this.getWinners().length;
+        const prize = this._prizeTable.find((item) =>
+            winnerLength >= item.min && winnerLength <= item.max);
+        const rankPrize = (prize?.prizes[rank] ?? 0);
+
+        return rankPrize * this.getPot() / 100;
+    }
+
+    getRankByPlayer (player: GamePlayer): number {
+        return this._master.getGameRound()?.getPlayerRank(player) ?? 0;
+    };
+}