trucoshi 0.0.7 → 0.0.8

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

@@ -0,0 +1,2 @@
+import { IDeck } from "../types";
+export declare function Deck(): IDeck;

package/build/lib/classes/Deck.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deck = void 0;
+var constants_1 = require("../constants");
+var utils_1 = require("../utils");
+function Deck() {
+    var deck = {
+        cards: Object.keys(constants_1.CARDS),
+        usedCards: [],
+        takeCard: function () {
+            var card = deck.cards.shift();
+            deck.usedCards.push(card);
+            return card;
+        },
+        shuffle: function () {
+            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;

package/build/lib/classes/Hand.d.ts

@@ -0,0 +1,2 @@
+import { IDeck, IHand, IMatch } from "../types";
+export declare function Hand(match: IMatch, deck: IDeck, idx: number): IHand;

package/build/lib/classes/Hand.js

@@ -0,0 +1,233 @@
+"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.Hand = void 0;
+var types_1 = require("../types");
+var utils_1 = require("../utils");
+var Play_1 = require("./Play");
+var Round_1 = require("./Round");
+var Truco_1 = require("./Truco");
+function Hand(match, deck, idx) {
+    var _a;
+    match.teams.forEach(function (team) {
+        team.players.forEach(function (player) {
+            var playerHand = [deck.takeCard(), deck.takeCard(), deck.takeCard()];
+            player.setHand(playerHand);
+            player.enable();
+            // player.setHand(["5c", "4c", "6c"])
+        });
+    });
+    function roundsGeneratorSequence() {
+        var currentRoundIdx, forehandTeamIdx, round, previousRound, newTurn, value, player, winnerTeamIdx;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    currentRoundIdx = 0;
+                    forehandTeamIdx = match.table.player(hand.turn).teamIdx;
+                    _a.label = 1;
+                case 1:
+                    if (!(currentRoundIdx < 3 && !hand.finished())) return [3 /*break*/, 9];
+                    round = (0, Round_1.Round)(0);
+                    hand.setCurrentRound(round);
+                    hand.pushRound(round);
+                    previousRound = hand.rounds[currentRoundIdx - 1];
+                    // Put previous round winner as forehand
+                    if (previousRound && previousRound.winner && !previousRound.tie) {
+                        newTurn = match.table.getPlayerPosition(previousRound.winner.id);
+                        if (newTurn !== -1) {
+                            hand.setTurn(newTurn);
+                        }
+                    }
+                    _a.label = 2;
+                case 2:
+                    if (!(round.turn < match.table.players.length)) return [3 /*break*/, 8];
+                    _a.label = 3;
+                case 3:
+                    if (!(hand.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER)) return [3 /*break*/, 6];
+                    value = hand.truco.getNextPlayer().value;
+                    if (!(value && value.currentPlayer)) return [3 /*break*/, 5];
+                    console.log({ value: value.currentPlayer });
+                    hand.setCurrentPlayer(value.currentPlayer);
+                    return [4 /*yield*/, hand];
+                case 4:
+                    _a.sent();
+                    _a.label = 5;
+                case 5: return [3 /*break*/, 3];
+                case 6:
+                    player = match.table.player(hand.turn);
+                    hand.setCurrentPlayer(player);
+                    if (player.disabled) {
+                        hand.setCurrentPlayer(null);
+                    }
+                    return [4 /*yield*/, hand];
+                case 7:
+                    _a.sent();
+                    return [3 /*break*/, 2];
+                case 8:
+                    if (match.teams[0].isTeamDisabled() && match.teams[1].isTeamDisabled()) {
+                        hand.setState(types_1.EHandState.FINISHED);
+                        return [3 /*break*/, 9];
+                    }
+                    winnerTeamIdx = (0, utils_1.checkHandWinner)(hand.rounds, forehandTeamIdx);
+                    if (match.teams[0].isTeamDisabled()) {
+                        winnerTeamIdx = 1;
+                    }
+                    if (match.teams[1].isTeamDisabled()) {
+                        winnerTeamIdx = 0;
+                    }
+                    if (winnerTeamIdx !== null) {
+                        hand.addPoints(winnerTeamIdx, hand.truco.state);
+                        hand.setState(types_1.EHandState.FINISHED);
+                    }
+                    currentRoundIdx++;
+                    return [3 /*break*/, 1];
+                case 9: return [4 /*yield*/, hand];
+                case 10:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }
+    var roundsGenerator = roundsGeneratorSequence();
+    var commands = (_a = {},
+        _a[types_1.ESayCommand.MAZO] = function (player) {
+            hand.disablePlayer(player);
+        },
+        _a[types_1.ESayCommand.TRUCO] = function (player) {
+            var teamIdx = hand.truco.teamIdx;
+            if (teamIdx === null || teamIdx !== player.teamIdx) {
+                hand.setState(types_1.EHandState.WAITING_FOR_TRUCO_ANSWER);
+                hand.truco.sayTruco(player.teamIdx, match.teams[Number(!player.teamIdx)].players);
+            }
+        },
+        _a[types_1.ESayCommand.QUIERO] = function () {
+            if (hand.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
+                hand.truco.setAnswer(true);
+                hand.setState(types_1.EHandState.WAITING_PLAY);
+            }
+        },
+        _a[types_1.ESayCommand.NO_QUIERO] = function (player) {
+            if (hand.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
+                hand.truco.setAnswer(false);
+                hand.setState(types_1.EHandState.WAITING_PLAY);
+            }
+        },
+        _a[types_1.ESayCommand.FLOR] = function () { },
+        _a[types_1.ESayCommand.CONTRAFLOR] = function () { },
+        _a[types_1.EEnvidoCommand.ENVIDO] = function () { },
+        _a[types_1.EEnvidoCommand.ENVIDO_ENVIDO] = function () { },
+        _a[types_1.EEnvidoCommand.REAL_ENVIDO] = function () { },
+        _a[types_1.EEnvidoCommand.FALTA_ENVIDO] = function () { },
+        _a);
+    var hand = {
+        idx: idx,
+        turn: Number(match.table.forehandIdx),
+        state: types_1.EHandState.WAITING_PLAY,
+        rounds: [],
+        truco: (0, Truco_1.Truco)(),
+        envido: {
+            accept: 1,
+            decline: 2,
+            teamIdx: null,
+        },
+        points: [0, 0],
+        currentRound: null,
+        _currentPlayer: null,
+        set currentPlayer(player) {
+            hand._currentPlayer = player;
+        },
+        get currentPlayer() {
+            if (hand.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
+                return hand.truco.currentPlayer;
+            }
+            return hand._currentPlayer;
+        },
+        commands: commands,
+        play: function () {
+            return (0, Play_1.PlayInstance)(hand, match.teams);
+        },
+        use: function (idx) {
+            var player = hand.currentPlayer;
+            var round = hand.currentRound;
+            if (!player || !round) {
+                return null;
+            }
+            var card = player.useCard(idx);
+            if (card) {
+                hand.nextTurn();
+                return round.use({ player: player, card: card });
+            }
+            return null;
+        },
+        nextTurn: function () {
+            var _a;
+            if (hand.turn >= match.table.players.length - 1) {
+                hand.setTurn(0);
+            }
+            else {
+                hand.setTurn(hand.turn + 1);
+            }
+            (_a = hand.currentRound) === null || _a === void 0 ? void 0 : _a.nextTurn();
+        },
+        getNextPlayer: function () {
+            return roundsGenerator.next();
+        },
+        disablePlayer: function (player) {
+            match.teams[player.teamIdx].disable(player);
+        },
+        addPoints: function (team, points) {
+            hand.points[team] = hand.points[team] + points;
+        },
+        pushRound: function (round) {
+            hand.rounds.push(round);
+            return round;
+        },
+        setTurn: function (turn) {
+            hand.turn = turn;
+            return match.table.player(hand.turn);
+        },
+        setCurrentRound: function (round) {
+            hand.currentRound = round;
+            return hand.currentRound;
+        },
+        setCurrentPlayer: function (player) {
+            hand._currentPlayer = player;
+            return hand._currentPlayer;
+        },
+        setState: function (state) {
+            hand.state = state;
+            return hand.state;
+        },
+        finished: function () {
+            return hand.state === types_1.EHandState.FINISHED;
+        },
+    };
+    return hand;
+}
+exports.Hand = Hand;

package/build/lib/classes/Match.d.ts

@@ -0,0 +1,2 @@
+import { IMatch, ITable, ITeam } from "../types";
+export declare function Match(table: ITable, teams?: Array<ITeam>, matchPoint?: number): IMatch;

package/build/lib/classes/Match.js

@@ -0,0 +1,115 @@
+"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.Match = void 0;
+var Deck_1 = require("./Deck");
+var Hand_1 = require("./Hand");
+function Match(table, teams, matchPoint) {
+    if (teams === void 0) { teams = []; }
+    if (matchPoint === void 0) { matchPoint = 9; }
+    var deck = (0, Deck_1.Deck)().shuffle();
+    var size = teams[0].players.length;
+    if (size !== teams[1].players.length) {
+        throw new Error("Team size mismatch");
+    }
+    function handsGeneratorSequence() {
+        var hand, value, teams_1, winner;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!!match.winner) return [3 /*break*/, 4];
+                    deck.shuffle();
+                    hand = match.setCurrentHand((0, Hand_1.Hand)(match, deck, match.hands.length + 1));
+                    match.pushHand(hand);
+                    _a.label = 1;
+                case 1:
+                    if (!!hand.finished()) return [3 /*break*/, 3];
+                    value = hand.getNextPlayer().value;
+                    if (value && value.finished()) {
+                        return [3 /*break*/, 1];
+                    }
+                    match.setCurrentHand(value);
+                    return [4 /*yield*/, match];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 1];
+                case 3:
+                    match.setCurrentHand(null);
+                    teams_1 = match.addPoints(hand.points);
+                    winner = teams_1.find(function (team) { return team.points.winner; });
+                    if (winner) {
+                        match.setWinner(winner);
+                        match.setCurrentHand(null);
+                        return [3 /*break*/, 4];
+                    }
+                    match.table.nextTurn();
+                    return [3 /*break*/, 0];
+                case 4: return [4 /*yield*/, match];
+                case 5:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }
+    var handsGenerator = handsGeneratorSequence();
+    var match = {
+        winner: null,
+        teams: teams,
+        hands: [],
+        table: table,
+        currentHand: null,
+        play: function () {
+            match.getNextTurn();
+            if (!match.currentHand) {
+                return null;
+            }
+            return match.currentHand.play();
+        },
+        addPoints: function (points) {
+            match.teams[0].addPoints(matchPoint, points[0]);
+            match.teams[1].addPoints(matchPoint, points[1]);
+            return match.teams;
+        },
+        pushHand: function (hand) {
+            match.hands.push(hand);
+        },
+        setCurrentHand: function (hand) {
+            match.currentHand = hand;
+            return match.currentHand;
+        },
+        setWinner: function (winner) {
+            match.winner = winner;
+        },
+        getNextTurn: function () {
+            return handsGenerator.next();
+        },
+    };
+    return match;
+}
+exports.Match = Match;

package/build/lib/classes/Play.d.ts

@@ -0,0 +1,2 @@
+import { IHand, IPlayInstance, ITeam } from "../types";
+export declare function PlayInstance(hand: IHand, teams: [ITeam, ITeam]): IPlayInstance;

package/build/lib/classes/Play.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayInstance = void 0;
+var types_1 = require("../types");
+function PlayInstance(hand, teams) {
+    var _a, _b, _c;
+    var instance = {
+        state: hand.state,
+        teams: teams,
+        truco: hand.truco,
+        envido: hand.envido,
+        handIdx: hand.idx,
+        roundIdx: hand.rounds.length,
+        player: hand.currentPlayer,
+        commands: [],
+        rounds: hand.rounds,
+        use: function (idx) {
+            return hand.use(idx);
+        },
+        say: function (command) {
+            var _a;
+            if (!hand._currentPlayer || !((_a = instance.commands) === null || _a === void 0 ? void 0 : _a.includes(command))) {
+                return null;
+            }
+            hand.commands[command](hand._currentPlayer);
+            return command;
+        },
+    };
+    (_a = instance.commands) === null || _a === void 0 ? void 0 : _a.push(types_1.ESayCommand.MAZO);
+    (_b = instance.commands) === null || _b === void 0 ? void 0 : _b.push(types_1.ESayCommand.TRUCO);
+    if (hand.rounds.length === 1) {
+        (_c = instance.commands) === null || _c === void 0 ? void 0 : _c.push(types_1.EEnvidoCommand.ENVIDO);
+    }
+    if (hand.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
+        instance.commands = [types_1.ESayCommand.TRUCO, types_1.ESayCommand.QUIERO, types_1.ESayCommand.NO_QUIERO];
+    }
+    return instance;
+}
+exports.PlayInstance = PlayInstance;

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

@@ -0,0 +1,2 @@
+import { IPlayer } from "../types";
+export declare function Player(id: string, teamIdx: number): IPlayer;

package/build/lib/classes/Player.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Player = void 0;
+function Player(id, teamIdx) {
+    var player = {
+        id: id,
+        teamIdx: teamIdx,
+        hand: [],
+        commands: [],
+        usedHand: [],
+        disabled: false,
+        ready: false,
+        enable: function () {
+            player.disabled = false;
+        },
+        disable: function () {
+            player.disabled = true;
+        },
+        setReady: function (ready) {
+            player.ready = ready;
+        },
+        setHand: function (hand) {
+            player.hand = hand;
+            player.usedHand = [];
+            return hand;
+        },
+        useCard: function (idx) {
+            if (player.hand[idx]) {
+                var card = player.hand.splice(idx, 1)[0];
+                player.usedHand.push(card);
+                return card;
+            }
+            return null;
+        },
+    };
+    return player;
+}
+exports.Player = Player;

package/build/lib/classes/Round.d.ts

@@ -0,0 +1,2 @@
+import { IRound } from "../types";
+export declare function Round(turn: number): IRound;

package/build/lib/classes/Round.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Round = void 0;
+var utils_1 = require("../utils");
+function Round(turn) {
+    var round = {
+        turn: turn,
+        highest: -1,
+        winner: null,
+        cards: [],
+        tie: false,
+        nextTurn: function () {
+            round.turn++;
+        },
+        use: function (_a) {
+            var _b;
+            var card = _a.card, player = _a.player;
+            var value = (0, utils_1.getCardValue)(card);
+            if (value === round.highest && player.teamIdx !== ((_b = round.winner) === null || _b === void 0 ? void 0 : _b.teamIdx)) {
+                round.tie = true;
+            }
+            if (value > round.highest) {
+                round.tie = false;
+                round.highest = value;
+                round.winner = player;
+            }
+            round.cards.push({ card: card, player: player });
+            return card;
+        },
+    };
+    return round;
+}
+exports.Round = Round;

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

@@ -0,0 +1,2 @@
+import { IPlayer, ITable, ITeam } from "../types";
+export declare function Table(players: Array<IPlayer>, teams: Array<ITeam>): ITable;

package/build/lib/classes/Table.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Table = void 0;
+function Table(players, teams) {
+    var table = {
+        players: players,
+        cards: [],
+        forehandIdx: 0,
+        nextTurn: function () {
+            if (table.forehandIdx < table.players.length - 1) {
+                table.forehandIdx++;
+            }
+            else {
+                table.forehandIdx = 0;
+            }
+            return table.player();
+        },
+        getPlayerPosition: function (id) {
+            return table.players.findIndex(function (p) { return p.id === id; });
+        },
+        player: function (idx) {
+            if (idx !== undefined) {
+                return table.players[idx];
+            }
+            return table.players[table.forehandIdx];
+        },
+    };
+    return table;
+}
+exports.Table = Table;

package/build/lib/classes/Team.d.ts

@@ -0,0 +1,2 @@
+import { IPlayer, ITeam } from "../types";
+export declare function Team(players: Array<IPlayer>): ITeam;

package/build/lib/classes/Team.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Team = void 0;
+function Team(players) {
+    var team = {
+        _players: new Map(),
+        get players() {
+            return Array.from(team._players.values());
+        },
+        points: {
+            buenas: 0,
+            malas: 0,
+            winner: false,
+        },
+        isTeamDisabled: function () {
+            return team.players.reduce(function (prev, curr) { return prev && curr.disabled; }, true);
+        },
+        disable: function (player) {
+            var _a;
+            (_a = team._players.get(player.id)) === null || _a === void 0 ? void 0 : _a.disable();
+            return team.isTeamDisabled();
+        },
+        addPoints: function (matchPoint, points) {
+            var malas = team.points.malas + points;
+            var diff = malas - matchPoint;
+            if (diff > 0) {
+                team.points.malas = matchPoint;
+                team.points.buenas += diff;
+                if (team.points.buenas >= matchPoint) {
+                    team.points.winner = true;
+                }
+            }
+            else {
+                team.points.malas = malas;
+            }
+            return team.points;
+        },
+    };
+    players.forEach(function (player) { return team._players.set(player.id, player); });
+    return team;
+}
+exports.Team = Team;

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

@@ -0,0 +1,2 @@
+import { ITruco } from "../types";
+export declare function Truco(): ITruco;