trucoshi 0.3.3 → 0.3.4

package/dist/lib/classes/Play.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlayInstance = void 0;
-const types_1 = require("../../types");
+const types_1 = require("../types");
 function PlayInstance(hand, prevHand, teams) {
     const instance = {
         state: hand.state,
@@ -17,13 +17,28 @@ function PlayInstance(hand, prevHand, teams) {
             return hand.use(idx, card);
         },
         say(command, player) {
-            hand.commands[command](player);
-            return command;
+            try {
+                const fn = hand.say[command];
+                if (fn) {
+                    if (!player.commands.includes(command)) {
+                        throw new Error(types_1.GAME_ERROR.INVALID_COMAND);
+                    }
+                    fn(player);
+                }
+                else {
+                    if (!player.envido.includes(command)) {
+                        throw new Error(types_1.GAME_ERROR.INVALID_ENVIDO_POINTS);
+                    }
+                    hand.sayEnvidoPoints(player, command);
+                }
+                return command;
+            }
+            catch (e) {
+                console.error(e);
+                return null;
+            }
         },
     };
-    if (!hand.truco.waitingAnswer) {
-        teams.forEach((team) => team.players.forEach((player) => player._commands.add(types_1.ESayCommand.MAZO)));
-    }
     return instance;
 }
 exports.PlayInstance = PlayInstance;

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

@@ -6,25 +6,30 @@ export interface IPlayer {
     key: string;
     session?: string;
     hand: Array<ICard>;
+    envido: Array<number>;
     _commands: Set<ECommand>;
     get commands(): Array<ECommand>;
     usedHand: Array<ICard>;
     prevHand: Array<ICard>;
     isTurn: boolean;
+    hasFlor: boolean;
+    isEnvidoTurn: boolean;
     isOwner: boolean;
     disabled: boolean;
     ready: boolean;
+    resetCommands(): void;
+    calculateEnvido(): Array<number>;
     setTurn(turn: boolean): void;
+    setEnvidoTurn(turn: boolean): void;
     getPublicPlayer(): IPublicPlayer;
     setSession(session: string): void;
     enable(): void;
     disable(): void;
-    setOwner(owner: boolean): void;
     setReady(ready: boolean): void;
     setHand(hand: Array<ICard>): Array<ICard>;
     useCard(idx: number, card: ICard): ICard | null;
 }
