jp.ms.common.engine 1.0.21 → 2.0.0

package/src/base/game-table.ts

@@ -1,11 +1,13 @@
-import { compact, first, remove, slice } from 'lodash';
+import { compact, first, slice } from 'lodash';
 
 import { GamePlayer } from './game-player';
 import { GameTableSeats } from './game-table-seats';
+import { GameRoom } from './game-room';
+import { GamePlayerExited } from './game-player-exited';
 import { GameMaster } from './game-master';
 
-export type GameTableConfig = {
-    roomId: string;
+export interface GameTableConfig {
+    room: GameRoom;
     number: number;
     tableSize: number;
     bet: number;
@@ -14,12 +16,15 @@ export type GameTableConfig = {
     subtitle: Record<string, string>;
     turnTimeout: number;
     restartTimeout: number;
-    onRoomFinishRound: (table: GameTable) => void
-    onRoomRestartRound: (table: GameTable) => void
 }
 
 export class GameTable {
-    private readonly roomId: string;
+    private readonly room: GameRoom;
+    private readonly watchers: Map<string, GamePlayer>;
+    private readonly tableQueue: Map<string, GamePlayer>;
+    public readonly seats: GameTableSeats;
+    private readonly exitedPlayers: Map<string, GamePlayerExited>;
+
     private readonly number: number;
     private readonly tableSize: number;
     private readonly bet: number;
@@ -27,19 +32,12 @@ export class GameTable {
     private readonly subtitle: Record<string, string>;
     private readonly turnTimeout: number;
     private readonly restartTimeout: number;
-    private readonly queue: Array<GamePlayer>;
-    private readonly watchers: Array<GamePlayer>;
-    public readonly seats: GameTableSeats;
-    public master: GameMaster;
-    public onRoomFinishRound: (table: GameTable) => void;
-    public onRoomRestartRound: (table: GameTable) => void;
 
     constructor (config: GameTableConfig) {
-        this.queue = [];
-        this.watchers = [];
-        this.onRoomFinishRound = config.onRoomFinishRound;
-        this.onRoomRestartRound = config.onRoomRestartRound;
-        this.roomId = config.roomId;
+        this.tableQueue = new Map();
+        this.watchers = new Map();
+        this.exitedPlayers = new Map();
+        this.room = config.room;
         this.number = config.number;
         this.tableSize = config.tableSize;
         this.bet = config.bet;
@@ -50,12 +48,16 @@ export class GameTable {
         this.seats = new GameTableSeats(this.getTableSize());
     }
 
+    getMaster<T extends GameMaster> () {
+        return this.room.getMasterById(this.getId()) as T;
+    }
+
     getRoomId () {
-        return this.roomId;
+        return this.room.getId();
     }
 
     getId () {
-        return `${this.roomId}_${this.number}`;
+        return `${this.getRoomId()}_${this.number}`;
     }
 
     getNumber (): number {
@@ -90,11 +92,23 @@ export class GameTable {
         return this.restartTimeout;
     }
 
+    getPlayers<T extends GamePlayer> (): Array<T> {
+        return compact(this.seats.getSeats().map((seat) => seat.getPlayer())) as Array<T>;
+    }
+
+    getPlayerById (playerId: string): GamePlayer | undefined {
+        return this.getPlayers().find((item) => item.id === playerId);
+    }
+
+    getPlayerByColor (color: number): GamePlayer | undefined {
+        return this.getPlayers().find((item) => item.color === color);
+    }
+
     addPlayerToSeat (player: GamePlayer): boolean {
         const freeSeat = this.seats.findFreeSeat();
         if (freeSeat) {
             freeSeat.addPlayer(player);
-            player.seat(this.getRoomId(), this.getId(), freeSeat.getNumber());
+            player.becomePlayer(this.room, this, freeSeat);
             return true;
         }
 
@@ -102,23 +116,15 @@ export class GameTable {
     }
 
     removePlayerFromSeat (player: GamePlayer): void {
-        const seat = this.seats.getSeat(player.getSeatNumber());
+        const seat = this.seats.getSeatByNumber(player.seatNumber);
         if (seat) {
             seat.removePlayer();
             player.quit();
         }
     }
 
-    getPlayers (): Array<GamePlayer> {
-        return compact(this.seats.getSeats().map((seat) => seat.getPlayer()));
-    }
-
-    getPlayerByColor (color: number): GamePlayer | undefined {
-        return this.getPlayers().find((item) => item.getColor() === color);
-    }
-
     getPlayersWithQueue (): Array<GamePlayer> {
-        return [...this.getPlayers(), ...this.queue];
+        return [...this.getPlayers(), ...this.getTableQueue()];
     }
 
     getLastPlayer (): GamePlayer | null {
@@ -137,54 +143,89 @@ export class GameTable {
         return this.getPlayers().filter((player) => player.hasEmptyStack());
     }
 
-    getQueue (): Array<GamePlayer> {
-        return this.queue;
+    getTableQueue (): Array<GamePlayer> {
+        return Array.from(this.tableQueue.values());
+    }
+
+    getTableQueuerById (playerId: string): GamePlayer | undefined {
+        return this.tableQueue.get(playerId);
+    }
+
+    moveUsersFromQueueToSeats () {
+        for (let i = 0; i < this.getTableQueue().length; i++) {
+            const queuedUser = this.getTableQueue()[i];
+            const freeSeat = this.seats.findFreeSeat();
+
+            if (!queuedUser.hasOpenConnection()) {
+                this.removePlayerFromQueue(queuedUser);
+            } else if (freeSeat) {
+                freeSeat.addPlayer(queuedUser);
+                queuedUser.becomePlayer(this.room, this, freeSeat);
+                i -= 1;
+
+                this.removePlayerFromQueue(queuedUser);
+            } else {
+                break;
+            }
+        }
     }
 
-    getRedundantQueuers (): Array<GamePlayer> {
-        return slice(this.queue, this.getTableSize() - this.getPlayers().length - 1);
+    getRedundantTableQueuers (): Array<GamePlayer> {
+        return slice(this.getTableQueue(), this.getTableSize() - this.getPlayers().length - 1);
     }
 
     addPlayerToQueue (player: GamePlayer): void {
-        this.queue.push(player);
-        player.getInTableQueue(this.getRoomId(), this.getId());
+        this.tableQueue.set(player.id, player);
+        player.becomeTableQueuer(this.room, this);
     }
 
     removePlayerFromQueue (player: GamePlayer): void {
-        remove(this.queue, (queuer) => queuer.getId() === player.getId());
+        this.tableQueue.delete(player.id);
         player.quit();
     }
 
-    hasInQueue (PlayerId: string): boolean {
-        return !!this.getQueue().find((queuer) => queuer.getId() === PlayerId);
+    getWatchers (): Array<GamePlayer> {
+        return Array.from(this.watchers.values());
     }
 
-    getWatchers (): Array<GamePlayer> {
-        return this.watchers;
+    getWatcherById (playerId: string): GamePlayer | undefined {
+        return this.watchers.get(playerId);
     }
 
     addPlayerToWatchers (player: GamePlayer): void {
-        this.watchers.push(player);
-        player.watch(this.getRoomId(), this.getId());
+        this.watchers.set(player.id, player);
+        player.becomeWatcher(this.room, this);
     }
 
     removePlayerFromWatchers (player: GamePlayer): void {
-        remove(this.watchers, (watcher) => watcher.getId() === player.getId());
+        this.watchers.delete(player.id);
         player.quit();
     }
 
-    hasInWatchers (PlayerId: string): boolean {
-        return !!this.getWatchers().find((watcher) => watcher.getId() === PlayerId);
-    }
-
-    getAllWatchers () {
+    getAllObservers (): Array<GamePlayer> {
         return [
-            ...this.getWatchers(),
-            ...this.getQueue(),
             ...this.getPlayers(),
+            ...this.getTableQueue(),
+            ...this.getWatchers(),
         ];
     }
 
+    getExitedPlayers (): Array<GamePlayerExited> {
+        return Array.from(this.exitedPlayers.values());
+    }
+
+    addPlayerToExited (player: GamePlayer) {
+        this.exitedPlayers.set(player.id, new GamePlayerExited(player));
+    }
+
+    clearExitedPlayers (): void {
+        this.exitedPlayers.clear();
+    }
+
+    getAllOtherObservers (player: GamePlayer): Array<GamePlayer> {
+        return this.getAllObservers().filter((item) => item.id !== player.id);
+    }
+
     isFull (): boolean {
         return !this.seats.findFreeSeat();
     }
@@ -196,13 +237,5 @@ export class GameTable {
     hasSeats (): boolean {
         return !!this.seats.findFreeSeat();
     }
-
-    onFinishRound () {
-        this.onRoomFinishRound(this);
-    }
-
-    onRestartRound () {
-        this.onRoomRestartRound(this);
-    }
 }
 

package/src/base/index.ts

@@ -1,8 +1,8 @@
 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 { GamePlayer, IGamePlayerConfig } from './game-player';
+import { GamePlayerExited } from './game-player-exited';
 import { GameRoom, GameRoomConfig } from './game-room';
 import { GameRound } from './game-round';
 import { GameStateMachine, StateMachineConfig } from './game-state-machine';
@@ -10,15 +10,21 @@ import { GameTable, GameTableConfig } from './game-table';
 import { GameTableSeat } from './game-table-seat';
 import { GameTableSeats } from './game-table-seats';
 import { StandardGameState } from './standard-game-state';
-import { BaseGameStateType } from './base-game-state.type';
+import { GameRoundHistoryItem } from './game-round-history-item';
 import { BaseMoveData } from './base-move-data';
+import { BasePlayerMove } from './base-player-move';
+import { BasePlayerMoveFactory } from './base-player-move-factory';
+import { GameResultHelper } from './game-result-helper';
+import { GameResultEqualHelper } from './game-result-equal-helper';
+import { GameResultRatingHelper } from './game-result-rating-helper';
 
 export {
     GameControlPlayerTurn,
     GameControlRestart,
     GameMaster,
     GamePlayer,
-    GamePlayerMove,
+    IGamePlayerConfig,
+    GamePlayerExited,
     GameRoom,
     GameRound,
     GameStateMachine,
@@ -29,6 +35,11 @@ export {
     GameTableSeats,
     GameRoomConfig,
     StandardGameState,
-    BaseGameStateType,
+    GameRoundHistoryItem,
     BaseMoveData,
+    BasePlayerMove,
+    BasePlayerMoveFactory,
+    GameResultHelper,
+    GameResultEqualHelper,
+    GameResultRatingHelper,
 }

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

@@ -1,27 +1,29 @@
+import { IBaseMoveData } from 'jp.common.models';
+
 import { GamePlayer, GameRoom } from '../base';
-import { BaseMoveData } from '../base/base-move-data';
 
 export abstract class SimpleRoom extends GameRoom {
-    handleWatchTheTable<T>(player: GamePlayer, tableId: string): T {
-        return this.getMasterById(tableId)?.watchTheTable<T>(player);
+    handleWatchTheTable(player: GamePlayer, tableId: string): void {
+        return this.getMasterById(tableId)?.watchTheTable(player);
     }
 
-    handleEnterTheTable<T> (player: GamePlayer, tableId: string): T {
-        return this.getMasterById(tableId)?.enterTheTable<T>(player);
+    handleEnterTheTable (player: GamePlayer, tableId: string): void {
+        return this.getMasterById(tableId)?.enterTheTable(player);
     }
 
-    handleExitTheTable<T> (player: GamePlayer, tableId: string): T {
-        return this.getMasterById(tableId)?.exitTheTable<T>(player);
+    handleExitTheTable (player: GamePlayer, tableId: string): void {
+        return this.getMasterById(tableId)?.exitTheTable(player);
     }
 
-    handleMoveOnTheTable<T> (player: GamePlayer, tableId: string, moveData: BaseMoveData): T {
-        return this.getMasterById(tableId)?.onHandleMove<T>(player, moveData);
+    handleMoveOnTheTable (player: GamePlayer, tableId: string, moveData: IBaseMoveData): void {
+        return this.getMasterById(tableId)?.moveOnTheTable(player, moveData);
     }
 
-    handleFinishRound () {
-        // save users balances
+    handleRestartTable (tableId: string): void {
+        return this.restartTable(tableId);
     }
 
-    handleRestartRound () {
+    handleTechBreakOn (): void {
+        this.techBreakOn();
     }
 }

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

@@ -60,7 +60,7 @@ export class TournamentState extends GameStateMachine {
         return this.getCurrentState() === TournamentStateMachineStates.STATE_IN_PROGRESS;
     }
 
-    isFinished () {
+    isFinish () {
         return this.getCurrentState() === TournamentStateMachineStates.STATE_FINISHED;
     }
 

package/src/cards-game/cards/card.ts

@@ -1,60 +1,82 @@
-export type ClientCard = {
-    id: number;
-    rank: number;
-    suit: string;
-    isDisable: boolean;
-}
+import { BaseFigure } from '../../base/base-figure';
+import { BaseFigureTypeEnum } from '../../base/base-figure-type.enum';
 
-export class Card {
-    private readonly _id: number;
+export class Card extends BaseFigure {
     private readonly _rank: number;
     private readonly _suit: string;
     private _isDisable: boolean;
+    private _targets: Array<number>;
 
     constructor (id: number, rank: number, suit: string) {
-        this._id = id;
+        super(id, BaseFigureTypeEnum.CARD);
+
         this._rank = rank;
         this._suit = suit;
         this._isDisable = false;
+        this._targets = [];
+    }
+
+    get rank () {
+        return this._rank;
+    }
+
+    get suit () {
+        return this._suit;
+    }
+
+    get isDisable () {
+        return this._isDisable;
     }
 
-    public getId () {
-        return this._id;
+    get isEnable () {
+        return !this._isDisable;
     }
 
-    public getRank () {
+    get targets () {
+        return this._targets;
+    }
+
+    getRank () {
         return this._rank;
     }
 
-    public getSuit () {
+    getSuit () {
         return this._suit;
     }
 
-    public getIsDisable () {
+    hasSameSuit (suit: string) {
+        return this._suit === suit;
+    }
+
+    getIsDisable () {
         return this._isDisable;
     }
 
-    public disable () {
+    disable () {
         this._isDisable = true;
     }
 
-    public enable () {
+    enable () {
         this._isDisable = false;
     }
 
-    public toClient (): ClientCard {
-        return {
-            id: this._id,
-            rank: this._rank,
-            suit: this._suit,
-            isDisable: this._isDisable,
-        };
+    getTargets () {
+        return this._targets;
+    }
+
+    setTarget (target: number) {
+        this._targets = [target];
+    }
+
+    setTargets (targets: Array<number>) {
+        this._targets = targets;
+    }
+
+    clearTargets () {
+        this._targets = [];
     }
 
-    public toLogCard (): { rank: number; suit: string; } {
-        return {
-            rank: this.getRank(),
-            suit: this.getSuit(),
-        }
+    getName (): string {
+        return `${this._suit}_${this._rank}`;
     }
 }

package/src/cards-game/cards-deck/cards-deck-type.enum.ts

@@ -0,0 +1,8 @@
+export enum CardsDeckTypeEnum {
+    _12 = '12',
+    _24 = '24',
+    _36 = '36',
+    _52 = '52',
+    _52_AND_JOKER = '52_AND_JOKER',
+}
+

package/src/cards-game/cards-deck/cards-deck.ts

@@ -0,0 +1,105 @@
+import { cloneDeep, groupBy, maxBy, minBy, sortBy, sumBy, uniqBy } from 'lodash';
+
+import { superShuffle } from '../../utils';
+
+import { Card } from '../cards/card';
+import { deck12 } from './types/deck12';
+import { deck24 } from './types/deck24';
+import { deck36 } from './types/deck36';
+import { deck52 } from './types/deck52';
+import { CardsDeckTypeEnum } from './cards-deck-type.enum';
+
+export class CardsDeck {
+    private _cards: Array<Card>;
+
+    constructor (cards: Array<Card>) {
+        this._cards = cards;
+    }
+
+    static createFromDeckType (deckType: string) {
+        switch (deckType) {
+            case CardsDeckTypeEnum._12: {
+                return new CardsDeck(cloneDeep(deck12));
+            }
+            case CardsDeckTypeEnum._24: {
+                return new CardsDeck(cloneDeep(deck24));
+            }
+            case CardsDeckTypeEnum._36: {
+                return new CardsDeck(cloneDeep(deck36));
+            }
+            default: {
+                return new CardsDeck(cloneDeep(deck52));
+            }
+        }
+    }
+
+    get cards () {
+        return this._cards;
+    }
+
+    shuffle () {
+        this._cards = superShuffle(this._cards);
+    }
+
+    takeCardFromTop () {
+        return this._cards.pop();
+    }
+
+    pushCardToDeck (card: Card, position: number) {
+        this._cards.splice(position, 0, card);
+    }
+
+    pushCardToBottom (card: Card) {
+        this.pushCardToDeck(card, 0);
+    }
+
+    isEmpty () {
+        return this._cards.length === 0;
+    }
+
+    sortByRank (): CardsDeck {
+        this._cards = sortBy(this._cards, (card) => card.rank);
+
+        return this;
+    }
+
+    sortBySuit (): CardsDeck {
+        this._cards = sortBy(this._cards, (card) => card.suit);
+
+        return this;
+    }
+
+    sortCardsByEnabled (): CardsDeck {
+        this._cards = sortBy(this._cards, (item) => item.isEnable).reverse();
+
+        return this;
+    }
+
+    groupByRank (): Record<number, Array<Card>> {
+        return groupBy(this._cards, (card) => card.rank);
+    }
+
+    groupBySuit (): Record<string, Array<Card>> {
+        return groupBy(this._cards, (card) => card.suit);
+    }
+
+    groupByEnabled (): Record<string, Array<Card>> {
+        return groupBy(this._cards, (card) => card.isEnable);
+    }
+
+    minByRank (): Card | undefined {
+        return minBy(this._cards, (card) => card.rank);
+    }
+
+    maxByRank (): Card | undefined {
+        return maxBy(this._cards, (card) => card.rank);
+    }
+
+    uniqByRank (): Array<Card> {
+        return uniqBy(this._cards, (card) => card.rank);
+    }
+
+    sumByRank (): number {
+        return sumBy(this._cards, (card) => card.rank);
+    }
+}

package/src/cards-game/cards-deck/types/deck12.ts

@@ -0,0 +1,32 @@
+import {
+    club_ace,
+    club_king,
+    club_queen,
+    diamond_ace,
+    diamond_king,
+    diamond_queen,
+    heart_ace,
+    heart_king,
+    heart_queen,
+    spade_queen,
+    spade_king,
+    spade_ace,
+} from '../../cards/cards';
+
+export const deck12 = [
+    heart_queen,
+    heart_king,
+    heart_ace,
+
+    diamond_queen,
+    diamond_king,
+    diamond_ace,
+
+    club_queen,
+    club_king,
+    club_ace,
+
+    spade_queen,
+    spade_king,
+    spade_ace,
+];

package/src/cards-game/cards-deck/types/deck24.ts

@@ -0,0 +1,56 @@
+import {
+    club_9,
+    club_10,
+    club_ace,
+    club_jack,
+    club_king,
+    club_queen,
+    diamond_9,
+    diamond_10,
+    diamond_ace,
+    diamond_jack,
+    diamond_king,
+    diamond_queen,
+    heart_9,
+    heart_10,
+    heart_ace,
+    heart_jack,
+    heart_king,
+    heart_queen,
+    spade_9,
+    spade_10,
+    spade_queen,
+    spade_jack,
+    spade_king,
+    spade_ace,
+} from '../../cards/cards';
+
+export const deck24 = [
+    heart_9,
+    heart_10,
+    heart_jack,
+    heart_queen,
+    heart_king,
+    heart_ace,
+
+    diamond_9,
+    diamond_10,
+    diamond_jack,
+    diamond_queen,
+    diamond_king,
+    diamond_ace,
+
+    club_9,
+    club_10,
+    club_jack,
+    club_queen,
+    club_king,
+    club_ace,
+
+    spade_9,
+    spade_10,
+    spade_jack,
+    spade_queen,
+    spade_king,
+    spade_ace,
+];

package/src/cards-game/{cards → cards-deck/types}/deck36.ts

@@ -35,7 +35,7 @@ import {
     spade_jack,
     spade_king,
     spade_ace,
-} from './cards';
+} from '../../cards/cards';
 
 export const deck36 = [
     heart_6,

package/src/cards-game/{cards → cards-deck/types}/deck52.ts

@@ -51,7 +51,7 @@ import {
     spade_jack,
     spade_king,
     spade_queen,
-} from './cards';
+} from '../../cards/cards';
 
 export const deck52 = [
     heart_2,