jp.ms.common.engine 1.0.2 → 1.0.4

package/src/base/game-table.ts

@@ -2,58 +2,9 @@ import { compact, first, remove, slice } from 'lodash';
 
 import { GamePlayer } from './game-player';
 import { GameTableSeats } from './game-table-seats';
+import { GameMaster } from './game-master';
 
-export interface IGameTable<GP extends GamePlayer> {
-    getId (): string;
-
-    hasInQueue (PlayerId: string): boolean;
-
-    hasInWatchers (PlayerId: string): boolean;
-
-    isFull (): boolean;
-
-    getSeats (): GameTableSeats<GP>;
-
-    hasSeats (): boolean;
-
-    addPlayerToQueue (player: GP);
-
-    addPlayerToSeat (player: GP);
-
-    removePlayerFromSeat (player: GP);
-
-    removePlayerFromQueue (player: GP);
-
-    removePlayerFromWatchers (player: GP);
-
-    addPlayerToWatchers (player: GP);
-
-    getPlayers (): Array<GP>;
-
-    getPlayerByColor (color: number): GP | undefined;
-
-    getPlayersWithQueue (): Array<GP>;
-
-    getEmptyStackPlayers (): Array<GP>;
-
-    remainOnePlayer (): boolean;
-
-    startNewRound (): void;
-
-    getQueue (): Array<GP>;
-
-    getTableSize (): number;
-
-    getRedundantQueuers (): Array<GP>;
-
-    getLastPlayer (): GP | null;
-
-    getTurnTimeout (): number;
-
-    getRestartTimeout (): number;
-}
-
-export type GameTableConfig<GP extends GamePlayer> = {
+export type GameTableConfig = {
     roomId: string;
     number: number;
     tableSize: number;
@@ -61,25 +12,25 @@ export type GameTableConfig<GP extends GamePlayer> = {
     rulesType: string;
     turnTimeout: number;
     restartTimeout: number;
-    onRoomFinishRound: (table: IGameTable<GP>) => void
-    onRoomRestartRound: (table: IGameTable<GP>) => void
+    onRoomFinishRound: (table: GameTable) => void
+    onRoomRestartRound: (table: GameTable) => void
 }
 
-export abstract class GameTable<GP extends GamePlayer, GM, GSR> implements IGameTable<GP> {
+export class GameTable {
     private readonly roomId: string;
     private readonly number: number;
     private readonly tableSize: number;
     private readonly bet: number;
     private readonly turnTimeout: number;
     private readonly restartTimeout: number;
-    private readonly queue: Array<GP>;
-    private readonly watchers: Array<GP>;
-    public readonly seats: GameTableSeats<GP>;
-    public master: GM;
-    public onRoomFinishRound: (table: IGameTable<GP>) => void;
-    public onRoomRestartRound: (table: IGameTable<GP>) => void;
-
-    protected constructor (config: GameTableConfig<GP>) {
+    private readonly queue: Array<GamePlayer>;
+    private readonly watchers: Array<GamePlayer>;
+    public readonly seats: GameTableSeats;
+    public master: GameMaster;
+    public onRoomFinishRound: (table: GameTable) => void;
+    public onRoomRestartRound: (table: GameTable) => void;
+
+    constructor (config: GameTableConfig) {
         this.queue = [];
         this.watchers = [];
         this.onRoomFinishRound = config.onRoomFinishRound;
@@ -93,8 +44,6 @@ export abstract class GameTable<GP extends GamePlayer, GM, GSR> implements IGame
         this.seats = new GameTableSeats(this.getTableSize());
     }
 
-    abstract startNewRound (): void
-
     getRoomId () {
         return this.roomId;
     }
@@ -127,7 +76,7 @@ export abstract class GameTable<GP extends GamePlayer, GM, GSR> implements IGame
         return this.restartTimeout;
     }
 
-    addPlayerToSeat (player: GP): boolean {
+    addPlayerToSeat (player: GamePlayer): boolean {
         const freeSeat = this.seats.findFreeSeat();
         if (freeSeat) {
             freeSeat.addPlayer(player);
@@ -138,7 +87,7 @@ export abstract class GameTable<GP extends GamePlayer, GM, GSR> implements IGame
         return false;
     }
 
-    removePlayerFromSeat (player: GP): void {
+    removePlayerFromSeat (player: GamePlayer): void {
         const seat = this.seats.getSeat(player.getSeatNumber());
         if (seat) {
             seat.removePlayer();
@@ -146,19 +95,19 @@ export abstract class GameTable<GP extends GamePlayer, GM, GSR> implements IGame
         }
     }
 
-    getPlayers (): Array<GP> {
+    getPlayers (): Array<GamePlayer> {
         return compact(this.seats.getSeats().map((seat) => seat.getPlayer()));
     }
 
-    getPlayerByColor (color: number): GP | undefined {
+    getPlayerByColor (color: number): GamePlayer | undefined {
         return this.getPlayers().find((item) => item.getColor() === color);
     }
 
-    getPlayersWithQueue (): Array<GP> {
+    getPlayersWithQueue (): Array<GamePlayer> {
         return [...this.getPlayers(), ...this.queue];
     }
 
-    getLastPlayer (): GP | null {
+    getLastPlayer (): GamePlayer | null {
         return first(this.getPlayers()) ?? null;
     }
 
@@ -170,24 +119,24 @@ export abstract class GameTable<GP extends GamePlayer, GM, GSR> implements IGame
         return this.getPlayers().length > 1;
     }
 
-    getEmptyStackPlayers (): Array<GP> {
+    getEmptyStackPlayers (): Array<GamePlayer> {
         return this.getPlayers().filter((player) => player.hasEmptyStack());
     }
 
-    getQueue (): Array<GP> {
+    getQueue (): Array<GamePlayer> {
         return this.queue;
     }
 
-    getRedundantQueuers (): Array<GP> {
+    getRedundantQueuers (): Array<GamePlayer> {
         return slice(this.queue, this.getTableSize() - this.getPlayers().length - 1);
     }
 
-    addPlayerToQueue (player: GP): void {
+    addPlayerToQueue (player: GamePlayer): void {
         this.queue.push(player);
         player.getInTableQueue(this.getRoomId(), this.getId());
     }
 
-    removePlayerFromQueue (player: GP): void {
+    removePlayerFromQueue (player: GamePlayer): void {
         remove(this.queue, (queuer) => queuer.getId() === player.getId());
         player.quit();
     }
@@ -196,16 +145,16 @@ export abstract class GameTable<GP extends GamePlayer, GM, GSR> implements IGame
         return !!this.getQueue().find((queuer) => queuer.getId() === PlayerId);
     }
 
-    getWatchers (): Array<GP> {
+    getWatchers (): Array<GamePlayer> {
         return this.watchers;
     }
 
-    addPlayerToWatchers (player: GP): void {
+    addPlayerToWatchers (player: GamePlayer): void {
         this.watchers.push(player);
         player.watch(this.getRoomId(), this.getId());
     }
 
-    removePlayerFromWatchers (player: GP): void {
+    removePlayerFromWatchers (player: GamePlayer): void {
         remove(this.watchers, (watcher) => watcher.getId() === player.getId());
         player.quit();
     }
@@ -218,7 +167,7 @@ export abstract class GameTable<GP extends GamePlayer, GM, GSR> implements IGame
         return !this.seats.findFreeSeat();
     }
 
-    getSeats (): GameTableSeats<GP> {
+    getSeats (): GameTableSeats {
         return this.seats;
     }
 

package/src/base/index.ts

@@ -9,6 +9,7 @@ import { GameStateMachine, StateMachineConfig } from './game-state-machine';
 import { GameTable, GameTableConfig } from './game-table';
 import { GameTableSeat } from './game-table-seat';
 import { GameTableSeats } from './game-table-seats';
+import { StandardGameState } from './standard-game-state';
 
 export {
     GameControlPlayerTurn,
@@ -25,4 +26,5 @@ export {
     GameTableSeat,
     GameTableSeats,
     GameRoomConfig,
+    StandardGameState,
 }

package/src/base/standard-game-state.ts

@@ -42,7 +42,7 @@ const config: StateMachineConfig = {
     },
 };
 
-export class StandardGameState extends GameStateMachine<StandardStateMachineStates, StandardStateMachineActions> {
+export class StandardGameState extends GameStateMachine {
     constructor () {
         super(StandardStateMachineStates.STATE_WAITING_FOR_PLAYERS, config);
     }
@@ -55,7 +55,7 @@ export class StandardGameState extends GameStateMachine<StandardStateMachineStat
         return this.getCurrentState() === StandardStateMachineStates.STATE_IN_PROGRESS;
     }
 
-    isEnd () {
+    isFinish () {
         return this.getCurrentState() === StandardStateMachineStates.STATE_END;
     }
 

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

@@ -1,59 +1,59 @@
-import { GamePlayer } from '../base';
-import { IGameTable } from '../base/game-table';
-
-import { TournamentRoom, TournamentRoomConfig } from './tournament-room';
-
-export abstract class FastTournamentRoom<
-    GT extends IGameTable<GP>,
-    GP extends GamePlayer,
-> extends TournamentRoom<GT, GP> {
-    constructor (config: TournamentRoomConfig) {
-        super(config);
-        this.createTable();
-    }
-
-    handleJoinTournament (player: GP) {
-        const onlyTable = this.getFirstTable();
-        if (this.getState().isWaiting() && onlyTable && onlyTable.hasSeats()) {
-            onlyTable.addPlayerToSeat(player);
-            if (onlyTable.isFull()) {
-                this.startTournament();
-            }
-        }
-    }
-
-    handleLeaveTournament (player: GP) {
-        const onlyTable = this.getFirstTable();
-        if (onlyTable) {
-            if (player.isPlayer()) {
-                onlyTable.removePlayerFromSeat(player);
-            } else {
-                onlyTable.removePlayerFromWatchers(player);
-            }
-        }
-    }
-
-    handleFinishRound = () => {
-    };
-
-    handleRestartRound = () => {
-        if (this.isTournamentFinish()) {
-            this.finishTournament();
-        }
-    };
-
-    startTournament () {
-        this.getFirstTable()?.getPlayers().forEach((player) => this.addParticipant(player));
-        this.getState().toStart();
-        this.getFirstTable()?.startNewRound();
-    }
-
-    finishTournament () {
-        this.getState().toFinish();
-        this.calculateWinners();
-    }
-
-    isTournamentFinish (): boolean {
-        return this.getFirstTable()?.remainOnePlayer() ?? false;
-    }
-}
+// import { GamePlayer } from '../base';
+// import { IGameTable } from '../base/game-table';
+//
+// import { TournamentRoom, TournamentRoomConfig } from './tournament-room';
+//
+// export abstract class FastTournamentRoom<
+//     GT extends IGameTable<GP>,
+//     GP extends GamePlayer,
+// > extends TournamentRoom<GT, GP> {
+//     constructor (config: TournamentRoomConfig) {
+//         super(config);
+//         this.createTable();
+//     }
+//
+//     handleJoinTournament (player: GP) {
+//         const onlyTable = this.getFirstTable();
+//         if (this.getState().isWaiting() && onlyTable && onlyTable.hasSeats()) {
+//             onlyTable.addPlayerToSeat(player);
+//             if (onlyTable.isFull()) {
+//                 this.startTournament();
+//             }
+//         }
+//     }
+//
+//     handleLeaveTournament (player: GP) {
+//         const onlyTable = this.getFirstTable();
+//         if (onlyTable) {
+//             if (player.isPlayer()) {
+//                 onlyTable.removePlayerFromSeat(player);
+//             } else {
+//                 onlyTable.removePlayerFromWatchers(player);
+//             }
+//         }
+//     }
+//
+//     handleFinishRound = () => {
+//     };
+//
+//     handleRestartRound = () => {
+//         if (this.isTournamentFinish()) {
+//             this.finishTournament();
+//         }
+//     };
+//
+//     startTournament () {
+//         this.getFirstTable()?.getPlayers().forEach((player) => this.addParticipant(player));
+//         this.getState().toStart();
+//         this.getFirstTable()?.startNewRound();
+//     }
+//
+//     finishTournament () {
+//         this.getState().toFinish();
+//         this.calculateWinners();
+//     }
+//
+//     isTournamentFinish (): boolean {
+//         return this.getFirstTable()?.remainOnePlayer() ?? false;
+//     }
+// }

package/src/base-rooms/index.ts

@@ -1,19 +1,20 @@
-import { FastTournamentRoom } from './fast-tournament-room';
-import { ScheduledTournamentRoom } from './scheduled-tournament-room';
+// import { FastTournamentRoom } from './fast-tournament-room';
+// import { ScheduledTournamentRoom } from './scheduled-tournament-room';
 import { SimpleRoom } from './simple-room';
 import { ITournamentParticipant } from './tournament-participant';
 import { TournamentPrizes } from './tournament-prize';
-import { TournamentRoom } from './tournament-room';
-import { TournamentState } from './tournament-state';
+// import { TournamentRoom, TournamentRoomConfig } from './tournament-room';
+// import { TournamentState } from './tournament-state';
 import { ITournamentWinner } from './tournament-winner';
 
 export {
-    FastTournamentRoom,
+    // TournamentRoomConfig,
+    // FastTournamentRoom,
     SimpleRoom,
     ITournamentParticipant,
     TournamentPrizes,
-    ScheduledTournamentRoom,
-    TournamentRoom,
-    TournamentState,
+    // ScheduledTournamentRoom,
+    // TournamentRoom,
+    // TournamentState,
     ITournamentWinner,
 }