trucoshi 0.3.3 → 0.3.5

package/README.md

@@ -1,60 +1,60 @@
-# Trucoshi
-
-### English
-
-Work in progress
-
-Pretends to be an Argentinian Truco game socket server that allows you to put Satoshis on the table ;)
-
-Try current demo at [Trucoshi](https://trucoshi.com)
-
-### Spanish
-
-En construccion
-
-Pretende ser un server basado en sockets del juego de Truco Argentino que te permita poner unos Satoshis en la mesa ;)
-
-Proba la demo actual en [Trucoshi](https://trucoshi.com)
-
-# Test
-
-Right now there's only a local CLI way of playing as there is no socket server implementation and its just the game logic.
-
-### Installation
-
-`yarn`
-
-### Build
-
-`yarn build`
-
-### Play
-
-`yarn test:play`
-
-### Autoplay
-
-`yarn test:autoplay`
-
-# Todo
-
-    [x] Logica de turnos, rondas y battalla de cartas
-    [x] Irse al mazo
-    [x] Cantar truco
-    [] Cantar envido
-    [] Cantar flor
-    [x] Socket server
-    [-] Unit tests
-    [] Bitcoin Lightning integration
-
-# Donations
-
-Donate Bitcoin at [jfrader.com](https://jfrader.com)
-
-# License
-
-This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+# Trucoshi
+
+### English
+
+Work in progress
+
+Pretends to be an Argentinian Truco game socket server that allows you to put Satoshis on the table ;)
+
+Try current demo at [Trucoshi](https://trucoshi.com)
+
+### Spanish
+
+En construccion
+
+Pretende ser un server basado en sockets del juego de Truco Argentino que te permita poner unos Satoshis en la mesa ;)
+
+Proba la demo actual en [Trucoshi](https://trucoshi.com)
+
+# Test
+
+Right now there's only a local CLI way of playing as there is no socket server implementation and its just the game logic.
+
+### Installation
+
+`yarn`
+
+### Build
+
+`yarn build`
+
+### Play
+
+`yarn test:play`
+
+### Autoplay
+
+`yarn test:autoplay`
+
+# Todo
+
+    [x] Logica de turnos, rondas y battalla de cartas
+    [x] Irse al mazo
+    [x] Cantar truco
+    [] Cantar envido
+    [] Cantar flor
+    [x] Socket server
+    [-] Unit tests
+    [] Bitcoin Lightning integration
+
+# Donations
+
+Donate Bitcoin at [jfrader.com](https://jfrader.com)
+
+# License
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./lib";
-export * from "./types";
+export * from "./lib";
+export * from "./types";

package/dist/index.js

@@ -1,18 +1,18 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./lib"), exports);
-__exportStar(require("./types"), exports);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib"), exports);
+__exportStar(require("./types"), exports);

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

@@ -1,17 +1,17 @@
-import { CARDS } from "../constants";
-import { IPlayer, IPublicPlayer } from "./Player";
-export interface IDeck {
-    cards: Array<ICard>;
-    usedCards: Array<ICard>;
-    takeCard(): ICard;
-    takeThree(): [ICard, ICard, ICard];
-    shuffle(): IDeck;
-}
-export type ICard = keyof typeof CARDS;
-export interface IPlayedCard {
-    get key(): string;
-    player: IPlayer & IPublicPlayer;
-    card: ICard;
-}
-export declare function Deck(): IDeck;
-export declare function PlayedCard(player: IPlayer, card: ICard): IPlayedCard;
+import { CARDS } from "../constants";
+import { IPlayer, IPublicPlayer } from "./Player";
+export interface IDeck {
+    cards: Array<ICard>;
+    usedCards: Array<ICard>;
+    takeCard(): ICard;
+    takeThree(): [ICard, ICard, ICard];
+    shuffle(): IDeck;
+}
+export type ICard = keyof typeof CARDS;
+export interface IPlayedCard {
+    get key(): string;
+    player: IPlayer | IPublicPlayer;
+    card: ICard;
+}
+export declare function Deck(): IDeck;
+export declare function PlayedCard(player: IPlayer | IPublicPlayer, card: ICard): IPlayedCard;

package/dist/lib/classes/Deck.js

@@ -1,41 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlayedCard = exports.Deck = void 0;
-const constants_1 = require("../constants");
-const utils_1 = require("../utils");
-function Deck() {
-    const deck = {
-        cards: Object.keys(constants_1.CARDS),
-        usedCards: [],
-        takeCard() {
-            const card = deck.cards.shift();
-            deck.usedCards.push(card);
-            return card;
-        },
-        takeThree() {
-            return [deck.takeCard(), deck.takeCard(), deck.takeCard()];
-        },
-        shuffle() {
-            deck.cards = deck.cards.concat(deck.usedCards);
-            deck.usedCards = [];
-            deck.cards = (0, utils_1.shuffleArray)(deck.cards);
-            if (deck.cards.length !== 40) {
-                throw new Error("This is not good");
-            }
-            return deck;
-        },
-    };
-    return deck;
-}
-exports.Deck = Deck;
-function PlayedCard(player, card) {
-    const pc = {
-        player,
-        card,
-        get key() {
-            return card + player.key;
-        },
-    };
-    return pc;
-}
-exports.PlayedCard = PlayedCard;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayedCard = exports.Deck = void 0;
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+function Deck() {
+    const deck = {
+        cards: Object.keys(constants_1.CARDS),
+        usedCards: [],
+        takeCard() {
+            const card = deck.cards.shift();
+            deck.usedCards.push(card);
+            return card;
+        },
+        takeThree() {
+            return [deck.takeCard(), deck.takeCard(), deck.takeCard()];
+        },
+        shuffle() {
+            deck.cards = deck.cards.concat(deck.usedCards);
+            deck.usedCards = [];
+            deck.cards = (0, utils_1.shuffleArray)(deck.cards);
+            if (deck.cards.length !== 40) {
+                throw new Error("This is not good");
+            }
+            return deck;
+        },
+    };
+    return deck;
+}
+exports.Deck = Deck;
+function PlayedCard(player, card) {
+    const pc = {
+        player,
+        card,
+        get key() {
+            return card + player.key;
+        },
+    };
+    return pc;
+}
+exports.PlayedCard = PlayedCard;

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

@@ -0,0 +1,34 @@
+import { ECommand, EEnvidoCommand } from "../../types";
+import { IEnvidoCalculator } from "../types";
+import { IPlayer } from "./Player";
+import { ITable } from "./Table";
+import { ITeam } from "./Team";
+export interface IEnvido {
+    started: boolean;
+    accepted: boolean;
+    answered: boolean;
+    finished: boolean;
+    possibleAnswerCommands: Array<ECommand>;
+    stake: number;
+    declineStake: number;
+    teamIdx: 0 | 1 | null;
+    answer: boolean | null;
+    pointAnswersCount: number;
+    winningPointsAnswer: number;
+    turn: number;
+    winningPlayer: IPlayer | null;
+    winner: ITeam | null;
+    teams: [ITeam, ITeam];
+    players: Array<IPlayer>;
+    currentPlayer: IPlayer | null;
+    generator: Generator<IEnvido, void, unknown>;
+    sayPoints(player: IPlayer, points: number): IEnvido;
+    sayEnvido(command: EEnvidoCommand, player: IPlayer): IEnvido;
+    sayAnswer(player: IPlayer, answer: boolean | null): IEnvido;
+    setTurn(turn: number): number;
+    setTeam(idx: 0 | 1): 0 | 1;
+    setCurrentPlayer(player: IPlayer | null): IPlayer | null;
+    getNextPlayer(): IteratorResult<IEnvido, IEnvido | void>;
+}
+export declare const EnvidoCalculator: IEnvidoCalculator;
+export declare function Envido(teams: [ITeam, ITeam], matchPoint: number, table: ITable): IEnvido;

package/dist/lib/classes/Envido.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Envido = exports.EnvidoCalculator = void 0;
+const types_1 = require("../../types");
+const types_2 = require("../types");
+const utils_1 = require("../utils");
+const EMPTY_ENVIDO = {
+    turn: 0,
+    teamIdx: null,
+    answer: null,
+    winningPlayer: null,
+    currentPlayer: null,
+    players: [],
+};
+exports.EnvidoCalculator = {
+    [types_1.EEnvidoCommand.ENVIDO]: (args) => {
+        if (!args || args.stake === undefined || args.declineStake === undefined) {
+            throw new Error("Envido calculator arguments are undefined");
+        }
+        const next = [
+            types_1.EEnvidoCommand.REAL_ENVIDO,
+            types_1.EEnvidoCommand.FALTA_ENVIDO,
+            types_1.EAnswerCommand.QUIERO,
+            types_1.EAnswerCommand.NO_QUIERO,
+        ];
+        return {
+            accept: 2,
+            decline: 1,
+            next: args.stake < 2 ? [types_1.EEnvidoCommand.ENVIDO, ...next] : next,
+        };
+    },
+    [types_1.EEnvidoCommand.REAL_ENVIDO]: () => ({
+        accept: 3,
+        decline: 1,
+        next: [types_1.EEnvidoCommand.FALTA_ENVIDO, types_1.EAnswerCommand.QUIERO, types_1.EAnswerCommand.NO_QUIERO],
+    }),
+    [types_1.EEnvidoCommand.FALTA_ENVIDO]: (args) => {
+        if (!args || !args.teams || !args.matchPoint) {
+            throw new Error("Envido calculator arguments are undefined");
+        }
+        const { teams, matchPoint } = args;
+        const totals = teams.map((team) => team.points.malas + team.points.buenas);
+        const higher = (0, utils_1.getMaxNumberIndex)(totals);
+        const points = teams[higher].points;
+        const accept = points.buenas > 0 ? matchPoint - points.buenas : matchPoint - points.malas;
+        return {
+            accept: 0,
+            decline: 2,
+            replace: accept,
+            next: [types_1.EAnswerCommand.QUIERO, types_1.EAnswerCommand.NO_QUIERO],
+        };
+    },
+};
+function Envido(teams, matchPoint, table) {
+    function* envidoAnswerGeneratorSequence() {
+        let i = 0;
+        while (i < envido.players.length && (envido.answer === null || envido.winner === null)) {
+            const player = envido.players[envido.turn];
+            envido.setCurrentPlayer(player);
+            if (player.disabled || !player.ready) {
+                envido.setCurrentPlayer(null);
+            }
+            if (envido.turn >= envido.players.length - 1) {
+                envido.setTurn(0);
+            }
+            else {
+                envido.setTurn(envido.turn + 1);
+            }
+            i++;
+            yield envido;
+        }
+        envido.setCurrentPlayer(null);
+        yield envido;
+    }
+    const envido = Object.assign(Object.assign({}, EMPTY_ENVIDO), { started: false, finished: false, answered: false, accepted: false, possibleAnswerCommands: Object.values(types_1.EEnvidoCommand), declineStake: 0, winningPointsAnswer: 0, pointAnswersCount: 0, winner: null, stake: 0, teams, generator: envidoAnswerGeneratorSequence(), sayEnvido(command, player) {
+            const playerTeamIdx = player.teamIdx;
+            if (envido.teamIdx !== playerTeamIdx && envido.possibleAnswerCommands.includes(command)) {
+                const opponentIdx = Number(!playerTeamIdx);
+                const { accept, decline, replace, next } = exports.EnvidoCalculator[command]({
+                    stake: envido.stake,
+                    declineStake: envido.declineStake,
+                    teams,
+                    matchPoint,
+                });
+                envido.teamIdx = playerTeamIdx;
+                envido.stake += accept;
+                envido.declineStake += decline;
+                envido.generator = envidoAnswerGeneratorSequence();
+                envido.players = teams[opponentIdx].players;
+                envido.started = true;
+                envido.answered = false;
+                if (replace) {
+                    envido.stake = replace;
+                }
+                envido.possibleAnswerCommands = next;
+            }
+            return envido;
+        },
+        sayPoints(player, points) {
+            if (!envido.accepted) {
+                throw new Error(types_2.GAME_ERROR.ENVIDO_NOT_ACCEPTED);
+            }
+            if (!envido.winningPlayer || !envido.winningPointsAnswer) {
+                envido.winningPlayer = player;
+                envido.winningPointsAnswer = points;
+            }
+            else {
+                if (points > envido.winningPointsAnswer) {
+                    envido.winningPlayer = player;
+                    envido.winningPointsAnswer = points;
+                }
+                if (points === envido.winningPointsAnswer) {
+                    const forehandWinner = table.getPlayerPosition(player.key, true) <
+                        table.getPlayerPosition(envido.winningPlayer.key, true)
+                        ? player
+                        : envido.winningPlayer;
+                    envido.winningPlayer = forehandWinner;
+                }
+            }
+            envido.pointAnswersCount++;
+            if (envido.pointAnswersCount >= envido.players.length) {
+                envido.finished = true;
+                envido.winner = teams[envido.winningPlayer.teamIdx];
+            }
+            return envido;
+        },
+        sayAnswer(player, answer) {
+            const opponentIdx = Number(!player.teamIdx);
+            if (answer === null || player.teamIdx === envido.teamIdx) {
+                return envido;
+            }
+            if (answer) {
+                envido.accepted = true;
+                envido.generator = envidoAnswerGeneratorSequence();
+                envido.turn = 0;
+                table.players.forEach((player) => player.calculateEnvido());
+                envido.players = table.getPlayersForehandFirst();
+            }
+            if (answer === false) {
+                envido.finished = true;
+                const opponentTeam = teams[opponentIdx];
+                opponentTeam.addPoints(matchPoint, envido.declineStake);
+                envido.winner = opponentTeam;
+            }
+            envido.answered = true;
+            envido.teamIdx = opponentIdx;
+            envido.answer = answer;
+            envido.turn = 0;
+            return envido;
+        },
+        setTeam(idx) {
+            envido.teamIdx = idx;
+            return envido.teamIdx;
+        },
+        setTurn(turn) {
+            envido.turn = turn;
+            return envido.turn;
+        },
+        setCurrentPlayer(player) {
+            envido.currentPlayer = player;
+            return envido.currentPlayer;
+        },
+        getNextPlayer() {
+            return envido.generator.next();
+        } });
+    return envido;
+}
+exports.Envido = Envido;

package/dist/lib/classes/Flor.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -1,23 +1,26 @@
-import { IHand } from "./Hand";
-import { IMatch } from "./Match";
-import { IPlayInstance } from "./Play";
-import { IPlayer } from "./Player";
-import { ITeam } from "./Team";
-export type IWinnerCallback = (winner: ITeam, teams: [ITeam, ITeam]) => Promise<void>;
-export type ITurnCallback = (play: IPlayInstance, newHandJustStarted: boolean) => Promise<void>;
-export type ITrucoCallback = (play: IPlayInstance) => Promise<void>;
-export interface IGameLoop {
-    _onTruco: ITrucoCallback;
-    _onTurn: ITurnCallback;
-    _onWinner: IWinnerCallback;
-    currentPlayer: IPlayer | null;
-    currentHand: IHand | null;
-    lastCheckedHand: number | null;
-    teams: Array<ITeam>;
-    winner: ITeam | null;
-    onTurn: (callback: ITurnCallback) => IGameLoop;
-    onWinner: (callback: IWinnerCallback) => IGameLoop;
-    onTruco: (callback: ITrucoCallback) => IGameLoop;
-    begin: () => Promise<void>;
-}
-export declare const GameLoop: (match: IMatch) => IGameLoop;
+import { IHand } from "./Hand";
+import { IMatch } from "./Match";
+import { IPlayInstance } from "./Play";
+import { IPlayer } from "./Player";
+import { ITeam } from "./Team";
+export type IWinnerCallback = (winner: ITeam, teams: [ITeam, ITeam]) => Promise<void>;
+export type ITurnCallback = (play: IPlayInstance, newHandJustStarted: boolean) => Promise<void>;
+export type ITrucoCallback = (play: IPlayInstance) => Promise<void>;
+export type IEnvidoCallback = (play: IPlayInstance, pointsRound: boolean) => Promise<void>;
+export interface IGameLoop {
+    _onTruco: ITrucoCallback;
+    _onTurn: ITurnCallback;
+    _onWinner: IWinnerCallback;
+    _onEnvido: IEnvidoCallback;
+    currentPlayer: IPlayer | null;
+    currentHand: IHand | null;
+    lastCheckedHand: number | null;
+    teams: Array<ITeam>;
+    winner: ITeam | null;
+    onTurn: (callback: ITurnCallback) => IGameLoop;
+    onWinner: (callback: IWinnerCallback) => IGameLoop;
+    onTruco: (callback: ITrucoCallback) => IGameLoop;
+    onEnvido: (callback: IEnvidoCallback) => IGameLoop;
+    begin: () => Promise<void>;
+}
+export declare const GameLoop: (match: IMatch) => IGameLoop;