jp.ms.common.engine 1.0.0

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

@@ -0,0 +1,80 @@
+import {
+    club_6,
+    club_7,
+    club_8,
+    club_9,
+    club_10,
+    club_ace,
+    club_jack,
+    club_king,
+    club_queen,
+    diamond_6,
+    diamond_7,
+    diamond_8,
+    diamond_9,
+    diamond_10,
+    diamond_ace,
+    diamond_jack,
+    diamond_king,
+    diamond_queen,
+    heart_6,
+    heart_7,
+    heart_8,
+    heart_9,
+    heart_10,
+    heart_ace,
+    heart_jack,
+    heart_king,
+    heart_queen,
+    spade_6,
+    spade_7,
+    spade_8,
+    spade_9,
+    spade_10,
+    spade_queen,
+    spade_jack,
+    spade_king,
+    spade_ace,
+} from './cards';
+
+export const deck36 = [
+    heart_6,
+    heart_7,
+    heart_8,
+    heart_9,
+    heart_10,
+    heart_jack,
+    heart_queen,
+    heart_king,
+    heart_ace,
+
+    diamond_6,
+    diamond_7,
+    diamond_8,
+    diamond_9,
+    diamond_10,
+    diamond_jack,
+    diamond_queen,
+    diamond_king,
+    diamond_ace,
+
+    club_6,
+    club_7,
+    club_8,
+    club_9,
+    club_10,
+    club_jack,
+    club_queen,
+    club_king,
+    club_ace,
+
+    spade_6,
+    spade_7,
+    spade_8,
+    spade_9,
+    spade_10,
+    spade_jack,
+    spade_queen,
+    spade_king,
+    spade_ace,
+];

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

@@ -0,0 +1,112 @@
+import {
+    club_2,
+    club_3,
+    club_4,
+    club_5,
+    club_6,
+    club_7,
+    club_8,
+    club_9,
+    club_10,
+    club_ace,
+    club_jack,
+    club_king,
+    club_queen,
+    diamond_2,
+    diamond_3,
+    diamond_4,
+    diamond_5,
+    diamond_6,
+    diamond_7,
+    diamond_8,
+    diamond_9,
+    diamond_10,
+    diamond_ace,
+    diamond_jack,
+    diamond_king,
+    diamond_queen,
+    heart_2,
+    heart_3,
+    heart_4,
+    heart_5,
+    heart_6,
+    heart_7,
+    heart_8,
+    heart_9,
+    heart_10,
+    heart_ace,
+    heart_jack,
+    heart_king,
+    heart_queen,
+    spade_10,
+    spade_2,
+    spade_3,
+    spade_4,
+    spade_5,
+    spade_6,
+    spade_7,
+    spade_8,
+    spade_9,
+    spade_ace,
+    spade_jack,
+    spade_king,
+    spade_queen,
+} from './cards';
+
+export const deck52 = [
+    heart_2,
+    heart_3,
+    heart_4,
+    heart_5,
+    heart_6,
+    heart_7,
+    heart_8,
+    heart_9,
+    heart_10,
+    heart_jack,
+    heart_queen,
+    heart_king,
+    heart_ace,
+
+    diamond_2,
+    diamond_3,
+    diamond_4,
+    diamond_5,
+    diamond_6,
+    diamond_7,
+    diamond_8,
+    diamond_9,
+    diamond_10,
+    diamond_jack,
+    diamond_queen,
+    diamond_king,
+    diamond_ace,
+
+    club_2,
+    club_3,
+    club_4,
+    club_5,
+    club_6,
+    club_7,
+    club_8,
+    club_9,
+    club_10,
+    club_jack,
+    club_queen,
+    club_king,
+    club_ace,
+
+    spade_2,
+    spade_3,
+    spade_4,
+    spade_5,
+    spade_6,
+    spade_7,
+    spade_8,
+    spade_9,
+    spade_10,
+    spade_jack,
+    spade_queen,
+    spade_king,
+    spade_ace,
+];

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

@@ -0,0 +1,19 @@
+/* eslint-disable no-unused-vars */
+
+export enum Ranks {
+    UNKNOWN_RANK = 0,
+    MIN_ACE = 1,
+    TWO = 2,
+    THREE = 3,
+    FOUR = 4,
+    FIVE = 5,
+    SIX = 6,
+    SEVEN = 7,
+    EIGHT = 8,
+    NINE = 9,
+    TEN = 10,
+    JACK = 11,
+    QUEEN = 12,
+    KING = 13,
+    ACE = 14,
+}

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

@@ -0,0 +1,10 @@
+/* eslint-disable no-unused-vars */
+
+export enum Suits {
+    UNKNOWN_SUIT = 'unknown_suit',
+    HEART = 'heart',
+    DIAMOND = 'diamond',
+    CLUB = 'club',
+    SPADE = 'spade',
+}
+

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

