trucoshi 0.0.2 → 0.0.5

package/build/lib/classes/Truco.js

@@ -0,0 +1,110 @@
+"use strict";
+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.Truco = void 0;
+function Truco() {
+    function trucoAnswerGeneratorSequence() {
+        var i, player;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < truco.players.length && truco.answer === null)) return [3 /*break*/, 3];
+                    player = truco.players[truco.turn];
+                    truco.setCurrentPlayer(player);
+                    if (player.disabled) {
+                        truco.setCurrentPlayer(null);
+                    }
+                    if (truco.turn >= truco.players.length - 1) {
+                        truco.setTurn(0);
+                    }
+                    else {
+                        truco.setTurn(truco.turn + 1);
+                    }
+                    i++;
+                    return [4 /*yield*/, truco];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 1];
+                case 3: return [4 /*yield*/, truco];
+                case 4:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }
+    var truco = {
+        turn: 0,
+        state: 1,
+        teamIdx: null,
+        answer: null,
+        currentPlayer: null,
+        generator: trucoAnswerGeneratorSequence(),
+        players: [],
+        sayTruco: function (teamIdx, players) {
+            truco.teamIdx = teamIdx;
+            truco.answer = null;
+            truco.players = players;
+            truco.generator = trucoAnswerGeneratorSequence();
+            return truco;
+        },
+        setPlayers: function (players) {
+            truco.players = players;
+        },
+        setAnswer: function (answer) {
+            if (answer) {
+                truco.state++;
+            }
+            if (answer !== null) {
+                truco.teamIdx = null;
+            }
+            truco.answer = answer;
+            return truco;
+        },
+        setTeam: function (idx) {
+            truco.teamIdx = idx;
+            return truco.teamIdx;
+        },
+        setTurn: function (turn) {
+            truco.turn = turn;
+            return truco.turn;
+        },
+        setCurrentPlayer: function (player) {
+            truco.currentPlayer = player;
+            return truco.currentPlayer;
+        },
+        getNextPlayer: function () {
+            return truco.generator.next();
+        },
+    };
+    return truco;
+}
+exports.Truco = Truco;

package/build/lib/constants.d.ts

@@ -1,18 +1,19 @@
+import { IEnvidoCalculator } from "./types";
 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;
