jp.ms.common.engine 1.0.2 → 1.0.4

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

@@ -1,6 +1,7 @@
-import { GameMaster } from '../base';
-import { IGameTable } from '../base/game-table';
-import { IGameRound } from '../base/game-round';
+import { cloneDeep } from 'lodash';
+
+import { GameMaster, GameRoom } from '../base';
+import { superShuffle } from '../utils';
 
 import { CardsPlayer } from './cards-player';
 import { Card } from './cards/card';
@@ -9,22 +10,24 @@ const ONE_CARD = 1;
 const TWO_CARDS = 2;
 const SIX_CARDS = 6;
 
-export abstract class CardsGameMaster<GT extends IGameTable<GP>, GR extends IGameRound<GP>, GP extends CardsPlayer, GSR> extends GameMaster<GT, GR, GP, GSR> {
-    private deck: Array<Card>;
+export abstract class CardsGameMaster extends GameMaster {
+    private sourceDeck: Array<Card>;
+    private gameDeck: Array<Card>;
     private readonly gameCards: Array<Card>;
 
-    protected constructor (table: GT) {
-        super(table);
-        this.deck = [];
+    constructor (room: GameRoom, sourceDeck: Array<Card>) {
+        super(room);
+        this.sourceDeck = cloneDeep(sourceDeck);
+        this.gameDeck = [];
         this.gameCards = [];
     }
 
-    getDeck () {
-        return this.deck;
+    shuffleDeck () {
+        this.sourceDeck = superShuffle(this.sourceDeck);
     }
 
-    takeNewDeck (deck: Array<Card>) {
-        this.deck = deck;
+    takeNewDeck () {
+        this.gameDeck = cloneDeep(this.sourceDeck);
     }
 
     getGameCards () {
@@ -32,7 +35,7 @@ export abstract class CardsGameMaster<GT extends IGameTable<GP>, GR extends IGam
     }
 
     putCardsOnTheTableFromDeck () {
-        const popCard = this.deck.pop();
+        const popCard = this.gameDeck.pop();
         if (popCard) {
             this.gameCards.push(popCard);
         }
@@ -43,11 +46,11 @@ export abstract class CardsGameMaster<GT extends IGameTable<GP>, GR extends IGam
     }
 
     popCardFromDeck () {
-        return this.deck.pop();
+        return this.gameDeck.pop();
     }
 
     pushCardToDeck (card: Card, position: number) {
-        this.deck.splice(position, 0, card);
+        this.gameDeck.splice(position, 0, card);
     }
 
     pushCardToBeggingOfTheDeck (card: Card) {
@@ -64,7 +67,7 @@ export abstract class CardsGameMaster<GT extends IGameTable<GP>, GR extends IGam
 
     giveCardsToAllPlayers (count: number) {
         this.table.getPlayers().forEach((player) => {
-            this.giveCardsToPlayer(player, count);
+            this.giveCardsToPlayer(player as CardsPlayer, count);
         });
     }
 

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

@@ -1,7 +1,8 @@
+import { first, remove } from 'lodash';
+
 import { GamePlayer } from '../base';
 
 import { Card } from './cards/card';
-import { first, remove } from 'lodash';
 
 export abstract class CardsPlayer extends GamePlayer {
     private cards: Array<Card>;

package/src/cards-game/index.ts

@@ -6,7 +6,6 @@ import { Ranks } from './cards/ranks';
 import { Suits } from './cards/suits';
 import { CardsGameMaster } from './cards-game-master';
 import { CardsPlayer } from './cards-player';
-import { CardsTable } from './cards-table';
 
 export {
   cards,
@@ -17,5 +16,4 @@ export {
   Suits,
   CardsGameMaster,
   CardsPlayer,
-  CardsTable,
 }

package/src/index.ts

@@ -1,5 +1,5 @@
 export * from './base';
 export * from './base-rooms';
-export * from './board-game';
+// export * from './board-game';
 export * from './cards-game';
 export * from './utils';

package/src/tests/just-black-jack/domain/black-jack-dealer.ts

@@ -0,0 +1,15 @@
+import { BlackJackPlayer } from './black-jack-player';
+
+export class BlackJackDealer extends BlackJackPlayer {
+  constructor (tableId: string) {
+    super(`${tableId}_dealer`,
+      'Dealer John',
+      '',
+      1000000
+    );
+  }
+
+  override isDealer (): boolean {
+    return true;
+  }
+}

package/src/tests/just-black-jack/domain/black-jack-game-master.ts

@@ -0,0 +1,103 @@
+import { GameRound, StandardGameState } from '../../../base';
+import { CardsGameMaster } from '../../../cards-game';
+
+import { BlackJackPlayer } from './black-jack-player';
+import { BlackJackDealer } from './black-jack-dealer';
+
+export enum BlackJackMoveActionType {
+    GET_CARD = 'GET_CARD',
+    FINISH_MOVE = 'FINISH_MOVE',
+}
+
+export enum BlackJackSeatRole {
+    DEALER = 'DEALER',
+}
+
+export class BlackJackGameMaster extends CardsGameMaster {
+    getGameRoundState (): StandardGameState {
+        return (this.gameRound?.getState() as StandardGameState);
+    }
+
+    getPlayers (): Array<BlackJackPlayer> {
+        return (this.table.getPlayers() as Array<BlackJackPlayer>);
+    }
+
+    startNewRound () {
+        this.getTable().getSeats()[0].setRole(BlackJackSeatRole.DEALER);
+        this.getTable().addPlayerToSeat(new BlackJackDealer(this.getId()));
+
+        this.shuffleDeck();
+        this.takeNewDeck();
+
+        this.setGameRound(new GameRound(new StandardGameState()));
+        this.give2CardsToAllPlayers();
+        this.getGameRoundState().toStart();
+
+        const firstPlayer = this.table.seats.getNextPlayer(this.getDealerSeat()?.getNumber() ?? 0);
+        if (firstPlayer) {
+            this.gameRound?.setActivePlayer(firstPlayer);
+        }
+    }
+
+    changePlayer () {
+        this.changePlayerClockwise();
+    }
+
+    finishRound () {
+        this.getGameRoundState().toFinish();
+    }
+
+    getResults (): {} | null {
+        return null;
+    }
+
+    kickPlayer (player: BlackJackPlayer) {
+    }
+
+    onHandleMove (player: BlackJackPlayer) {
+        const move = player.getMove();
+
+        switch (move?.getAction()) {
+            case BlackJackMoveActionType.GET_CARD: {
+                this.getCard(player);
+                break;
+            }
+            case BlackJackMoveActionType.FINISH_MOVE: {
+                this.finishMove(player);
+                break;
+            }
+        }
+    }
+
+    onHandleRestartTimeout () {
+    }
+
+    onHandleTurnTimeout (player: BlackJackPlayer) {
+    }
+
+    getCard (player: BlackJackPlayer) {
+        this.give1CardsToPlayer(player);
+    }
+
+    finishMove (player: BlackJackPlayer) {
+        player.finishMove();
+
+        if (this.isFinish()) {
+            this.finishRound();
+        } else {
+            this.changePlayer();
+        }
+    }
+
+    isFinish () {
+        return this.getPlayers().filter((item) => item.isFinishedMove()).length === this.table.getPlayers().length;
+    }
+
+    getDealerSeat () {
+        return this.getTable().seats.getSeats().find((seat) => seat.getRole() === BlackJackSeatRole.DEALER);
+    }
+
+    getDealer (): BlackJackPlayer | undefined {
+        return this.getDealerSeat()?.getPlayer() as BlackJackPlayer | undefined;
+    }
+}

package/src/tests/just-black-jack/domain/black-jack-player.ts

@@ -0,0 +1,27 @@
+import { CardsPlayer } from '../../../cards-game';
+
+export class BlackJackPlayer extends CardsPlayer {
+  private isFinishMove: boolean;
+
+  constructor (
+    id: string,
+    fullName: string,
+    avatarUrl: string,
+    balance: number,
+  ) {
+    super(id, fullName, avatarUrl, balance);
+    this.isFinishMove = false;
+  }
+
+  isDealer (): boolean {
+    return false;
+  }
+
+  finishMove () {
+    this.isFinishMove = true;
+  }
+
+  isFinishedMove () {
+    return this.isFinishMove;
+  }
+}

package/src/tests/just-black-jack/helpers/calculate-result.test.ts

@@ -0,0 +1,49 @@
+import {
+  heart_2,
+  heart_3,
+  heart_jack,
+  heart_queen,
+  heart_king,
+  heart_ace,
+  club_ace,
+} from '../../../cards-game/cards/cards';
+
+import { calculateResult } from './calculate-result';
+
+describe('calculate result', () => {
+  it('calc digit', () => {
+    expect(calculateResult([heart_2, heart_3])).toBe(5);
+  });
+
+  it('calc with jack', () => {
+    expect(calculateResult([heart_2, heart_jack])).toBe(12);
+  });
+
+  it('calc with queen', () => {
+    expect(calculateResult([heart_2, heart_queen])).toBe(12);
+  });
+
+  it('calc with king', () => {
+    expect(calculateResult([heart_2, heart_king])).toBe(12);
+  });
+
+  it('calc with ace, less 21', () => {
+    expect(calculateResult([heart_2, heart_ace])).toBe(13);
+  });
+
+  it('calc with ace, more 21', () => {
+    expect(calculateResult([heart_2, heart_king, heart_ace])).toBe(13);
+  });
+
+  it('calc with two aces, more 21', () => {
+    expect(calculateResult([heart_2, heart_king, heart_ace, club_ace])).toBe(14);
+  });
+
+  it('calc with ace, more 21, overlimit', () => {
+    expect(calculateResult([heart_2, heart_king, heart_queen, heart_ace])).toBe(23);
+  });
+
+  it('calc 21', () => {
+    expect(calculateResult([heart_king, heart_ace])).toBe(21);
+  });
+});

package/src/tests/just-black-jack/helpers/calculate-result.ts

@@ -0,0 +1,34 @@
+import { sumBy } from 'lodash';
+
+import { Card, Ranks } from '../../../cards-game';
+
+
+const PICTURE_RANK = 10;
+const ACE_RANK_11 = 11;
+const AIM = 21;
+const ACE_DIFF = 10;
+
+export function calculateResult (cards: Array<Card>): number {
+  const result = sumBy(cards, (card) => {
+    switch (card.getRank()) {
+      case Ranks.JACK:
+      case Ranks.QUEEN:
+      case Ranks.KING: {
+        return PICTURE_RANK;
+      }
+      case Ranks.ACE: {
+        return ACE_RANK_11;
+      }
+    }
+
+    return card.getRank();
+  });
+
+  const aces = cards.filter((item) => item.getRank() === Ranks.ACE);
+
+  if (result > AIM && aces.length > 0) {
+    return result - (ACE_DIFF * aces.length);
+  }
+
+  return result;
+}

package/src/tests/just-black-jack/rooms/black-jack-simple-room.ts

@@ -0,0 +1,10 @@
+import { SimpleRoom } from '../../../base-rooms';
+import { GameMaster } from '../../../base';
+import { BlackJackGameMaster } from '../domain/black-jack-game-master';
+import { deck52 } from '../../../cards-game';
+
+export class BlackJackSimpleRoom extends SimpleRoom {
+  createMaster (): GameMaster {
+    return new BlackJackGameMaster(this, deck52);
+  }
+}

package/src/tests/just-black-jack/tests/black-jack-simple-room.test.ts

@@ -0,0 +1,75 @@
+import { cloneDeep } from 'lodash';
+
+import { BlackJackPlayer } from '../domain/black-jack-player';
+import { BlackJackSimpleRoom } from '../rooms/black-jack-simple-room';
+
+import { mockDeck, player1, player2 } from './common';
+import { calculateResult } from '../helpers/calculate-result';
+import { GameRoomConfig } from '../../../base';
+import { BlackJackGameMaster } from '../domain/black-jack-game-master';
+
+describe('black jack simple room', () => {
+  let newPlayer1: BlackJackPlayer;
+  let newPlayer2: BlackJackPlayer;
+
+  let cashRoomConfig: GameRoomConfig = {
+    id: '1',
+    gameType: 'JUST_BLACK_JACK',
+    roomType: 'simple',
+    rulesType: 'STANDARD',
+    maxPlayers: 6,
+    bet: 10,
+    turnTimeout: 0,
+    restartTimeout: 0,
+  };
+
+  beforeAll(() => {
+    mockDeck();
+  });
+
+  beforeEach(() => {
+    newPlayer1 = cloneDeep(player1);
+    newPlayer2 = cloneDeep(player2);
+  });
+
+  it('black jack simple room', () => {
+    const room = new BlackJackSimpleRoom(cashRoomConfig);
+    room.addMaster();
+
+    const master = room.getMasters()[0] as BlackJackGameMaster | undefined;
+    const table1 = master.getTable();
+    const dealer = master.getDealer();
+
+    if (table1 && dealer) {
+      table1.addPlayerToSeat(newPlayer1);
+      newPlayer1.setStack(100);
+
+      table1.addPlayerToSeat(newPlayer2);
+      newPlayer2.setStack(100);
+
+      expect(master.getGameRound()?.getState()).toBeUndefined();
+
+      master.startNewRound();
+      expect(master.getGameRoundState().isInProgress()).toBeTruthy();
+      expect(table1.getPlayers().length).toBe(3);
+
+      expect(master.getGameRound()?.getActivePlayer()).toBe(newPlayer1);
+      expect(calculateResult(newPlayer1.getCards())).toBe(20);
+
+      master.finishMove(newPlayer1);
+
+      expect(master.getGameRound()?.getActivePlayer()).toBe(newPlayer2);
+      expect(calculateResult(newPlayer2.getCards())).toBe(19);
+
+      master.getCard(newPlayer2);
+      expect(calculateResult(newPlayer2.getCards())).toBe(27);
+      master.finishMove(newPlayer2);
+
+      expect(master.getGameRound()?.getActivePlayer()).toBe(dealer);
+      expect(calculateResult(master.getDealer()?.getCards() ?? [])).toBe(21);
+      master.finishMove(dealer);
+
+      expect(master.getGameRoundState().isFinish()).toBeTruthy();
+    }
+  });
+});

package/src/tests/just-black-jack/tests/common.ts

@@ -0,0 +1,63 @@
+import { BlackJackPlayer } from '../domain/black-jack-player';
+import * as shuffle from '../../../utils/shuffle';
+
+export const player1 = new BlackJackPlayer(
+  '5ef77417f471c39c885d18f5',
+  'dima',
+  '',
+  1000,
+);
+
+export const player2 = new BlackJackPlayer(
+  '5ef774a71486d104736561a4',
+  'vova',
+  '',
+  500,
+);
+
+export const player3 = new BlackJackPlayer(
+  '5ef774a71486d104736561a5',
+  'pasha',
+  '',
+  500,
+);
+
+export const player4 = new BlackJackPlayer(
+  '5ef774a71486d104736561a7',
+  'petya',
+  '',
+  500,
+);
+
+export const player5 = new BlackJackPlayer(
+  '5ef774a71486d104736561a8',
+  'dima 2',
+  '',
+  500,
+);
+
+export const player6 = new BlackJackPlayer(
+  '5ef774a71486d104736561a9',
+  'vova 2',
+  '',
+  500,
+);
+
+export const player7 = new BlackJackPlayer(
+  '5ef774a71486d104736561a10',
+  'pasha 2',
+  '',
+  500,
+);
+
+export const player8 = new BlackJackPlayer(
+  '5ef774a71486d104736561a11',
+  'petya 2',
+  '',
+  500,
+);
+
+
+export function mockDeck () {
+  jest.spyOn(shuffle, 'superShuffle').mockImplementation((collection: any[]) => collection);
+}

package/dist/cards-game/cards-table.d.ts

@@ -1,11 +0,0 @@
-import { GameTable } from '../base';
-import { GamePlayer } from '../base';
-import { GameTableConfig } from '../base/game-table';
-import { Card } from './cards/card';
-export declare abstract class CardsTable<GP extends GamePlayer, GM, GSR> extends GameTable<GP, GM, GSR> {
-    private deck;
-    protected constructor(config: GameTableConfig<GP>, deck: Array<Card>);
-    shuffleDeck(): void;
-    getDeck(): Card[];
-}
-//# sourceMappingURL=cards-table.d.ts.map

package/dist/cards-game/cards-table.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cards-table.d.ts","sourceRoot":"","sources":["../../src/cards-game/cards-table.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEpC,8BAAsB,UAAU,CAAC,EAAE,SAAS,UAAU,EAAE,EAAE,EAAE,GAAG,CAAE,SAAQ,SAAS,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC;IAC3F,OAAO,CAAC,IAAI,CAAc;IAE1B,SAAS,aACL,MAAM,EAAE,eAAe,CAAC,EAAE,CAAC,EAC3B,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC;IAMrB,WAAW;IAIX,OAAO;CAGV"}

package/dist/cards-game/cards-table.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CardsTable = void 0;
-const lodash_1 = require("lodash");
-const base_1 = require("../base");
-const utils_1 = require("../utils");
-class CardsTable extends base_1.GameTable {
-    constructor(config, deck) {
-        super(config);
-        this.deck = deck;
-    }
-    shuffleDeck() {
-        this.deck = (0, utils_1.superShuffle)(this.deck);
-    }
-    getDeck() {
-        return (0, lodash_1.cloneDeep)(this.deck);
-    }
-}
-exports.CardsTable = CardsTable;
-//# sourceMappingURL=cards-table.js.map

package/dist/cards-game/cards-table.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cards-table.js","sourceRoot":"","sources":["../../src/cards-game/cards-table.ts"],"names":[],"mappings":";;;AAAA,mCAAmC;AAEnC,kCAAoC;AAEpC,oCAAwC;AAKxC,MAAsB,UAA2C,SAAQ,gBAAsB;IAG3F,YACI,MAA2B,EAC3B,IAAiB;QAEjB,KAAK,CAAC,MAAM,CAAC,CAAC;QACd,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACrB,CAAC;IAED,WAAW;QACP,IAAI,CAAC,IAAI,GAAG,IAAA,oBAAY,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;IAED,OAAO;QACH,OAAO,IAAA,kBAAS,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;CACJ;AAlBD,gCAkBC"}

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

@@ -1,28 +0,0 @@
-import { cloneDeep } from 'lodash';
-
-import { GameTable } from '../base';
-import { GamePlayer } from '../base';
-import { superShuffle } from '../utils';
-import { GameTableConfig } from '../base/game-table';
-
-import { Card } from './cards/card';
-
-export abstract class CardsTable<GP extends GamePlayer, GM, GSR> extends GameTable<GP, GM, GSR> {
-    private deck: Array<Card>;
-
-    protected constructor (
-        config: GameTableConfig<GP>,
-        deck: Array<Card>,
-    ) {
-        super(config);
-        this.deck = deck;
-    }
-
-    shuffleDeck () {
-        this.deck = superShuffle(this.deck);
-    }
-
-    getDeck () {
-        return cloneDeep(this.deck);
-    }
-}