trucoshi 0.3.54 → 0.4.1

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { ICard, IHandPoints, IPlayedCard, IPlayer, IPublicPlayer, IPublicTeam, ITeam } from "./lib";
+import { CARDS } from "./lib/constants";
 export interface ISaidCommand {
     player: IPlayer | IPublicPlayer;
     command: ECommand | number;
@@ -42,7 +42,7 @@ export interface IChatRoom {
     id: string;
     messages: Array<IChatMessage>;
     send(user: IChatMessage["user"], message: string): void;
-    card(user: IChatMessage["user"], command: ICard): void;
+    card(user: IChatMessage["user"], card: ICard): void;
     command(team: 0 | 1, command: ECommand | number): void;
     system(message: string): void;
     emit(message?: IChatMessage): void;
@@ -90,28 +90,9 @@ export declare enum EHandState {
     FINISHED = "FINISHED"
 }
 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",
-    UNEXPECTED_TEAM_SIZE = "UNEXPECTED_TEAM_SIZE",
-    TEAM_NOT_READY = "TEAM_NOT_READY",
-    TEAM_IS_FULL = "TEAM_IS_FULL"
-}
 export type IHandCommands = {
     [key in ECommand]: (player: IPlayer) => void;
 };
-export type IEnvidoCalculatorResult = {
-    accept: number;
-    decline: number;
-    next: Array<ECommand>;
-};
-export type IEnvidoCalculatorArgs = {
-    teams: [ITeam, ITeam];
-    matchPoint: number;
-};
-export type IEnvidoCalculator = {
-    [key in EEnvidoCommand]: (args?: IEnvidoCalculatorArgs) => IEnvidoCalculatorResult;
-};
 export declare enum EServerEvent {
     PONG = "PONG",
     PREVIOUS_HAND = "PREVIOUS_HAND",
@@ -194,3 +175,103 @@ export declare class TMap<K, V> extends Map<K, V> {
     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"
+}
+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];
+    matchPoint: number;
+};
+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 {
+    get key(): string;
+    player: IPlayer | IPublicPlayer;
+    card: ICard;
+}
+export interface IHandPoints {
+    0: number;
+    1: number;
+}
+export type IPublicPlayer = Pick<IPlayer, "id" | "key" | "disabled" | "ready" | "hand" | "envido" | "usedHand" | "prevHand" | "teamIdx" | "session" | "hasFlor" | "isTurn" | "isEnvidoTurn" | "isOwner"> & {
+    commands: Array<ECommand>;
+};
+export type IPublicTeam = Pick<ITeam, "points"> & {
+    players: Array<IPublicPlayer>;
+};
+export interface IPlayer {
+    teamIdx: number;
+    id: string;
+    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;
+    setIsOwner(isOwner: boolean): void;
+    enable(): void;
+    disable(): 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>;
+    players: Array<IPlayer>;
+    points: ITeamPoints;
+    getPublicTeam(playerSession?: string): IPublicTeam;
+    isTeamDisabled(): boolean;
+    disable(player: IPlayer): boolean;
+    enable(player?: IPlayer): boolean;
+    addPoints(matchPoint: number, points: number): ITeamPoints;
+}
+export interface ITeamPoints {
+    buenas: number;
+    malas: number;
+    winner: boolean;
+}

package/dist/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TMap = exports.ETrucoshiMatchState = exports.EClientEvent = exports.EServerEvent = exports.GAME_ERROR = exports.EHandState = exports.EEnvidoCommand = exports.EEnvidoAnswerCommand = exports.EAnswerCommand = exports.ETrucoCommand = exports.EFlorCommand = exports.ESayCommand = exports.EMatchTableState = exports.EChatSystem = void 0;
+exports.GAME_ERROR = exports.TMap = exports.ETrucoshiMatchState = exports.EClientEvent = exports.EServerEvent = 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";
@@ -52,14 +52,6 @@ var EHandState;
     EHandState["WAITING_ENVIDO_POINTS_ANSWER"] = "WAITING_ENVIDO_POINTS_ANSWER";
     EHandState["FINISHED"] = "FINISHED";
 })(EHandState = exports.EHandState || (exports.EHandState = {}));
