jp.ms.common.engine 1.0.20 → 2.0.0

package/src/cards-game/cards-game-master.ts

@@ -1,34 +1,38 @@
-import { cloneDeep } from 'lodash';
-
-import { GameMaster, GameRoom } from '../base';
-import { superShuffle } from '../utils';
+import { GameMaster, GameRoom, GameRoundHistoryItem } from '../base';
 
 import { CardsPlayer } from './cards-player';
 import { Card } from './cards/card';
+import { CardPairSlots } from './cards-pairs/card-pair-slots';
+import { CardsDeck } from './cards-deck/cards-deck';
+import { cards } from './index';
 
 const ONE_CARD = 1;
 const TWO_CARDS = 2;
 const SIX_CARDS = 6;
 
 export abstract class CardsGameMaster extends GameMaster {
-    private sourceDeck: Array<Card>;
-    private gameDeck: Array<Card>;
+    private sourceDeck: CardsDeck;
+    private gameDeck: CardsDeck | null;
     private readonly gameCards: Array<Card>;
+    private readonly gameCardPairSlots: CardPairSlots;
+    private gameBaseCard: Card | undefined;
 
-    constructor (room: GameRoom, sourceDeck: Array<Card>) {
+    protected constructor (room: GameRoom) {
         super(room);
-        this.sourceDeck = cloneDeep(sourceDeck);
-        this.gameDeck = [];
+        this.sourceDeck = CardsDeck.createFromDeckType(this.room.getDeckType() ?? '');
+        this.gameDeck = null;
         this.gameCards = [];
+        this.gameCardPairSlots = new CardPairSlots();
+        this.gameBaseCard = undefined;
     }
 
-    shuffleDeck () {
-        this.sourceDeck = superShuffle(this.sourceDeck);
+    getDeck (): CardsDeck | null {
+        return this.gameDeck;
     }
 
     takeNewDeck () {
-        this.shuffleDeck();
-        this.gameDeck = cloneDeep(this.sourceDeck);
+        this.sourceDeck.shuffle();
+        this.gameDeck = new CardsDeck(this.sourceDeck.cards);
     }
 
     getGameCards () {
@@ -36,7 +40,7 @@ export abstract class CardsGameMaster extends GameMaster {
     }
 
     putCardsOnTheTableFromDeck () {
-        const popCard = this.gameDeck.pop();
+        const popCard = this.gameDeck?.takeCardFromTop();
         if (popCard) {
             this.gameCards.push(popCard);
         }
@@ -46,18 +50,6 @@ export abstract class CardsGameMaster extends GameMaster {
         this.gameCards.push(card);
     }
 
-    popCardFromDeck () {
-        return this.gameDeck.pop();
-    }
-
-    pushCardToDeck (card: Card, position: number) {
-        this.gameDeck.splice(position, 0, card);
-    }
-
-    pushCardToBeggingOfTheDeck (card: Card) {
-        this.pushCardToDeck(card, 0);
-    }
-
     give2CardsToAllPlayers () {
         this.giveCardsToAllPlayers(TWO_CARDS);
     }
@@ -77,11 +69,56 @@ export abstract class CardsGameMaster extends GameMaster {
     }
 
     giveCardsToPlayer (player: CardsPlayer, count: number) {
+        const cards: Array<Card> = [];
+
         for (let i = 0; i < count; i += 1) {
-            const popCard = this.popCardFromDeck();
+            const popCard = this.gameDeck?.takeCardFromTop();
             if (popCard) {
+                cards.push(popCard);
                 player.takeCard(popCard);
             }
         }
+
+        this.getGameRound()?.addToHistory(GameRoundHistoryItem.createMasterGivesFigureItem(this.getStateId(), this._turnNumber, cards));
+    }
+
+    getPlayersWithoutCards () {
+        return this.getTable().getPlayers<CardsPlayer>().filter((item) => !item.hasCards());
+    }
+
+    getPlayersWithCards () {
+        return this.getTable().getPlayers<CardsPlayer>().filter((item) => item.hasCards());
+    }
+
+    getGameCardPairSlots () {
+        return this.gameCardPairSlots;
+    }
+
+    getGameBaseCard () {
+        return this.gameBaseCard;
+    }
+
+    setGameBaseCard (card: Card) {
+        this.gameBaseCard = card;
+    }
+
+    clearBaseCard () {
+        this.gameBaseCard = undefined;
+    }
+
+    enableAllCards () {
+        this.getTable().getPlayers<CardsPlayer>().forEach((item) => item.enableAllCards());
+    }
+
+    disableAllCards () {
+        this.getTable().getPlayers<CardsPlayer>().forEach((item) => item.disableAllCards());
+    }
+
+    clearTargetsCards () {
+        this.getTable().getPlayers<CardsPlayer>().forEach((item) => item.clearTargetsCard());
+    }
+
+    clearPlayersCards () {
+        this.getTable().getPlayers<CardsPlayer>().forEach((item) => item.clearCards());
     }
 }

package/src/cards-game/cards-pairs/card-pair-slot.ts

@@ -0,0 +1,73 @@
+import { Card } from '../cards/card';
+
+export class CardPairSlot {
+    private readonly _id: number;
+    private _bottom: Card | null;
+    private _top: Card | null;
+    private _activated: boolean;
+    private _disabled: boolean;
+
+    constructor (id: number, activated: boolean, disabled: boolean) {
+        this._id = id;
+        this._activated = activated;
+        this._disabled = disabled;
+        this._top = null;
+        this._bottom = null;
+    }
+
+    get id () {
+        return this._id;
+    }
+
+    get bottom (): Card | null {
+        return this._bottom;
+    }
+
+    set bottom (card: Card) {
+        this._bottom = card;
+    }
+
+    get top (): Card | null {
+        return this._top;
+    }
+
+    set top (card: Card) {
+        this._top = card;
+    }
+
+    get activated () {
+        return this._activated;
+    }
+
+    activate () {
+        this._activated = true;
+    }
+
+    get disabled () {
+        return this._disabled;
+    }
+
+    disable () {
+        this._disabled = true;
+    }
+
+    enable () {
+        this._disabled = false;
+    }
+
+    isFree () {
+        return !this.bottom && !this.top;
+    }
+
+    isHalfOccupied () {
+        return this.bottom && !this.top;
+    }
+
+    isOccupied () {
+        return this.bottom && this.top;
+    }
+
+    static createEmptySlot (id: number) {
+        return new CardPairSlot(id, false, true);
+    }
+}

package/src/cards-game/cards-pairs/card-pair-slots.ts

@@ -0,0 +1,104 @@
+import { compact, first } from 'lodash';
+
+import { Card } from '../cards/card';
+
+import { CardPairSlot } from './card-pair-slot';
+
+export class CardPairSlots {
+    private _slots: Array<CardPairSlot>;
+
+    constructor () {
+        this._slots = [];
+    }
+
+    init (size: number) {
+        this._slots = [];
+
+        for (let i = 0; i < size; i += 1) {
+            this._slots.push(CardPairSlot.createEmptySlot(this._slots.length));
+        }
+    }
+
+    getSlots () {
+        return this._slots;
+    }
+
+    getLength () {
+        return this._slots.length;
+    }
+
+    getSlotById (id: number) {
+        return this._slots.find((item) => item.id === id);
+    }
+
+    getFreeSlots () {
+        return this._slots.filter((pair) => pair.isFree());
+    }
+
+    getFreeSlot (): CardPairSlot | undefined {
+        return first(this.getFreeSlots());
+    }
+
+    getHalfOccupiedSlots () {
+        return this._slots.filter((pair) => pair.isHalfOccupied());
+    }
+
+    getHalfOccupiedSLot (): CardPairSlot | undefined {
+        return first(this.getHalfOccupiedSlots());
+    }
+
+    getOccupiedSlots () {
+        return this._slots.filter((pair) => pair.isOccupied());
+    }
+
+    getOccupiedSlot (): CardPairSlot | undefined {
+        return first(this.getOccupiedSlots());
+    }
+
+    getCardsWithoutPair (): Array<Card> {
+        return compact(this.getHalfOccupiedSlots().map((item) => item.bottom));
+    }
+
+    isAllSlotsOccupied () {
+        return this.getOccupiedSlots().length === this.getLength();
+    }
+
+    getCards (): Array<Card> {
+        return this._slots.reduce((allCards, currentPair) => {
+            const { bottom, top } = currentPair;
+            if (bottom) {
+                allCards.push(bottom);
+            }
+            if (top) {
+                allCards.push(top);
+            }
+            return allCards;
+        }, [] as Array<Card>);
+    }
+
+    hasNoCards () {
+        return this.getCards().length === 0;
+    }
+
+    putCard (id: number, card: Card) {
+        const slot =  this.getSlotById(id);
+        if (slot) {
+            slot.bottom = card;
+        }
+    }
+
+    putCardOnCard (id: number, card: Card) {
+        const slot =  this.getSlotById(id);
+        if (slot) {
+            slot.top = card;
+        }
+    }
+
+    disableAllSlots () {
+        this._slots.forEach((item) => item.disable());
+    }
+
+    clearSlots () {
+        this._slots = [];
+    }
+}

package/src/cards-game/cards-player.ts

@@ -1,41 +1,89 @@
-import { first, remove } from 'lodash';
+import { concat, first, intersectionBy, remove } from 'lodash';
 
-import { GamePlayer } from '../base';
+import { GamePlayer, IGamePlayerConfig } from '../base';
 
 import { Card } from './cards/card';
 
 export abstract class CardsPlayer extends GamePlayer {
-    private cards: Array<Card>;
+    private _cards: Array<Card>;
+    private _usingCards: Array<Card>;
 
-    protected constructor (
-        id: string,
-        fullName: string,
-        avatarUrl: string,
-        balance: number,
-    ) {
-        super(id, fullName, avatarUrl, balance);
-        this.cards = [];
+    protected constructor (config: IGamePlayerConfig) {
+        super(config);
+        this._cards = [];
+        this._usingCards = [];
     }
 
     getCards (): Array<Card> {
-        return this.cards;
+        return this._cards;
     }
 
-    hasCards (): boolean {
-        return this.cards.length > 0;
+    getCardById (cardId: number | undefined): Card | undefined {
+        return this._cards.find((item) => item.getId() === cardId);
     }
 
-    clearCards (): void {
-        this.cards = [];
+    hasCards (): boolean {
+        return this._cards.length > 0 || this._usingCards.length > 0;
     }
 
     takeCard (card: Card): void {
-        this.cards.push(card);
+        this._cards.push(card);
+    }
+
+    takeCards (cards: Array<Card>): void {
+        this._cards = concat(this._cards, cards);
     }
 
-    putCard (cardId: number): Card | undefined {
-        const removedCard = remove(this.cards, (card) => card.getId() === cardId);
+    clearCards () {
+        this._cards = [];
+    }
+
+    putCard (puttingCard: Card): Card | undefined {
+        const removedCards = remove(this._cards, (card: Card) => card.getId() === puttingCard.getId());
+        const removedCard = first<Card | undefined>(removedCards);
+
+        if (removedCard) {
+            this._usingCards.push(removedCard);
+        }
+
+        return removedCard;
+    }
+
+    getCardsWithRank (cards: Array<Card>): Array<Card> {
+        return intersectionBy(this._cards, cards, (card) => card.getRank());
+    }
+
+    hasCardsWithRank (cards: Array<Card>): boolean {
+        return this.getCardsWithRank(cards).length > 0;
+    }
+
+    enableAllCards () {
+        this._cards.forEach((item) => item.enable());
+    }
+
+    disableAllCards () {
+        this._cards.forEach((item) => item.disable());
+    }
+
+    hasEnabledCards (): boolean {
+        return this._cards.some((card) => card.isEnable);
+    }
+
+    clearTargetsCard () {
+        this._cards.forEach((item) => item.clearTargets());
+    }
+
+    clearUsingCards () {
+        this._usingCards = [];
+    }
+
+    removeUsingCard (card: Card) {
+        remove(this._usingCards, (item: Card) => item.id === card.id)
+    }
 
-        return first(removedCard);
+    flush () {
+        super.flush();
+        this._cards = [];
+        this._usingCards = [];
     }
 }

package/src/cards-game/index.ts

@@ -1,11 +1,14 @@
 import * as cards from './cards/cards';
 import { Card } from './cards/card';
-import { deck36 } from './cards/deck36';
-import { deck52 } from './cards/deck52';
+import { deck36 } from './cards-deck/types/deck36';
+import { deck52 } from './cards-deck/types/deck52';
 import { Ranks } from './cards/ranks';
 import { Suits } from './cards/suits';
 import { CardsGameMaster } from './cards-game-master';
 import { CardsPlayer } from './cards-player';
+import { CardPairSlots } from './cards-pairs/card-pair-slots';
+import { CardPairSlot } from './cards-pairs/card-pair-slot';
+import { CardsDeck } from './cards-deck/cards-deck';
 
 export {
   cards,
@@ -16,4 +19,7 @@ export {
   Suits,
   CardsGameMaster,
   CardsPlayer,
+  CardPairSlots,
+  CardPairSlot,
+  CardsDeck,
 }

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

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

package/src/events/base/game-player.event.ts

@@ -0,0 +1,26 @@
+import { BaseMoveData, GameMaster, GamePlayer, GameRoom } from '../../base';
+
+import { GameTableEvent } from './game-table.event';
+
+export class GamePlayerEvent extends GameTableEvent {
+    private readonly _player: GamePlayer;
+    private readonly _move?: BaseMoveData;
+
+    constructor (room: GameRoom, master: GameMaster, player: GamePlayer, move?: BaseMoveData) {
+        super(room, master);
+        this._player = player;
+        this._move = move;
+    }
+
+    get getPlayerId (): string {
+        return this._player.id;
+    }
+
+    get getPlayerFullName (): string {
+        return this._player.fullName;
+    }
+
+    get getMoveAction (): string {
+        return this._move?.action ?? '';
+    }
+}

package/src/events/base/game-room.event.ts

@@ -0,0 +1,16 @@
+import { GameRoom } from '../../base';
+
+import { BaseGameEvent } from './base-game.event';
+
+export class GameRoomEvent extends BaseGameEvent {
+    private readonly _room: GameRoom;
+
+    get roomId (): string {
+        return this._room.getId();
+    }
+
+    constructor (room: GameRoom) {
+        super();
+        this._room = room;
+    }
+}

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

@@ -0,0 +1,16 @@
+import { GameMaster, GameRoom } from '../../base';
+
+import { GameRoomEvent } from './game-room.event';
+
+export class GameTableEvent extends GameRoomEvent {
+    private readonly _master: GameMaster;
+
+    constructor (room: GameRoom, master: GameMaster) {
+        super(room);
+        this._master = master;
+    }
+
+    get tableId (): string {
+        return this._master.getId();
+    }
+}

package/src/events/game/game-player-activate.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerActivateEvent extends GamePlayerEvent {}

package/src/events/game/game-player-activated.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerActivatedEvent extends GamePlayerEvent {}

package/src/events/game/game-player-deactivate.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerDeactivateEvent extends GamePlayerEvent {}

package/src/events/game/game-player-deactivated.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerDeactivatedEvent extends GamePlayerEvent {}

package/src/events/game/game-player-enter-the-table.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerEnterTheTableEvent extends GamePlayerEvent {}

package/src/events/game/game-player-entered-the-table.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerEnteredTheTableEvent extends GamePlayerEvent {}

package/src/events/game/game-player-exit-the-table.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerExitTheTableEvent extends GamePlayerEvent {}

package/src/events/game/game-player-exited-the-table.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerExitedTheTableEvent extends GamePlayerEvent {}

package/src/events/game/game-player-kick-out-the-table.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerKickOutTheTableEvent extends GamePlayerEvent {}

package/src/events/game/game-player-kicked-out-the-table.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerKickedOutTheTableEvent extends GamePlayerEvent {}

package/src/events/game/game-player-move-on-the-table.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerMoveOnTheTableEvent extends GamePlayerEvent {}

package/src/events/game/game-player-moved-on-the-table.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerMovedOnTheTableEvent extends GamePlayerEvent {}

package/src/events/game/game-player-turn-timer-executed.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerTurnTimerExecutedEvent extends GamePlayerEvent {}

package/src/events/game/game-player-turn-timer-set-off.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerTurnTimerSetOffEvent extends GamePlayerEvent {}

package/src/events/game/game-player-turn-timer-set-on.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerTurnTimerSetOnEvent extends GamePlayerEvent {}

package/src/events/game/game-player-watch-the-table.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerWatchTheTableEvent extends GamePlayerEvent {}

package/src/events/game/game-player-watched-the-table.event.ts

@@ -0,0 +1,3 @@
+import { GamePlayerEvent } from '../base/game-player.event';
+
+export class GamePlayerWatchedTheTableEvent extends GamePlayerEvent {}

package/src/events/game/game-room-room-created.event.ts

@@ -0,0 +1,3 @@
+import { GameRoomEvent } from '../base/game-room.event';
+
+export class GameRoomRoomCreatedEvent extends GameRoomEvent {}

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

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

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

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

package/src/events/game/game-table-master-created.event.ts

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

package/src/events/game/game-table-restart-timer-executed.event.ts

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

package/src/events/game/game-table-restart-timer-set-on.event.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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