trucoshi 4.0.3 → 4.0.4

package/dist/lib/classes/Deck.d.ts

@@ -0,0 +1,11 @@
+import { ICard, IDeck, IPlayedCard, IPlayer, IPublicPlayer } from "../../types";
+import { ITable } from "./Table";
+export declare function Deck(): IDeck;
+export declare const getAllCards: () => ("rb" | "1e" | "1b" | "7e" | "7o" | "3e" | "3o" | "3b" | "3c" | "2e" | "2o" | "2b" | "2c" | "1o" | "1c" | "re" | "ro" | "rc" | "ce" | "co" | "cb" | "cc" | "pe" | "po" | "pb" | "pc" | "7b" | "7c" | "6e" | "6o" | "6b" | "6c" | "5e" | "5o" | "5b" | "5c" | "4e" | "4o" | "4b" | "4c")[];
+export declare function dealCards<TPlayer extends {
+    key: string;
+    idx: number;
+    setHand(h: Array<ICard>): void;
+} = IPlayer>(table: ITable<TPlayer>, deck: IDeck): void;
+export declare function shuffleArray<T = unknown>(array: Array<T>, getRandom?: (max: number) => number): T[];
+export declare function PlayedCard(player: IPlayer | IPublicPlayer, card: ICard, burn?: boolean): IPlayedCard;

package/dist/lib/classes/Deck.js

@@ -0,0 +1,61 @@
+import { BURNT_CARD, CARDS } from "../constants";
+import { Random } from "./Random";
+export function Deck() {
+    const deck = {
+        cards: getAllCards(),
+        random: Random(),
+        usedCards: [],
+        takeCard() {
+            const card = deck.cards.shift();
+            deck.usedCards.push(card);
+            return card;
+        },
+        takeThree() {
+            return [deck.takeCard(), deck.takeCard(), deck.takeCard()];
+        },
+        shuffle(dealer) {
+            deck.cards = getAllCards();
+            deck.usedCards = [];
+            deck.cards = shuffleArray(deck.cards, (max) => deck.random.pick(dealer, max - 1));
+            if (deck.cards.length !== 40) {
+                throw new Error("This is not good");
+            }
+            return deck;
+        },
+    };
+    return deck;
+}
+export const getAllCards = () => Object.keys(CARDS);
+export function dealCards(table, deck) {
+    const playerHands = [];
+    for (let i = 0; i < 3; i++) {
+        for (const player of table.getPlayersForehandFirst()) {
+            playerHands[player.idx] = [...(playerHands[player.idx] || []), deck.takeCard()];
+        }
+    }
+    for (const [key, player] of table.players.entries()) {
+        player.setHand(playerHands[key]);
+    }
+}
+const defaultGetRandom = (max) => Math.floor(Math.random() * max);
+export function shuffleArray(array, getRandom = defaultGetRandom) {
+    let currentIndex = array.length, randomIndex;
+    while (currentIndex != 0) {
+        randomIndex = getRandom(currentIndex);
+        currentIndex--;
+        [array[currentIndex], array[randomIndex]] = [array[randomIndex], array[currentIndex]];
+    }
+    return array;
+}
+export function PlayedCard(player, card, burn) {
+    const pc = {
+        player,
+        card,
+        key: card + player.idx,
+    };
+    if (burn) {
+        pc.card = BURNT_CARD;
+        pc.key = Math.floor(Math.random() * 100).toString();
+    }
+    return pc;
+}

package/dist/lib/classes/Queue.d.ts

@@ -0,0 +1,5 @@
+export interface IQueue {
+    promise: Promise<void>;
+    queue(operation: () => any): Promise<void>;
+}
+export declare const Queue: () => IQueue;

package/dist/lib/classes/Queue.js

