jp.ms.common.engine 1.0.20 → 2.0.0

package/src/base/game-master.ts

@@ -1,158 +1,576 @@
+import { Subject } from 'rxjs';
+import { IBaseMoveData, IBaseTableGameState } from 'jp.common.models';
+
+import {
+  NotActivePlayerMoveException,
+  NotValidPlayerMoveException,
+  PlayerHasNoPossibleMoveException,
+} from '../exceptions';
+import {
+  GameTableTurnStartEvent,
+  GameTableTurnStartedEvent,
+  GameTableTurnFinishEvent,
+  GameTableTurnFinishedEvent,
+  GameTableWaitEvent,
+  GameTableWaitedEvent,
+  GameTableStartEvent,
+  GameTableStartedEvent,
+  GameTableFinishEvent,
+  GameTableFinishedEvent,
+  GameTableRestartEvent,
+  GameTableRestartedEvent,
+  GamePlayerActivateEvent,
+  GamePlayerActivatedEvent,
+  GamePlayerDeactivateEvent,
+  GamePlayerDeactivatedEvent,
+  GamePlayerTurnTimerSetOnEvent,
+  GamePlayerTurnTimerSetOffEvent,
+  GamePlayerTurnTimerExecutedEvent,
+  GameTableRestartTimerSetOnEvent,
+  GameTableRestartTimerExecutedEvent,
+  GamePlayerMoveOnTheTableEvent,
+  GamePlayerMovedOnTheTableEvent,
+  GamePlayerWatchTheTableEvent,
+  GamePlayerWatchedTheTableEvent,
+  GamePlayerEnterTheTableEvent,
+  GamePlayerEnteredTheTableEvent,
+  GamePlayerExitTheTableEvent,
+  GamePlayerExitedTheTableEvent,
+  GamePlayerKickOutTheTableEvent,
+  GamePlayerKickedOutTheTableEvent,
+  GameTableMasterCreatedEvent,
+  WsEvent,
+  WsEventEnum,
+} from '../events';
+
 import { GamePlayer } from './game-player';
 import { GameControlPlayerTurn } from './game-control-player-turn';
 import { GameControlRestart } from './game-control-restart';
 import { GameTable } from './game-table';
-import { GameSummaryResult } from './game-summary-result';
 import { GameRound } from './game-round';
 import { GameRoom } from './game-room';
