trucoshi 0.0.1 → 0.0.4

package/build/lib/constants.js

@@ -1,16 +1,94 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.COLORS = exports.CARDS = void 0;
+exports.EnvidoCalculator = exports.COLORS = exports.CARDS = void 0;
+var types_1 = require("./types");
+var utils_1 = require("./utils");
 exports.CARDS = {
-    '1e': 14, '1b': 13, '7e': 12, '7o': 11,
-    '3e': 10, '3o': 10, '3b': 10, '3c': 10,
-    '2e': 9, '2o': 9, '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
+    "1e": 14,
+    "1b": 13,
+    "7e": 12,
+    "7o": 11,
+    "3e": 10,
+    "3o": 10,
+    "3b": 10,
+    "3c": 10,
+    "2e": 9,
+    "2o": 9,
+    "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,
 };
-exports.COLORS = ["#9b111", "#17c6c6", "#8c1d1d", "#9f9b9b", "#a5a5a5", "#f5a623", "#f44336", "#c2185b"];
+exports.COLORS = [
+    "#9b111",
+    "#17c6c6",
+    "#8c1d1d",
+    "#9f9b9b",
+    "#a5a5a5",
+    "#f5a623",
+    "#f44336",
+    "#c2185b",
+];
+exports.EnvidoCalculator = (_a = {},
+    _a[types_1.EEnvidoCommand.ENVIDO] = function () { return ({
+        accept: 2,
+        decline: 1,
+        next: [types_1.EEnvidoCommand.ENVIDO_ENVIDO, types_1.EEnvidoCommand.REAL_ENVIDO, types_1.EEnvidoCommand.FALTA_ENVIDO],
+    }); },
+    _a[types_1.EEnvidoCommand.ENVIDO_ENVIDO] = function () { return ({
+        accept: 4,
+        decline: 2,
+        next: [types_1.EEnvidoCommand.REAL_ENVIDO, types_1.EEnvidoCommand.FALTA_ENVIDO],
+    }); },
+    _a[types_1.EEnvidoCommand.REAL_ENVIDO] = function () { return ({
+        accept: 3,
+        decline: 1,
+        next: [types_1.EEnvidoCommand.FALTA_ENVIDO],
+    }); },
+    _a[types_1.EEnvidoCommand.FALTA_ENVIDO] = function (args) {
+        if (!args || !args.teams || !args.matchPoint) {
+            return {
+                accept: 1,
+                decline: 1,
+                next: [],
+            };
+        }
+        var teams = args.teams, matchPoint = args.matchPoint;
+        var totals = teams.map(function (team) { return team.points.malas + team.points.buenas; });
+        var higher = (0, utils_1.getMaxNumberIndex)(totals);
+        var points = teams[higher].points;
+        var accept = points.buenas > 0 ? matchPoint - points.buenas : matchPoint - points.malas;
+        return {
+            accept: accept,
+            decline: 2,
+            next: [],
+        };
+    },
+    _a);

package/build/lib/index.d.ts

@@ -0,0 +1,11 @@
+import { IPlayInstance, ITeam } from "./types";
+export type IWinnerCallback = (winner: ITeam, teams: [ITeam, ITeam]) => Promise<void>;
+export type ITurnCallback = (match: IPlayInstance) => Promise<void>;
+export interface IGameLoop {
+    _onTurn: (match: IPlayInstance) => Promise<void>;
+    _onWinner: (winner: ITeam, teams: [ITeam, ITeam]) => Promise<void>;
+    onTurn: (callback: ITurnCallback) => IGameLoop;
+    onWinner: (callback: IWinnerCallback) => IGameLoop;
+    start: () => void;
+}
+export declare function Trucoshi(idsTeam0: Array<string>, idsTeam1: Array<string>, matchPoint: 9 | 12 | 15): IGameLoop;

package/build/lib/index.js

