jp.ms.common.engine 1.0.20 → 2.0.0

package/src/events/game/game-table-turn-started.event.ts

@@ -0,0 +1,3 @@
+import { GameTableEvent } from '../base/game-table.event';
+
+export class GameTableTurnStartedEvent extends GameTableEvent {}

package/src/events/game/game-table-wait.event.ts

@@ -0,0 +1,3 @@
+import { GameTableEvent } from '../base/game-table.event';
+
+export class GameTableWaitEvent extends GameTableEvent {}

package/src/events/game/game-table-waited.event.ts

@@ -0,0 +1,3 @@
+import { GameTableEvent } from '../base/game-table.event';
+
+export class GameTableWaitedEvent extends GameTableEvent {}

package/src/events/index.ts

@@ -0,0 +1,40 @@
+export { GameTableTurnStartEvent } from './game/game-table-turn-start.event';
+export { GameTableTurnStartedEvent } from './game/game-table-turn-started.event';
+export { GameTableTurnFinishEvent } from './game/game-table-turn-finish.event';
+export { GameTableTurnFinishedEvent } from './game/game-table-turn-finished.event';
+export { GameTableWaitEvent } from './game/game-table-wait.event';
+export { GameTableWaitedEvent } from './game/game-table-waited.event';
+export { GameTableStartEvent } from './game/game-table-start.event';
+export { GameTableStartedEvent } from './game/game-table-started.event';
+export { GameTableFinishEvent } from './game/game-table-finish.event';
+export { GameTableFinishedEvent } from './game/game-table-finished.event';
+export { GameTableRestartEvent } from './game/game-table-restart.event';
+export { GameTableRestartedEvent } from './game/game-table-restarted.event';
+export { GamePlayerActivateEvent } from './game/game-player-activate.event';
+export { GamePlayerActivatedEvent } from './game/game-player-activated.event';
+export { GamePlayerDeactivateEvent } from './game/game-player-deactivate.event';
+export { GamePlayerDeactivatedEvent } from './game/game-player-deactivated.event';
+export { GamePlayerTurnTimerSetOnEvent } from './game/game-player-turn-timer-set-on.event';
+export { GamePlayerTurnTimerSetOffEvent } from './game/game-player-turn-timer-set-off.event';
+export { GamePlayerTurnTimerExecutedEvent } from './game/game-player-turn-timer-executed.event';
+export { GameTableRestartTimerSetOnEvent } from './game/game-table-restart-timer-set-on.event';
+export { GameTableRestartTimerExecutedEvent } from './game/game-table-restart-timer-executed.event';
+export { GamePlayerMoveOnTheTableEvent } from './game/game-player-move-on-the-table.event';
+export { GamePlayerMovedOnTheTableEvent } from './game/game-player-moved-on-the-table.event';
+export { GamePlayerWatchTheTableEvent } from './game/game-player-watch-the-table.event';
+export { GamePlayerWatchedTheTableEvent } from './game/game-player-watched-the-table.event';
+export { GamePlayerEnterTheTableEvent } from './game/game-player-enter-the-table.event';
+export { GamePlayerEnteredTheTableEvent } from './game/game-player-entered-the-table.event';
+export { GamePlayerExitTheTableEvent } from './game/game-player-exit-the-table.event';
+export { GamePlayerExitedTheTableEvent } from './game/game-player-exited-the-table.event';
+export { GamePlayerKickOutTheTableEvent } from './game/game-player-kick-out-the-table.event';
+export { GamePlayerKickedOutTheTableEvent } from './game/game-player-kicked-out-the-table.event';
+export { GameTableMasterCreatedEvent } from './game/game-table-master-created.event';
+export { GameRoomRoomCreatedEvent } from './game/game-room-room-created.event';
+export { BaseGameEvent } from './base/base-game.event';
+export { GameTableEvent } from './base/game-table.event';
+export { GamePlayerEvent } from './base/game-player.event';
+export { GameRoomEvent } from './base/game-room.event';
+export { WsEvent } from './ws/ws-event';
+export { WsEventEnum } from './ws/ws-event.enum';
+