@@ -0,0 +1,83 @@
+import { GameMaster } from '../base';
+import { IGameTable } from '../base/game-table';
+import { IGameRound } from '../base/game-round';
+
+import { CardsPlayer } from './cards-player';
+import { Card } from './cards/card';
+
+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>;
+    private readonly gameCards: Array<Card>;
+
+    protected constructor (table: GT) {
+        super(table);
+        this.deck = [];
+        this.gameCards = [];
+    }
+
+    getDeck () {
+        return this.deck;
+    }
+
+    takeNewDeck (deck: Array<Card>) {
+        this.deck = deck;
+    }
+
+    getGameCards () {
+        return this.gameCards;
+    }
+
+    putCardsOnTheTableFromDeck () {
+        const popCard = this.deck.pop();
+        if (popCard) {
+            this.gameCards.push(popCard);
+        }
+    }
+
+    putCardOnTheTable (card: Card) {
+        this.gameCards.push(card);
+    }
+
+    popCardFromDeck () {
+        return this.deck.pop();
+    }
+
+    pushCardToDeck (card: Card, position: number) {
+        this.deck.splice(position, 0, card);
+    }
+
+    pushCardToBeggingOfTheDeck (card: Card) {
+        this.pushCardToDeck(card, 0);
+    }
+
+    give2CardsToAllPlayers () {
+        this.giveCardsToAllPlayers(TWO_CARDS);
+    }
+
+    give6CardsToAllPlayers () {
+        this.giveCardsToAllPlayers(SIX_CARDS);
+    }
+
+    giveCardsToAllPlayers (count: number) {
+        this.table.getPlayers().forEach((player) => {
+            this.giveCardsToPlayer(player, count);
+        });
+    }
+
+    give1CardsToPlayer (player: CardsPlayer) {
+        this.giveCardsToPlayer(player, ONE_CARD)
+    }
+
+    giveCardsToPlayer (player: CardsPlayer, count: number) {
+        for (let i = 0; i < count; i += 1) {
+            const popCard = this.popCardFromDeck();
+            if (popCard) {
+                player.takeCard(popCard);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+import { GamePlayer } from '../base';
+
+import { Card } from './cards/card';
+import { first, remove } from 'lodash';
+
+export abstract class CardsPlayer extends GamePlayer {
+    private cards: Array<Card>;
+
+    protected constructor (
+        id: string,
+        fullName: string,
+        avatarUrl: string,
+        balance: number,
+    ) {
+        super(id, fullName, avatarUrl, balance);
+        this.cards = [];
+    }
+
+    getCards (): Array<Card> {
+        return this.cards;
+    }
+
+    hasCards (): boolean {
+        return this.cards.length > 0;
+    }
+
+    clearCards (): void {
+        this.cards = [];
+    }
+
+    takeCard (card: Card): void {
+        this.cards.push(card);
+    }
+
+    putCard (cardId: number): Card | undefined {
+        const removedCard = remove(this.cards, (card) => card.getId() === cardId);
+
+        return first(removedCard);
+    }
+}

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

@@ -0,0 +1,28 @@
+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);
+    }
+}

package/src/cards-game/index.ts

@@ -0,0 +1,21 @@
+import * as cards from './cards/cards';
+import { Card } from './cards/card';
+import { deck36 } from './cards/deck36';
+import { deck52 } from './cards/deck52';
+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,
+  Card,
+  deck36,
+  deck52,
+  Ranks,
+  Suits,
+  CardsGameMaster,
+  CardsPlayer,
+  CardsTable,
+}

package/src/const.ts

@@ -0,0 +1,3 @@
+export const ONE_SECOND = 1000
+
+export const TWO_PLAYER_GAME = 2;

package/src/index.ts

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

package/src/utils/circle-list.ts

@@ -0,0 +1,130 @@
+import { slice } from 'lodash';
+
+export class CircleListNode<T> {
+    private data: T;
+    private next: CircleListNode<T> | null;
+    private prev: CircleListNode<T> | null;
+
+    constructor (data: T) {
+        this.data = data;
+    }
+
+    getData () {
+        return this.data;
+    }
+
+    setData (data: T) {
+        this.data = data;
+    }
+
+    getNext () {
+        return this.next;
+    }
+
+    setNext (node: CircleListNode<T>) {
+        this.next = node;
+    }
+
+    clearNext () {
+        this.next = null;
+    }
+
+    getPrev () {
+        return this.prev;
+    }
+
+    setPrev (node: CircleListNode<T>) {
+        this.prev = node;
+    }
+
+    clearPrev () {
+        this.prev = null;
+    }
+}
+
+export class CircleList<T> {
+    private readonly list: Array<CircleListNode<T>>;
+
+    constructor () {
+        this.list = [];
+    }
+
+    get (index: number): CircleListNode<T> | undefined {
+        return this.list[index];
+    }
+
+    getData (index: number) {
+        return this.get(index)?.getData();
+    }
+
+    getNextChain (first: number): Array<T> {
+        const chain: Array<T> = [];
+        let firstNode = this.list[first];
+        let nextNode = firstNode.getNext();
+
+        chain.push(firstNode.getData());
+
+        while (firstNode !== nextNode && nextNode) {
+            chain.push(nextNode.getData());
+            nextNode = nextNode.getNext();
+        }
+
+        return chain;
+    }
+
+    getPrevChain (first: number): Array<T> {
+        const chain: Array<T> = [];
+        let firstNode = this.list[first];
+        let prevNode = firstNode.getPrev();
+
+        chain.push(firstNode.getData());
+
+        while (firstNode !== prevNode && prevNode) {
+            chain.push(prevNode.getData());
+            prevNode = prevNode.getPrev();
+        }
+
+        return chain;
+    }
+
+    getSize () {
+        return this.list.length;
+    }
+
+    getSlice (start: number, end?: number): Array<T> {
+        return slice(this.list, start, end).map((item) => item.getData());
+    }
+
+    push (data: T) {
+        this.list.push(new CircleListNode(data));
+        this.connect();
+    }
+
+    toArray (): Array<T> {
+        return this.list.map((item) => item.getData());
+    }
+
+    private connect () {
+        this.clearLinks();
+
+        for (let i = 0; i < this.list.length; i += 1) {
+            const currentNode = this.list[i];
+
+            if (i === this.list.length - 1) {
+                currentNode.setNext(this.list[0]);
+                currentNode.getNext()?.setPrev(currentNode);
+                return;
+            }
+
+            currentNode.setNext(this.list[i + 1]);
+            currentNode.getNext()?.setPrev(currentNode);
+        }
+    }
+
+    private clearLinks () {
+        this.list.forEach((node) => {
+            node.clearNext();
+            node.clearPrev();
+        });
+    }
+}