@@ -0,0 +1,18 @@
+import logger from "../../utils/logger";
+export const Queue = () => {
+    const queue = {
+        promise: Promise.resolve(),
+        queue(operation) {
+            return new Promise((resolve) => {
+                queue.promise = queue.promise
+                    .then(operation)
+                    .then(resolve)
+                    .catch((e) => {
+                    logger.error(e, "Error in queue operation %o", operation);
+                    resolve();
+                });
+            });
+        },
+    };
+    return queue;
+};

package/dist/lib/classes/Random.d.ts

@@ -0,0 +1,18 @@
+import { IRandom } from "../../types";
+export declare const Random: () => IRandom;
+export interface IRng {
+    combine(client: string, server: string, nonce: number): string;
+    sha512(string: string): string;
+    generateServerSeed(): string;
+    hexToBytes(hex: string): Uint8Array;
+    byteGenerator(clientseed: string, serverseed: string, nonce: number): Uint8Array;
+    generateInteger(clientSeed: string, serverSeed: string, nonce: number, min: number, max: number): number;
+    generateFloat(clientSeed: string, serverSeed: string, nonce: number, precision?: number): number;
+    generateBool(clientSeed: string, serverSeed: string, nonce: number): boolean;
+    selectRandomObject<T extends {
+        probability: number;
+    } = {
+        probability: number;
+        [x: string]: any;
+    }>(clientSeed: string, serverSeed: string, nonce: number, objects: Array<T>): T | null;
+}

package/dist/lib/classes/Random.js

