jp.ms.common.modules 1.0.41 → 1.0.43

package/src/modules/anti-freeze-system/anti-freeze-system.service.ts

@@ -1,105 +1,136 @@
-import { Injectable } from '@nestjs/common';
-import {
-  GameRoom,
-  ManyTablesTournamentRoom,
-  OneTableTournamentRoom,
-  TournamentMaster,
-} from 'jp.ms.common.engine';
-
-import { SimpleRoomsManagerService } from '../simple-rooms-manager/simple-rooms-manager.service';
-import { OneTableTournamentRoomsManagerService } from '../one-table-tournament-rooms-manager/one-table-tournament-rooms-manager.service';
-import { ManyTablesTournamentRoomsManagerService } from '../many-tables-tournament-rooms-manager/many-tables-tournament-rooms-manager.service';
-
-export interface IRoomSetItem {
-  tableId: string;
-  hash: string;
-  count: number;
-  room: GameRoom;
-}
-
-@Injectable()
-export class AntiFreezeSystemService {
-  private prevSet: Map<string, IRoomSetItem>;
-
-  constructor(
-    private readonly simpleRoomsManagerService: SimpleRoomsManagerService,
-    private readonly oneTableRoomsManagerService: OneTableTournamentRoomsManagerService,
-    private readonly manyTablesRoomsManagerService: ManyTablesTournamentRoomsManagerService,
-  ) {
-    this.prevSet = new Map<string, IRoomSetItem>();
-  }
-
-  process(checkCount: number) {
-    this.mergeSets();
-    this.clear(checkCount);
-  }
-
-  private mergeSets() {
-    if (this.prevSet.size === 0) {
-      this.prevSet = this.getCurrentSet();
-    } else {
-      const newSet = new Map<string, IRoomSetItem>();
-      const currentSet = this.getCurrentSet();
-
-      currentSet.forEach((currentSetItem, currentSetKey) => {
-        const prevSetItem = this.prevSet.get(currentSetKey);
-        if (prevSetItem && prevSetItem.hash === currentSetItem.hash) {
-          newSet.set(currentSetKey, {
-            ...currentSetItem,
-            count: prevSetItem.count + 1,
-          });
-        } else {
-          newSet.set(currentSetKey, currentSetItem);
-        }
-      });
-
-      this.prevSet = newSet;
-    }
-  }
-
-  private getCurrentSet() {
-    const newSet = new Map<string, IRoomSetItem>();
-    const allTables = [
-      ...this.simpleRoomsManagerService.getTables(),
-      ...this.oneTableRoomsManagerService.getTables(),
-      ...this.manyTablesRoomsManagerService.getTables(),
-    ];
-
-    const list: Array<IRoomSetItem> = allTables
-      .filter((item) => item.isInProgress())
-      .map((item) => ({
-        tableId: item.getId(),
-        hash: item.getHash(),
-        count: 0,
-        room: item.getRoom(),
-      }));
-
-    list.forEach((obj) => newSet.set(obj.tableId, obj));
-
-    return newSet;
-  }
-
-  private clear(checkCount: number) {
-    this.prevSet.forEach((item) => {
-      if (item.count === checkCount) {
-        if (item.room instanceof OneTableTournamentRoom) {
-          const room = this.oneTableRoomsManagerService.getRoomByTableId(
-            item.tableId,
-          );
-          room?.getRoomMaster<TournamentMaster>().cancelTournament();
-        } else if (item.room instanceof ManyTablesTournamentRoom) {
-          const room = this.manyTablesRoomsManagerService.getRoomByTableId(
-            item.tableId,
-          );
-          room?.getRoomMaster<TournamentMaster>().cancelTournament();
-        } else {
-          this.simpleRoomsManagerService
-            .getRoomByTableId(item.tableId)
-            ?.restartTable(item.tableId);
-        }
-
-        this.prevSet.delete(item.tableId);
-      }
-    });
-  }
-}
+import { Inject, Injectable } from '@nestjs/common';
+import {
+  GameRoom,
+  ManyTablesTournamentRoom,
+  OneTableTournamentRoom,
+  TournamentMaster,
+} from 'jp.ms.common.engine';
+
+import { SimpleRoomsManagerService } from '../simple-rooms-manager/simple-rooms-manager.service';
+import { OneTableTournamentRoomsManagerService } from '../one-table-tournament-rooms-manager/one-table-tournament-rooms-manager.service';
+import { ManyTablesTournamentRoomsManagerService } from '../many-tables-tournament-rooms-manager/many-tables-tournament-rooms-manager.service';
+import { JpLoggerService } from '../logger';
+
+import { AntiFreezeSystemFactoryOptions } from './anti-freeze-system.interfaces';
+import { ANTI_FREEZE_SYSTEM_OPTIONS } from './anti-freeze-system.constants';
+
+export interface IRoomSetItem {
+  tableId: string;
+  hash: string;
+  count: number;
+  room: GameRoom;
+}
+
+@Injectable()
+export class AntiFreezeSystemService {
+  private prevSet: Map<string, IRoomSetItem>;
+
+  constructor(
+    private readonly simpleRoomsManagerService: SimpleRoomsManagerService,
+    private readonly oneTableRoomsManagerService: OneTableTournamentRoomsManagerService,
+    private readonly manyTablesRoomsManagerService: ManyTablesTournamentRoomsManagerService,
+    @Inject() private readonly logger: JpLoggerService,
+    @Inject(ANTI_FREEZE_SYSTEM_OPTIONS)
+    private readonly options: AntiFreezeSystemFactoryOptions,
+  ) {
+    this.prevSet = new Map<string, IRoomSetItem>();
+  }
+
+  process() {
+    this.mergeSets();
+    this.clear();
+  }
+
+  private mergeSets() {
+    if (this.prevSet.size === 0) {
+      this.prevSet = this.getCurrentSet();
+    } else {
+      const newSet = new Map<string, IRoomSetItem>();
+      const currentSet = this.getCurrentSet();
+
+      currentSet.forEach((currentSetItem, currentSetKey) => {
+        const prevSetItem = this.prevSet.get(currentSetKey);
+        if (prevSetItem && prevSetItem.hash === currentSetItem.hash) {
+          newSet.set(currentSetKey, {
+            ...currentSetItem,
+            count: prevSetItem.count + 1,
+          });
+
+          this.logger.log(
+            `${AntiFreezeSystemService.name}: tableId: ${prevSetItem.tableId}, count: ${prevSetItem.count}`,
+          );
+        } else {
+          newSet.set(currentSetKey, currentSetItem);
+        }
+      });
+
+      this.prevSet = newSet;
+    }
+  }
+
+  private getCurrentSet() {
+    const newSet = new Map<string, IRoomSetItem>();
+    const allTables = [
+      ...this.simpleRoomsManagerService.getTables(),
+      ...this.oneTableRoomsManagerService.getTables(),
+      ...this.manyTablesRoomsManagerService.getTables(),
+    ];
+
+    const list: Array<IRoomSetItem> = allTables
+      .filter((item) => item.isInProgress())
+      .map((item) => ({
+        tableId: item.getId(),
+        hash: item.getHash(),
+        count: 0,
+        room: item.getRoom(),
+      }));
+
+    list.forEach((obj) => newSet.set(obj.tableId, obj));
+
+    return newSet;
+  }
+
+  private clear() {
+    this.prevSet.forEach((item) => {
+      if (item.count === this.options.antiFreezeSystemCheckCount) {
+        if (item.room instanceof OneTableTournamentRoom) {
+          this.logger.log(
+            `${AntiFreezeSystemService.name}: cancel tournamentId: ${item.room.getId()}`,
+          );
+          const room = this.oneTableRoomsManagerService.getRoomByTableId(
+            item.tableId,
+          );
+          room?.getTables().forEach((table) => {
+            table.getPlayers().forEach((player) => {
+              room?.handleLeaveTournament(player);
+            });
+          });
+          room?.getRoomMaster<TournamentMaster>().onTournamentCancel();
+        } else if (item.room instanceof ManyTablesTournamentRoom) {
+          this.logger.log(
+            `${AntiFreezeSystemService.name}: cancel tournamentId: ${item.room.getId()}`,
+          );
+          const room = this.manyTablesRoomsManagerService.getRoomByTableId(
+            item.tableId,
+          );
+          room?.getTables().forEach((table) => {
+            table.getPlayers().forEach((player) => {
+              room?.handleLeaveTournament(player);
+            });
+          });
+          room?.getRoomMaster<TournamentMaster>().onTournamentCancel();
+        } else {
+          this.logger.log(
+            `${AntiFreezeSystemService.name}: restart tableId: ${item.tableId}`,
+          );
+
+          this.simpleRoomsManagerService
+            .getRoomByTableId(item.tableId)
+            ?.restartTable(item.tableId);
+        }
+
+        this.prevSet.delete(item.tableId);
+      }
+    });
+  }
+}

package/src/modules/anti-freeze-system/index.ts

@@ -1 +1 @@
-export { AntiFreezeSystemModule } from './anti-freeze-system.module';
+export { AntiFreezeSystemModule } from './anti-freeze-system.module';