package/src/utils/index.ts

@@ -0,0 +1,8 @@
+import { CircleListNode, CircleList } from './circle-list';
+import { superShuffle } from './shuffle';
+
+export {
+    CircleListNode,
+    CircleList,
+    superShuffle,
+}

package/src/utils/shuffle.ts

@@ -0,0 +1,12 @@
+import shuffle from 'shuffle-array';
+import seedrandom from 'seedrandom';
+import { flow } from 'lodash';
+
+const rng = seedrandom();
+
+export function rngShuffle(collection: any[]) {
+  return shuffle(collection, { rng, copy: true });
+}
+
+export const superShuffle = flow(rngShuffle, rngShuffle, rngShuffle, rngShuffle);
+

package/src/utils/tests/circle-list.test.ts

@@ -0,0 +1,72 @@
+import { CircleList } from '../circle-list';
+
+type TestItemType = {
+    id: number;
+}
+
+describe('circle list', () => {
+    const item1 = { id: 1 };
+    const item2 = { id: 2 };
+    const item3 = { id: 3 };
+
+    const list = new CircleList<TestItemType>();
+    list.push(item1);
+    list.push(item2);
+    list.push(item3);
+
+    it('circle list', () => {
+        expect(list.getSize()).toBe(3);
+
+        expect(list.get(0)?.getData()).toBe(item1);
+        expect(list.get(0)?.getNext()).toBe(list.get(1));
+        expect(list.get(0)?.getPrev()).toBe(list.get(2));
+
+        expect(list.get(1)?.getData()).toBe(item2);
+        expect(list.get(1)?.getNext()).toBe(list.get(2));
+        expect(list.get(1)?.getPrev()).toBe(list.get(0));
+
+        expect(list.get(2)?.getData()).toBe(item3);
+        expect(list.get(2)?.getNext()).toBe(list.get(0));
+        expect(list.get(2)?.getPrev()).toBe(list.get(1));
+    });
+
+    it('getNextChain', () => {
+        const nextChain0 = list.getNextChain(0);
+        expect(nextChain0.length).toBe(3);
+        expect(nextChain0[0].id).toBe(1);
+        expect(nextChain0[1].id).toBe(2);
+        expect(nextChain0[2].id).toBe(3);
+
+        const nextChain1 = list.getNextChain(1);
+        expect(nextChain1.length).toBe(3);
+        expect(nextChain1[0].id).toBe(2);
+        expect(nextChain1[1].id).toBe(3);
+        expect(nextChain1[2].id).toBe(1);
+
+        const nextChain2 = list.getNextChain(2);
+        expect(nextChain2.length).toBe(3);
+        expect(nextChain2[0].id).toBe(3);
+        expect(nextChain2[1].id).toBe(1);
+        expect(nextChain2[2].id).toBe(2);
+    });
+
+    it('getPrevChain', () => {
+        const prevChain0 = list.getPrevChain(0);
+        expect(prevChain0.length).toBe(3);
+        expect(prevChain0[0].id).toBe(1);
+        expect(prevChain0[1].id).toBe(3);
+        expect(prevChain0[2].id).toBe(2);
+
+        const prevChain1 = list.getPrevChain(1);
+        expect(prevChain1.length).toBe(3);
+        expect(prevChain1[0].id).toBe(2);
+        expect(prevChain1[1].id).toBe(1);
+        expect(prevChain1[2].id).toBe(3);
+
+        const prevChain2 = list.getPrevChain(2);
+        expect(prevChain2.length).toBe(3);
+        expect(prevChain2[0].id).toBe(3);
+        expect(prevChain2[1].id).toBe(2);
+        expect(prevChain2[2].id).toBe(1);
+    });
+});