@@ -0,0 +1,140 @@
+import forge from "node-forge";
+const rnd = Rng();
+export const Random = () => {
+    const random = {
+        secret: rnd.generateServerSeed(),
+        clients: [],
+        nonce: 0,
+        pick(key, max) {
+            return rnd.generateInteger(random.clients[key], random.secret, random.nonce, 0, max);
+        },
+        next() {
+            random.nonce++;
+        },
+        reveal() {
+            return { secret: random.secret, clients: [...random.clients] };
+        },
+    };
+    return random;
+};
+function Rng() {
+    return {
+        /**
+         * Generates a random 256 long hex hash
+         *
+         * @param   {string} clientSeed - the clientSeed
+         * @param   {string} serverSeed - the serverSeed
+         * @param   {number} nonce      - the nonce
+         * @returns {string} combined string
+         */
+        combine: (client, server, nonce) => client + server + nonce,
+        /**
+         * Generates a sha512 hash from a string
+         *
+         * @param   {string} string - input string
+         * @returns {string} random 256 long string
+         */
+        sha512: (string) => forge.md.sha512.create().update(string).digest().toHex(),
+        /**
+         * Generates a random 256 long hex hash
+         *
+         * @returns {string} random 256 long string
+         */
+        generateServerSeed: function () {
+            return forge.util.bytesToHex(forge.random.getBytesSync(256));
+        },
+        /**
+         * Converts a hex string to a Uint8Array of bytes.
+         * @param {string} hex - The hex string to convert.
+         * @returns {Uint8Array} The resulting byte array.
+         */
+        hexToBytes: function (hex) {
+            const byteCount = hex.length / 2;
+            const bytes = new Uint8Array(byteCount);
+            for (let i = 0; i < byteCount; i++) {
+                const byteHex = hex.substring(i * 2, 2);
+                bytes[i] = parseInt(byteHex, 16);
+            }
+            return bytes;
+        },
+        /**
+         * Generates an array of 32 random bytes using the given serverseed, clientseed, and nonce.
+         *
+         * @param {string} clientseed - The clientseed to use.
+         * @param {string} serverseed - The serverseed to use.
+         * @param {number} nonce - The nonce to use.
+         * @returns {Uint8Array} - The generated bytes as a Uint8Array.
+         */
+        byteGenerator: function (clientseed, serverseed, nonce) {
+            const preHash = this.combine(clientseed, serverseed, nonce);
+            const hash = this.sha512(preHash);
+            return this.hexToBytes(hash.slice(0, 64));
+        },
+        /**
+         * Generates a random integer between min and max using the specified client seed, server seed, and nonce.
+         *
+         * @param {string} clientSeed - The client seed.
+         * @param {string} serverSeed - The server seed.
+         * @param {number} nonce - The nonce.
+         * @param {number} min - The minimum value of the range.
+         * @param {number} max - The maximum value of the range.
+         * @returns {number} A random integer between min and max (inclusive).
+         */
+        generateInteger: function (clientSeed, serverSeed, nonce, min, max) {
+            const preHash = this.combine(clientSeed, serverSeed, nonce);
+            const hash = this.sha512(preHash);
+            const range = max - min + 1;
+            return (parseInt(hash.slice(0, 8), 16) % range) + min;
+        },
+        /**
+         * Generates a random float between 0 and 1 using the fairjs library.
+         * @param {string} clientSeed - The client seed to use for the random number generation.
+         * @param {string} serverSeed - The server seed to use for the random number generation.
+         * @param {number} nonce - The nonce to use for the random number generation.
+         * @param {number} [precision=2] - The number of decimal places to include in the result.
+         * @returns {number} - The random float between 0 and 1.
+         */
+        generateFloat: function (clientSeed, serverSeed, nonce, precision = 2) {
+            const bytes = this.byteGenerator(clientSeed, serverSeed, nonce);
+            const float = parseFloat("0." + bytes.join(""));
+            return parseFloat(float.toFixed(precision));
+        },
+        /**
+         *  Generates a random boolean using the specified client seed, server seed, and nonce.
+         *
+         * @param {string} clientSeed - The client seed.
+         * @param {string} serverSeed - The server seed.
+         * @param {number} nonce       - The nonce.
+         * @returns {float, boolean} random boolean true/false
+         */
+        generateBool: function (clientSeed, serverSeed, nonce) {
+            return this.generateFloat(clientSeed, serverSeed, nonce, 10) <= 0.5 ? true : false;
+        },
+        /**
+         * Selects a random object from an array of objects based on their probabilities.
+         *
+         * @param {string} clientSeed - The client seed.
+         * @param {string} serverSeed - The server seed.
+         * @param {number} nonce      - The nonce.
+         * @param {Array}  objects    - An array of objects with an ID and a probability property.
+         * @returns {String} The ID of the randomly selected object.
+         */
+        selectRandomObject: function (clientSeed, serverSeed, nonce, objects) {
+            let totalProbability = 0;
+            for (const obj of objects) {
+                totalProbability += obj.probability;
+            }
+            const normalizedProbabilities = objects.map((obj) => obj.probability / totalProbability);
+            const randomFloat = this.generateFloat(clientSeed, serverSeed, nonce, 10);
+            let index = 0;
+            for (let i = 0; i < normalizedProbabilities.length; i++) {
+                index += normalizedProbabilities[i];
+                if (randomFloat < index) {
+                    return objects[i];
+                }
+            }
+            // If no object is selected, return null
+            return null;
+        },
+    };
+}

package/dist/lib/classes/Table.d.ts

@@ -0,0 +1,15 @@
+import { IPlayedCard, IPlayer } from "../../types";
+export interface ITable<TPlayer extends {
+    key: string;
+} = IPlayer> {
+    forehandIdx: number;
+    cards: Array<Array<IPlayedCard>>;
+    players: Array<TPlayer>;
+    nextHand(): TPlayer;
+    getPlayerByPosition(idx?: number, forehandFirst?: boolean): TPlayer;
+    getPlayerPosition(key: string, forehandFirst?: boolean): number;
+    getPlayersForehandFirst(forehandIdx?: number): Array<TPlayer>;
+}
+export declare function Table<TPlayer extends {
+    key: string;
+} = IPlayer>(players: Array<TPlayer>): ITable<TPlayer>;

package/dist/lib/classes/Table.js