@@ -0,0 +1,88 @@
+"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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trucoshi = void 0;
+var Match_1 = require("./classes/Match");
+var Player_1 = require("./classes/Player");
+var Team_1 = require("./classes/Team");
+var GameLoop = function (match) {
+    var gameloop = {
+        _onTurn: function () { return Promise.resolve(); },
+        _onWinner: function () { return Promise.resolve(); },
+        onTurn: function (callback) {
+            gameloop._onTurn = callback;
+            return gameloop;
+        },
+        onWinner: function (callback) {
+            gameloop._onWinner = callback;
+            return gameloop;
+        },
+        start: function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var play;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!!match.winner) return [3 /*break*/, 2];
+                            play = match.play();
+                            if (!play || !play.player) {
+                                return [3 /*break*/, 0];
+                            }
+                            return [4 /*yield*/, gameloop._onTurn(play)];
+                        case 1:
+                            _a.sent();
+                            return [3 /*break*/, 0];
+                        case 2: return [4 /*yield*/, gameloop._onWinner(match.winner, match.teams)];
+                        case 3:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        },
+    };
+    return gameloop;
+};
+function Trucoshi(idsTeam0, idsTeam1, matchPoint) {
+    var teams = [
+        (0, Team_1.Team)(idsTeam0.map(function (id) { return (0, Player_1.Player)(id, 0); })),
+        (0, Team_1.Team)(idsTeam1.map(function (id) { return (0, Player_1.Player)(id, 1); })),
+    ];
+    return GameLoop((0, Match_1.Match)(teams, matchPoint));
+}
+exports.Trucoshi = Trucoshi;

package/build/lib/types.d.ts

