trucoshi 1.0.0 → 2.0.1

package/README.md

@@ -0,0 +1,64 @@
+# 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)
+
+# Client
+
+[Trucoshi React Client](https://github.com/jfrader/trucoshi-client)
+
+### Installation
+
+`yarn`
+
+### Build
+
+`yarn build`
+
+# Test
+
+`yarn test`
+
+### Play
+
+`yarn cli:play`
+
+### Autoplay
+
+`yarn cli:autoplay`
+
+# Todo
+
+    [x] Logica de turnos, rondas y battalla de cartas
+    [x] Irse al mazo
+    [x] Cantar truco
+    [x] Cantar envido
+    [] Cantar flor
+    [x] Socket server
+    [x] 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/lib/constants.d.ts

@@ -0,0 +1,89 @@
+export declare const PLAYER_ABANDON_TIMEOUT: number;
+export declare const PLAYER_TURN_TIMEOUT: number;
+export declare const PREVIOUS_HAND_ACK_TIMEOUT: number;
+export declare const CARDS: {
+    "1e": number;
+    "1b": number;
+    "7e": number;
+    "7o": number;
+    "3e": number;
+    "3o": number;
+    "3b": number;
+    "3c": number;
+    "2e": number;
+    "2o": number;
+    "2b": number;
+    "2c": number;
+    "1o": number;
+    "1c": number;
+    re: number;
+    ro: number;
+    rb: number;
+    rc: number;
+    ce: number;
+    co: number;
+    cb: number;
+    cc: number;
+    pe: number;
+    po: number;
+    pb: number;
+    pc: number;
+    "7b": number;
+    "7c": number;
+    "6e": number;
+    "6o": number;
+    "6b": number;
+    "6c": number;
+    "5e": number;
+    "5o": number;
+    "5b": number;
+    "5c": number;
+    "4e": number;
+    "4o": number;
+    "4b": number;
+    "4c": number;
+};
+export declare const BURNT_CARD: "rb" | "1e" | "1b" | "7e" | "7o" | "3e" | "3o" | "3b" | "3c" | "2e" | "2o" | "2b" | "2c" | "1o" | "1c" | "re" | "ro" | "rc" | "ce" | "co" | "cb" | "cc" | "pe" | "po" | "pb" | "pc" | "7b" | "7c" | "6e" | "6o" | "6b" | "6c" | "5e" | "5o" | "5b" | "5c" | "4e" | "4o" | "4b" | "4c";
+export declare const CARDS_HUMAN_READABLE: {
+    "1e": string;
+    "1b": string;
+    "7e": string;
+    "7o": string;
+    "3e": string;
+    "3o": string;
+    "3b": string;
+    "3c": string;
+    "2e": string;
+    "2o": string;
+    "2b": string;
+    "2c": string;
+    "1o": string;
+    "1c": string;
+    re: string;
+    ro: string;
+    rb: string;
+    rc: string;
+    ce: string;
+    co: string;
+    cb: string;
+    cc: string;
+    pe: string;
+    po: string;
+    pb: string;
+    pc: string;
+    "7b": string;
+    "7c": string;
+    "6e": string;
+    "6o": string;
+    "6b": string;
+    "6c": string;
+    "5e": string;
+    "5o": string;
+    "5b": string;
+    "5c": string;
+    "4e": string;
+    "4o": string;
+    "4b": string;
+    "4c": string;
+};
+export declare const TEAM_SIZE_VALUES: number[];

package/dist/lib/constants.js

@@ -0,0 +1,89 @@
+export const PLAYER_ABANDON_TIMEOUT = 1000 * 45;
+export const PLAYER_TURN_TIMEOUT = 1000 * 30;
+export const PREVIOUS_HAND_ACK_TIMEOUT = 1000 * 5;
+export const CARDS = {
+    "1e": 13,
+    "1b": 12,
+    "7e": 11,
+    "7o": 10,
+    "3e": 9,
+    "3o": 9,
+    "3b": 9,
+    "3c": 9,
+    "2e": 8,
+    "2o": 8,
+    "2b": 8,
+    "2c": 8,
+    "1o": 7,
+    "1c": 7,
+    re: 6,
+    ro: 6,
+    rb: 6,
+    rc: 6,
+    ce: 5,
+    co: 5,
+    cb: 5,
+    cc: 5,
+    pe: 4,
+    po: 4,
+    pb: 4,
+    pc: 4,
+    "7b": 3,
+    "7c": 3,
+    "6e": 2,
+    "6o": 2,
+    "6b": 2,
+    "6c": 2,
+    "5e": 1,
+    "5o": 1,
+    "5b": 1,
+    "5c": 1,
+    "4e": 0,
+    "4o": 0,
+    "4b": 0,
+    "4c": 0,
+};
+export const BURNT_CARD = "xx";
+export const CARDS_HUMAN_READABLE = {
+    "1e": "1🗡️",
+    "1b": "1🌵",
+    "7e": "7🗡️",
+    "7o": "7💰",
+    "3e": "3🗡️",
+    "3o": "3💰",
+    "3b": "3🌵",
+    "3c": "3🍷",
+    "2e": "2🗡️",
+    "2o": "2💰",
+    "2b": "2🌵",
+    "2c": "2🍷",
+    "1o": "1💰",
+    "1c": "1🍷",
+    re: "12🗡️",
+    ro: "12💰",
+    rb: "12🌵",
+    rc: "12🍷",
+    ce: "11🗡️",
+    co: "11💰",
+    cb: "11🌵",
+    cc: "11🍷",
+    pe: "10🗡️",
+    po: "10💰",
+    pb: "10🌵",
+    pc: "10🍷",
+    "7b": "7🌵",
+    "7c": "7🍷",
+    "6e": "6🗡️",
+    "6o": "6💰",
+    "6b": "6🌵",
+    "6c": "6🍷",
+    "5e": "5🗡️",
+    "5o": "5💰",
+    "5b": "5🌵",
+    "5c": "5🍷",
+    "4e": "4🗡️",
+    "4o": "4💰",
+    "4b": "4🌵",
+    "4c": "4🍷",
+};
+export const TEAM_SIZE_VALUES = [1, 2, 3];

package/dist/server/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const PLAYER_TIMEOUT_GRACE = 500;
+export declare const PLAYER_LOBBY_TIMEOUT: number;
+export declare const MATCH_FINISHED_CLEANUP_TIMEOUT: number;

package/dist/server/constants.js

@@ -0,0 +1,3 @@
+export const PLAYER_TIMEOUT_GRACE = 500;
+export const PLAYER_LOBBY_TIMEOUT = 1000 * 10;
+export const MATCH_FINISHED_CLEANUP_TIMEOUT = 1000 * 60 * 2;

package/dist/types.d.ts

@@ -0,0 +1,333 @@
+import { User } from "lightning-accounts";
+import { CARDS, IHand } from "./lib";
+import { IUserData } from "./server";
+import { EMatchState } from "@prisma/client";
+export { CARDS, CARDS_HUMAN_READABLE, BURNT_CARD } from "./lib/constants";
+export { EMatchState };
+export interface ILobbyOptions {
+    maxPlayers: 2 | 4 | 6;
+    faltaEnvido: 1 | 2;
+    flor: boolean;
+    matchPoint: number;
+    handAckTime: number;
+    turnTime: number;
+    abandonTime: number;
+    satsPerPlayer: number;
+}
+export interface ISaidCommand {
+    player: IPlayer | IPublicPlayer;
+    command: ECommand | number;
+}
+export interface IMatchPreviousHand {
+    rounds: IPlayedCard[][];
+    points: IHandPoints;
+    matchSessionId: string;
+}
+export interface IPublicMatch {
+    options: ILobbyOptions;
+    state: EMatchState;
+    winner: ITeam | null;
+    matchSessionId: string;
+    teams: Array<IPublicTeam>;
+    players: Array<IPublicPlayer>;
+    me: IPublicPlayer | null;
+    freshHand: boolean;
+    rounds: IPlayedCard[][];
+    lastCard?: ICard | null;
+    lastCommand?: ECommand | number | null;
+}
+export interface IPublicMatchInfo {
+    ownerId: string;
+    matchSessionId: string;
+    players: number;
+    options: ILobbyOptions;
+    state: EMatchState;
+}
+export type IPublicChatRoom = Pick<IChatRoom, "id" | "messages">;
+export interface IChatMessage {
+    id: string;
+    date: number;
+    user: {
+        name: string;
+        key: string;
+    };
+    system?: boolean;
+    command?: boolean;
+    card?: boolean;
+    content: string;
+}
+export interface IChatRoom {
+    id: string;
+    messages: Array<IChatMessage>;
+    socket: {
+        emit(socket: string): void;
+    };
+    send(user: IChatMessage["user"], message: string): void;
+    card(user: IChatMessage["user"], card: ICard): void;
+    command(team: 0 | 1, command: ECommand | number): void;
+    system(message: string): void;
+    emit(message?: IChatMessage): void;
+}
+export declare enum EChatSystem {
+    TEAM_0 = 0,
+    TEAM_1 = 1,
+    SYSTEM = "SYSTEM"
+}
+export declare enum ESayCommand {
+    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",
+    REAL_ENVIDO = "REAL_ENVIDO",
+    FALTA_ENVIDO = "FALTA_ENVIDO"
+}
+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 | EAnswerCommand | EEnvidoAnswerCommand | ETrucoCommand | EFlorCommand;
+export type IHandCommands = {
+    [key in ECommand]: (hand: IHand, player: IPlayer) => void;
+};
+export type IEventCallback<T = {}> = (args: {
+    success: boolean;
+} & T) => void;
+export declare enum EServerEvent {
+    PONG = "PONG",
+    SET_SESSION = "SET_SESSION",
+    PREVIOUS_HAND = "PREVIOUS_HAND",
+    UPDATE_MATCH = "UPDATE_MATCH",
+    MATCH_DELETED = "MATCH_DELETED",
+    WAITING_PLAY = "WAITING_PLAY",
+    KICK_PLAYER = "PLAYER_KICKED",
+    UPDATE_ACTIVE_MATCHES = "UPDATE_ACTIVE_MATCHES",
+    PLAYER_USED_CARD = "PLAYER_USED_CARD",
+    PLAYER_SAID_COMMAND = "PLAYER_SAID_COMMAND",
+    WAITING_POSSIBLE_SAY = "WAITING_POSSIBLE_SAY",
+    UPDATE_CHAT = "UPDAET_CHAT"
+}
+export interface ServerToClientEvents {
+    [EServerEvent.PONG]: (serverTime: number, clientTime: number) => void;
+    [EServerEvent.PREVIOUS_HAND]: (value: IMatchPreviousHand, callback: () => void) => void;
+    [EServerEvent.UPDATE_CHAT]: (room: IPublicChatRoom, message?: IChatMessage) => void;
+    [EServerEvent.UPDATE_ACTIVE_MATCHES]: (activeMatches: IPublicMatchInfo[]) => void;
+    [EServerEvent.UPDATE_MATCH]: (match: IPublicMatch, callback?: () => void) => void;
+    [EServerEvent.PLAYER_USED_CARD]: (match: IPublicMatch, card: IPlayedCard) => void;
+    [EServerEvent.PLAYER_SAID_COMMAND]: (match: IPublicMatch, command: ISaidCommand) => void;
+    [EServerEvent.KICK_PLAYER]: (match: IPublicMatch, session: string, reason?: string) => void;
+    [EServerEvent.MATCH_DELETED]: (matchSessionId: string) => void;
+    [EServerEvent.SET_SESSION]: (userData: IUserData, serverVersion: string, activeMatches: Array<IPublicMatchInfo>) => void;
+    [EServerEvent.WAITING_POSSIBLE_SAY]: (match: IPublicMatch, callback: (data: IWaitingSayData) => void) => void;
+    [EServerEvent.WAITING_PLAY]: (match: IPublicMatch, callback: (data: IWaitingPlayData) => void) => void;
+}
+export declare enum EClientEvent {
+    LOGIN = "LOGIN",
+    LOGOUT = "LOGOUT",
+    LEAVE_MATCH = "LEAVE_MATCH",
+    CREATE_MATCH = "CREATE_MATCH",
+    SET_MATCH_OPTIONS = "SET_MATCH_OPTIONS",
+    LIST_MATCHES = "LIST_MATCHES",
+    JOIN_MATCH = "JOIN_MATCH",
+    START_MATCH = "START_MATCH",
+    SET_PLAYER_READY = "SET_PLAYER_READY",
+    FETCH_MATCH = "FETCH_MATCH",
+    CHAT = "CHAT",
+    PING = "PING",
+    SAY = "SAY"
+}
+export interface ClientToServerEvents {
+    [EClientEvent.LOGOUT]: (callback: IEventCallback<{}>) => void;
+    [EClientEvent.PING]: (clientTime: number) => void;
+    [EClientEvent.CHAT]: (matchId: string, msg: string, callback: () => void) => void;
+    [EClientEvent.LEAVE_MATCH]: (matchId: string, callback?: IEventCallback<{}>) => void;
+    [EClientEvent.CREATE_MATCH]: (callback: IEventCallback<{
+        match?: IPublicMatch;
+        activeMatches?: IPublicMatchInfo[];
+    }>) => void;
+    [EClientEvent.SET_MATCH_OPTIONS]: (identityJwt: string | null, matchSessionId: string, options: Partial<ILobbyOptions>, callback: IEventCallback<{
+        match?: IPublicMatch;
+        activeMatches?: IPublicMatchInfo[];
+    }>) => void;
+    [EClientEvent.SET_PLAYER_READY]: (matchSessionId: string, ready: boolean, callback: IEventCallback<{
+        match?: IPublicMatch;
+    }>) => void;
+    [EClientEvent.JOIN_MATCH]: (matchSessionId: string, teamIdx: 0 | 1 | undefined, callback: IEventCallback<{
+        match?: IPublicMatch;
+        activeMatches?: IPublicMatchInfo[];
+    }>) => void;
+    [EClientEvent.START_MATCH]: (identityJwt: string | null, matchId: string, callback: IEventCallback<{
+        matchSessionId?: string;
+    }>) => void;
+    [EClientEvent.FETCH_MATCH]: (matchId: string, callback: IEventCallback<{
+        match: IPublicMatch | null;
+    }>) => void;
+    [EClientEvent.LIST_MATCHES]: (filters: {
+        state?: Array<EMatchState>;
+    }, callback: IEventCallback<{
+        matches: Array<IPublicMatchInfo>;
+    }>) => void;
+    [EClientEvent.LOGIN]: (user: User, identityToken: string, callback: IEventCallback<{
+        activeMatches?: IPublicMatchInfo[];
+    }>) => void;
+}
+export type IWaitingPlayData = {
+    cardIdx: number;
+    card: ICard;
+};
+export type IWaitingPlayCallback = (data: IWaitingPlayData) => void | null;
+export type IWaitingSayData = {
+    command: ECommand | number;
+};
+export type IWaitingSayCallback = (data: IWaitingSayData) => void | null;
+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>;
+}
+export declare enum GAME_ERROR {
+    MATCH_ALREADY_STARTED = "MATCH_ALREADY_STARTED",
+    LOBBY_IS_FULL = "LOBBY_IS_FULL",
+    UNEXPECTED_TEAM_SIZE = "UNEXPECTED_TEAM_SIZE",
+    TEAM_NOT_READY = "TEAM_NOT_READY",
+    TEAM_IS_FULL = "TEAM_IS_FULL",
+    INVALID_ENVIDO_POINTS = "INVALID_ENVIDO_POINTS",
+    ENVIDO_NOT_ACCEPTED = "ENVIDO_NOT_ACCEPTED",
+    INVALID_COMAND = "INVALID_COMAND",
+    INSUFFICIENT_BALANCE = "INSUFFICIENT_BALANCE",
+    GAME_REQUIRES_ACCOUNT = "GAME_REQUIRES_ACCOUNT"
+}
+export interface EnvidoState {
+    accept: number;
+    decline: number;
+    teamIdx: 0 | 1 | null;
+}
+export type IEnvidoCalculatorResult = {
+    accept: number;
+    decline: number;
+    replace?: number;
+    next: Array<ECommand>;
+};
+export type IFaltaEnvidoCalculatorArgs = {
+    teams: [ITeam, ITeam];
+    options: ILobbyOptions;
+};
+export type IEnvidoCalculatorArgs = {
+    stake: number;
+    declineStake: number;
+} & (IFaltaEnvidoCalculatorArgs | never);
+export type IEnvidoCalculator = {
+    [key in EEnvidoCommand]: (args?: IEnvidoCalculatorArgs) => IEnvidoCalculatorResult;
+};
+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 {
+    key: string;
+    player: IPlayer | IPublicPlayer;
+    card: ICard;
+}
+export interface IHandPoints {
+    0: number;
+    1: number;
+}
+export type IPublicPlayer = Pick<IPlayer, "name" | "key" | "disabled" | "abandoned" | "ready" | "hand" | "usedHand" | "prevHand" | "teamIdx" | "isTurn" | "turnExpiresAt" | "turnExtensionExpiresAt" | "isEnvidoTurn" | "isOwner"> & ({
+    isMe?: true;
+    commands: IPlayer["commands"];
+    hasFlor: IPlayer["hasFlor"];
+    envido: IPlayer["envido"];
+    payRequestId?: IPlayer["payRequestId"];
+} | {
+    isMe?: false;
+    commands?: undefined;
+    hasFlor?: undefined;
+    envido?: undefined;
+    payRequestId?: undefined;
+});
+export type IPublicTeam = Pick<ITeam, "points" | "id" | "name"> & {
+    players: Array<IPublicPlayer>;
+};
+export interface IPlayer {
+    idx: number;
+    teamIdx: number;
+    accountId: number | undefined;
+    matchPlayerId: number | undefined;
+    name: string;
+    key: string;
+    session: string;
+    payRequestId?: number;
+    hand: Array<ICard>;
+    usedHand: Array<ICard>;
+    prevHand: Array<ICard>;
+    envido: Array<number>;
+    _commands: Set<ECommand>;
+    get commands(): Array<ECommand>;
+    isTurn: boolean;
+    turnExpiresAt: number | null;
+    turnExtensionExpiresAt: number | null;
+    hasFlor: boolean;
+    isEnvidoTurn: boolean;
+    isOwner: boolean;
+    disabled: boolean;
+    abandoned: boolean;
+    ready: boolean;
+    resetCommands(): void;
+    calculateEnvido(): Array<number>;
+    setIdx(idx: number): void;
+    setPayRequest(id?: number): void;
+    setMatchPlayerId(id?: number): void;
+    setTurn(turn: boolean): void;
+    setTurnExpiration(...args: [number, number | null] | [null, null]): void;
+    setEnvidoTurn(turn: boolean): void;
+    getPublicPlayer(session?: string): IPublicPlayer;
+    setSession(session: string): void;
+    setIsOwner(isOwner: boolean): void;
+    enable(): void;
+    disable(): void;
+    abandon(): void;
+    setReady(ready: boolean): void;
+    setHand(hand: Array<ICard>): Array<ICard>;
+    useCard(idx: number, card: ICard): ICard | null;
+}
+export interface ITeam {
+    _players: Map<string, IPlayer>;
+    id: 0 | 1;
+    name: string;
+    players: Array<IPlayer>;
+    points: ITeamPoints;
+    pointsToWin(matchPoint: number): number;
+    getPublicTeam(playerSession?: string): IPublicTeam;
+    isTeamDisabled(): boolean;
+    disable(player: IPlayer): boolean;
+    enable(player?: IPlayer): boolean;
+    addPoints(matchPoint: number, points: number, simulate?: boolean): ITeamPoints;
+}
+export interface ITeamPoints {
+    buenas: number;
+    malas: number;
+    winner: boolean;
+}
+export type IPublicUser = Pick<User, "id" | "email" | "name" | "role">;