-import { BaseGameStateType } from './base-game-state.type';
-import { BaseMoveDataType } from './base-move-data.type';
+import { GameStateMachine } from './game-state-machine';
+import { GameRoundHistoryItem } from './game-round-history-item';
+import { BaseGameLevelHelper } from '../level-helper';
+import { BasePlayerMoveFactory } from './base-player-move-factory';
+import { BasePlayerMove } from './base-player-move';
+import { GameResultHelper } from './game-result-helper';
+import { StandardGameState } from './standard-game-state';
 
 export abstract class GameMaster {
-    protected readonly room: GameRoom;
-    protected readonly table: GameTable;
-    protected gameRound?: GameRound;
-    public readonly controlTurn: GameControlPlayerTurn;
-    public readonly controlRestart: GameControlRestart;
+  static parseTableId (roomIdWithTable: string): { roomId: string; tableId: string; } {
+    const pattern = /([a-zA-z0-9.]*)_([0-9]*)/;
+    const data = roomIdWithTable.match(pattern);
+
+    if (!data) {
+      const pattern2 = /([a-zA-z0-9.]*)/;
+      const data2 = roomIdWithTable.match(pattern2);
+
+      return {
+        roomId: data2?.[1] ?? '',
+        tableId: '1',
+      };
+    }
 
-    protected constructor (room: GameRoom) {
-        this.room = room;
-        this.table = new GameTable(room.getConfigForTable());
-        this.controlTurn = new GameControlPlayerTurn(this.table.getTurnTimeout(), this.onHandleTurnTimeout);
-        this.controlRestart = new GameControlRestart(this.table.getRestartTimeout(), this.onHandleRestartTimeout);
+    return {
+      roomId: data?.[1] ?? '',
+      tableId: data?.[2] ?? '',
+    };
+  }
+
+  protected readonly room: GameRoom;
+  protected readonly table: GameTable;
+  protected gameRound?: GameRound;
+  private controlPlayersTurn: GameControlPlayerTurn;
+  private controlRestart: GameControlRestart;
+  private playersSubject = new Subject<Array<GamePlayer>>();
+  protected _levelHelper: BaseGameLevelHelper;
+  private _moveFactory: BasePlayerMoveFactory;
+  protected _turnNumber: number;
+
+  protected onGameWait (master: GameMaster): void {
+    this.room.onRoomEvent(new GameTableWaitEvent(this.room, this));
+    this.gameRound = undefined;
+    this.onGameWaited(master);
+  }
+
+  protected onGameWaited (master: GameMaster): void {
+    this.room.onRoomEvent(new GameTableWaitedEvent(this.room, this));
+    this.notifyAllObservers(WsEventEnum.STATE_UPDATE);
+  }
+
+  protected onGameStart (master: GameMaster): void {
+    this.room.onRoomEvent(new GameTableStartEvent(this.room, this));
+    if (this.enoughPlayersForGame()) {
+      this.gameRound = new GameRound(this.createGameStateMachine());
+      this.getGameRound()?.getState().toStart();
+      this._turnNumber = 0;
+      this.startNewRound();
+      this.onGameStarted(this);
     }
+  }
+
+  protected onGameStarted (master: GameMaster): void {
+    this.room.onRoomEvent(new GameTableStartedEvent(this.room, this));
+    this.onGameTurnStart(master);
+  }
+
+  protected onGameTurnStart (master: GameMaster): void {
+    this.room.onRoomEvent(new GameTableTurnStartEvent(this.room, this));
+    this._turnNumber += 1;
+    this.startNewTurn();
+    this.onGameTurnStarted(master);
+  }
+
+  protected onGameTurnStarted (master: GameMaster): void {
+    this.room.onRoomEvent(new GameTableTurnStartedEvent(this.room, this));
+    this.notifyAllObservers(WsEventEnum.STATE_UPDATE);
+  }
+
+  protected onGameTurnFinish (master: GameMaster): void {
+    this.room.onRoomEvent(new GameTableTurnFinishEvent(this.room, this));
+    this.finishTurn();
+    this.onGameTurnFinished(master);
+  }
+
+  protected onGameTurnFinished (master: GameMaster): void {
+    this.room.onRoomEvent(new GameTableTurnFinishedEvent(this.room, this));
+
+    if (this.isGameOver()) {
+      this.onGameFinish(this);
+    } else {
+      this.onGameTurnStart(master);
+    }
+  }
 
-    static parseTableId (roomIdWithTable: string): {
-        roomId: string;
-        tableId: string;
-    } {
-        const pattern = /([a-zA-z0-9.]*)_([0-9]*)/;
-        const data = roomIdWithTable.match(pattern);
+  protected onGameFinish (master: GameMaster): void {
+    this.room.onRoomEvent(new GameTableFinishEvent(this.room, this));
+    this.getGameRound()?.getState().toFinish();
 
-        if (!data) {
-            const pattern2 = /([a-zA-z0-9.]*)/;
-            const data2 = roomIdWithTable.match(pattern2);
+    const activePlayer = this.getActivePlayer();
+    if (activePlayer) {
+      this.onGamePlayerDeactivate(this, activePlayer);
+    }
 
-            return {
-                roomId: data2?.[1] ?? '',
-                tableId: '1',
-            };
-        }
+    this.finishRound();
+    this.onGameFinished(this);
+  }
 
-        return {
-            roomId: data?.[1] ?? '',
-            tableId: data?.[2] ?? '',
-        };
+  protected onGameFinished (master: GameMaster): void {
+    this.room.onRoomEvent(new GameTableFinishedEvent(this.room, this));
+    this.room.onRoomTableGameFinished(master);
+    this.onGameRestart(master);
+  }
+
+  protected onGameRestart (master: GameMaster): void {
+    this.room.onRoomEvent(new GameTableRestartEvent(this.room, this));
+    if (this.controlRestart.isEnableTimer()) {
+      this.onGameRestartTimerSetOn(master);
+    }
+  }
+
+  protected onGameRestarted (master: GameMaster): void {
+    this.room.onRoomEvent(new GameTableRestartedEvent(this.room, this));
+    if (this.enoughPlayersForGame()) {
+      this.flushAllPlayers();
+      this.table.moveUsersFromQueueToSeats();
+      this.onGameStart(master);
+    } else {
+      this.onGameWait(master);
     }
+  }
 
-    abstract onHandleTurnTimeout (player: GamePlayer);
+  protected onGamePlayerActivate (master: GameMaster, player: GamePlayer) {
+    this.room.onRoomEvent(new GamePlayerActivateEvent(this.room, this, player));
+    if (this.controlPlayersTurn.isEnableTimer()) {
+      this.onGamePlayerTurnTimerSetOn(master, player);
+    }
+  }
 
-    abstract onHandleRestartTimeout ();
+  protected onGamePlayerActivated (master: GameMaster, player: GamePlayer) {
+    this.room.onRoomEvent(new GamePlayerActivatedEvent(this.room, this, player));
+  }
 
-    abstract onHandleMove<T>(player: GamePlayer, moveData: BaseMoveDataType): T;
+  protected onGamePlayerDeactivate (master: GameMaster, player: GamePlayer) {
+    this.room.onRoomEvent(new GamePlayerDeactivateEvent(this.room, this, player));
+    if (this.controlPlayersTurn.isEnableTimer()) {
+      this.onGamePlayerTurnTimerSetOff(master, player);
+    }
+    this.onGamePlayerDeactivated(master, player);
+  }
+
+  protected onGamePlayerDeactivated (master: GameMaster, player: GamePlayer) {
+    this.room.onRoomEvent(new GamePlayerDeactivatedEvent(this.room, this, player));
+  }
+
+  protected onGamePlayerTurnTimerSetOn (master: GameMaster, player: GamePlayer): void {
+    this.room.onRoomEvent(new GamePlayerTurnTimerSetOnEvent(this.room, this, player));
+    this.controlPlayersTurn.setPlayerTurnTimeout(player);
+  }
+
+  protected onGamePlayerTurnTimerExecuted (master: GameMaster, player: GamePlayer): void {
+    this.room.onRoomEvent(new GamePlayerTurnTimerExecutedEvent(this.room, this, player));
+    this.onPlayerKickOutFromTheTable(master, player);
+  }
+
+  protected onGamePlayerTurnTimerSetOff (master: GameMaster, player: GamePlayer): void {
+    this.room.onRoomEvent(new GamePlayerTurnTimerSetOffEvent(this.room, this, player));
+    this.controlPlayersTurn.clearPlayerTurnTimeout(player);
+  }
+
+  protected onGameRestartTimerSetOn (master: GameMaster): void {
+    this.room.onRoomEvent(new GameTableRestartTimerSetOnEvent(this.room, this));
+    this.controlRestart.setRestartTimeout();
+  }
+
+  protected onGameRestartTimerExecuted (master: GameMaster): void {
+    this.room.onRoomEvent(new GameTableRestartTimerExecutedEvent(this.room, this));
+    this.onGameRestarted(this);
+  }
+
+  protected onPlayerMoveOnTheTable (master: GameMaster, player: GamePlayer, move: BasePlayerMove): void {
+    this.room.onRoomEvent(new GamePlayerMoveOnTheTableEvent(this.room, this, player, move.getMoveData()));
+
+    if (!this.isActivePlayer(player.id)) {
+      throw new NotActivePlayerMoveException();
+    }
 
-    abstract kickPlayer (player: GamePlayer);
+    if (!move.isValid()) {
+      throw new NotValidPlayerMoveException();
+    }
 
-    abstract startNewRound ();
+    if (!master.hasPossibleMove(player, move.action)) {
+      throw new PlayerHasNoPossibleMoveException();
+    }
 
-    abstract finishRound ();
+    player.lastMove = move.getMoveData();
 
-    abstract changePlayer ();
+    this.gameRound?.addToHistory(GameRoundHistoryItem.createPlayerMove(
+      player.id,
+      player.fullName,
+      this.getStateId(),
+      this._turnNumber,
+      move.getMoveData(),
+    ));
 
-    abstract getResults (): GameSummaryResult | null;
+    move.commit();
 
-    getId () {
-        return this.table.getId();
-    }
+    this.processMove(player, move);
 
-    setGameRound (gameRound: GameRound): void {
-        this.gameRound = gameRound;
-    }
+    this.onPlayerMovedOnTheTable(master, player, move);
+  }
 
-    getGameRound (): GameRound | null {
-        return this.gameRound;
-    }
+  protected onPlayerMovedOnTheTable (master: GameMaster, player: GamePlayer, move: BasePlayerMove): void {
+    this.room.onRoomEvent(new GamePlayerMovedOnTheTableEvent(this.room, this, player, move.getMoveData()));
 
-    getTable () {
-        return this.table;
+    if (this.isActivePlayer(player.id)) {
+      if (this.controlPlayersTurn.isEnableTimer()) {
+        this.onGamePlayerTurnTimerSetOff(master, player);
+      }
     }
 
-    enterTheTable<T> (player: GamePlayer): T {
-        if (this.table.isFull()) {
-            this.table.addPlayerToQueue(player);
-        } else {
-            this.table.addPlayerToSeat(player);
-        }
+    const nextPlayer = this.getNextGamePlayer();
 
-        return this.getGameState() as T;
+    if (this.isTurnOver()) {
+      this.onGameTurnFinish(master);
+    } else if (nextPlayer) {
+      this.setActivePlayer(nextPlayer);
     }
 
-    exitTheTable<T> (player: GamePlayer): T {
-        if (player.isPlayer()) {
-            this.table.removePlayerFromSeat(player);
-        } else if (player.isTableQueuer()) {
-            this.table.removePlayerFromQueue(player);
-        } else {
-            this.table.removePlayerFromWatchers(player);
-        }
+    this.notifyObserversWithoutPlayer(player, WsEventEnum.PLAYER_MOVED, move.action);
+  }
 
-        return this.getGameState() as T;
-    }
+  protected onPlayerWatchTheTable (master: GameMaster, player: GamePlayer): void {
+    this.room.onRoomEvent(new GamePlayerWatchTheTableEvent(this.room, this, player));
+  }
 
-    watchTheTable<T> (player: GamePlayer): T {
-        this.table.addPlayerToWatchers(player);
+  protected onPlayerWatchedTheTable (master: GameMaster, player: GamePlayer): void {
+    this.room.onRoomEvent(new GamePlayerWatchedTheTableEvent(this.room, this, player));
+  }
 
-        return this.getGameState() as T;
-    }
+  protected onPlayerEnterTheTable (master: GameMaster, player: GamePlayer): void {
+    this.room.onRoomEvent(new GamePlayerEnterTheTableEvent(this.room, this, player));
+  }
 
-    startFromWhite () {
-        const firstPlayer = this.table.getPlayers().find((item) => item.isWhite());
-        if (firstPlayer) {
-            this.gameRound?.setActivePlayer(firstPlayer);
-        }
-    }
+  protected onPlayerEnteredTheTable (master: GameMaster, player: GamePlayer): void {
+    this.room.onRoomEvent(new GamePlayerEnteredTheTableEvent(this.room, this, player));
+    this.playersSubject.next(this.getTable().getPlayers());
+  }
 
-    changePlayerClockwise () {
-        const activePlayer = this.getGameRound()?.getActivePlayer();
-        const nextPlayer = this.table.getSeats().getNextPlayer(activePlayer?.getSeatNumber() ?? 0);
+  protected onPlayerExitTheTable (master: GameMaster, player: GamePlayer): void {
+    this.room.onRoomEvent(new GamePlayerExitTheTableEvent(this.room, this, player));
 
-        if (nextPlayer) {
-            this.gameRound?.setActivePlayer(nextPlayer);
-        }
+    if (this.isActivePlayer(player.id)) {
+      this.onGamePlayerDeactivated(this, player);
+      this.setActivePlayer(this.getNextGamePlayer());
+    }
+  }
+
+  protected onPlayerExitedTheTable (master: GameMaster, player: GamePlayer): void {
+    this.room.onRoomEvent(new GamePlayerExitedTheTableEvent(this.room, this, player));
+    this.table.addPlayerToExited(player);
+    this.playersSubject.next(this.getTable().getPlayers());
+    this.notifyAllObservers(WsEventEnum.STATE_UPDATE);
+  }
+
+  protected onPlayerKickOutFromTheTable (master: GameMaster, player: GamePlayer): void {
+    this.room.onRoomEvent(new GamePlayerKickOutTheTableEvent(this.room, this, player));
+    if (this.isActivePlayer(player.id)) {
+      this.setActivePlayer(this.getNextGamePlayer());
     }
+    this.table.removePlayerFromSeat(player);
+    this.onPlayerKickedOutFromTheTable(master, player);
+    this.notifyObserver(player, WsEventEnum.PLAYER_KICKED_OUT);
+    this.notifyAllObservers(WsEventEnum.STATE_UPDATE);
+  }
+
+  protected onPlayerKickedOutFromTheTable (master: GameMaster, player: GamePlayer): void {
+    this.room.onRoomEvent(new GamePlayerKickedOutTheTableEvent(this.room, this, player));
+    this.playersSubject.next(this.getTable().getPlayers());
+  }
+
+  protected constructor (room: GameRoom) {
+    this.room = room;
+    this.table = new GameTable(room.getConfigForTable());
+    this.controlPlayersTurn = new GameControlPlayerTurn(
+      this.table.getTurnTimeout(),
+      (player: GamePlayer) => this.onGamePlayerTurnTimerExecuted(this, player),
+    );
+    this.controlRestart = new GameControlRestart(
+      this.table.getRestartTimeout(),
+      () => this.onGameRestartTimerExecuted(this),
+    );
+    this.playersSubject.subscribe(this.observePlayers);
+    this.onGameWait(this);
+    this.room.onRoomEvent(new GameTableMasterCreatedEvent(this.room, this));
+    this._levelHelper = new BaseGameLevelHelper(this);
+    this._moveFactory = this.createMoveFactory();
+    this._turnNumber = 0;
+  }
+
+  private observePlayers = (players: Array<GamePlayer>) => {
+    if (this.isWaiting() && this.enoughPlayersForGame()) {
+      this.onGameStart(this);
+    } else if (this.isInProgress() && !this.enoughPlayersForGame()) {
+      this.onGameFinish(this);
+    }
+  };
 
-    changePlayerCounterClockwise () {
-        const activePlayer = this.getGameRound()?.getActivePlayer();
-        const prevPlayer = this.table.getSeats().getPrevPlayer(activePlayer?.getSeatNumber() ?? 0);
+  abstract startNewRound ();
 
-        if (prevPlayer) {
-            this.gameRound?.setActivePlayer(prevPlayer);
-        }
-    }
+  abstract finishRound ();
 
-    getActivePlayer (): GamePlayer | null {
-        return this.getGameRound()?.getActivePlayer() ?? null;
-    }
+  abstract startNewTurn ();
+
+  abstract finishTurn ();
+
+  abstract createGameStateDto (player: GamePlayer): IBaseTableGameState;
+
+  abstract createMoveFactory (): BasePlayerMoveFactory;
+
+  abstract isGameOver (): boolean;
+
+  abstract isTurnOver (): boolean;
+
+  abstract getNextGamePlayer (): GamePlayer | null;
 
-    getNextPlayer () {
-        return this.table.getSeats().getNextPlayer(this.getActivePlayer()?.getSeatNumber() ?? 0);
+  abstract getPossibleMoves (player: GamePlayer): Array<string>;
+
+  abstract getGameResultHelper (): GameResultHelper;
+
+  createGameStateMachine (): GameStateMachine {
+    return new StandardGameState();
+  }
+
+  hasPossibleMove (player: GamePlayer, action: string) {
+    return this.getPossibleMoves(player).includes(action);
+  }
+
+  processMove (player: GamePlayer, move: BasePlayerMove): void {
+  }
+
+  watchTheTable (player: GamePlayer): void {
+    this.onPlayerWatchTheTable(this, player);
+
+    if (player.isNew()) {
+      this.table.addPlayerToWatchers(player);
     }
 
-    getNextAfterNextPlayer () {
-        return this.table.getSeats().getNextPlayer(this.getNextPlayer()?.getSeatNumber() ?? 0);
+    this.onPlayerWatchedTheTable(this, player);
+  }
+
+  enterTheTable (player: GamePlayer): void {
+    this.onPlayerEnterTheTable(this, player);
+
+    this.table.removePlayerFromWatchers(player);
+
+    if (this.table.isFull() || this.isInProgress()) {
+      this.table.addPlayerToQueue(player);
+    } else if (!player.isPlayer()) {
+      this.table.addPlayerToSeat(player);
     }
 
-    getNextPlayerBySeat (seat: number) {
-        return this.table.getSeats().getNextPlayer(seat);
+    this.onPlayerEnteredTheTable(this, player);
+  }
+
+  exitTheTable (player: GamePlayer): void {
+    this.onPlayerExitTheTable(this, player);
+
+    if (player.isPlayer()) {
+      this.table.removePlayerFromSeat(player);
+    } else if (player.isTableQueuer()) {
+      this.table.removePlayerFromQueue(player);
+    } else {
+      this.table.removePlayerFromWatchers(player);
     }
 
-    getGameState (): BaseGameStateType {
-        return {
-            roomId: this.room.getId(),
-            tableId: this.table.getId(),
-            gameId: this.gameRound?.getId(),
-            pot: this.gameRound?.getPot() ?? 0,
-            players: this.getTable().getPlayers().map((item) => item.getFullName()),
-        };
+    this.onPlayerExitedTheTable(this, player);
+  }
+
+  moveOnTheTable (player: GamePlayer, moveData: IBaseMoveData): void {
+    this.onPlayerMoveOnTheTable(this, player, this._moveFactory.createMove(player, moveData));
+  }
+
+  getId () {
+    return this.table.getId();
+  }
+
+  getRoom () {
+    return this.room;
+  }
+
+  getGameRound (): GameRound | undefined {
+    return this.gameRound;
+  }
+
+  getTable () {
+    return this.table;
+  }
+
+  getTicketPrice () {
+    return this.room.getTicketPrice();
+  }
+
+  getRestartTimerRemain (): number | undefined {
+    return this.controlRestart.getTimerRemain();
+  }
+
+  getPlayerTurnTimerRemain (): number | undefined {
+    return this.controlPlayersTurn.getTimerRemain();
+  }
+
+  isTechBreak () {
+    return this.room.isTechBreak();
+  }
+
+  getWhitePlayer (): GamePlayer | null {
+    return this.table.getPlayers().find((item) => item.isWhite()) ?? null;
+  }
+
+  getBlackPlayer (): GamePlayer | null {
+    return this.table.getPlayers().find((item) => item.isBlack()) ?? null;
+  }
+
+  getNextPlayerClockwise (): GamePlayer | null {
+    return this.getActivePlayer()?.getSeat()?.getNextPlayer() ?? null;
+  }
+
+  getNextPlayerCounterClockwise (): GamePlayer | null {
+    return this.getActivePlayer()?.getSeat()?.getPrevPlayer() ?? null;
+  }
+
+  getActivePlayer<T extends GamePlayer> (): T | undefined {
+    return this.getGameRound()?.getActivePlayer() as T | undefined;
+  }
+
+  setActivePlayer (player: GamePlayer | null) {
+    if (player) {
+      this.onGamePlayerActivate(this, player);
+      this.gameRound?.setActivePlayer(player);
+      this.onGamePlayerActivated(this, player);
     }
+  }
+
+  clearActivePlayer (player: GamePlayer) {
+    this.onGamePlayerDeactivate(this, player);
+    this.gameRound?.clearActivePlayer();
+    this.onGamePlayerDeactivated(this, player);
+  }
+
+  isActivePlayer (playerId: string): boolean {
+    return this.getActivePlayer()?.id === playerId;
+  }
+
+  setStackForAllPlayers () {
+    this.table.getPlayers().forEach((player) => {
+      player.stack = this.getTicketPrice();
+    });
+  }
+
+  takeRequiredBids () {
+    this.table.getPlayers().forEach((player) => {
+      player.increaseBet(this.room.getBet());
+      this.getGameRound()?.addToPot(this.room.getBet());
+    });
+  }
+
+  flushAllPlayers () {
+    this.table.getPlayers().forEach((player) => player.flush());
+  }
+
+  getMaxBet () {
+    const bids = this.table.getPlayers().map((player) => player.bet);
+    const roomBet = this.table.getBet();
+
+    return Math.max(...bids, roomBet);
+  }
+
+  getState () {
+    return this.gameRound?.getState();
+  }
+
+  getStateId () {
+    return this.getState()?.getCurrentState() ?? '';
+  }
+
+  isWaiting () {
+    return this.getState()?.isWaiting() ?? true;
+  }
+
+  isInProgress () {
+    return this.getState()?.isInProgress();
+  }
+
+  isFinish () {
+    return this.getState()?.isFinish();
+  }
+
+  enoughPlayersForGame () {
+    return this.room.startStrategy.shouldStart(this.getTable());
+  }
+
+  notifyAllObservers (eventType: WsEventEnum, action?: string) {
+    this.table.getAllObservers()
+      .forEach((player) =>
+        player.sendMessage(new WsEvent(eventType, this.createGameStateDto(player), action)));
+  }
+
+  notifyObserversWithoutPlayer (player: GamePlayer, eventType: WsEventEnum, action?: string) {
+    this.table.getAllObservers()
+        .filter((item) => item.id !== player.id)
+        .forEach((player) =>
+            player.sendMessage(new WsEvent(eventType, this.createGameStateDto(player), action)));
+  }
+
+  notifyObserver (player: GamePlayer, eventType: WsEventEnum) {
+    player.sendMessage(new WsEvent(eventType, this.createGameStateDto(player)));
+  }
+
+  get levelHelper (): BaseGameLevelHelper {
+    return this._levelHelper;
+  }
+
+  isFirstTurn () {
+    return this._turnNumber === 1;
+  }
 }