@@ -19,11 +19,10 @@ export interface IPlayer {
     useCard(idx: number): ICard | null;
 }
 export interface ITeam {
-    color: string;
     _players: Map<string, IPlayer>;
     players: Array<IPlayer>;
-    points: number;
-    addPoints(points: number): number;
+    points: TeamPoints;
+    addPoints(matchPoint: number, points: number): TeamPoints;
 }
 export interface IMatch {
     teams: [ITeam, ITeam];
@@ -31,57 +30,92 @@ export interface IMatch {
     winner: ITeam | null;
     currentHand: IHand | null;
     table: ITable;
-    play(): IPlayInstance | undefined;
-    addPoints(points: IPoints): void;
+    play(): IPlayInstance | null;
+    addPoints(points: HandPoints): [ITeam, ITeam];
     pushHand(hand: IHand): void;
     setCurrentHand(hand: IHand | null): IHand | null;
     setWinner(winner: ITeam): void;
     getNextTurn(): IteratorResult<IMatch | null, IMatch | null | void>;
 }
-export type IPoints = {
+export interface TeamPoints {
+    buenas: number;
+    malas: number;
+    winner: boolean;
+}
+export interface HandPoints {
     0: number;
     1: number;
-    2?: number;
-};
-export type IGetNextPlayerResult = {
-    currentPlayer?: IPlayer;
-    currentRound?: IRound;
-    points?: IPoints;
-};
-export declare enum EHandPlayCommand {
-    TRUCO = 0,
-    ENVIDO = 1,
-    ENVIDO_ENVIDO = 2,
-    REAL_ENVIDO = 3,
-    FALTA_ENVIDO = 4,
-    MAZO = 5,
-    FLOR = 6,
-    CONTRAFLOR = 7
+}
+export interface RoundPoints {
+    0: number;
+    1: number;
+    ties: number;
+}
+export declare enum ESayCommand {
+    TRUCO = "TRUCO",
+    MAZO = "MAZO",
+    FLOR = "FLOR",
+    CONTRAFLOR = "CONTRAFLOR"
+}
+export declare enum EEnvidoCommand {
+    ENVIDO = "ENVIDO",
+    ENVIDO_ENVIDO = "ENVIDO_ENVIDO",
+    REAL_ENVIDO = "REAL_ENVIDO",
+    FALTA_ENVIDO = "FALTA_ENVIDO"
+}
+export type ECommand = ESayCommand | EEnvidoCommand;
+export interface TrucoState {
+    state: 1 | 2 | 3 | 4;
+    teamIdx: 0 | 1 | null;
+}
+export interface EnvidoState {
+    accept: number;
+    decline: number;
+    teamIdx: 0 | 1 | null;
 }
 export interface IPlayInstance {
+    teams: [ITeam, ITeam];
     handIdx: number;
     roundIdx: number;
+    state: EHandState;
+    truco: TrucoState;
+    envido: EnvidoState;
     player: IPlayer | null;
-    commands: Array<EHandPlayCommand> | null;
+    commands: Array<ECommand> | null;
     rounds: Array<IRound> | null;
     use(idx: number): ICard | null;
-    say(command: EHandPlayCommand): IHand | null;
+    say(command: ECommand): ECommand | null;
 }
+export declare enum EHandState {
+    WAITING_PLAY = "WAITING_PLAY",
+    WAITING_FOR_TRUCO_ANSWER = "WAITING_FOR_TRUCO_ANSWER",
+    WAITING_ENVIDO_ANSWER = "WAITING_ENVIDO_ANSWER",
+    FINISHED = "FINISHED"
+}
+export type IHandCommands = {
+    [key in ECommand]: (player: IPlayer) => void;
+};
 export interface IHand {
     idx: number;
+    state: EHandState;
     turn: number;
-    finished: boolean;
-    points: IPoints;
+    points: HandPoints;
+    truco: TrucoState;
+    envido: EnvidoState;
     rounds: Array<IRound>;
     currentPlayer: IPlayer | null;
     currentRound: IRound | null;
-    play(): IPlayInstance;
+    disabledPlayerIds: Array<string>;
+    commands: IHandCommands;
+    finished: () => boolean;
+    play(): IPlayInstance | null;
     pushRound(round: IRound): IRound;
     setTurn(turn: number): IPlayer;
     addPoints(team: 0 | 1, points: number): void;
+    disablePlayer(player: IPlayer): void;
     setCurrentRound(round: IRound | null): IRound | null;
     setCurrentPlayer(player: IPlayer | null): IPlayer | null;
-    setFinished(finshed: boolean): boolean;
+    setState(state: EHandState): EHandState;
     getNextPlayer(): IteratorResult<IHand, IHand | void>;
 }
 export interface ITable {
@@ -97,5 +131,17 @@ export interface IRound {
     winner: IPlayer | null;
     highest: number;
     cards: Array<IPlayedCard>;
-    play(playedCard: IPlayedCard): ICard;
+    use(playedCard: IPlayedCard): ICard;
 }
+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;
+};

package/build/lib/types.js

@@ -1,14 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EHandPlayCommand = void 0;
-var EHandPlayCommand;
-(function (EHandPlayCommand) {
-    EHandPlayCommand[EHandPlayCommand["TRUCO"] = 0] = "TRUCO";
-    EHandPlayCommand[EHandPlayCommand["ENVIDO"] = 1] = "ENVIDO";
-    EHandPlayCommand[EHandPlayCommand["ENVIDO_ENVIDO"] = 2] = "ENVIDO_ENVIDO";
-    EHandPlayCommand[EHandPlayCommand["REAL_ENVIDO"] = 3] = "REAL_ENVIDO";
-    EHandPlayCommand[EHandPlayCommand["FALTA_ENVIDO"] = 4] = "FALTA_ENVIDO";
-    EHandPlayCommand[EHandPlayCommand["MAZO"] = 5] = "MAZO";
-    EHandPlayCommand[EHandPlayCommand["FLOR"] = 6] = "FLOR";
-    EHandPlayCommand[EHandPlayCommand["CONTRAFLOR"] = 7] = "CONTRAFLOR";
-})(EHandPlayCommand = exports.EHandPlayCommand || (exports.EHandPlayCommand = {}));
+exports.EHandState = exports.EEnvidoCommand = exports.ESayCommand = void 0;
+var ESayCommand;
+(function (ESayCommand) {
+    ESayCommand["TRUCO"] = "TRUCO";
+    ESayCommand["MAZO"] = "MAZO";
+    ESayCommand["FLOR"] = "FLOR";
+    ESayCommand["CONTRAFLOR"] = "CONTRAFLOR";
+})(ESayCommand = exports.ESayCommand || (exports.ESayCommand = {}));
+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 = {}));
+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["FINISHED"] = "FINISHED";
+})(EHandState = exports.EHandState || (exports.EHandState = {}));

