trucoshi 0.3.4 → 0.3.5

package/dist/lib/classes/Envido.js

@@ -1,167 +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.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;
+"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

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

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

@@ -1,26 +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 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;
+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;

package/dist/lib/classes/GameLoop.js

@@ -1,105 +1,106 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GameLoop = void 0;
-const types_1 = require("../../types");
-const GameLoop = (match) => {
-    let gameloop = {
-        _onEnvido: () => Promise.resolve(),
-        _onTruco: () => Promise.resolve(),
-        _onTurn: () => Promise.resolve(),
-        _onWinner: () => Promise.resolve(),
-        teams: [],
-        winner: null,
-        currentPlayer: null,
-        currentHand: null,
-        lastCheckedHand: null,
-        onTruco: (callback) => {
-            gameloop._onTruco = callback;
-            return gameloop;
-        },
-        onTurn: (callback) => {
-            gameloop._onTurn = callback;
-            return gameloop;
-        },
-        onWinner: (callback) => {
-            gameloop._onWinner = callback;
-            return gameloop;
-        },
-        onEnvido: (callback) => {
-            gameloop._onEnvido = callback;
-            return gameloop;
-        },
-        begin() {
-            var _a;
-            return __awaiter(this, void 0, void 0, function* () {
-                gameloop.teams = match.teams;
-                while (!match.winner) {
-                    const play = match.play();
-                    gameloop.currentHand = match.currentHand;
-                    if (!play || !play.player) {
-                        continue;
-                    }
-                    gameloop.currentPlayer = play.player;
-                    if (play.state === types_1.EHandState.WAITING_ENVIDO_ANSWER) {
-                        try {
-                            play.player.setTurn(true);
-                            yield gameloop._onEnvido(play, false);
-                            play.player.setTurn(false);
-                        }
-                        catch (e) {
-                            console.error("GAME LOOP ERROR - WAITING ENVIDO ANSWER", e);
-                        }
-                        continue;
-                    }
-                    if (play.state === types_1.EHandState.WAITING_ENVIDO_POINTS_ANSWER) {
-                        try {
-                            play.player.setEnvidoTurn(true);
-                            yield gameloop._onEnvido(play, true);
-                            play.player.setEnvidoTurn(false);
-                        }
-                        catch (e) {
-                            console.error("GAME LOOP ERROR - WAITING ENVIDO POINTS ANSWER", e);
-                        }
-                        continue;
-                    }
-                    if (play.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
-                        try {
-                            yield gameloop._onTruco(play);
-                        }
-                        catch (e) {
-                            console.error("GAME LOOP ERROR - WAITING TRUCO ANSWER", e);
-                        }
-                        continue;
-                    }
-                    if (play.state === types_1.EHandState.WAITING_PLAY) {
-                        try {
-                            play.player.setTurn(true);
-                            const newHandJustStarted = gameloop.lastCheckedHand !== ((_a = play.prevHand) === null || _a === void 0 ? void 0 : _a.idx);
-                            gameloop.lastCheckedHand = play.prevHand ? play.prevHand.idx : null;
-                            yield gameloop._onTurn(play, newHandJustStarted);
-                            play.player.setTurn(false);
-                        }
-                        catch (e) {
-                            console.error("GAME LOOP ERROR - WAITING PLAY", e);
-                        }
-                        continue;
-                    }
-                }
-                gameloop.winner = match.winner;
-                gameloop.currentPlayer = null;
-                yield gameloop._onWinner(match.winner, match.teams);
-            });
-        },
-    };
-    return gameloop;
-};
-exports.GameLoop = GameLoop;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GameLoop = void 0;
+const types_1 = require("../../types");
+const GameLoop = (match) => {
+    let gameloop = {
+        _onEnvido: () => Promise.resolve(),
+        _onTruco: () => Promise.resolve(),
+        _onTurn: () => Promise.resolve(),
+        _onWinner: () => Promise.resolve(),
+        teams: [],
+        winner: null,
+        currentPlayer: null,
+        currentHand: null,
+        lastCheckedHand: null,
+        onTruco: (callback) => {
+            gameloop._onTruco = callback;
+            return gameloop;
+        },
+        onTurn: (callback) => {
+            gameloop._onTurn = callback;
+            return gameloop;
+        },
+        onWinner: (callback) => {
+            gameloop._onWinner = callback;
+            return gameloop;
+        },
+        onEnvido: (callback) => {
+            gameloop._onEnvido = callback;
+            return gameloop;
+        },
+        begin() {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function* () {
+                gameloop.teams = match.teams;
+                while (!match.winner) {
+                    const play = match.play();
+                    gameloop.currentHand = match.currentHand;
+                    if (!play || !play.player) {
+                        continue;
+                    }
+                    gameloop.currentPlayer = play.player;
+                    if (play.state === types_1.EHandState.WAITING_ENVIDO_ANSWER) {
+                        try {
+                            play.player.setTurn(true);
+                            yield gameloop._onEnvido(play, false);
+                            play.player.setTurn(false);
+                        }
+                        catch (e) {
+                            console.error("GAME LOOP ERROR - WAITING ENVIDO ANSWER", e);
+                        }
+                        continue;
+                    }
+                    if (play.state === types_1.EHandState.WAITING_ENVIDO_POINTS_ANSWER) {
+                        try {
+                            play.player.setEnvidoTurn(true);
+                            yield gameloop._onEnvido(play, true);
+                            play.player.setEnvidoTurn(false);
+                        }
+                        catch (e) {
+                            console.error("GAME LOOP ERROR - WAITING ENVIDO POINTS ANSWER", e);
+                        }
+                        continue;
+                    }
+                    if (play.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
+                        try {
+                            yield gameloop._onTruco(play);
+                        }
+                        catch (e) {
+                            console.error("GAME LOOP ERROR - WAITING TRUCO ANSWER", e);
+                        }
+                        continue;
+                    }
+                    if (play.state === types_1.EHandState.WAITING_PLAY) {
+                        try {
+                            play.player.setTurn(true);
+                            const newHandJustStarted = gameloop.lastCheckedHand !== ((_a = play.prevHand) === null || _a === void 0 ? void 0 : _a.idx) &&
+                                ((_b = gameloop.currentHand) === null || _b === void 0 ? void 0 : _b.rounds[0].cards.length) === 0;
+                            gameloop.lastCheckedHand = play.prevHand ? play.prevHand.idx : null;
+                            yield gameloop._onTurn(play, newHandJustStarted);
+                            play.player.setTurn(false);
+                        }
+                        catch (e) {
+                            console.error("GAME LOOP ERROR - WAITING PLAY", e);
+                        }
+                        continue;
+                    }
+                }
+                gameloop.winner = match.winner;
+                gameloop.currentPlayer = null;
+                yield gameloop._onWinner(match.winner, match.teams);
+            });
+        },
+    };
+    return gameloop;
+};
+exports.GameLoop = GameLoop;