-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 = exports.GAME_ERROR || (exports.GAME_ERROR = {}));
 var EServerEvent;
 (function (EServerEvent) {
     EServerEvent["PONG"] = "PONG";
@@ -121,3 +113,14 @@ class TMap extends Map {
     }
 }
 exports.TMap = TMap;
+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 = exports.GAME_ERROR || (exports.GAME_ERROR = {}));

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "trucoshi",
-  "version": "0.3.54",
-  "main": "dist/index.js",
+  "version": "0.4.1",
+  "main": "dist/types.js",
   "license": "GPL-3.0",
   "scripts": {
-    "dev": "nodemon",
-    "start": "node ./bin/trucoshi-server",
+    "start": "nodemon",
+    "profiler": "yarn build && node --prof ./bin/trucoshi-server",
     "build": "yarn run rimraf ./dist && yarn run tsc --project .",
     "prepublishOnly": "yarn test && yarn build",
     "test": "yarn run ts-mocha --exit ./test/**/*.ts",
@@ -24,17 +24,19 @@
     "ts-mocha": "^10.0.0"
   },
   "files": [
-    "dist/index.js",
-    "dist/index.d.ts",
+    "dist/lib/constants.js",
+    "dist/lib/constants.d.ts",
     "dist/types.js",
-    "dist/types.d.ts",
-    "dist/lib/**/*"
+    "dist/types.d.ts"
   ],
   "dependencies": {
+    "@types/pino": "^7.0.5",
+    "pino": "^8.11.0",
+    "pino-pretty": "^10.0.0",
     "rimraf": "^4.1.1",
     "socket.io": "^4.5.4",
     "ts-node": "^10.9.1",
     "tsc": "^2.0.4",
     "typescript": "^4.9.4"
   }
-}
+}

package/dist/index.d.ts

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

package/dist/index.js

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

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

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

package/dist/lib/classes/Deck.js

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

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

@@ -1,34 +0,0 @@
-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

@@ -1,168 +0,0 @@
-"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 +0,0 @@
-"use strict";

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

@@ -1,28 +0,0 @@
-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) => Promise<void>;
-export type ITrucoCallback = (play: IPlayInstance) => Promise<void>;
-export type IHandFinishedCallback = (hand: IHand | null) => Promise<void>;
-export type IEnvidoCallback = (play: IPlayInstance, pointsRound: boolean) => Promise<void>;
-export interface IGameLoop {
-    _onTruco: ITrucoCallback;
-    _onTurn: ITurnCallback;
-    _onWinner: IWinnerCallback;
-    _onEnvido: IEnvidoCallback;
-    _onHandFinished: IHandFinishedCallback;
-    currentPlayer: IPlayer | null;
-    currentHand: IHand | null;
-    teams: Array<ITeam>;
-    winner: ITeam | null;
-    onTurn: (callback: ITurnCallback) => IGameLoop;
-    onWinner: (callback: IWinnerCallback) => IGameLoop;
-    onTruco: (callback: ITrucoCallback) => IGameLoop;
-    onEnvido: (callback: IEnvidoCallback) => IGameLoop;
-    onHandFinished: (callback: IHandFinishedCallback) => IGameLoop;
-    begin: () => Promise<void>;
-}
-export declare const GameLoop: (match: IMatch) => IGameLoop;

package/dist/lib/classes/GameLoop.js

@@ -1,115 +0,0 @@
-"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(),
-        _onHandFinished: () => Promise.resolve(),
-        teams: [],
-        winner: null,
-        currentPlayer: null,
-        currentHand: null,
-        onHandFinished: (callback) => {
-            gameloop._onHandFinished = callback;
-            return gameloop;
-        },
-        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() {
-            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) {
-                        try {
-                            yield gameloop._onHandFinished(match.prevHand);
-                        }
-                        catch (e) {
-                            console.error("GAME LOOP ERROR - ON HAND FINISHED");
-                        }
-                        continue;
-                    }
-                    if (!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);
-                            yield gameloop._onTurn(play);
-                            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;