package/build/lib/utils.d.ts

@@ -1,5 +1,5 @@
 import { ICard, IRound, ITeam } from "./types";
+export declare function getMaxNumberIndex<T = number>(array: Array<T>): number;
 export declare function getCardValue(card: ICard): number;
-export declare function shuffleArray<T = never>(array: Array<T>): T[];
-export declare function checkHandWinner(rounds: Array<IRound>, forehandTeamIdx: 0 | 1): null | 0 | 1;
-export declare function checkMatchWinner(teams: Array<ITeam>, matchPoint: number): ITeam | null;
+export declare function shuffleArray<T = unknown>(array: Array<T>): T[];
+export declare function checkHandWinner(rounds: Array<IRound>, forehandTeamIdx: 0 | 1, disabledPlayerIds: Array<string>, teams: [ITeam, ITeam]): null | 0 | 1;

package/build/lib/utils.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkMatchWinner = exports.checkHandWinner = exports.shuffleArray = exports.getCardValue = void 0;
+exports.checkHandWinner = exports.shuffleArray = exports.getCardValue = exports.getMaxNumberIndex = void 0;
 var constants_1 = require("./constants");
+function getMaxNumberIndex(array) {
+    return array.reduce(function (accumulator, current, index) {
+        return current > array[accumulator] ? index : accumulator;
+    }, 0);
+}
+exports.getMaxNumberIndex = getMaxNumberIndex;
 function getCardValue(card) {
     return constants_1.CARDS[card] || -1;
 }
@@ -12,26 +18,41 @@ function shuffleArray(array) {
     while (currentIndex != 0) {
         randomIndex = Math.floor(Math.random() * currentIndex);
         currentIndex--;
-        _a = [
-            array[randomIndex], array[currentIndex]
-        ], array[currentIndex] = _a[0], array[randomIndex] = _a[1];
+        _a = [array[randomIndex], array[currentIndex]], array[currentIndex] = _a[0], array[randomIndex] = _a[1];
     }
     return array;
 }
 exports.shuffleArray = shuffleArray;