@@ -0,0 +1,34 @@
+export function Table(players) {
+    const table = {
+        players,
+        cards: [],
+        forehandIdx: 0,
+        nextHand() {
+            if (table.forehandIdx < table.players.length - 1) {
+                table.forehandIdx++;
+            }
+            else {
+                table.forehandIdx = 0;
+            }
+            return table.getPlayerByPosition();
+        },
+        getPlayerPosition(key, forehandFirst = false) {
+            const array = forehandFirst ? table.getPlayersForehandFirst() : table.players;
+            return array.findIndex((p) => p.key === key);
+        },
+        getPlayersForehandFirst(forehand) {
+            const idx = forehand !== undefined ? forehand : table.forehandIdx;
+            const cut = players.slice(idx, table.players.length);
+            const end = players.slice(0, idx);
+            return cut.concat(end);
+        },
+        getPlayerByPosition(idx, forehandFirst = false) {
+            const array = forehandFirst ? table.getPlayersForehandFirst() : table.players;
+            if (idx !== undefined) {
+                return array[idx];
+            }
+            return array[0];
+        },
+    };
+    return table;
+}

package/dist/lib/classes/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Deck";
+export * from "./Table";
+export * from "./Random";

package/dist/lib/classes/index.js

@@ -0,0 +1,3 @@
+export * from "./Deck";
+export * from "./Table";
+export * from "./Random";

package/dist/lib/utils.d.ts

@@ -0,0 +1,5 @@
+import { IRound } from "../truco";
+import { ICard } from "../types";
+export declare function getMaxNumberIndex<T = number>(array: Array<T>): number;
+export declare function getCardValue(card: ICard): number;
+export declare function checkHandWinner(rounds: Array<IRound>, forehandTeamIdx: 0 | 1): null | 0 | 1;

package/dist/lib/utils.js

@@ -0,0 +1,45 @@
+import { CARDS } from "./constants";
+export function getMaxNumberIndex(array) {
+    return array.reduce((accumulator, current, index) => {
+        return current > array[accumulator] ? index : accumulator;
+    }, 0);
+}
+export function getCardValue(card) {
+    return CARDS[card] !== undefined ? CARDS[card] : -2;
+}
+export function checkHandWinner(rounds, forehandTeamIdx) {
+    var _a, _b, _c;
+    const roundsWon = {
+        0: 0,
+        1: 0,
+        ties: 0,
+    };
+    for (let i = 0; i < rounds.length; i++) {
+        const round = rounds[i];
+        if (round.tie) {
+            roundsWon[0] += 1;
+            roundsWon[1] += 1;
+            roundsWon.ties = roundsWon.ties + 1;
+            continue;
+        }
+        if (((_a = round.winner) === null || _a === void 0 ? void 0 : _a.teamIdx) === 0) {
+            roundsWon[0] += 1;
+        }
+        if (((_b = round.winner) === null || _b === void 0 ? void 0 : _b.teamIdx) === 1) {
+            roundsWon[1] += 1;
+        }
+    }
+    if (roundsWon[0] > 2 && roundsWon[1] > 2) {
+        return forehandTeamIdx;
+    }
+    if (rounds.length > 2 && roundsWon.ties > 0 && ((_c = rounds[0]) === null || _c === void 0 ? void 0 : _c.winner)) {
+        return rounds[0].winner.teamIdx;
+    }
+    if (roundsWon[0] >= 2 && roundsWon[1] < 2) {
+        return 0;
+    }
+    if (roundsWon[1] >= 2 && roundsWon[0] < 2) {
+        return 1;
+    }
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trucoshi",
-  "version": "4.0.3",
+  "version": "4.0.4",
   "description": "Lightning Truco Server",
   "main": "dist/types.js",
   "license": "GPL-3.0",
@@ -47,10 +47,7 @@
     "ts-mocha": "^10.0.0"
   },
   "files": [
-    "dist/lib/index.js",
-    "dist/lib/index.d.ts",
-    "dist/lib/constants.js",
-    "dist/lib/constants.d.ts",
+    "dist/lib/*",
     "dist/types.js",
     "dist/types.d.ts",
     "dist/events.js",