trucoshi 0.3.3 → 0.3.4

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

package/dist/lib/classes/Flor.js

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

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

@@ -6,10 +6,12 @@ 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;
@@ -18,6 +20,7 @@ export interface IGameLoop {
     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

@@ -13,6 +13,7 @@ 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(),
@@ -33,6 +34,10 @@ const GameLoop = (match) => {
             gameloop._onWinner = callback;
             return gameloop;
         },
+        onEnvido: (callback) => {
+            gameloop._onEnvido = callback;
+            return gameloop;
+        },
         begin() {
             var _a;
             return __awaiter(this, void 0, void 0, function* () {
@@ -44,26 +49,48 @@ const GameLoop = (match) => {
                         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", e);
+                            console.error("GAME LOOP ERROR - WAITING TRUCO ANSWER", e);
                         }
                         continue;
                     }
                     if (play.state === types_1.EHandState.WAITING_PLAY) {
-                        play.player.setTurn(true);
                         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", e);
+                            console.error("GAME LOOP ERROR - WAITING PLAY", e);
                         }
-                        play.player.setTurn(false);
                         continue;
                     }
                 }

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

@@ -1,5 +1,6 @@
-import { EHandState, EnvidoState, IHandCommands } from "../../types";
+import { EHandState, IHandCommands } from "../../types";
 import { ICard, IDeck } from "./Deck";
+import { IEnvido } from "./Envido";
 import { IMatch } from "./Match";
 import { IPlayInstance } from "./Play";
 import { IPlayer } from "./Player";
@@ -16,16 +17,19 @@ export interface IHand {
     started: boolean;
     points: IHandPoints;
     truco: ITruco;
-    envido: EnvidoState;
+    envido: IEnvido;
     rounds: Array<IRound>;
     _currentPlayer: IPlayer | null;
     get currentPlayer(): IPlayer | null;
     set currentPlayer(player: IPlayer | null);
     currentRound: IRound | null;
-    commands: IHandCommands;
+    say: IHandCommands;
     finished: () => boolean;
+    setTurnCommands(): void;
     play(prevHand: IHand | null): IPlayInstance | null;
     nextTurn(): void;
+    endEnvido(): void;
+    sayEnvidoPoints(player: IPlayer, points: number): IEnvido;
     use(idx: number, card: ICard): ICard | null;
     pushRound(round: IRound): IRound;
     setTurn(turn: number): IPlayer;

package/dist/lib/classes/Hand.js

@@ -4,6 +4,7 @@ exports.Hand = void 0;
 const types_1 = require("../../types");
 const utils_1 = require("../utils");
 const Deck_1 = require("./Deck");
+const Envido_1 = require("./Envido");
 const Play_1 = require("./Play");
 const Round_1 = require("./Round");
 const Truco_1 = require("./Truco");
@@ -12,11 +13,12 @@ function Hand(match, deck, idx) {
         for (const player of team.players) {
             player.enable();
             player.setHand(deck.takeThree());
+            player.resetCommands();
         }
     }
     function* roundsGeneratorSequence() {
         let currentRoundIdx = 0;
-        let forehandTeamIdx = match.table.player(hand.turn).teamIdx;
+        let forehandTeamIdx = match.table.getPlayer(hand.turn).teamIdx;
         while (currentRoundIdx < 3 && !hand.finished()) {
             const round = (0, Round_1.Round)();
             hand.setCurrentRound(round);
@@ -24,17 +26,25 @@ function Hand(match, deck, idx) {
             let previousRound = hand.rounds[currentRoundIdx - 1];
             // Put previous round winner as forehand
             if (previousRound && previousRound.winner) {
-                if (!previousRound.tie) {
-                    const newTurn = match.table.getPlayerPosition(previousRound.winner.id);
+                if (previousRound.tie) {
+                    hand.setTurn(match.table.forehandIdx);
+                }
+                else {
+                    const newTurn = match.table.getPlayerPosition(previousRound.winner.key);
                     if (newTurn !== -1) {
                         hand.setTurn(newTurn);
                     }
                 }
-                else {
-                    hand.setTurn(match.table.forehandIdx);
-                }
             }
             while (round.turn < match.table.players.length) {
+                while (hand.state === types_1.EHandState.WAITING_ENVIDO_ANSWER ||
+                    hand.state === types_1.EHandState.WAITING_ENVIDO_POINTS_ANSWER) {
+                    const { value } = hand.envido.getNextPlayer();
+                    if (value && value.currentPlayer) {
+                        hand.setCurrentPlayer(value.currentPlayer);
+                        yield hand;
+                    }
+                }
                 while (hand.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
                     const { value } = hand.truco.getNextPlayer();
                     if (value && value.currentPlayer) {
@@ -46,11 +56,8 @@ function Hand(match, deck, idx) {
                     hand.setState(types_1.EHandState.FINISHED);
                     break;
                 }
-                const player = match.table.player(hand.turn);
+                const player = match.table.getPlayer(hand.turn);
                 hand.setCurrentPlayer(player);
-                if (player.disabled) {
-                    hand.setCurrentPlayer(null);
-                }
                 if (match.teams.some((team) => team.isTeamDisabled())) {
                     hand.setState(types_1.EHandState.FINISHED);
                     break;
@@ -67,44 +74,18 @@ function Hand(match, deck, idx) {
             if (winnerTeamIdx !== null) {
                 hand.addPoints(winnerTeamIdx, hand.truco.state);
                 hand.setState(types_1.EHandState.FINISHED);
+                if (hand.envido.winner && hand.envido.winningPlayer) {
+                    hand.addPoints(hand.envido.winningPlayer.teamIdx, hand.envido.answer === false ? hand.envido.declineStake : hand.envido.stake);
+                }
             }
             currentRoundIdx++;
         }
         yield hand;
     }
     const roundsGenerator = roundsGeneratorSequence();
-    const commands = {
-        [types_1.ESayCommand.MAZO]: (player) => {
-            hand.disablePlayer(player);
-            hand.setState(types_1.EHandState.WAITING_PLAY);
-            hand.truco.reset();
-            hand.nextTurn();
-        },
-        [types_1.ESayCommand.TRUCO]: (player) => {
-            hand.truco.sayTruco(player, () => {
-                hand.setState(types_1.EHandState.WAITING_FOR_TRUCO_ANSWER);
-            });
-        },
-        [types_1.ESayCommand.QUIERO]: (player) => {
-            if (hand.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
-                hand.truco.sayAnswer(player, true, () => {
-                    hand.setState(types_1.EHandState.WAITING_PLAY);
-                });
-            }
-        },
-        [types_1.ESayCommand.NO_QUIERO]: (player) => {
-            if (hand.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
-                hand.truco.sayAnswer(player, false, () => {
-                    hand.setState(types_1.EHandState.WAITING_PLAY);
-                });
-            }
-        },
-        [types_1.ESayCommand.FLOR]: () => { },
-        [types_1.ESayCommand.CONTRAFLOR]: () => { },
-        [types_1.EEnvidoCommand.ENVIDO]: () => { },
-        [types_1.EEnvidoCommand.ENVIDO_ENVIDO]: () => { },
-        [types_1.EEnvidoCommand.REAL_ENVIDO]: () => { },
-        [types_1.EEnvidoCommand.FALTA_ENVIDO]: () => { },
+    const trucoCommand = (player) => {
+        hand.truco.sayTruco(player);
+        hand.setState(types_1.EHandState.WAITING_FOR_TRUCO_ANSWER);
     };
     const hand = {
         idx,
@@ -112,11 +93,55 @@ function Hand(match, deck, idx) {
         turn: Number(match.table.forehandIdx),
         state: types_1.EHandState.WAITING_PLAY,
         rounds: [],
+        envido: (0, Envido_1.Envido)(match.teams, match.matchPoint, match.table),
         truco: (0, Truco_1.Truco)(match.teams),
-        envido: {
-            accept: 1,
-            decline: 2,
-            teamIdx: null,
+        setTurnCommands() {
+            var _a;
+            match.table.players.forEach((player) => {
+                player.resetCommands();
+            });
+            if (hand.rounds.length === 1) {
+                if (hand.envido.teamIdx !== null && !hand.envido.answered) {
+                    match.teams[Number(!hand.envido.teamIdx)].players.forEach((player) => {
+                        hand.envido.possibleAnswerCommands.forEach((command) => {
+                            player._commands.add(command);
+                        });
+                    });
+                }
+                if (hand.envido.accepted && !hand.envido.finished && hand.envido.winningPointsAnswer) {
+                    (_a = hand.currentPlayer) === null || _a === void 0 ? void 0 : _a._commands.add(types_1.EEnvidoAnswerCommand.SON_BUENAS);
+                }
+                if (hand.currentPlayer &&
+                    !hand.envido.started &&
+                    (hand.truco.state < 2 || (hand.truco.state === 2 && hand.truco.answer === null))) {
+                    for (const key in types_1.EEnvidoCommand) {
+                        hand.currentPlayer._commands.add(key);
+                    }
+                }
+            }
+            if (hand.envido.finished || !hand.envido.started) {
+                if (hand.truco.waitingAnswer) {
+                    match.teams[Number(!hand.truco.teamIdx)].players.forEach((player) => {
+                        const nextCommand = hand.truco.getNextTrucoCommand();
+                        if (nextCommand) {
+                            player._commands.add(nextCommand);
+                        }
+                        player._commands.add(types_1.EAnswerCommand.QUIERO);
+                        player._commands.add(types_1.EAnswerCommand.NO_QUIERO);
+                    });
+                }
+                else {
+                    match.table.players.forEach((player) => {
+                        if (hand.truco.teamIdx !== player.teamIdx) {
+                            const nextCommand = hand.truco.getNextTrucoCommand();
+                            if (nextCommand) {
+                                player._commands.add(nextCommand);
+                            }
+                        }
+                        player._commands.add(types_1.ESayCommand.MAZO);
+                    });
+                }
+            }
         },
         points: [0, 0],
         currentRound: null,
@@ -125,15 +150,86 @@ function Hand(match, deck, idx) {
             hand._currentPlayer = player;
         },
         get currentPlayer() {
+            let player = hand._currentPlayer;
+            if (hand.state === types_1.EHandState.WAITING_ENVIDO_ANSWER ||
+                hand.state === types_1.EHandState.WAITING_ENVIDO_POINTS_ANSWER) {
+                player = hand.envido.currentPlayer;
+            }
             if (hand.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
-                return hand.truco.currentPlayer;
+                player = hand.truco.currentPlayer;
             }
-            return hand._currentPlayer;
+            if (player && player.disabled) {
+                return null;
+            }
+            return player;
+        },
+        say: {
+            [types_1.ESayCommand.MAZO]: (player) => {
+                hand.disablePlayer(player);
+                hand.nextTurn();
+            },
+            [types_1.EAnswerCommand.QUIERO]: (player) => {
+                if (hand.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
+                    hand.truco.sayAnswer(player, true);
+                    hand.setState(types_1.EHandState.WAITING_PLAY);
+                }
+                if (hand.state === types_1.EHandState.WAITING_ENVIDO_ANSWER) {
+                    hand.envido.sayAnswer(player, true);
+                    hand.setState(types_1.EHandState.WAITING_ENVIDO_POINTS_ANSWER);
+                }
+            },
+            [types_1.EAnswerCommand.NO_QUIERO]: (player) => {
+                if (hand.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
+                    hand.truco.sayAnswer(player, false);
+                    hand.setState(types_1.EHandState.WAITING_PLAY);
+                }
+                if (hand.state === types_1.EHandState.WAITING_ENVIDO_ANSWER) {
+                    hand.envido.sayAnswer(player, false);
+                    hand.endEnvido();
+                }
+            },
+            [types_1.EEnvidoAnswerCommand.SON_BUENAS]: (player) => {
+                if (hand.state === types_1.EHandState.WAITING_ENVIDO_POINTS_ANSWER) {
+                    hand.envido.sayPoints(player, 0);
+                    hand.endEnvido();
+                }
+            },
+            [types_1.ETrucoCommand.TRUCO]: trucoCommand,
+            [types_1.ETrucoCommand.RE_TRUCO]: trucoCommand,
+            [types_1.ETrucoCommand.VALE_CUATRO]: trucoCommand,
+            [types_1.EEnvidoCommand.ENVIDO]: (player) => {
+                hand.envido.sayEnvido(types_1.EEnvidoCommand.ENVIDO, player);
+                hand.setState(types_1.EHandState.WAITING_ENVIDO_ANSWER);
+            },
+            [types_1.EEnvidoCommand.REAL_ENVIDO]: (player) => {
+                hand.envido.sayEnvido(types_1.EEnvidoCommand.REAL_ENVIDO, player);
+                hand.setState(types_1.EHandState.WAITING_ENVIDO_ANSWER);
+            },
+            [types_1.EEnvidoCommand.FALTA_ENVIDO]: (player) => {
+                hand.envido.sayEnvido(types_1.EEnvidoCommand.FALTA_ENVIDO, player);
+                hand.setState(types_1.EHandState.WAITING_ENVIDO_ANSWER);
+            },
+            [types_1.EFlorCommand.FLOR]: () => { },
+            [types_1.EFlorCommand.CONTRAFLOR]: () => { },
         },
-        commands,
         play(prevHand) {
             return (0, Play_1.PlayInstance)(hand, prevHand, match.teams);
         },
+        sayEnvidoPoints(player, points) {
+            const { winner } = hand.envido.sayPoints(player, points);
+            if (winner) {
+                hand.endEnvido();
+            }
+            return hand.envido;
+        },
+        endEnvido() {
+            if (hand.truco.waitingAnswer) {
+                hand.setState(types_1.EHandState.WAITING_FOR_TRUCO_ANSWER);
+            }
+            else {
+                hand.setState(types_1.EHandState.WAITING_PLAY);
+            }
+        },
         use(idx, card) {
             hand.started = true;
             const player = hand.currentPlayer;
@@ -160,7 +256,9 @@ function Hand(match, deck, idx) {
             (_a = hand.currentRound) === null || _a === void 0 ? void 0 : _a.nextTurn();
         },
         getNextPlayer() {
-            return roundsGenerator.next();
+            const player = roundsGenerator.next();
+            hand.setTurnCommands();
+            return player;
         },
         disablePlayer(player) {
             match.teams[player.teamIdx].disable(player);
@@ -174,7 +272,7 @@ function Hand(match, deck, idx) {
         },
         setTurn(turn) {
             hand.turn = turn;
-            return match.table.player(hand.turn);
+            return match.table.getPlayer(hand.turn);
         },
         setCurrentRound(round) {
             hand.currentRound = round;

package/dist/lib/classes/Lobby.js

@@ -99,7 +99,7 @@ function Lobby(teamSize) {
                 lobby.teams[1].players.length !== actualTeamSize) {
                 throw new Error(types_1.GAME_ERROR.UNEXPECTED_TEAM_SIZE);
             }
-            lobby.table = (0, Table_1.Table)(lobby.players, lobby.teams);
+            lobby.table = (0, Table_1.Table)(lobby.players);
             lobby.gameLoop = (0, GameLoop_1.GameLoop)((0, Match_1.Match)(lobby.table, lobby.teams, matchPoint));
             lobby.started = true;
             return lobby.gameLoop;

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

@@ -8,6 +8,7 @@ export interface IMatch {
     winner: ITeam | null;
     prevHand: IHand | null;
     currentHand: IHand | null;
+    matchPoint: number;
     table: ITable;
     play(): IPlayInstance | null;
     addPoints(points: IHandPoints): [ITeam, ITeam];

package/dist/lib/classes/Match.js

@@ -47,6 +47,7 @@ function Match(table, teams = [], matchPoint = 9) {
     const handsGenerator = handsGeneratorSequence();
     const match = {
         winner: null,
+        matchPoint,
         teams: teams,
         hands: [],
         table,

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

@@ -1,5 +1,6 @@
-import { ECommand, EHandState, EnvidoState } from "../../types";
+import { ECommand, EHandState } from "../../types";
 import { ICard } from "./Deck";
+import { IEnvido } from "./Envido";
 import { IHand } from "./Hand";
 import { IPlayer } from "./Player";
 import { IRound } from "./Round";
@@ -11,11 +12,11 @@ export interface IPlayInstance {
     roundIdx: number;
     state: EHandState;
     truco: ITruco;
-    envido: EnvidoState;
+    envido: IEnvido;
     player: IPlayer | null;
     rounds: Array<IRound> | null;
     prevHand: IHand | null;
     use(idx: number, card: ICard): ICard | null;
-    say(command: ECommand, player: IPlayer): ECommand | null;
+    say(command: ECommand | number, player: IPlayer): ECommand | number | null;
 }
 export declare function PlayInstance(hand: IHand, prevHand: IHand | null, teams: [ITeam, ITeam]): IPlayInstance;