jp.ms.common.engine 1.0.2 → 1.0.4

package/src/base-rooms/scheduled-tournament-room.ts

@@ -1,181 +1,181 @@
-import schedule from 'node-schedule';
-import dayjs from 'dayjs';
-import { chunk, sumBy } from 'lodash';
-
-import { GamePlayer } from '../base';
-import { IGameTable } from '../base/game-table';
-
-import { TournamentRoom, TournamentRoomConfig } from './tournament-room';
-
-export abstract class ScheduledTournamentRoom<
-    GT extends IGameTable<GP>,
-    GP extends GamePlayer,
-> extends TournamentRoom<GT, GP> {
-    private readonly startDate: Date | null;
-    private readonly minUserForMergeTables: number;
-    private readonly startJob: Promise<schedule.Job> | null;
-
-    constructor (config: TournamentRoomConfig, minUserForMergeTables, startDate: Date | null) {
-        super(config);
-        this.minUserForMergeTables = minUserForMergeTables;
-        this.startDate = startDate;
-        if (startDate) {
-            this.startJob = this.scheduleTournament();
-        }
-    }
-
-    handleJoinTournament (player: GP) {
-        if (this.getState().isWaiting()) {
-            this.addUserRoomToQueue(player);
-        } else if (this.getState().isInProgress()) {
-            if (this.isParticipant(player.getId())) {
-                // redirect to table
-            } else {
-                // redirect
-            }
-        } else {
-            // redirect to status
-        }
-    }
-
-    handleLeaveTournament (player: GP) {
-        if (this.getState().isWaiting()) {
-            this.removeUserFromQueue(player);
-        } else if (this.getState().isInProgress()) {
-
-        }
-    }
-
-    handleFinishRound () {
-    }
-
-    handleRestartRound = (table: GT) => {
-        if (this.isTournamentFinish()) {
-            this.finishTournament();
-        } else if (this.isTableFinish(table)) {
-            const lastPlayer = table.getLastPlayer();
-            if (lastPlayer) {
-                table.removePlayerFromSeat(lastPlayer);
-                this.removeTable(table);
-                this.processAloneUser(lastPlayer, table);
-            }
-        } else if (this.isMergeTables(table)) {
-            this.mergeTables(table);
-        } else {
-
-        }
-    };
-
-    handleStartTournament = () => {
-        this.startTournament();
-    };
-
-    startTournament () {
-        const onlineQueuers = this.getOnlineQueuers();
-        if (onlineQueuers.length > 1) {
-            this.initTables(onlineQueuers);
-            this.getTables().forEach((table) => table.startNewRound());
-            this.getState().toStart();
-        } else {
-            this.getState().toCancel();
-        }
-    }
-
-    finishTournament () {
-        this.getState().toFinish();
-        this.calculateWinners();
-    }
-
-    async scheduleTournament (): Promise<schedule.Job> {
-        if (this.getState().isWaiting() && dayjs().isBefore(this.startDate)) {
-            return schedule.scheduleJob(this.startDate ?? 0, this.handleStartTournament);
-        }
-    }
-
-    isTournamentFinish (): boolean {
-        return this.remainOneTable() && this.getTables()[0].remainOnePlayer();
-    }
-
-    isTableFinish (table: GT): boolean {
-        return !this.remainOneTable() && table.remainOnePlayer();
-    }
-
-    isMergeTables (table: GT) {
-        const otherTables = this.getTables().filter((item) => item.getId() !== table.getId());
-        const totalSeats = this.getMaxPlayers() * otherTables.length;
-        const playersOnSeats = sumBy(otherTables, (item) => item.getPlayersWithQueue().length);
-        const freeSeats = totalSeats - playersOnSeats;
-
-        return freeSeats >= table.getPlayers().length && table.getPlayers().length <= this.minUserForMergeTables;
-    }
-
-    initTables (players: Array<GP>): Array<GT> {
-        const newTables: Array<GT> = [];
-        const tablesDividedOnTables = chunk<GP>(players, this.getMaxPlayers());
-        tablesDividedOnTables.forEach((tablePlayers) => {
-            if (tablePlayers.length > 1) {
-                const newTable = this.createTable();
-                tablePlayers.forEach((player) => this.movePlayerToAnotherTable(player, null, newTable));
-            } else {
-                this.processAloneUser(tablePlayers[0], null);
-            }
-        });
-
-        return newTables;
-    }
-
-    mergeTables (table: GT) {
-        this.removeTable(table);
-
-        const movingUsers = table.getPlayers();
-        movingUsers.forEach((movingPlayer) => {
-            const freeTable = this.getTableWithFreeSeats();
-            if (freeTable) {
-                table.removePlayerFromSeat(movingPlayer);
-                this.movePlayerToAnotherTable(movingPlayer, table, freeTable);
-            }
-        });
-    }
-
-    movePlayerToAnotherTable (player: GP, fromTable: GT | null, toTable: GT) {
-        if (toTable.isFull()) {
-            toTable.addPlayerToQueue(player);
-        } else {
-            toTable.addPlayerToSeat(player);
-        }
-    }
-
-    processAloneUser (aloneUser: GP, fromTable: GT | null) {
-        const freeTable = this.getTableWithFreeSeats();
-        const redundantPlayers = this.getRedundantPlayers();
-        const firstTable = this.getFirstTable();
-        aloneUser.flush();
-
-        if (freeTable) {
-            this.movePlayerToAnotherTable(aloneUser, fromTable, freeTable);
-        } else if (redundantPlayers.length > 0) {
-            redundantPlayers.forEach((user) => user.flush());
-            this.initTables([...redundantPlayers, aloneUser]);
-        } else if (firstTable) {
-            this.movePlayerToAnotherTable(aloneUser, fromTable, firstTable);
-        }
-    }
-
-    getRedundantPlayers (): Array<GP> {
-        const table = this.getFirstTable();
-        if (table) {
-            const redundantQueuers = table.getRedundantQueuers();
-            redundantQueuers.forEach((user) => {
-                table.removePlayerFromQueue(user);
-            });
-
-            return redundantQueuers;
-        }
-
-        return [];
-    }
-
-    async cancelJob () {
-        return (await this.startJob)?.cancel();
-    }
-}
+// import schedule from 'node-schedule';
+// import dayjs from 'dayjs';
+// import { chunk, sumBy } from 'lodash';
+//
+// import { GamePlayer } from '../base';
+// import { IGameTable } from '../base/game-table';
+//
+// import { TournamentRoom, TournamentRoomConfig } from './tournament-room';
+//
+// export abstract class ScheduledTournamentRoom<
+//     GT extends IGameTable<GP>,
+//     GP extends GamePlayer,
+// > extends TournamentRoom<GT, GP> {
+//     private readonly startDate: Date | null;
+//     private readonly minUserForMergeTables: number;
+//     private readonly startJob: Promise<schedule.Job> | null;
+//
+//     constructor (config: TournamentRoomConfig, minUserForMergeTables, startDate: Date | null) {
+//         super(config);
+//         this.minUserForMergeTables = minUserForMergeTables;
+//         this.startDate = startDate;
+//         if (startDate) {
+//             this.startJob = this.scheduleTournament();
+//         }
+//     }
+//
+//     handleJoinTournament (player: GP) {
+//         if (this.getState().isWaiting()) {
+//             this.addUserRoomToQueue(player);
+//         } else if (this.getState().isInProgress()) {
+//             if (this.isParticipant(player.getId())) {
+//                 // redirect to table
+//             } else {
+//                 // redirect
+//             }
+//         } else {
+//             // redirect to status
+//         }
+//     }
+//
+//     handleLeaveTournament (player: GP) {
+//         if (this.getState().isWaiting()) {
+//             this.removeUserFromQueue(player);
+//         } else if (this.getState().isInProgress()) {
+//
+//         }
+//     }
+//
+//     handleFinishRound () {
+//     }
+//
+//     handleRestartRound = (table: GT) => {
+//         if (this.isTournamentFinish()) {
+//             this.finishTournament();
+//         } else if (this.isTableFinish(table)) {
+//             const lastPlayer = table.getLastPlayer();
+//             if (lastPlayer) {
+//                 table.removePlayerFromSeat(lastPlayer);
+//                 this.removeTable(table);
+//                 this.processAloneUser(lastPlayer, table);
+//             }
+//         } else if (this.isMergeTables(table)) {
+//             this.mergeTables(table);
+//         } else {
+//
+//         }
+//     };
+//
+//     handleStartTournament = () => {
+//         this.startTournament();
+//     };
+//
+//     startTournament () {
+//         const onlineQueuers = this.getOnlineQueuers();
+//         if (onlineQueuers.length > 1) {
+//             this.initTables(onlineQueuers);
+//             this.getTables().forEach((table) => table.startNewRound());
+//             this.getState().toStart();
+//         } else {
+//             this.getState().toCancel();
+//         }
+//     }
+//
+//     finishTournament () {
+//         this.getState().toFinish();
+//         this.calculateWinners();
+//     }
+//
+//     async scheduleTournament (): Promise<schedule.Job> {
+//         if (this.getState().isWaiting() && dayjs().isBefore(this.startDate)) {
+//             return schedule.scheduleJob(this.startDate ?? 0, this.handleStartTournament);
+//         }
+//     }
+//
+//     isTournamentFinish (): boolean {
+//         return this.remainOneTable() && this.getTables()[0].remainOnePlayer();
+//     }
+//
+//     isTableFinish (table: GT): boolean {
+//         return !this.remainOneTable() && table.remainOnePlayer();
+//     }
+//
+//     isMergeTables (table: GT) {
+//         const otherTables = this.getTables().filter((item) => item.getId() !== table.getId());
+//         const totalSeats = this.getMaxPlayers() * otherTables.length;
+//         const playersOnSeats = sumBy(otherTables, (item) => item.getPlayersWithQueue().length);
+//         const freeSeats = totalSeats - playersOnSeats;
+//
+//         return freeSeats >= table.getPlayers().length && table.getPlayers().length <= this.minUserForMergeTables;
+//     }
+//
+//     initTables (players: Array<GP>): Array<GT> {
+//         const newTables: Array<GT> = [];
+//         const tablesDividedOnTables = chunk<GP>(players, this.getMaxPlayers());
+//         tablesDividedOnTables.forEach((tablePlayers) => {
+//             if (tablePlayers.length > 1) {
+//                 const newTable = this.createTable();
+//                 tablePlayers.forEach((player) => this.movePlayerToAnotherTable(player, null, newTable));
+//             } else {
+//                 this.processAloneUser(tablePlayers[0], null);
+//             }
+//         });
+//
+//         return newTables;
+//     }
+//
+//     mergeTables (table: GT) {
+//         this.removeTable(table);
+//
+//         const movingUsers = table.getPlayers();
+//         movingUsers.forEach((movingPlayer) => {
+//             const freeTable = this.getTableWithFreeSeats();
+//             if (freeTable) {
+//                 table.removePlayerFromSeat(movingPlayer);
+//                 this.movePlayerToAnotherTable(movingPlayer, table, freeTable);
+//             }
+//         });
+//     }
+//
+//     movePlayerToAnotherTable (player: GP, fromTable: GT | null, toTable: GT) {
+//         if (toTable.isFull()) {
+//             toTable.addPlayerToQueue(player);
+//         } else {
+//             toTable.addPlayerToSeat(player);
+//         }
+//     }
+//
+//     processAloneUser (aloneUser: GP, fromTable: GT | null) {
+//         const freeTable = this.getTableWithFreeSeats();
+//         const redundantPlayers = this.getRedundantPlayers();
+//         const firstTable = this.getFirstTable();
+//         aloneUser.flush();
+//
+//         if (freeTable) {
+//             this.movePlayerToAnotherTable(aloneUser, fromTable, freeTable);
+//         } else if (redundantPlayers.length > 0) {
+//             redundantPlayers.forEach((user) => user.flush());
+//             this.initTables([...redundantPlayers, aloneUser]);
+//         } else if (firstTable) {
+//             this.movePlayerToAnotherTable(aloneUser, fromTable, firstTable);
+//         }
+//     }
+//
+//     getRedundantPlayers (): Array<GP> {
+//         const table = this.getFirstTable();
+//         if (table) {
+//             const redundantQueuers = table.getRedundantQueuers();
+//             redundantQueuers.forEach((user) => {
+//                 table.removePlayerFromQueue(user);
+//             });
+//
+//             return redundantQueuers;
+//         }
+//
+//         return [];
+//     }
+//
+//     async cancelJob () {
+//         return (await this.startJob)?.cancel();
+//     }
+// }

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

@@ -1,10 +1,21 @@
 import { GamePlayer, GameRoom } from '../base';
-import { IGameTable } from '../base/game-table';
 
-export abstract class SimpleRoom<GT extends IGameTable<GP>, GP extends GamePlayer> extends GameRoom<GT, GP> {
-  abstract handleEnterTheTable (player: GP, tableId: string);
+export abstract class SimpleRoom extends GameRoom {
+  handleWatchTheTable (player: GamePlayer, masterId: string) {
+    this.getMasterById(masterId)?.watchTheTable(player);
+  }
+
+  handleEnterTheTable (player: GamePlayer, masterId: string) {
+    this.getMasterById(masterId)?.enterTheTable(player);
+  }
 
-  abstract handleExitTheTable (player: GP, tableId: string);
+  handleExitTheTable (player: GamePlayer, masterId: string) {
+    this.getMasterById(masterId)?.exitTheTable(player);
+  }
+
+  handleMoveOnTheTable (player: GamePlayer, masterId: string) {
+    this.getMasterById(masterId)?.onHandleMove(player);
+  }
 
   handleFinishRound () {
     // save users balances