package/dist/types.js

@@ -0,0 +1,113 @@
+import { EMatchState } from "@prisma/client";
+export { CARDS, CARDS_HUMAN_READABLE, BURNT_CARD } from "./lib/constants";
+export { EMatchState };
+export var EChatSystem;
+(function (EChatSystem) {
+    EChatSystem[EChatSystem["TEAM_0"] = 0] = "TEAM_0";
+    EChatSystem[EChatSystem["TEAM_1"] = 1] = "TEAM_1";
+    EChatSystem["SYSTEM"] = "SYSTEM";
+})(EChatSystem || (EChatSystem = {}));
+export var ESayCommand;
+(function (ESayCommand) {
+    ESayCommand["MAZO"] = "MAZO";
+})(ESayCommand || (ESayCommand = {}));
+export var EFlorCommand;
+(function (EFlorCommand) {
+    EFlorCommand["FLOR"] = "FLOR";
+    EFlorCommand["CONTRAFLOR"] = "CONTRAFLOR";
+})(EFlorCommand || (EFlorCommand = {}));
+export var ETrucoCommand;
+(function (ETrucoCommand) {
+    ETrucoCommand["TRUCO"] = "TRUCO";
+    ETrucoCommand["RE_TRUCO"] = "RE_TRUCO";
+    ETrucoCommand["VALE_CUATRO"] = "VALE_CUATRO";
+})(ETrucoCommand || (ETrucoCommand = {}));
+export var EAnswerCommand;
+(function (EAnswerCommand) {
+    EAnswerCommand["QUIERO"] = "QUIERO";
+    EAnswerCommand["NO_QUIERO"] = "NO_QUIERO";
+})(EAnswerCommand || (EAnswerCommand = {}));
+export var EEnvidoAnswerCommand;
+(function (EEnvidoAnswerCommand) {
+    EEnvidoAnswerCommand["SON_BUENAS"] = "SON_BUENAS";
+})(EEnvidoAnswerCommand || (EEnvidoAnswerCommand = {}));
+export var EEnvidoCommand;
+(function (EEnvidoCommand) {
+    EEnvidoCommand["ENVIDO"] = "ENVIDO";
+    EEnvidoCommand["REAL_ENVIDO"] = "REAL_ENVIDO";
+    EEnvidoCommand["FALTA_ENVIDO"] = "FALTA_ENVIDO";
+})(EEnvidoCommand || (EEnvidoCommand = {}));
+export var EHandState;
+(function (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 || (EHandState = {}));
+export var EServerEvent;
+(function (EServerEvent) {
+    EServerEvent["PONG"] = "PONG";
+    EServerEvent["SET_SESSION"] = "SET_SESSION";
+    EServerEvent["PREVIOUS_HAND"] = "PREVIOUS_HAND";
+    EServerEvent["UPDATE_MATCH"] = "UPDATE_MATCH";
+    EServerEvent["MATCH_DELETED"] = "MATCH_DELETED";
+    EServerEvent["WAITING_PLAY"] = "WAITING_PLAY";
+    EServerEvent["KICK_PLAYER"] = "PLAYER_KICKED";
+    EServerEvent["UPDATE_ACTIVE_MATCHES"] = "UPDATE_ACTIVE_MATCHES";
+    EServerEvent["PLAYER_USED_CARD"] = "PLAYER_USED_CARD";
+    EServerEvent["PLAYER_SAID_COMMAND"] = "PLAYER_SAID_COMMAND";
+    EServerEvent["WAITING_POSSIBLE_SAY"] = "WAITING_POSSIBLE_SAY";
+    EServerEvent["UPDATE_CHAT"] = "UPDAET_CHAT";
+})(EServerEvent || (EServerEvent = {}));
+export var EClientEvent;
+(function (EClientEvent) {
+    EClientEvent["LOGIN"] = "LOGIN";
+    EClientEvent["LOGOUT"] = "LOGOUT";
+    EClientEvent["LEAVE_MATCH"] = "LEAVE_MATCH";
+    EClientEvent["CREATE_MATCH"] = "CREATE_MATCH";
+    EClientEvent["SET_MATCH_OPTIONS"] = "SET_MATCH_OPTIONS";
+    EClientEvent["LIST_MATCHES"] = "LIST_MATCHES";
+    EClientEvent["JOIN_MATCH"] = "JOIN_MATCH";
+    EClientEvent["START_MATCH"] = "START_MATCH";
+    EClientEvent["SET_PLAYER_READY"] = "SET_PLAYER_READY";
+    EClientEvent["FETCH_MATCH"] = "FETCH_MATCH";
+    EClientEvent["CHAT"] = "CHAT";
+    EClientEvent["PING"] = "PING";
+    EClientEvent["SAY"] = "SAY";
+})(EClientEvent || (EClientEvent = {}));
+export class TMap extends Map {
+    find(finder) {
+        let result = undefined;
+        for (let value of this.values()) {
+            const find = finder(value);
+            if (!result && find) {
+                result = value;
+            }
+        }
+        return result;
+    }
+    findAll(finder) {
+        return Array.from(this.values()).filter(finder);
+    }
+    getOrThrow(key) {
+        const result = key && this.get(key);
+        if (!result) {
+            throw new Error(`getOrThrow(${key}) not found`);
+        }
+        return result;
+    }
+}
+export var GAME_ERROR;
+(function (GAME_ERROR) {
+    GAME_ERROR["MATCH_ALREADY_STARTED"] = "MATCH_ALREADY_STARTED";
+    GAME_ERROR["LOBBY_IS_FULL"] = "LOBBY_IS_FULL";
+    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["INSUFFICIENT_BALANCE"] = "INSUFFICIENT_BALANCE";
+    GAME_ERROR["GAME_REQUIRES_ACCOUNT"] = "GAME_REQUIRES_ACCOUNT";
+})(GAME_ERROR || (GAME_ERROR = {}));