trucoshi 0.0.4 → 0.0.6

package/README.md

@@ -1,10 +1,10 @@
 # Trucoshi
 
 ### English 
-Pretends to be an Argentinian Truco game socket server
+Pretends to be an Argentinian Truco game socket server that allows you to put Satoshis on the table ;)
 
 ### Spanish
-Pretende ser un server basado en sockets del juego de Truco Argentino
+Pretende ser un server basado en sockets del juego de Truco Argentino que te permita poner unos Satoshis en la mesa ;)
 
 # Test
 Right now there's only a local CLI way of playing as there is no socket server implementation and its just the game logic.
@@ -25,6 +25,7 @@ Right now there's only a local CLI way of playing as there is no socket server i
     [] Cantar envido
     [] Cantar flor
     [] Socket server
+    [] Bitcoin Lightning integration
     [] Unit tests
 
 # License 

package/build/lib/classes/Hand.js

@@ -32,17 +32,19 @@ 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, i, round, previousRound, newTurn, player, teamIdx;
+        var currentRoundIdx, forehandTeamIdx, round, previousRound, newTurn, value, player, winnerTeamIdx;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -50,9 +52,8 @@ function Hand(match, deck, idx) {
                     forehandTeamIdx = match.table.player(hand.turn).teamIdx;
                     _a.label = 1;
                 case 1:
-                    if (!(currentRoundIdx < 3 && !hand.finished())) return [3 /*break*/, 5];
-                    i = 0;
-                    round = (0, Round_1.Round)();
+                    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];
@@ -65,33 +66,49 @@ function Hand(match, deck, idx) {
                     }
                     _a.label = 2;
                 case 2:
-                    if (!(i < match.table.players.length)) return [3 /*break*/, 4];
+                    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 (hand.disabledPlayerIds.includes(player.id)) {
+                    if (player.disabled) {
                         hand.setCurrentPlayer(null);
                     }
-                    if (hand.turn >= match.table.players.length - 1) {
-                        hand.setTurn(0);
-                    }
-                    else {
-                        hand.setTurn(hand.turn + 1);
-                    }
-                    i++;
                     return [4 /*yield*/, hand];
-                case 3:
+                case 7:
                     _a.sent();
                     return [3 /*break*/, 2];
-                case 4:
-                    teamIdx = (0, utils_1.checkHandWinner)(hand.rounds, forehandTeamIdx, hand.disabledPlayerIds, match.teams);
-                    if (teamIdx !== null) {
-                        hand.addPoints(teamIdx, hand.truco.state);
+                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 5: return [4 /*yield*/, hand];
-                case 6:
+                case 9: return [4 /*yield*/, hand];
+                case 10:
                     _a.sent();
                     return [2 /*return*/];
             }
@@ -106,6 +123,19 @@ function Hand(match, deck, idx) {
             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 () { },
@@ -120,28 +150,56 @@ function Hand(match, deck, idx) {
         turn: Number(match.table.forehandIdx),
         state: types_1.EHandState.WAITING_PLAY,
         rounds: [],
-        truco: {
-            state: 1,
-            teamIdx: null,
-        },
+        truco: (0, Truco_1.Truco)(),
         envido: {
             accept: 1,
             decline: 2,
             teamIdx: null,
         },
         points: [0, 0],
-        disabledPlayerIds: [],
         currentRound: null,
-        currentPlayer: 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) {
-            hand.disabledPlayerIds.push(player.id);
+            match.teams[player.teamIdx].disable(player);
         },
         addPoints: function (team, points) {
             hand.points[team] = hand.points[team] + points;
@@ -159,8 +217,8 @@ function Hand(match, deck, idx) {
             return hand.currentRound;
         },
         setCurrentPlayer: function (player) {
-            hand.currentPlayer = player;
-            return hand.currentPlayer;
+            hand._currentPlayer = player;
+            return hand._currentPlayer;
         },
         setState: function (state) {
             hand.state = state;

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

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

package/build/lib/classes/Match.js

@@ -30,8 +30,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Match = void 0;
 var Deck_1 = require("./Deck");
 var Hand_1 = require("./Hand");
-var Table_1 = require("./Table");
-function Match(teams, matchPoint) {
+function Match(table, teams, matchPoint) {
     if (teams === void 0) { teams = []; }
     if (matchPoint === void 0) { matchPoint = 9; }
     var deck = (0, Deck_1.Deck)().shuffle();
@@ -83,7 +82,7 @@ function Match(teams, matchPoint) {
         winner: null,
         teams: teams,
         hands: [],
-        table: (0, Table_1.Table)(teams, size),
+        table: table,
         currentHand: null,
         play: function () {
             match.getNextTurn();

package/build/lib/classes/Play.js

@@ -15,23 +15,14 @@ function PlayInstance(hand, teams) {
         commands: [],
         rounds: hand.rounds,
         use: function (idx) {
-            var player = hand.currentPlayer;
-            var round = hand.currentRound;
-            if (!player || !round) {
-                return null;
-            }
-            var card = player.useCard(idx);
-            if (card) {
-                return round.use({ player: player, card: card });
-            }
-            return null;
+            return hand.use(idx);
         },
         say: function (command) {
             var _a;
-            if (!hand.currentPlayer || !((_a = instance.commands) === null || _a === void 0 ? void 0 : _a.includes(command))) {
+            if (!hand._currentPlayer || !((_a = instance.commands) === null || _a === void 0 ? void 0 : _a.includes(command))) {
                 return null;
             }
-            hand.commands[command](hand.currentPlayer);
+            hand.commands[command](hand._currentPlayer);
             return command;
         },
     };
@@ -40,6 +31,9 @@ function PlayInstance(hand, teams) {
     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.js

@@ -6,7 +6,19 @@ function Player(id, teamIdx) {
         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 = [];

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

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

package/build/lib/classes/Round.js

@@ -2,12 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Round = void 0;
 var utils_1 = require("../utils");
-function Round() {
+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;

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

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

package/build/lib/classes/Table.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Table = void 0;
-function Table(teams, size) {
+function Table(players, teams) {
     var table = {
-        players: [],
+        players: players,
         cards: [],
         forehandIdx: 0,
         nextTurn: function () {
-            if (table.forehandIdx < size * 2 - 1) {
+            if (table.forehandIdx < table.players.length - 1) {
                 table.forehandIdx++;
             }
             else {
@@ -25,13 +25,6 @@ function Table(teams, size) {
             return table.players[table.forehandIdx];
         },
     };
-    if (teams[0].players.length != size || teams[1].players.length != size) {
-        throw new Error("Unexpected team size");
-    }
-    for (var i = 0; i < size; i++) {
-        table.players.push(teams[0].players[i]);
-        table.players.push(teams[1].players[i]);
-    }
     return table;
 }
 exports.Table = Table;

package/build/lib/classes/Team.js

@@ -12,6 +12,14 @@ function Team(players) {
             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;

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

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

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

@@ -42,4 +42,10 @@ export declare const CARDS: {
     "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,7 +1,7 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnvidoCalculator = 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 = {
@@ -56,6 +56,13 @@ exports.COLORS = [
     "#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,

package/build/lib/index.d.ts

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