+    "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;
@@ -25,19 +26,26 @@ export declare const CARDS: {
     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;
+    "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 COLORS: string[];
+export declare const TEAM_SIZE_VALUES: number[];
+export declare enum GAME_ERROR {
+    UNEXPECTED_TEAM_SIZE = "UNEXPECTED_TEAM_SIZE",
+    TEAM_NOT_READY = "TEAM_NOT_READY",
+    TEAM_IS_FULL = "TEAM_IS_FULL"
+}
+export declare const EnvidoCalculator: IEnvidoCalculator;

package/build/lib/constants.js

@@ -1,16 +1,101 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.COLORS = exports.CARDS = void 0;
+exports.EnvidoCalculator = exports.GAME_ERROR = exports.TEAM_SIZE_VALUES = 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.TEAM_SIZE_VALUES = [1, 2, 3];
+var GAME_ERROR;
+(function (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 = exports.GAME_ERROR || (exports.GAME_ERROR = {}));
+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,18 @@
+import { IPlayInstance, ITeam, ITrucoshi } from "./types";
+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 interface IGameLoop {
+    _onTruco: ITrucoCallback;
+    _onTurn: ITurnCallback;
+    _onWinner: IWinnerCallback;
+    onTurn: (callback: ITurnCallback) => IGameLoop;
+    onWinner: (callback: IWinnerCallback) => IGameLoop;
+    onTruco: (callback: ITrucoCallback) => IGameLoop;
+    begin: () => void;
+}
+export declare function Trucoshi(teamSize?: 1 | 2 | 3): {
+    addPlayer: (id: string, teamIdx?: 0 | 1 | undefined) => import("./types").IPlayer;
+    removePlayer: (id: string) => ITrucoshi;
+    startMatch: (matchPoint?: 9 | 12 | 15 | undefined) => IGameLoop;
+};

package/build/lib/index.js

@@ -0,0 +1,161 @@
+"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 Table_1 = require("./classes/Table");
+var Team_1 = require("./classes/Team");
+var constants_1 = require("./constants");
+var types_1 = require("./types");
+var GameLoop = function (match) {
+    var gameloop = {
+        _onTruco: function () { return Promise.resolve(); },
+        _onTurn: function () { return Promise.resolve(); },
+        _onWinner: function () { return Promise.resolve(); },
+        onTruco: function (callback) {
+            gameloop._onTruco = callback;
+            return gameloop;
+        },
+        onTurn: function (callback) {
+            gameloop._onTurn = callback;
+            return gameloop;
+        },
+        onWinner: function (callback) {
+            gameloop._onWinner = callback;
+            return gameloop;
+        },
+        begin: 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*/, 5];
+                            play = match.play();
+                            if (!play || !play.player) {
+                                return [3 /*break*/, 0];
+                            }
+                            if (!(play.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, gameloop._onTruco(play)];
+                        case 1:
+                            _a.sent();
+                            return [3 /*break*/, 0];
+                        case 2:
+                            if (!(play.state === types_1.EHandState.WAITING_PLAY)) return [3 /*break*/, 4];
+                            return [4 /*yield*/, gameloop._onTurn(play)];
+                        case 3:
+                            _a.sent();
+                            return [3 /*break*/, 0];
+                        case 4: return [3 /*break*/, 0];
+                        case 5: return [4 /*yield*/, gameloop._onWinner(match.winner, match.teams)];
+                        case 6:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        },
+    };
+    return gameloop;
+};
+function Trucoshi(teamSize) {
+    var trucoshi = {
+        lastTeamIdx: 1,
+        _players: new Map(),
+        get players() {
+            return Array.from(trucoshi._players.values());
+        },
+        teams: [],
+        table: null,
+        maxPlayers: teamSize ? teamSize * 2 : 6,
+        full: false,
+        ready: false,
+        calculateReady: function () {
+            trucoshi.ready = trucoshi.players.reduce(function (prev, curr) { return prev && curr.ready; }, true);
+            return trucoshi.ready;
+        },
+        calculateFull: function () {
+            trucoshi.full = trucoshi._players.size >= trucoshi.maxPlayers;
+            return trucoshi.full;
+        },
+        addPlayer: function (id, teamIdx) {
+            var maxSize = teamSize ? teamSize : 3;
+            if (trucoshi.full || trucoshi.players.filter(function (p) { return p.teamIdx === teamIdx; }).length > maxSize) {
+                throw new Error(constants_1.GAME_ERROR.TEAM_IS_FULL);
+            }
+            var player = (0, Player_1.Player)(id, teamIdx !== undefined ? teamIdx : Number(!trucoshi.lastTeamIdx));
+            trucoshi.lastTeamIdx = Number(!trucoshi.lastTeamIdx);
+            trucoshi._players.set(id, player);
+            trucoshi.calculateFull();
+            trucoshi.calculateReady();
+            return player;
+        },
+        removePlayer: function (id) {
+            trucoshi._players.delete(id);
+            trucoshi.calculateFull();
+            trucoshi.calculateReady();
+            return trucoshi;
+        },
+        startMatch: function (matchPoint) {
+            if (matchPoint === void 0) { matchPoint = 9; }
+            trucoshi.calculateReady();
+            var teamSize = trucoshi._players.size / 2;
+            if (!constants_1.TEAM_SIZE_VALUES.includes(teamSize)) {
+                throw new Error(constants_1.GAME_ERROR.UNEXPECTED_TEAM_SIZE);
+            }
+            if (!trucoshi.ready) {
+                throw new Error(constants_1.GAME_ERROR.TEAM_NOT_READY);
+            }
+            trucoshi.teams.push((0, Team_1.Team)(trucoshi.players.filter(function (p) { return p.teamIdx === 0; })));
+            trucoshi.teams.push((0, Team_1.Team)(trucoshi.players.filter(function (p) { return p.teamIdx === 1; })));
+            if (trucoshi.teams[0].players.length !== teamSize ||
+                trucoshi.teams[1].players.length !== teamSize) {
+                throw new Error(constants_1.GAME_ERROR.UNEXPECTED_TEAM_SIZE);
+            }
+            trucoshi.table = (0, Table_1.Table)(trucoshi.players, trucoshi.teams);
+            return GameLoop((0, Match_1.Match)(trucoshi.table, trucoshi.teams, matchPoint));
+        },
+    };
+    return {
+        addPlayer: trucoshi.addPlayer,
+        removePlayer: trucoshi.removePlayer,
+        startMatch: trucoshi.startMatch,
+    };
+}
+exports.Trucoshi = Trucoshi;