jp.ms.common.modules 1.0.24 → 1.0.26

package/src/modules/simple-rooms-manager/simple-rooms-manager.service.ts

@@ -9,6 +9,9 @@ import {
     GameRoomConfig,
     RoomUpdateStateEvent,
     UserWonTheGameAppEvent,
+    GameTableFinishedEvent,
+    GamePlayerEnteredTheTableEvent,
+    GamePlayerExitedTheTableEvent,
 } from 'jp.ms.common.engine';
 import {
     GameResultRepository,
@@ -42,47 +45,87 @@ export class SimpleRoomsManagerService {
         this.rooms = new Map<string, SimpleRoom>();
     }
 
-    get gameType() {
+    get gameType () {
         return this.options.configService.get<string>('GAME_TYPE') || '';
     }
 
-    getRoomById(roomId: string): SimpleRoom | undefined {
+    getRoomById (roomId: string): SimpleRoom | undefined {
         return this.rooms.get(roomId);
     }
 
-    getRoomByTableId(tableId: string): SimpleRoom | undefined {
+    getRoomByTableId (tableId: string): SimpleRoom | undefined {
         const { roomId } = GameMaster.parseTableId(tableId);
 
         return this.getRoomById(roomId);
     }
 
-    getRooms(): Array<SimpleRoom> {
+    getRooms (): Array<SimpleRoom> {
         return Array.from(this.rooms.values());
     }
 
-    getTables(): Array<GameMaster> {
+    getTables (): Array<GameMaster> {
         return this.getRooms().reduce(
             (result, currentValue) => {
                 return [...result, ...currentValue.getMasters()];
-            }, [] as Array<GameMaster>);
+            }, [] as Array<GameMaster>
+        );
     }
 
-    addRoom(room: SimpleRoom) {
+    addRoom (room: SimpleRoom) {
         this.rooms.set(room.getId(), room);
     }
 
-    async hydrateRoomsFromDB() {
+    async hydrateRoomsFromDB () {
         const templates = await this.roomsRepository.findRooms(this.gameType);
 
         templates.forEach((item) => {
             const newRoom = this.options.createRoom(
-                this.simpleRoomDocumentToTournamentRoom(item)
+                this.simpleRoomDocumentToRoom(item)
             );
             this.addRoom(newRoom);
         });
     }
 
-    private simpleRoomDocumentToTournamentRoom(room: SimpleRoomDocument): GameRoomConfig {
+    /*
+        1. Сначала ищем стол в котором один игрок
+        2. Далее ищем стол за которым есть игроки и свободные места
+        3. Отправляем на стол для быстрой игры если там есть места
+        4. Наконец создаем стол для быстрой игры и отправляем туда
+    */
+    getFreeFastGameRoom (): GameMaster | undefined {
+        if (this.getRooms().some((item) => item.isTechBreak())) {
+            return;
+        }
+
+        const tables = this.getTables();
+
+        let freeTable = tables.find(
+            (master) => master.getTable().remainOnePlayer() && master.getTable().getPlayers()[0].hasOpenConnection()
+        );
+
+        if (!freeTable) {
+            freeTable = tables.find(
+                (master) => master.getTable().hasMinPlayers() && !master.getTable().isFullWithQueue(),
+            );
+        }
+
+        if (!freeTable) {
+            freeTable = tables.filter((item) => item.getRoom().getEnableForFastGame()).find(
+                (master) => !master.getTable().isFullWithQueue(),
+            );
+        }
+
+        if (!freeTable) {
+            const fastGameRoom = this.getRooms().find((item) => item.getEnableForFastGame());
+            if (fastGameRoom) {
+                freeTable = fastGameRoom.addMaster();
+            }
+        }
+
+        return freeTable;
+    }
+
+    private simpleRoomDocumentToRoom (room: SimpleRoomDocument): GameRoomConfig {
         const restartGameTimeout = this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
         const playersTurnTimeout = this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 0;
 
@@ -98,18 +141,25 @@ export class SimpleRoomsManagerService {
             title: room.title,
             subtitle: room.subtitle,
             description: room.description,
+            enableForFastGame: room.enableForFastGame,
             turnTimeout: playersTurnTimeout,
             restartTimeout: restartGameTimeout,
             localeService: this.options.i18n,
             startStrategy: new MinPlayersStartStrategy(),
             onRoomEvent: this.handleRoomEvent,
-            onRoomTableGameFinished: this.handleRoomTableGameFinished,
-            onRoomStatusUpdated: this.handleRoomStatusUpdated,
+            // onRoomTableGameFinished: this.handleRoomTableGameFinished,
+            // onRoomStatusUpdated: this.handleRoomStatusUpdated,
         } as GameRoomConfig;
     }
 
     private handleRoomEvent = (event: BaseGameEvent) => {
-        this.logger.log(event.toLog());        
+        this.logger.log(event.toLog());
+
+        if (event instanceof GameTableFinishedEvent) {
+            this.handleRoomTableGameFinished(event.master!!);
+        } else if (event instanceof GamePlayerEnteredTheTableEvent || event instanceof GamePlayerExitedTheTableEvent) {
+            this.handleRoomStatusUpdated(new RoomUpdateStateEvent(event.gameType, event.roomId));
+        }
     };
 
     private handleRoomTableGameFinished = async (master: GameMaster) => {
@@ -122,7 +172,7 @@ export class SimpleRoomsManagerService {
         );
 
         // TODO: записать разные события для достижений
-        this.eventsBusAppSubscribeService.pushNewEvent(new UserWonTheGameAppEvent('123'));
+        this.eventsBusAppSubscribeService.pushNewEvent(new UserWonTheGameAppEvent(this.gameType, '123'));
     };
 
     private handleRoomStatusUpdated = (event: RoomUpdateStateEvent) => {

package/src/modules/tournament-many-tables-rooms-manager/tournament-many-tables-rooms-manager.service.ts

@@ -3,6 +3,13 @@ import {
     BaseGameEvent,
     GameMaster,
     GamePlayer,
+    GameTableFinishedEvent,
+    GameTournamentCancelledEvent,
+    GameTournamentFinishedEvent,
+    GameTournamentPlayerJoinedTheTournamentEvent,
+    GameTournamentPlayerLeavedTheTournamentEvent,
+    GameTournamentStartedEvent,
+    GameTournamentWaitedEvent,
     ManyTablesTournamentRoom,
     ManyTablesTournamentRoomConfig,
     NoStartStrategy,
@@ -17,8 +24,8 @@ import {
 } from 'jp.db.schemas';
 import { InjectConnection } from '@nestjs/mongoose';
 import { Connection } from 'mongoose';
-import * as dayjs from 'dayjs';
-import * as schedule from 'node-schedule';
+import dayjs from 'dayjs';
+import schedule from 'node-schedule';
 import { Job } from 'node-schedule';
 
 import { saveGameTablesResult, saveTournamentResult } from '../../utils/game-table-result';
@@ -50,25 +57,25 @@ export class TournamentManyTablesRoomsManagerService {
         this.rooms = new Map<string, ManyTablesTournamentRoom>();
     }
 
-    get gameType() {
+    get gameType () {
         return this.options.configService.get<string>('GAME_TYPE') || '';
     }
 
-    getRoomById(roomId: string): ManyTablesTournamentRoom | undefined {
+    getRoomById (roomId: string): ManyTablesTournamentRoom | undefined {
         return this.rooms.get(roomId);
     }
 
-    getRoomByTableId(tableId: string): ManyTablesTournamentRoom | undefined {
+    getRoomByTableId (tableId: string): ManyTablesTournamentRoom | undefined {
         const { roomId } = GameMaster.parseTableId(tableId);
 
         return this.getRoomById(roomId);
     }
 
-    getRooms(): Array<ManyTablesTournamentRoom> {
+    getRooms (): Array<ManyTablesTournamentRoom> {
         return Array.from(this.rooms.values());
     }
 
-    getTables(): Array<GameMaster> {
+    getTables (): Array<GameMaster> {
         return this.getRooms().reduce(
             (result, currentValue) => {
                 return [...result, ...currentValue.getMasters()];
@@ -77,11 +84,11 @@ export class TournamentManyTablesRoomsManagerService {
         );
     }
 
-    addRoom(room: ManyTablesTournamentRoom) {
+    addRoom (room: ManyTablesTournamentRoom) {
         this.rooms.set(room.getId(), room);
     }
 
-    async hydrateTournamentsFromDB() {
+    async hydrateTournamentsFromDB () {
         const templates = await this.tournamentRepository.findTournaments(this.gameType);
         templates.forEach((item) => {
             this.addRoom(this.options.createTournamentRoom(
@@ -90,7 +97,7 @@ export class TournamentManyTablesRoomsManagerService {
         });
     }
 
-    async runDailyTournamentJob() {
+    async runDailyTournamentJob () {
         const dailyTournamentScheduleTaskTime = this.options.configService.get<string>('DAILY_TOURNAMENT_SCHEDULE_TASK_TIME');
         const dailyTournamentTime = this.options.configService.get<string>('DAILY_TOURNAMENT_TIME');
 
@@ -104,7 +111,7 @@ export class TournamentManyTablesRoomsManagerService {
         }
     }
 
-    async createTournament(createTournamentDto: ManyTablesTournamentCreateDto) {
+    async createTournament (createTournamentDto: ManyTablesTournamentCreateDto) {
         const newTournament = await this.tournamentRepository.createTournament(createTournamentDto);
 
         this.addRoom(this.options.createTournamentRoom(
@@ -112,21 +119,21 @@ export class TournamentManyTablesRoomsManagerService {
         ));
     }
 
-    async updateTournament(tournamentId: string, updateTournamentDto: ManyTablesTournamentUpdateDto) {
+    async updateTournament (tournamentId: string, updateTournamentDto: ManyTablesTournamentUpdateDto) {
         const updatedTournament = await this.tournamentRepository.updateTournament(tournamentId, updateTournamentDto);
 
-        this.getRoomById(tournamentId)?.getTournamentMaster().cancelTournament();
+        this.getRoomById(tournamentId)?.getRoomMaster<TournamentMaster>().cancelTournament();
 
         this.addRoom(this.options.createTournamentRoom(
             this.manyTablesTournamentDocumentToTournamentRoom(updatedTournament)
         ));
     }
 
-    async removeTournament(tournamentId: string) {
+    async removeTournament (tournamentId: string) {
         await this.tournamentRepository.removeTournament(tournamentId);
     }
 
-    async buyTicket(tournamentId: string, player: GamePlayer) {
+    async buyTicket (tournamentId: string, player: GamePlayer) {
         // TODO списать деньги у игрока
         await this.tournamentRepository.addPlayerToParticipants(tournamentId, {
             playerId: player.id,
@@ -135,7 +142,7 @@ export class TournamentManyTablesRoomsManagerService {
         });
     }
 
-    private manyTablesTournamentDocumentToTournamentRoom(tournamentDocument: TournamentManyTablesRoomDocument): ManyTablesTournamentRoomConfig {
+    private manyTablesTournamentDocumentToTournamentRoom (tournamentDocument: TournamentManyTablesRoomDocument): ManyTablesTournamentRoomConfig {
         const restartGameTimeout = this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
         const playersTurnTimeout = this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 0;
         const minPlayersForMergeTables = this.options.configService.get<number>('TOURNAMENT_MANY_TABLES_MIN_PLAYERS_FOR_MERGE_TABLES') || 0;
@@ -152,6 +159,7 @@ export class TournamentManyTablesRoomsManagerService {
             title: tournamentDocument.title,
             subtitle: tournamentDocument.subtitle,
             description: tournamentDocument.description,
+            enableForFastGame: false,
             scheduleDate: tournamentDocument.scheduleDate,
             turnTimeout: playersTurnTimeout,
             restartTimeout: restartGameTimeout,
@@ -170,7 +178,24 @@ export class TournamentManyTablesRoomsManagerService {
     }
 
     private handleRoomEvent = (event: BaseGameEvent) => {
-        this.logger.log(event.toLog());
+        if (event instanceof GameTableFinishedEvent) {
+            this.handleRoomTableGameFinished(event.master!!);
+        } else if (event instanceof GameTournamentStartedEvent) {
+            this.handleTournamentRoomStarted(event.room.getRoomMaster());
+        } else if (event instanceof GameTournamentCancelledEvent) {
+            this.handleTournamentRoomCancelled(event.room.getRoomMaster());
+        } else if (event instanceof GameTournamentFinishedEvent) {
+            this.handleTournamentRoomFinished(event.room.getRoomMaster());
+        } else if (
+            event instanceof GameTournamentPlayerJoinedTheTournamentEvent &&
+            event instanceof GameTournamentPlayerLeavedTheTournamentEvent &&
+            event instanceof GameTournamentCancelledEvent &&
+            event instanceof GameTournamentWaitedEvent &&
+            event instanceof GameTournamentStartedEvent &&
+            event instanceof GameTournamentFinishedEvent
+        ) {
+            this.handleRoomStatusUpdated(new RoomUpdateStateEvent(event.gameType, event.roomId));
+        }
     };
 
     private handleRoomTableGameFinished = async (master: GameMaster) => {

package/src/modules/tournament-one-table-rooms-manager/tournament-one-table-rooms-manager.service.ts

@@ -2,6 +2,13 @@ import { Inject, Injectable } from '@nestjs/common';
 import {
   BaseGameEvent,
   GameMaster,
+  GameTableFinishedEvent,
+  GameTournamentCancelledEvent,
+  GameTournamentFinishedEvent,
+  GameTournamentPlayerJoinedTheTournamentEvent,
+  GameTournamentPlayerLeavedTheTournamentEvent,
+  GameTournamentStartedEvent,
+  GameTournamentWaitedEvent,
   NoStartStrategy,
   OneTableTournamentRoom,
   RoomUpdateStateEvent,
@@ -18,7 +25,7 @@ import { InjectConnection } from '@nestjs/mongoose';
 import { Connection } from 'mongoose';
 
 import { JpLoggerService } from '../logger/jp-logger.service';
-import { saveGameTablesResult, saveTournamentResult } from '../../utils/game-table-result';
+import { isUpdateTounrmanentRoomEvent, saveGameTablesResult, saveTournamentResult } from '../../utils/game-table-result';
 import { EventsBusMainTablesSubscribeService, EventsBusOneTableTournamentSubscribeService } from '../event-bus';
 
 import { TOURNAMENT_ONE_TABLE_ROOMS_MANAGER_OPTIONS } from './tournament-one-table-rooms-manager.constants';
@@ -41,25 +48,25 @@ export class TournamentOneTableRoomsManagerService {
     this.rooms = new Map<string, OneTableTournamentRoom>();
   }
 
-  get gameType() {
+  get gameType () {
     return this.options.configService.get<string>('GAME_TYPE') || '';
   }
 
-  getRoomById(roomId: string): OneTableTournamentRoom | undefined {
+  getRoomById (roomId: string): OneTableTournamentRoom | undefined {
     return this.rooms.get(roomId);
   }
 
-  getRoomByTableId(tableId: string): OneTableTournamentRoom | undefined {
+  getRoomByTableId (tableId: string): OneTableTournamentRoom | undefined {
     const { roomId } = GameMaster.parseTableId(tableId);
 
     return this.getRoomById(roomId);
   }
 
-  getRooms(): Array<OneTableTournamentRoom> {
+  getRooms (): Array<OneTableTournamentRoom> {
     return Array.from(this.rooms.values());
   }
 
-  getTables(): Array<GameMaster> {
+  getTables (): Array<GameMaster> {
     return this.getRooms().reduce(
       (result, currentValue) => {
         return [...result, ...currentValue.getMasters()];
@@ -68,18 +75,18 @@ export class TournamentOneTableRoomsManagerService {
     );
   }
 
-  addRoom(room: OneTableTournamentRoom) {
+  addRoom (room: OneTableTournamentRoom) {
     this.rooms.set(room.getId(), room);
   }
 
-  async createMasterTournament() {
+  async createMasterTournament () {
     const waitingTournament = await this.tournamentRepository.findWaitingTournament(this.gameType);
     if (!waitingTournament) {
       await this.tournamentRepository.createTournamentFromMasterTemplate(this.gameType);
     }
   }
 
-  async hydrateTournamentsFromDB() {
+  async hydrateTournamentsFromDB () {
     const templates = await this.tournamentRepository.findTournaments(this.gameType);
     templates.forEach((item) => {
       this.addRoom(this.options.createTournamentRoom(
@@ -88,7 +95,7 @@ export class TournamentOneTableRoomsManagerService {
     });
   }
 
-  private oneTableTournamentDocumentToTournamentRoom(tournamentDocument: TournamentOneTableRoomDocument): TournamentRoomConfig {
+  private oneTableTournamentDocumentToTournamentRoom (tournamentDocument: TournamentOneTableRoomDocument): TournamentRoomConfig {
     const restartGameTimeout = this.options.configService.get<number>('RESTART_GAME_TIMEOUT') || 0;
     const playersTurnTimeout = this.options.configService.get<number>('PLAYERS_TURN_TIMEOUT') || 0;
 
@@ -104,16 +111,12 @@ export class TournamentOneTableRoomsManagerService {
       title: tournamentDocument.title,
       subtitle: tournamentDocument.subtitle,
       description: tournamentDocument.description,
+      enableForFastGame: false,
       turnTimeout: playersTurnTimeout,
       restartTimeout: restartGameTimeout,
       localeService: this.options.i18n,
       startStrategy: new NoStartStrategy(),
       onRoomEvent: this.handleRoomEvent,
-      onRoomTableGameFinished: this.handleRoomTableGameFinished,
-      onTournamentRoomStarted: this.handleTournamentRoomStarted,
-      onTournamentRoomFinished: this.handleTournamentRoomFinished,
-      onTournamentRoomCancelled: this.handleTournamentRoomCancelled,
-      onRoomStatusUpdated: this.handleRoomStatusUpdated,
       tournamentPrizeTable: this.options.tournamentPrizeTable,
       tournamentInitialStatus: tournamentDocument.status,
     } as TournamentRoomConfig;
@@ -121,6 +124,25 @@ export class TournamentOneTableRoomsManagerService {
 
   private handleRoomEvent = (event: BaseGameEvent) => {
     this.logger.log(event.toLog());
+
+    if (event instanceof GameTableFinishedEvent) {
+      this.handleRoomTableGameFinished(event.master!!);
+    } else if (event instanceof GameTournamentStartedEvent) {
+      this.handleTournamentRoomStarted(event.room.getRoomMaster());
+    } else if (event instanceof GameTournamentCancelledEvent) {
+      this.handleTournamentRoomCancelled(event.room.getRoomMaster());
+    } else if (event instanceof GameTournamentFinishedEvent) {
+      this.handleTournamentRoomFinished(event.room.getRoomMaster());
+    } else if (
+      event instanceof GameTournamentPlayerJoinedTheTournamentEvent &&
+      event instanceof GameTournamentPlayerLeavedTheTournamentEvent &&
+      event instanceof GameTournamentCancelledEvent &&
+      event instanceof GameTournamentWaitedEvent &&
+      event instanceof GameTournamentStartedEvent &&
+      event instanceof GameTournamentFinishedEvent
+    ) {
+      this.handleRoomStatusUpdated(new RoomUpdateStateEvent(event.gameType, event.roomId));
+    }
   };
 
   private handleRoomTableGameFinished = async (master: GameMaster) => {

package/src/utils/game-table-result.ts

@@ -1,11 +1,11 @@
-import { GameMaster, TournamentMaster } from 'jp.ms.common.engine';
+import { Connection } from 'mongoose';
+import { BaseGameEvent, GameMaster, GameTournamentCancelledEvent, GameTournamentFinishedEvent, GameTournamentPlayerJoinedTheTournamentEvent, GameTournamentPlayerLeavedTheTournamentEvent, GameTournamentStartedEvent, GameTournamentWaitedEvent, RoomUpdateStateEvent, TournamentMaster } from 'jp.ms.common.engine';
 import {
     GameResultRepository,
     TournamentManyTablesRoomsRepository,
     TournamentOneTableRoomsRepository,
     UsersRepository
 } from 'jp.db.schemas';
-import { Connection } from 'mongoose';
 
 export function getGameTableResults (master: GameMaster) {
     return {
@@ -91,7 +91,7 @@ export async function saveTournamentResult (
         };
     });
 
-    const session = await this.connection.startSession();
+    const session = await connection.startSession();
     session.startTransaction();
 
     try {
@@ -108,3 +108,18 @@ export async function saveTournamentResult (
         await session.endSession();
     }
 }
+
+export function isUpdateTounrmanentRoomEvent (event: BaseGameEvent) {
+    if (
+        event instanceof GameTournamentPlayerJoinedTheTournamentEvent &&
+        event instanceof GameTournamentPlayerLeavedTheTournamentEvent &&
+        event instanceof GameTournamentCancelledEvent &&
+        event instanceof GameTournamentWaitedEvent &&
+        event instanceof GameTournamentStartedEvent &&
+        event instanceof GameTournamentFinishedEvent
+    ) {
+        return event
+    }
+
+    return null;
+}

package/src/views/index.ts

@@ -1 +1,2 @@
-export { TournamentBuyTicketDialogView } from './tournament-buy-ticket-dialog.view';
+export { TournamentBuyTicketDialogView } from './tournament-buy-ticket-dialog.view';
+export { SimpleRoomConfirmExitDialogView } from './simple-room-conifrm-exit-dialog.view';

package/src/views/simple-room-conifrm-exit-dialog.view.ts

@@ -0,0 +1,21 @@
+import {
+    UniversalScreenDialogView,
+    AppScreenDialogIdEnum,
+    StandardDialogComponent,
+    FullButtonsButtonsComponent,
+    TextButtonComponent,
+} from "jp.common.models";
+
+export class SimpleRoomConfirmExitDialogView extends UniversalScreenDialogView {
+    build () {
+        return new StandardDialogComponent(
+            AppScreenDialogIdEnum.DIALOG_SIMPLE_ROOM_CONFIRM_EXIT,
+            this.localeService.t('common.room.screen.dialog.confirm.exit.game.title', { lang: this.lang }),
+            this.localeService.t('common.room.screen.dialog.confirm.exit.game.message', { lang: this.lang }),
+            new FullButtonsButtonsComponent(
+                new TextButtonComponent(this.localeService.t('common.room.screen.dialog.confirm.exit.game.ok', { lang: this.lang })),
+                new TextButtonComponent(this.localeService.t('common.room.screen.dialog.confirm.exit.game.cancel', { lang: this.lang })),
+            ),
+        );
+    }
+}

package/src/views/tournament-buy-ticket-dialog.view.ts

@@ -1,21 +1,21 @@
 import {
-    AppScreenSectionButton,
-    AppScreenSectionButtons,
     UniversalScreenDialogView,
-    AppScreenDialog,
     AppScreenDialogIdEnum,
- } from "jp.common.models";
+    StandardDialogComponent,
+    FullButtonsButtonsComponent,
+    TextButtonComponent,
+} from "jp.common.models";
 
 export class TournamentBuyTicketDialogView extends UniversalScreenDialogView {
-    build() {
-        return AppScreenDialog.CreateStandardDialog(
+    build () {
+        return new StandardDialogComponent(
             AppScreenDialogIdEnum.DIALOG_TOURNAMENT_BUY_TICKET,
             this.localeService.t('common.rooms.screen.buyTicket.title', { lang: this.lang }),
             this.localeService.t('common.rooms.screen.buyTicket.description', { lang: this.lang }),
-            AppScreenSectionButtons.CreateFullButtonSection(
-                AppScreenSectionButton.CreateTextButton('Ok'),
-                AppScreenSectionButton.CreateTextButton('Cancel'),
-            )
+            new FullButtonsButtonsComponent(
+                new TextButtonComponent(this.localeService.t('common.rooms.screen.buyTicket.button.ok', { lang: this.lang })),
+                new TextButtonComponent(this.localeService.t('common.rooms.screen.buyTicket.button.cancel', { lang: this.lang })),
+            ),
         );
     }
-}
+}