-function checkHandWinner(rounds, forehandTeamIdx) {
+function checkHandWinner(rounds, forehandTeamIdx, disabledPlayerIds, teams) {
     var _a, _b;
+    var winningTeamIdx = null;
+    // End hand if all players in one team go MAZO
+    if (disabledPlayerIds.length) {
+        var disabledTeams = teams.map(function (team) {
+            var forfeited = team.players.filter(function (player) { return disabledPlayerIds.includes(player.id); });
+            return forfeited.length === team.players.length;
+        });
+        if (disabledTeams[0] && disabledTeams[1]) {
+            return forehandTeamIdx;
+        }
+        if (disabledTeams[0]) {
+            return 1;
+        }
+        if (disabledTeams[1]) {
+            return 0;
+        }
+    }
     var roundsWon = {
         0: 0,
         1: 0,
-        2: 0 // tied rounds
+        ties: 0,
     };
     for (var i = 0; i < rounds.length; i++) {
         var round = rounds[i];
         if (round.tie) {
             roundsWon[0] += 1;
             roundsWon[1] += 1;
-            roundsWon[2] = (roundsWon[2] || 0) + 1;
+            roundsWon.ties = roundsWon.ties + 1;
             continue;
         }
         if (((_a = round.winner) === null || _a === void 0 ? void 0 : _a.teamIdx) === 0) {
@@ -41,8 +62,7 @@ function checkHandWinner(rounds, forehandTeamIdx) {
             roundsWon[1] += 1;
         }
     }
-    var ties = roundsWon[2] || 0;
-    if ((roundsWon[0] > 2 && roundsWon[1] > 2) || (rounds.length > 2 && ties > 0)) {
+    if ((roundsWon[0] > 2 && roundsWon[1] > 2) || (rounds.length > 2 && roundsWon.ties > 0)) {
         return forehandTeamIdx;
     }
     if (roundsWon[0] >= 2 && roundsWon[1] < 2) {
@@ -54,13 +74,3 @@ function checkHandWinner(rounds, forehandTeamIdx) {
     return null;
 }
 exports.checkHandWinner = checkHandWinner;
-function checkMatchWinner(teams, matchPoint) {
-    if (teams[0].points >= matchPoint) {
-        return teams[0];
-    }
-    if (teams[1].points >= matchPoint) {
-        return teams[1];
-    }
-    return null;
-}
-exports.checkMatchWinner = checkMatchWinner;

package/build/server/index.js

@@ -2,18 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var http_1 = require("http");
 var socket_io_1 = require("socket.io");
+var types_1 = require("./types");
 var PORT = 4001;
 var httpServer = (0, http_1.createServer)();
 var io = new socket_io_1.Server(httpServer, {
     cors: {
         origin: "http://localhost:3000",
-        methods: ["GET", "POST"]
-    }
+        methods: ["GET", "POST"],
+    },
 });
+var sessions = new Map();
 io.on("connection", function (socket) {
-    socket.on('ping', function (msg) {
-        io.emit('pong', msg);
+    socket.on(types_1.EClientEvent.PING, function (msg) {
+        io.emit(types_1.EServerEvent.PONG, msg);
+    });
+    socket.on(types_1.EClientEvent.CREATE_MATCH, function (msg) {
+    });
+    socket.on(types_1.EClientEvent.SET_PLAYER_ID, function (msg) {
+        if (typeof msg === 'string' && msg.length < 32) {
+        }
     });
 });
 httpServer.listen(PORT);
-console.log('Listening on port', PORT);
+console.log("Listening on port", PORT);

package/build/server/types.d.ts

@@ -0,0 +1,11 @@
+export declare enum EClientEvent {
+    PING = "PING",
+    CREATE_MATCH = "CREATE_MATCH",
+    JOIN_MATCH = "JOIN_MATCH",
+    START_MATCH = "START_MATCH",
+    SET_PLAYER_ID = "SET_PLAYER_ID"
+}
+export declare enum EServerEvent {
+    SET_SESSION_ID = "SET_SESSION_ID",
+    PONG = "PONG"
+}

package/build/server/types.js

@@ -1 +1,16 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EServerEvent = exports.EClientEvent = void 0;
+var EClientEvent;
+(function (EClientEvent) {
+    EClientEvent["PING"] = "PING";
+    EClientEvent["CREATE_MATCH"] = "CREATE_MATCH";
+    EClientEvent["JOIN_MATCH"] = "JOIN_MATCH";
+    EClientEvent["START_MATCH"] = "START_MATCH";
+    EClientEvent["SET_PLAYER_ID"] = "SET_PLAYER_ID";
+})(EClientEvent = exports.EClientEvent || (exports.EClientEvent = {}));
+var EServerEvent;
+(function (EServerEvent) {
+    EServerEvent["SET_SESSION_ID"] = "SET_SESSION_ID";
+    EServerEvent["PONG"] = "PONG";
+})(EServerEvent = exports.EServerEvent || (exports.EServerEvent = {}));

package/build/test/autoplay.js

@@ -36,38 +36,50 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var constants_1 = require("../lib/constants");
-var trucoshi_1 = require("../lib/trucoshi");
+var lib_1 = require("../lib");
 (function () { return __awaiter(void 0, void 0, void 0, function () {
-    var player1, player2, player3, player4, player5, player6, team1, team2, match, play, name, randomIdx, card;
-    var _a;
-    return __generator(this, function (_b) {
-        player1 = (0, trucoshi_1.Player)('lukini', 0);
-        player2 = (0, trucoshi_1.Player)('guada', 0);
-        player3 = (0, trucoshi_1.Player)('denoph', 1);
-        player4 = (0, trucoshi_1.Player)('juli', 1);
-        player5 = (0, trucoshi_1.Player)('fran', 1);
-        player6 = (0, trucoshi_1.Player)('day', 0);
-        team1 = (0, trucoshi_1.Team)(constants_1.COLORS[0], [player1, player2, player6]);
-        team2 = (0, trucoshi_1.Team)(constants_1.COLORS[1], [player3, player4, player5]);
-        match = (0, trucoshi_1.Match)([team1, team2], 9);
-        while (!match.winner) {
-            play = match.play();
-            if (!play || !play.player) {
-                break;
-            }
-            name = play.player.id.toUpperCase();
-            console.log("=== Mano ".concat(play.handIdx, " === Ronda ").concat(play.roundIdx, " === Turno de ").concat(name, " ==="));
-            match.teams.map(function (team, id) { return console.log("=== Team ".concat(id, " = ").concat(team.points, " Puntos ===")); });
-            console.log(play.rounds && play.rounds.length ? (play.rounds.map(function (round) { return round.cards.length ? round.cards.map(function (c) { return [c.player.id, c.card]; }) : ''; })) : '');
-            randomIdx = Math.round(Math.random() * (play.player.hand.length - 1));
-            card = play.use(randomIdx);
-            console.log("\n".concat(JSON.stringify(play.player.hand), "\nUsing ").concat(card));
-            console.log(play.rounds && play.rounds.length ? (play.rounds.map(function (round) { return round.cards.length ? round.cards.map(function (c) { return [c.player.id, c.card]; }) : ''; })) : '');
-        }
-        console.log('\n');
-        match.teams.map(function (t, i) { return console.log("Equipo ".concat(i, ": ").concat(t.players.map(function (p) { return " ".concat(p.id); }), " === ").concat(t.points, " puntos")); });
-        console.log("\nEquipo Ganador:".concat((_a = match.winner) === null || _a === void 0 ? void 0 : _a.players.map(function (p) { return " ".concat(p.id); })));
+    return __generator(this, function (_a) {
+        (0, lib_1.Trucoshi)(["lukini", "guada", "day"], ["denoph", "juli", "fran"], 9)
+            .onTurn(function (play) { return __awaiter(void 0, void 0, void 0, function () {
+            var name, randomIdx, handString, card;
+            var _a;
+            return __generator(this, function (_b) {
+                if (!play.player) {
+                    return [2 /*return*/];
+                }
+                name = (_a = play.player) === null || _a === void 0 ? void 0 : _a.id.toUpperCase();
+                console.log("=== Mano ".concat(play.handIdx, " === Ronda ").concat(play.roundIdx, " === Turno de ").concat(name, " ==="));
+                play.teams.map(function (team, id) {
+                    return console.log("=== Team ".concat(id, " = ").concat(team.points.malas, " malas ").concat(team.points.buenas, " buenas ==="));
+                });
+                console.log(play.rounds && play.rounds.length
+                    ? play.rounds.map(function (round) {
+                        return round.cards.length ? round.cards.map(function (c) { return [c.player.id, c.card]; }) : "";
+                    })
+                    : "");
+                randomIdx = Math.round(Math.random() * (play.player.hand.length - 1));
+                handString = JSON.stringify(play.player.hand);
+                card = play.use(randomIdx);
+                console.log("\n".concat(handString, "\nUsing ").concat(card));
+                console.log(play.rounds && play.rounds.length
+                    ? play.rounds.map(function (round) {
+                        return round.cards.length ? round.cards.map(function (c) { return [c.player.id, c.card]; }) : "";
+                    })
+                    : "");
+                return [2 /*return*/];
+            });
+        }); })
+            .onWinner(function (winner, teams) { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                console.log("\n");
+                teams.map(function (t, i) {
+                    return console.log("Equipo ".concat(i, ": ").concat(t.players.map(function (p) { return " ".concat(p.id); }), " === ").concat(t.points.malas, " malas ").concat(t.points.buenas, " buenas"));
+                });
+                console.log("\nEquipo Ganador:".concat(winner.players.map(function (p) { return " ".concat(p.id); })));
+                return [2 /*return*/];
+            });
+        }); })
+            .start();
         return [2 /*return*/];
     });
 }); })();