trucoshi 0.0.22 → 0.1.1

package/README.md

@@ -1,37 +1,37 @@
-# Trucoshi
-
-### English 
-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 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.
-
-### Installation
-`yarn`
-
-### Play
-`yarn test:play`
-
-### Autoplay
-`yarn test:autoplay`
-
-# Todo    
-    [x] Logica de turnos, rondas y battalla de cartas
-    [x] Irse al mazo
-    [] Cantar truco
-    [] Cantar envido
-    [] Cantar flor
-    [] Socket server
-    [] Bitcoin Lightning integration
-    [] Unit tests
-
-# License 
-
-This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+# Trucoshi
+
+### English 
+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 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.
+
+### Installation
+`yarn`
+
+### Play
+`yarn test:play`
+
+### Autoplay
+`yarn test:autoplay`
+
+# Todo    
+    [x] Logica de turnos, rondas y battalla de cartas
+    [x] Irse al mazo
+    [] Cantar truco
+    [] Cantar envido
+    [] Cantar flor
+    [] Socket server
+    [] Bitcoin Lightning integration
+    [] Unit tests
+
+# License 
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,18 @@
+"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,3 +1,16 @@
-import { ICard, IDeck, IPlayedCard, IPlayer } from "../types";
-export declare function Deck(): IDeck;
-export declare function PlayedCard(player: IPlayer, card: ICard): IPlayedCard;
+import { CARDS } from "../constants";
+import { IPlayer, IPublicPlayer } from "./Player";
+export interface IDeck {
+    cards: Array<ICard>;
+    usedCards: Array<ICard>;
+    takeCard(): 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, card: ICard): IPlayedCard;

package/dist/lib/classes/Deck.js

@@ -1,38 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlayedCard = 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;
-function PlayedCard(player, card) {
-    var pc = {
-        player: player,
-        card: card,
-        get key() {
-            return card + player.session;
-        },
-    };
-    return pc;
-}
-exports.PlayedCard = PlayedCard;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayedCard = 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;
+function PlayedCard(player, card) {
+    var pc = {
+        player: player,
+        card: card,
+        get key() {
+            return card + player.session;
+        },
+    };
+    return pc;
+}
+exports.PlayedCard = PlayedCard;

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

@@ -0,0 +1,20 @@
+import { IHand } from "./Hand";
+import { IMatch } from "./Match";
+import { IPlayInstance } from "./Play";
+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 interface IGameLoop {
+    _onTruco: ITrucoCallback;
+    _onTurn: ITurnCallback;
+    _onWinner: IWinnerCallback;
+    teams: Array<ITeam>;
+    hands: Array<IHand>;
+    winner: ITeam | null;
+    onTurn: (callback: ITurnCallback) => IGameLoop;
+    onWinner: (callback: IWinnerCallback) => IGameLoop;
+    onTruco: (callback: ITrucoCallback) => IGameLoop;
+    begin: () => Promise<void>;
+}
+export declare const GameLoop: (match: IMatch) => IGameLoop;

package/dist/lib/classes/GameLoop.js

@@ -0,0 +1,103 @@
+"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.GameLoop = void 0;
+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(); },
+        teams: [],
+        winner: null,
+        hands: [],
+        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:
+                            gameloop.teams = match.teams;
+                            _a.label = 1;
+                        case 1:
+                            if (!!match.winner) return [3 /*break*/, 6];
+                            play = match.play();
+                            gameloop.hands = match.hands;
+                            if (!play || !play.player) {
+                                return [3 /*break*/, 1];
+                            }
+                            if (!(play.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER)) return [3 /*break*/, 3];
+                            return [4 /*yield*/, gameloop._onTruco(play)];
+                        case 2:
+                            _a.sent();
+                            return [3 /*break*/, 1];
+                        case 3:
+                            if (!(play.state === types_1.EHandState.WAITING_PLAY)) return [3 /*break*/, 5];
+                            play.player.setTurn(true);
+                            return [4 /*yield*/, gameloop._onTurn(play)];
+                        case 4:
+                            _a.sent();
+                            play.player.setTurn(false);
+                            return [3 /*break*/, 1];
+                        case 5: return [3 /*break*/, 1];
+                        case 6:
+                            gameloop.winner = match.winner;
+                            return [4 /*yield*/, gameloop._onWinner(match.winner, match.teams)];
+                        case 7:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        },
+    };
+    return gameloop;
+};
+exports.GameLoop = GameLoop;

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

@@ -1,2 +1,38 @@
-import { IDeck, IHand, IMatch } from "../types";
-export declare function Hand(match: IMatch, deck: IDeck, idx: number): IHand;
+import { EHandState, EnvidoState, IHandCommands } from "../../types";
+import { ICard, IDeck } from "./Deck";
+import { IMatch } from "./Match";
+import { IPlayInstance } from "./Play";
+import { IPlayer } from "./Player";
+import { IRound } from "./Round";
+import { ITruco } from "./Truco";
+export interface IHandPoints {
+    0: number;
+    1: number;
+}
+export interface IHand {
+    idx: number;
+    state: EHandState;
+    turn: number;
+    points: IHandPoints;
+    truco: ITruco;
+    envido: EnvidoState;
+    rounds: Array<IRound>;
+    _currentPlayer: IPlayer | null;
+    get currentPlayer(): IPlayer | null;
+    set currentPlayer(player: IPlayer | null);
+    currentRound: IRound | null;
+    commands: IHandCommands;
+    finished: () => boolean;
+    play(): IPlayInstance | null;
+    nextTurn(): void;
+    use(idx: number, card: ICard): ICard | 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;
+    setState(state: EHandState): EHandState;
+    getNextPlayer(): IteratorResult<IHand, IHand | void>;
+}
+export declare function Hand(match: IMatch, deck: IDeck, idx: number): IHand;