package/src/events/ws/base-ws-event.ts

@@ -0,0 +1 @@
+export class BaseWsEvent {}

package/src/events/ws/ws-event.enum.ts

@@ -0,0 +1,5 @@
+export enum WsEventEnum {
+    STATE_UPDATE = 'STATE_UPDATE',
+    PLAYER_KICKED_OUT = 'PLAYER_KICKED_OUT',
+    PLAYER_MOVED = 'PLAYER_MOVED',
+}

package/src/events/ws/ws-event.ts

@@ -0,0 +1,14 @@
+import { BaseWsEvent } from './base-ws-event';
+
+export class WsEvent extends BaseWsEvent {
+    type: string;
+    action?: string;
+    data: object;
+
+    constructor (type: string, data: object, action?: string) {
+        super();
+        this.type = type;
+        this.data = data;
+        this.action = action;
+    }
+}

package/src/exceptions/index.ts

@@ -0,0 +1,3 @@
+export { PlayerHasNoPossibleMoveException } from './player-has-no-possible-move.exception';
+export { NotValidPlayerMoveException } from './not-valid-player-move.exception';
+export { NotActivePlayerMoveException } from './not-active-player-move.exception';

package/src/exceptions/not-active-player-move.exception.ts

@@ -0,0 +1,10 @@
+export class NotActivePlayerMoveException extends Error {
+    private statusCode: number;
+
+    constructor (message = 'Not active player move', statusCode = 500) {
+        super(message);
+        this.name = this.constructor.name;
+        this.statusCode = statusCode;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}

package/src/exceptions/not-implemented.exception.ts

@@ -0,0 +1,10 @@
+export class NotImplementedException extends Error {
+    private statusCode: number;
+
+    constructor (message = 'Not implemented case', statusCode = 500) {
+        super(message);
+        this.name = this.constructor.name;
+        this.statusCode = statusCode;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}

package/src/exceptions/not-valid-player-move.exception.ts

@@ -0,0 +1,10 @@
+export class NotValidPlayerMoveException extends Error {
+    private statusCode: number;
+
+    constructor (message = 'Not valid player move', statusCode = 500) {
+        super(message);
+        this.name = this.constructor.name;
+        this.statusCode = statusCode;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}

package/src/exceptions/player-has-no-possible-move.exception.ts

@@ -0,0 +1,10 @@
+export class PlayerHasNoPossibleMoveException extends Error {
+    private statusCode: number;
+
+    constructor (message = 'Player has no possible move', statusCode = 500) {
+        super(message);
+        this.name = this.constructor.name;
+        this.statusCode = statusCode;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}

package/src/index.ts

@@ -1,5 +1,7 @@
 export * from './base';
 export * from './base-rooms';
-// export * from './board-game';
 export * from './cards-game';
 export * from './utils';
+export * from './strategies';
+export * from './events';
+export * from './level-helper';

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

@@ -0,0 +1,74 @@
+import { GameMaster, GamePlayer } from '../base';
+
+import { ExperiencesAmountEnum } from './experiences-amount.enum';
+import { ExperiencesLevelRankEnum } from './experiences-level-rank.enum';
+import { ExperiencesLevelEdgeEnum } from './experiences-level-edge.enum';
+
+const LEVEL_SIZE = 10;
+
+export class BaseGameLevelHelper {
+    private readonly _master: GameMaster;
+
+    static getLevelRank (level: number): number {
+      if (level < ExperiencesLevelEdgeEnum.PLAYER) {
+            return ExperiencesLevelRankEnum.NEW;
+        } else if (
+            level >= ExperiencesLevelEdgeEnum.PLAYER &&
+            level < ExperiencesLevelEdgeEnum.PROFI
+        ) {
+            return ExperiencesLevelRankEnum.PLAYER;
+        } else {
+            return ExperiencesLevelRankEnum.PROFI;
+        }
+    }
+
+    constructor (master: GameMaster) {
+        this._master = master;
+    }
+
+    getMaster<T> () {
+        return this._master as T;
+    }
+
+    getNewExperienceAmount (player: GamePlayer): number {
+        if (player.isWinner) {
+            return ExperiencesAmountEnum.NORMAL;
+        }
+
+        return ExperiencesAmountEnum.MIN;
+    }
+
+    getNewLevelAdding (level: number, experience: number) {
+        return this.needUpLevel(level, experience) ? 1 : 0;
+    }
+
+    needUpLevel (level: number, experience: number) {
+        return this._getExperienceOnCurrentLevel(level, experience) >= this.getNextLevelExperience(level);
+    }
+
+    getNextLevelExperience (level: number) {
+        return level * LEVEL_SIZE;
+    }
+
+    getExperienceToNextLevel (level: number, experience: number) {
+        return this.getNextLevelExperience(level) - this._getExperienceOnCurrentLevel(level, experience);
+    }
+
+    getLevelRank (level: number) {
+        return BaseGameLevelHelper.getLevelRank(level);
+    }
+
+    private _getExperienceOnCurrentLevel (level: number, experience: number) {
+        return experience - this._getPrevLevelExperience(level);
+    }
+
+    private _getPrevLevelExperience (level: number) {
+        let prevLevelExperience = 0;
+        for (let i = 0; i < level; i += 1) {
+            prevLevelExperience += i * LEVEL_SIZE;
+        }
+
+        return prevLevelExperience;
+    }
+}
+

package/src/level-helper/experiences-amount.enum.ts

@@ -0,0 +1,5 @@
+export enum ExperiencesAmountEnum {
+  MAX = 10,
+  NORMAL = 5,
+  MIN = 2,
+}

package/src/level-helper/experiences-level-edge.enum.ts

@@ -0,0 +1,4 @@
+export enum ExperiencesLevelEdgeEnum {
+  PLAYER = 50,
+  PROFI = 100,
+}

package/src/level-helper/experiences-level-rank.enum.ts

@@ -0,0 +1,5 @@
+export enum ExperiencesLevelRankEnum {
+  NEW = 1,
+  PLAYER,
+  PROFI,
+}

package/src/level-helper/index.ts

@@ -0,0 +1,3 @@
+export { ExperiencesAmountEnum } from './experiences-amount.enum';
+export { ExperiencesLevelRankEnum } from './experiences-level-rank.enum';
+export { BaseGameLevelHelper } from './base-game-level-helper';

package/src/strategies/index.ts

@@ -0,0 +1,3 @@
+export { MaxPlayersStrategy } from './max-players-strategy';
+export { MinPlayersStartStrategy } from './min-players-strategy';
+export { IStartStrategy } from './start-strategy-interface';

package/src/strategies/max-players-strategy.ts

@@ -0,0 +1,8 @@
+import { IStartStrategy } from './start-strategy-interface';
+import { GameTable } from '../base';
+
+export class MaxPlayersStrategy implements IStartStrategy {
+    shouldStart (table: GameTable): boolean {
+        return table.isFull();
+    }
+}

package/src/strategies/min-players-strategy.ts

@@ -0,0 +1,8 @@
+import { IStartStrategy } from './start-strategy-interface';
+import { GameTable } from '../base';
+
+export class MinPlayersStartStrategy implements IStartStrategy {
+    shouldStart (table: GameTable): boolean {
+        return table.getPlayers().length > 1;
+    }
+}

package/src/strategies/start-strategy-interface.ts

@@ -0,0 +1,5 @@
+import { GameTable } from '../base';
+
+export interface IStartStrategy {
+    shouldStart (table: GameTable): boolean;
+}

package/src/tests/just-black-jack/domain/black-jack-dealer.ts

@@ -1,15 +1,20 @@
 import { BlackJackPlayer } from './black-jack-player';
 
 export class BlackJackDealer extends BlackJackPlayer {
-  constructor (tableId: string) {
-    super(`${tableId}_dealer`,
-      'Dealer John',
-      '',
-      1000000
-    );
-  }
+    constructor (tableId: string) {
+        super({
+                id: `${tableId}_dealer`,
+                fullName: 'Dealer John',
+                avatarUrl: '',
+                balance: 1000000,
+                level: 1,
+                experience: 0,
+                language: 'ru',
+            }
+        );
+    }
 
-  override isDealer (): boolean {
-    return true;
-  }
+    get isDealer (): boolean {
+        return true;
+    }
 }

package/src/tests/just-black-jack/domain/black-jack-game-master.ts

@@ -1,120 +1,97 @@
-import { BaseGameStateType, GameRound, StandardGameState } from '../../../base';
+import { IBaseTableGameState } from 'jp.common.models';
+
+import {
+    GameRoom,
+    GamePlayer,
+    BasePlayerMoveFactory,
+    GameResultHelper,
+} from '../../../base';
 import { CardsGameMaster } from '../../../cards-game';
 
 import { BlackJackPlayer } from './black-jack-player';
 import { BlackJackDealer } from './black-jack-dealer';
-import { BaseMoveDataType } from '../../../base/base-move-data.type';
-
-export enum BlackJackMoveActionType {
-    GET_CARD = 'GET_CARD',
-    FINISH_MOVE = 'FINISH_MOVE',
-}
+import { BlackJackMoveFactory } from './moves/black-jack-move-factory';
+import { BlackJackPlayerActionsEnum } from './black-jack-player-actions.enum';
+import { NotImplementedException } from '../../../exceptions/not-implemented.exception';
+import { BlackJackGameResultHelper } from './black-jack-game-result-helper';
 
 export enum BlackJackSeatRole {
     DEALER = 'DEALER',
 }
 
-export interface BlackJackGameStateType extends BaseGameStateType {
-    superbit: boolean;
-}
-
-export interface BlackJackMoveData extends BaseMoveDataType {
-    extra: number;
-}
-
 export class BlackJackGameMaster extends CardsGameMaster {
-    getGameRoundState (): StandardGameState {
-        return (this.gameRound?.getState() as StandardGameState);
-    }
+    constructor (room: GameRoom) {
+        super(room);
 
-    getPlayers (): Array<BlackJackPlayer> {
-        return (this.table.getPlayers() as Array<BlackJackPlayer>);
+        this.getTable().getSeats().getFirstSeat()?.setRole(BlackJackSeatRole.DEALER);
+        this.getTable().addPlayerToSeat(new BlackJackDealer(this.getId()));
     }
 
     startNewRound () {
         this.takeNewDeck();
-        this.setGameRound(new GameRound(new StandardGameState()));
-
-        this.getTable().getSeats()[0].setRole(BlackJackSeatRole.DEALER);
-        this.getTable().addPlayerToSeat(new BlackJackDealer(this.getId()));
-
         this.give2CardsToAllPlayers();
-        this.getGameRoundState().toStart();
-
-        const firstPlayer = this.table.seats.getNextPlayer(this.getDealerSeat()?.getNumber() ?? 0);
-        if (firstPlayer) {
-            this.gameRound?.setActivePlayer(firstPlayer);
-        }
-    }
-
-    changePlayer () {
-        this.changePlayerClockwise();
+        this.setActivePlayer(this.getFirstPlayerAfterDealer());
     }
 
     finishRound () {
-        this.getGameRoundState().toFinish();
-    }
-
-    getResults (): {} | null {
-        return null;
     }
 
-    kickPlayer (player: BlackJackPlayer) {
+    isGameOver () {
+        return this.table.getPlayers<BlackJackPlayer>().filter((item) =>
+            item.isFinishedMove).length === this.table.getPlayers().length;
     }
 
-    onHandleMove<T>(player: BlackJackPlayer, moveData: BaseMoveDataType): T {
-        const bjMoveData = moveData as BlackJackMoveData;
-
-        switch (bjMoveData.action) {
-            case BlackJackMoveActionType.GET_CARD: {
-                this.getCard(player);
-                break;
-            }
-            case BlackJackMoveActionType.FINISH_MOVE: {
-                this.finishMove(player);
-                break;
-            }
+    getNextGamePlayer (): GamePlayer | null {
+        const currentPlayer = this.getActivePlayer<BlackJackPlayer>();
+        if (currentPlayer && !currentPlayer?.isFinishedMove) {
+            return currentPlayer;
+        } else {
+            return this.getNextPlayerClockwise();
         }
-
-        return this.getGameState() as T;
     }
 
-    override getGameState (): BlackJackGameStateType {
-        return {
-            ...super.getGameState(),
-            superbit: true,
-        };
+    getDealerSeat () {
+        return this.getTable().seats.getSeats().find((seat) => seat.getRole() === BlackJackSeatRole.DEALER);
     }
 
-    onHandleRestartTimeout () {
+    getDealer (): BlackJackPlayer | undefined {
+        return this.getDealerSeat()?.getPlayer() as BlackJackPlayer | undefined;
     }
 
-    onHandleTurnTimeout (player: BlackJackPlayer) {
+    getFirstPlayerAfterDealer (): BlackJackPlayer | null {
+        return this.getDealerSeat()?.getNextPlayer() ?? null;
     }
 
-    getCard (player: BlackJackPlayer) {
-        this.give1CardsToPlayer(player);
+    createGameStateDto (): IBaseTableGameState {
+        throw new NotImplementedException();
     }
 
-    finishMove (player: BlackJackPlayer) {
-        player.finishMove();
+    createMoveFactory (): BasePlayerMoveFactory {
+        return new BlackJackMoveFactory(this);
+    }
 
-        if (this.isFinish()) {
-            this.finishRound();
-        } else {
-            this.changePlayer();
+    getPossibleMoves (player: BlackJackPlayer): Array<string> {
+        if (this.isActivePlayer(player.id)) {
+            return [
+                BlackJackPlayerActionsEnum.FINISH_MOVE,
+                BlackJackPlayerActionsEnum.GET_CARD,
+            ];
         }
+
+        return [];
     }
 
-    isFinish () {
-        return this.getPlayers().filter((item) => item.isFinishedMove()).length === this.table.getPlayers().length;
+    getGameResultHelper (): GameResultHelper {
+        return new BlackJackGameResultHelper(this);
     }
 
-    getDealerSeat () {
-        return this.getTable().seats.getSeats().find((seat) => seat.getRole() === BlackJackSeatRole.DEALER);
+    isTurnOver (): boolean {
+        return false;
     }
 
-    getDealer (): BlackJackPlayer | undefined {
-        return this.getDealerSeat()?.getPlayer() as BlackJackPlayer | undefined;
+    startNewTurn () {
+    }
+
+    finishTurn () {
     }
 }

package/src/tests/just-black-jack/domain/black-jack-game-result-helper.ts

@@ -0,0 +1,15 @@
+import { GameResultHelper } from '../../../base/game-result-helper';
+import { GamePlayer } from '../../../base';
+
+export class BlackJackGameResultHelper extends GameResultHelper {
+    getLosers (): Array<GamePlayer> {
+        return [];
+    }
+
+    getWinners (): Array<GamePlayer> {
+        return [];
+    }
+
+    calcResult (): void {
+    }
+}

package/src/tests/just-black-jack/domain/black-jack-move-data.ts

@@ -0,0 +1,14 @@
+import { BaseMoveData } from '../../../base';
+
+export class BlackJackMoveData extends BaseMoveData {
+    private readonly _extra: string;
+
+    constructor (action: string, extra: string) {
+        super(action);
+        this._extra = extra;
+    }
+
+    get extra () {
+        return this._extra;
+    }
+}

package/src/tests/just-black-jack/domain/black-jack-player-actions.enum.ts

@@ -0,0 +1,4 @@
+export class BlackJackPlayerActionsEnum {
+    static GET_CARD = 'GET_CARD';
+    static FINISH_MOVE = 'FINISH_MOVE';
+}

package/src/tests/just-black-jack/domain/black-jack-player.ts

@@ -1,27 +1,27 @@
 import { CardsPlayer } from '../../../cards-game';
+import { IGamePlayerConfig } from '../../../base';
 
 export class BlackJackPlayer extends CardsPlayer {
-  private isFinishMove: boolean;
+    private _isFinishMove: boolean;
 
-  constructor (
-    id: string,
-    fullName: string,
-    avatarUrl: string,
-    balance: number,
-  ) {
-    super(id, fullName, avatarUrl, balance);
-    this.isFinishMove = false;
-  }
+    constructor (config: IGamePlayerConfig) {
+        super(config);
+        this._isFinishMove = false;
+    }
 
-  isDealer (): boolean {
-    return false;
-  }
+    get isDealer (): boolean {
+        return false;
+    }
 
-  finishMove () {
-    this.isFinishMove = true;
-  }
+    finishMove () {
+        this._isFinishMove = true;
+    }
 
-  isFinishedMove () {
-    return this.isFinishMove;
-  }
+    get isFinishedMove () {
+        return this._isFinishMove;
+    }
+
+    hasOpenConnection (): boolean {
+        return true;
+    }
 }

package/src/tests/just-black-jack/domain/moves/black-jack-move-factory.ts

@@ -0,0 +1,24 @@
+import { BasePlayerMove, BasePlayerMoveFactory } from '../../../../base';
+import { BlackJackPlayer } from '../black-jack-player';
+import { BlackJackMoveData } from '../black-jack-move-data';
+import { NotImplementedException } from '../../../../exceptions/not-implemented.exception';
+import { BlackJackPlayerActionsEnum } from '../black-jack-player-actions.enum';
+
+import { BlackJackPlayerMoveGetCard } from './list/black-jack-player-move-get-card';
+import { BlackJackPlayerMoveFinishMove } from './list/black-jack-player-move-finish-move';
+
+export class BlackJackMoveFactory extends BasePlayerMoveFactory {
+    createMove (player: BlackJackPlayer, moveData: BlackJackMoveData): BasePlayerMove {
+        switch (moveData.action) {
+            case BlackJackPlayerActionsEnum.FINISH_MOVE: {
+                return new BlackJackPlayerMoveFinishMove(this.master, player, moveData);
+            }
+            case BlackJackPlayerActionsEnum.GET_CARD: {
+                return new BlackJackPlayerMoveGetCard(this.master, player, moveData);
+            }
+            default: {
+                throw new NotImplementedException();
+            }
+        }
+    }
+}

package/src/tests/just-black-jack/domain/moves/list/black-jack-player-move-finish-move.ts

@@ -0,0 +1,12 @@
+import { BlackJackPlayer } from '../../black-jack-player';
+import { BasePlayerMove } from '../../../../../base';
+
+export class BlackJackPlayerMoveFinishMove extends BasePlayerMove {
+    isValid (): boolean {
+        return true;
+    }
+
+    commit () {
+        this.getPlayer<BlackJackPlayer>().finishMove();
+    }
+}

package/src/tests/just-black-jack/domain/moves/list/black-jack-player-move-get-card.ts

@@ -0,0 +1,13 @@
+import { BasePlayerMove } from '../../../../../base';
+import { BlackJackGameMaster } from '../../black-jack-game-master';
+import { BlackJackPlayer } from '../../black-jack-player';
+
+export class BlackJackPlayerMoveGetCard extends BasePlayerMove {
+    isValid (): boolean {
+        return true;
+    }
+
+    commit () {
+        this.getMaster<BlackJackGameMaster>().give1CardsToPlayer(this.getPlayer<BlackJackPlayer>());
+    }
+}

package/src/tests/just-black-jack/rooms/black-jack-simple-room.ts

@@ -1,10 +1,9 @@
 import { SimpleRoom } from '../../../base-rooms';
 import { GameMaster } from '../../../base';
 import { BlackJackGameMaster } from '../domain/black-jack-game-master';
-import { deck52 } from '../../../cards-game';
 
 export class BlackJackSimpleRoom extends SimpleRoom {
-  createMaster (): GameMaster {
-    return new BlackJackGameMaster(this, deck52);
-  }
+    createMaster (): GameMaster {
+        return new BlackJackGameMaster(this);
+    }
 }