-export type IPublicPlayer = Pick<IPlayer, "id" | "key" | "disabled" | "ready" | "hand" | "usedHand" | "prevHand" | "teamIdx" | "session" | "isTurn" | "isOwner"> & {
+export type IPublicPlayer = Pick<IPlayer, "id" | "key" | "disabled" | "ready" | "hand" | "envido" | "usedHand" | "prevHand" | "teamIdx" | "session" | "hasFlor" | "isTurn" | "isEnvidoTurn" | "isOwner"> & {
     commands: Array<ECommand>;
 };
 export declare function Player(key: string, id: string, teamIdx: number, isOwner?: boolean): IPlayer;

package/dist/lib/classes/Player.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Player = void 0;
+const types_1 = require("../../types");
+const filterEnvidoCommands = (command) => Object.values(types_1.EEnvidoCommand).includes(command) ||
+    Object.values(types_1.EAnswerCommand).includes(command) ||
+    Object.values(types_1.EEnvidoAnswerCommand).includes(command);
+const filterNotEnvidoCommands = (command) => !Object.values(types_1.EEnvidoCommand).includes(command) &&
+    !Object.values(types_1.EEnvidoAnswerCommand).includes(command);
 function Player(key, id, teamIdx, isOwner = false) {
     const player = {
         key,
@@ -11,31 +17,41 @@ function Player(key, id, teamIdx, isOwner = false) {
         _commands: new Set(),
         usedHand: [],
         prevHand: [],
+        envido: [],
         isOwner,
         isTurn: false,
+        hasFlor: false,
+        isEnvidoTurn: false,
         disabled: false,
         ready: false,
         get commands() {
             return Array.from(player._commands.values());
         },
-        setOwner(owner) {
-            player.isOwner = owner;
+        resetCommands() {
+            player._commands = new Set();
         },
         setTurn(turn) {
             player.isTurn = turn;
         },
+        setEnvidoTurn(turn) {
+            player.isTurn = turn;
+            player.isEnvidoTurn = turn;
+        },
         getPublicPlayer() {
-            const { id, key, commands, disabled, ready, usedHand, prevHand, teamIdx, isTurn, isOwner, } = player;
+            const { id, key, commands, disabled, ready, usedHand, prevHand, teamIdx, hasFlor, isTurn, isEnvidoTurn, isOwner, envido, } = player;
             return {
                 id,
                 key,
                 commands,
                 disabled,
                 ready,
+                envido,
                 usedHand,
                 prevHand,
                 teamIdx,
+                hasFlor,
                 isTurn,
+                isEnvidoTurn,
                 isOwner,
                 hand: player.hand.map(() => "xx"),
                 session: undefined,
@@ -53,6 +69,42 @@ function Player(key, id, teamIdx, isOwner = false) {
         setReady(ready) {
             player.ready = ready;
         },
+        calculateEnvido() {
+            let flor = null;
+            const hand = player.hand.map((c) => {
+                let num = c.charAt(0);
+                const palo = c.charAt(1);
+                if (num === "p") {
+                    num = "10";
+                }
+                if (num === "c") {
+                    num = "11";
+                }
+                if (num === "r") {
+                    num = "12";
+                }
+                if (flor === null || flor === palo) {
+                    flor = palo;
+                }
+                else {
+                    flor = null;
+                }
+                return [num, palo];
+            });
+            player.hasFlor = Boolean(flor);
+            const possibles = hand.flatMap((v, i) => hand.slice(i + 1).map((w) => [v, w]));
+            const actual = possibles.filter((couple) => couple[0][1] === couple[1][1]);
+            player.envido = actual.map((couple) => {
+                const n1 = couple[0][0].at(-1);
+                const n2 = couple[1][0].at(-1);
+                return Number(n1) + Number(n2) + 20;
+            });
+            if (player.envido.length) {
+                return player.envido;
+            }
+            player.envido = Array.from(new Set(hand.map((c) => Number(c[0].at(-1)))));
+            return player.envido;
+        },
         setHand(hand) {
             player.prevHand = [...player.usedHand];
             player.hand = hand;
@@ -61,10 +113,10 @@ function Player(key, id, teamIdx, isOwner = false) {
         },
         useCard(idx, card) {
             if (player.hand[idx] && player.hand[idx] === card) {
-                const card = player.hand.splice(idx, 1)[0];
-                player.usedHand.push(card);
+                const playedCard = player.hand.splice(idx, 1)[0];
+                player.usedHand.push(playedCard);
                 player.isTurn = false;
-                return card;
+                return playedCard;
             }
             return null;
         },

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

@@ -1,12 +1,12 @@
 import { IPlayedCard } from "./Deck";
 import { IPlayer } from "./Player";
-import { ITeam } from "./Team";
 export interface ITable {
     forehandIdx: number;
     cards: Array<Array<IPlayedCard>>;
     players: Array<IPlayer>;
     nextTurn(): IPlayer;
-    player(idx?: number): IPlayer;
-    getPlayerPosition(id: string): number;
+    getPlayer(idx?: number, forehandFirst?: boolean): IPlayer;
+    getPlayerPosition(key: string, forehandFirst?: boolean): number;
+    getPlayersForehandFirst(forehandIdx?: number): Array<IPlayer>;
 }
-export declare function Table(players: Array<IPlayer>, teams: Array<ITeam>): ITable;
+export declare function Table(players: Array<IPlayer>): ITable;

package/dist/lib/classes/Table.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Table = void 0;
-function Table(players, teams) {
+function Table(players) {
     const table = {
         players,
         cards: [],
@@ -13,16 +13,24 @@ function Table(players, teams) {
             else {
                 table.forehandIdx = 0;
             }
-            return table.player();
+            return table.getPlayer();
         },
-        getPlayerPosition(id) {
-            return table.players.findIndex((p) => p.id === id);
+        getPlayerPosition(key, forehandFirst = false) {
+            const array = forehandFirst ? table.getPlayersForehandFirst() : table.players;
+            return array.findIndex((p) => p.key === key);
         },
-        player(idx) {
+        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);
+        },
+        getPlayer(idx, forehandFirst = false) {
+            const array = forehandFirst ? table.getPlayersForehandFirst() : table.players;
             if (idx !== undefined) {
-                return table.players[idx];
+                return array[idx];
             }
-            return table.players[table.forehandIdx];
+            return array[0];
         },
     };
     return table;

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

@@ -1,5 +1,11 @@
+import { ECommand, ETrucoCommand } from "../../types";
 import { IPlayer } from "./Player";
 import { ITeam } from "./Team";
+interface IPlayerCurrentCommands {
+    player: IPlayer;
+    add: Array<ECommand>;
+    del: Array<ECommand>;
+}
 export interface ITruco {
     state: 1 | 2 | 3 | 4;
     teamIdx: 0 | 1 | null;
@@ -8,14 +14,17 @@ export interface ITruco {
     turn: number;
     teams: [ITeam, ITeam];
     players: Array<IPlayer>;
+    currentCommands: Array<IPlayerCurrentCommands>;
     currentPlayer: IPlayer | null;
     generator: Generator<ITruco, void, unknown>;
-    sayTruco(player: IPlayer, callback: () => void): ITruco;
-    sayAnswer(player: IPlayer, answer: boolean | null, callback: () => void): ITruco;
+    sayTruco(player: IPlayer): ITruco;
+    sayAnswer(player: IPlayer, answer: boolean | null): ITruco;
     setTurn(turn: number): number;
     setTeam(idx: 0 | 1): 0 | 1;
+    getNextTrucoCommand(): ETrucoCommand | null;
     setCurrentPlayer(player: IPlayer | null): IPlayer | null;
     getNextPlayer(): IteratorResult<ITruco, ITruco | void>;
     reset(): void;
 }
 export declare function Truco(teams: [ITeam, ITeam]): ITruco;
+export {};

package/dist/lib/classes/Truco.js

@@ -10,6 +10,12 @@ const EMPTY_TRUCO = {
     currentPlayer: null,
     players: [],
 };
+const TRUCO_STATE_MAP = {
+    1: types_1.ETrucoCommand.TRUCO,
+    2: types_1.ETrucoCommand.RE_TRUCO,
+    3: types_1.ETrucoCommand.VALE_CUATRO,
+    4: null,
+};
 function Truco(teams) {
     function* trucoAnswerGeneratorSequence() {
         let i = 0;
@@ -30,18 +36,17 @@ function Truco(teams) {
         }
         yield truco;
     }
-    const truco = Object.assign(Object.assign({}, EMPTY_TRUCO), { state: 1, teams, generator: trucoAnswerGeneratorSequence(), reset() {
-            teams.forEach((team) => team.players.forEach((player) => {
-                player._commands.delete(types_1.ESayCommand.TRUCO);
-                player._commands.delete(types_1.ESayCommand.QUIERO);
-                player._commands.delete(types_1.ESayCommand.NO_QUIERO);
-            }));
+    const truco = Object.assign(Object.assign({}, EMPTY_TRUCO), { state: 1, teams, currentCommands: [], generator: trucoAnswerGeneratorSequence(), getNextTrucoCommand() {
+            return TRUCO_STATE_MAP[truco.state];
+        },
+        reset() {
             Object.assign(truco, EMPTY_TRUCO);
         },
-        sayTruco(player, callback) {
+        sayTruco(player) {
             if (truco.state === 4) {
                 return truco;
             }
+            truco.turn = 0;
             const playerTeamIdx = player.teamIdx;
             const teamIdx = truco.teamIdx;
             if (teamIdx === null || teamIdx !== playerTeamIdx) {
@@ -52,59 +57,23 @@ function Truco(teams) {
                 truco.answer = null;
                 truco.players = teams[opponentIdx].players;
                 truco.generator = trucoAnswerGeneratorSequence();
-                teams[playerTeamIdx].players.forEach((player) => {
-                    player._commands.delete(types_1.ESayCommand.TRUCO);
-                    player._commands.delete(types_1.ESayCommand.QUIERO);
-                    player._commands.delete(types_1.ESayCommand.NO_QUIERO);
-                });
-                teams[opponentIdx].players.forEach((player) => {
-                    if (truco.state < 4) {
-                        player._commands.add(types_1.ESayCommand.TRUCO);
-                    }
-                    else {
-                        player._commands.delete(types_1.ESayCommand.TRUCO);
-                    }
-                    player._commands.add(types_1.ESayCommand.QUIERO);
-                    player._commands.add(types_1.ESayCommand.NO_QUIERO);
-                });
-                callback();
                 return truco;
             }
             return truco;
         },
-        sayAnswer(player, answer, callback) {
-            const opponentIdx = Number(!player.teamIdx);
+        sayAnswer(player, answer) {
             if (player.teamIdx === truco.teamIdx) {
                 return truco;
             }
-            if (answer) {
-                teams[player.teamIdx].players.forEach((player) => {
-                    player._commands.add(types_1.ESayCommand.TRUCO);
-                    player._commands.delete(types_1.ESayCommand.NO_QUIERO);
-                    player._commands.delete(types_1.ESayCommand.QUIERO);
-                    if (truco.state > 3) {
-                        player._commands.delete(types_1.ESayCommand.TRUCO);
-                    }
-                });
-                teams[opponentIdx].players.forEach((player) => {
-                    player._commands.delete(types_1.ESayCommand.TRUCO);
-                });
-            }
-            if (answer === false) {
-                truco.state--;
-                const playerTeam = teams[player.teamIdx];
-                playerTeam.players.forEach((player) => playerTeam.disable(player));
-                teams[player.teamIdx].players.forEach((player) => {
-                    player._commands.delete(types_1.ESayCommand.QUIERO);
-                    player._commands.delete(types_1.ESayCommand.TRUCO);
-                    player._commands.delete(types_1.ESayCommand.NO_QUIERO);
-                });
-            }
             if (answer !== null) {
+                truco.currentCommands = [];
+                if (answer === false) {
+                    truco.state--;
+                    const playerTeam = teams[player.teamIdx];
+                    playerTeam.players.forEach((player) => playerTeam.disable(player));
+                }
                 truco.waitingAnswer = false;
-                truco.teamIdx = Number(!player.teamIdx);
                 truco.answer = answer;
-                callback();
             }
             return truco;
         },
@@ -123,9 +92,6 @@ function Truco(teams) {
         getNextPlayer() {
             return truco.generator.next();
         } });
-    teams.forEach((team) => team.players.forEach((player) => {
-        player._commands.add(types_1.ESayCommand.TRUCO);
-    }));
     return truco;
 }
 exports.Truco = Truco;

package/dist/lib/constants.d.ts

@@ -1,4 +1,3 @@
-import { IEnvidoCalculator } from "../types";
 export declare const CARDS: {
     "1e": number;
     "1b": number;
@@ -42,4 +41,3 @@ export declare const CARDS: {
     "4c": number;
 };
 export declare const TEAM_SIZE_VALUES: number[];
-export declare const EnvidoCalculator: IEnvidoCalculator;

package/dist/lib/constants.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnvidoCalculator = exports.TEAM_SIZE_VALUES = exports.CARDS = void 0;
-const types_1 = require("../types");
-const utils_1 = require("./utils");
+exports.TEAM_SIZE_VALUES = exports.CARDS = void 0;
 exports.CARDS = {
     "1e": 14,
     "1b": 13,
@@ -46,39 +44,3 @@ exports.CARDS = {
     "4c": 0,
 };
 exports.TEAM_SIZE_VALUES = [1, 2, 3];
-exports.EnvidoCalculator = {
-    [types_1.EEnvidoCommand.ENVIDO]: () => ({
-        accept: 2,
-        decline: 1,
-        next: [types_1.EEnvidoCommand.ENVIDO_ENVIDO, types_1.EEnvidoCommand.REAL_ENVIDO, types_1.EEnvidoCommand.FALTA_ENVIDO],
-    }),
-    [types_1.EEnvidoCommand.ENVIDO_ENVIDO]: () => ({
-        accept: 4,
-        decline: 2,
-        next: [types_1.EEnvidoCommand.REAL_ENVIDO, types_1.EEnvidoCommand.FALTA_ENVIDO],
-    }),
-    [types_1.EEnvidoCommand.REAL_ENVIDO]: () => ({
-        accept: 3,
-        decline: 1,
-        next: [types_1.EEnvidoCommand.FALTA_ENVIDO],
-    }),
-    [types_1.EEnvidoCommand.FALTA_ENVIDO]: (args) => {
-        if (!args || !args.teams || !args.matchPoint) {
-            return {
-                accept: 1,
-                decline: 1,
-                next: [],
-            };
-        }
-        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,
-            decline: 2,
-            next: [],
-        };
-    },
-};

package/dist/lib/types.d.ts

@@ -12,7 +12,10 @@ export declare enum GAME_ERROR {
     LOBBY_IS_FULL = "LOBBY_IS_FULL",
     UNEXPECTED_TEAM_SIZE = "UNEXPECTED_TEAM_SIZE",
     TEAM_NOT_READY = "TEAM_NOT_READY",
-    TEAM_IS_FULL = "TEAM_IS_FULL"
+    TEAM_IS_FULL = "TEAM_IS_FULL",
+    INVALID_ENVIDO_POINTS = "INVALID_ENVIDO_POINTS",
+    ENVIDO_NOT_ACCEPTED = "ENVIDO_NOT_ACCEPTED",
+    INVALID_COMAND = "INVALID_COMAND"
 }
 export interface EnvidoState {
     accept: number;
@@ -25,12 +28,17 @@ export type IHandCommands = {
 export type IEnvidoCalculatorResult = {
     accept: number;
     decline: number;
+    replace?: number;
     next: Array<ECommand>;
 };
-export type IEnvidoCalculatorArgs = {
+export type IFaltaEnvidoCalculatorArgs = {
     teams: [ITeam, ITeam];
     matchPoint: number;
 };
+export type IEnvidoCalculatorArgs = {
+    stake: number;
+    declineStake: number;
+} & (IFaltaEnvidoCalculatorArgs | never);
 export type IEnvidoCalculator = {
     [key in EEnvidoCommand]: (args?: IEnvidoCalculatorArgs) => IEnvidoCalculatorResult;
 };

package/dist/lib/types.js

@@ -15,4 +15,7 @@ var GAME_ERROR;
     GAME_ERROR["UNEXPECTED_TEAM_SIZE"] = "UNEXPECTED_TEAM_SIZE";
     GAME_ERROR["TEAM_NOT_READY"] = "TEAM_NOT_READY";
     GAME_ERROR["TEAM_IS_FULL"] = "TEAM_IS_FULL";
+    GAME_ERROR["INVALID_ENVIDO_POINTS"] = "INVALID_ENVIDO_POINTS";
+    GAME_ERROR["ENVIDO_NOT_ACCEPTED"] = "ENVIDO_NOT_ACCEPTED";
+    GAME_ERROR["INVALID_COMAND"] = "INVALID_COMAND";
 })(GAME_ERROR = exports.GAME_ERROR || (exports.GAME_ERROR = {}));

package/dist/types.d.ts

@@ -10,7 +10,7 @@ export interface IPublicMatch {
     matchSessionId: string;
     teams: Array<IPublicTeam>;
     players: Array<IPublicPlayer>;
-    me: IPublicPlayer;
+    me: IPublicPlayer | null;
     rounds: IPlayedCard[][];
 }
 export interface IPublicMatchInfo {
@@ -36,7 +36,7 @@ export interface IChatRoom {
     messages: Array<IChatMessage>;
     send(user: IChatMessage["user"], message: string): void;
     system(message: string): void;
-    command(team: 0 | 1, command: ECommand): void;
+    command(team: 0 | 1, command: ECommand | number): void;
     emit(): void;
 }
 export declare enum EChatSystem {
@@ -51,16 +51,26 @@ export declare enum EMatchTableState {
     FINISHED = 3
 }
 export declare enum ESayCommand {
-    QUIERO = "QUIERO",
-    NO_QUIERO = "NO_QUIERO",
-    TRUCO = "TRUCO",
-    MAZO = "MAZO",
+    MAZO = "MAZO"
+}
+export declare enum EFlorCommand {
     FLOR = "FLOR",
     CONTRAFLOR = "CONTRAFLOR"
 }
+export declare enum ETrucoCommand {
+    TRUCO = "TRUCO",
+    RE_TRUCO = "RE_TRUCO",
+    VALE_CUATRO = "VALE_CUATRO"
+}
+export declare enum EAnswerCommand {
+    QUIERO = "QUIERO",
+    NO_QUIERO = "NO_QUIERO"
+}
+export declare enum EEnvidoAnswerCommand {
+    SON_BUENAS = "SON_BUENAS"
+}
 export declare enum EEnvidoCommand {
     ENVIDO = "ENVIDO",
-    ENVIDO_ENVIDO = "ENVIDO_ENVIDO",
     REAL_ENVIDO = "REAL_ENVIDO",
     FALTA_ENVIDO = "FALTA_ENVIDO"
 }
@@ -68,9 +78,10 @@ export declare enum EHandState {
     WAITING_PLAY = "WAITING_PLAY",
     WAITING_FOR_TRUCO_ANSWER = "WAITING_FOR_TRUCO_ANSWER",
     WAITING_ENVIDO_ANSWER = "WAITING_ENVIDO_ANSWER",
+    WAITING_ENVIDO_POINTS_ANSWER = "WAITING_ENVIDO_POINTS_ANSWER",
     FINISHED = "FINISHED"
 }
-export type ECommand = ESayCommand | EEnvidoCommand;
+export type ECommand = ESayCommand | EEnvidoCommand | EAnswerCommand | EEnvidoAnswerCommand | ETrucoCommand | EFlorCommand;
 export declare enum GAME_ERROR {
     MATCH_ALREADY_STARTED = "MATCH_ALREADY_STARTED",
     LOBBY_IS_FULL = "LOBBY_IS_FULL",
@@ -78,11 +89,6 @@ export declare enum GAME_ERROR {
     TEAM_NOT_READY = "TEAM_NOT_READY",
     TEAM_IS_FULL = "TEAM_IS_FULL"
 }
-export interface EnvidoState {
-    accept: number;
-    decline: number;
-    teamIdx: 0 | 1 | null;
-}
 export type IHandCommands = {
     [key in ECommand]: (player: IPlayer) => void;
 };
@@ -132,9 +138,7 @@ export interface ClientToServerEvents {
     [EClientEvent.START_MATCH]: (callback: IEventCallback<{
         matchSessionId?: string;
     }>) => void;
-    [EClientEvent.FETCH_MATCH]: (session: string | null, matchId: string, callback: IEventCallback<{
-        match?: IPublicMatch | null;
-    }>) => void;
+    [EClientEvent.FETCH_MATCH]: (session: string | null, matchId: string, callback: IEventCallback) => void;
     [EClientEvent.LIST_MATCHES]: (filters: {
         state?: Array<EMatchTableState>;
     }, callback: IEventCallback<{
@@ -173,10 +177,8 @@ export type IWaitingSayData = {
     command: ECommand;
 };
 export type IWaitingSayCallback = (data: IWaitingSayData) => void | null;
-export interface TMap<K, V> extends Map<K, V> {
-    find(finder: (value: V) => boolean): V | void;
-}
 export declare class TMap<K, V> extends Map<K, V> {
+    find(finder: (value: V) => boolean): V | void;
     findAll(finder: (value: V) => boolean): V[];
     getOrThrow(key?: K): NonNullable<V>;
 }

package/dist/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TMap = exports.ETrucoshiMatchState = exports.EServerEvent = exports.EClientEvent = exports.GAME_ERROR = exports.EHandState = exports.EEnvidoCommand = exports.ESayCommand = exports.EMatchTableState = exports.EChatSystem = void 0;
+exports.TMap = exports.ETrucoshiMatchState = exports.EServerEvent = exports.EClientEvent = exports.GAME_ERROR = exports.EHandState = exports.EEnvidoCommand = exports.EEnvidoAnswerCommand = exports.EAnswerCommand = exports.ETrucoCommand = exports.EFlorCommand = exports.ESayCommand = exports.EMatchTableState = exports.EChatSystem = void 0;
 var EChatSystem;
 (function (EChatSystem) {
     EChatSystem[EChatSystem["TEAM_0"] = 0] = "TEAM_0";
@@ -16,17 +16,31 @@ var EMatchTableState;
 })(EMatchTableState = exports.EMatchTableState || (exports.EMatchTableState = {}));
 var ESayCommand;
 (function (ESayCommand) {
-    ESayCommand["QUIERO"] = "QUIERO";
-    ESayCommand["NO_QUIERO"] = "NO_QUIERO";
-    ESayCommand["TRUCO"] = "TRUCO";
     ESayCommand["MAZO"] = "MAZO";
-    ESayCommand["FLOR"] = "FLOR";
-    ESayCommand["CONTRAFLOR"] = "CONTRAFLOR";
 })(ESayCommand = exports.ESayCommand || (exports.ESayCommand = {}));
+var EFlorCommand;
+(function (EFlorCommand) {
+    EFlorCommand["FLOR"] = "FLOR";
+    EFlorCommand["CONTRAFLOR"] = "CONTRAFLOR";
+})(EFlorCommand = exports.EFlorCommand || (exports.EFlorCommand = {}));
+var ETrucoCommand;
+(function (ETrucoCommand) {
+    ETrucoCommand["TRUCO"] = "TRUCO";
+    ETrucoCommand["RE_TRUCO"] = "RE_TRUCO";
+    ETrucoCommand["VALE_CUATRO"] = "VALE_CUATRO";
+})(ETrucoCommand = exports.ETrucoCommand || (exports.ETrucoCommand = {}));
+var EAnswerCommand;
+(function (EAnswerCommand) {
+    EAnswerCommand["QUIERO"] = "QUIERO";
+    EAnswerCommand["NO_QUIERO"] = "NO_QUIERO";
+})(EAnswerCommand = exports.EAnswerCommand || (exports.EAnswerCommand = {}));
+var EEnvidoAnswerCommand;
+(function (EEnvidoAnswerCommand) {
+    EEnvidoAnswerCommand["SON_BUENAS"] = "SON_BUENAS";
+})(EEnvidoAnswerCommand = exports.EEnvidoAnswerCommand || (exports.EEnvidoAnswerCommand = {}));
 var EEnvidoCommand;
 (function (EEnvidoCommand) {
     EEnvidoCommand["ENVIDO"] = "ENVIDO";
-    EEnvidoCommand["ENVIDO_ENVIDO"] = "ENVIDO_ENVIDO";
     EEnvidoCommand["REAL_ENVIDO"] = "REAL_ENVIDO";
     EEnvidoCommand["FALTA_ENVIDO"] = "FALTA_ENVIDO";
 })(EEnvidoCommand = exports.EEnvidoCommand || (exports.EEnvidoCommand = {}));
@@ -35,6 +49,7 @@ var EHandState;
     EHandState["WAITING_PLAY"] = "WAITING_PLAY";
     EHandState["WAITING_FOR_TRUCO_ANSWER"] = "WAITING_FOR_TRUCO_ANSWER";
     EHandState["WAITING_ENVIDO_ANSWER"] = "WAITING_ENVIDO_ANSWER";
+    EHandState["WAITING_ENVIDO_POINTS_ANSWER"] = "WAITING_ENVIDO_POINTS_ANSWER";
     EHandState["FINISHED"] = "FINISHED";
 })(EHandState = exports.EHandState || (exports.EHandState = {}));
 var GAME_ERROR;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trucoshi",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "main": "dist/index.js",
   "license": "GPL-3.0",
   "scripts": {