trucoshi 0.3.3 → 0.3.5

package/dist/lib/classes/GameLoop.js

@@ -1,78 +1,106 @@
-"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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GameLoop = void 0;
-const types_1 = require("../../types");
-const GameLoop = (match) => {
-    let gameloop = {
-        _onTruco: () => Promise.resolve(),
-        _onTurn: () => Promise.resolve(),
-        _onWinner: () => Promise.resolve(),
-        teams: [],
-        winner: null,
-        currentPlayer: null,
-        currentHand: null,
-        lastCheckedHand: null,
-        onTruco: (callback) => {
-            gameloop._onTruco = callback;
-            return gameloop;
-        },
-        onTurn: (callback) => {
-            gameloop._onTurn = callback;
-            return gameloop;
-        },
-        onWinner: (callback) => {
-            gameloop._onWinner = callback;
-            return gameloop;
-        },
-        begin() {
-            var _a;
-            return __awaiter(this, void 0, void 0, function* () {
-                gameloop.teams = match.teams;
-                while (!match.winner) {
-                    const play = match.play();
-                    gameloop.currentHand = match.currentHand;
-                    if (!play || !play.player) {
-                        continue;
-                    }
-                    gameloop.currentPlayer = play.player;
-                    if (play.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
-                        try {
-                            yield gameloop._onTruco(play);
-                        }
-                        catch (e) {
-                            console.error("GAME LOOP ERROR", e);
-                        }
-                        continue;
-                    }
-                    if (play.state === types_1.EHandState.WAITING_PLAY) {
-                        play.player.setTurn(true);
-                        try {
-                            const newHandJustStarted = gameloop.lastCheckedHand !== ((_a = play.prevHand) === null || _a === void 0 ? void 0 : _a.idx);
-                            gameloop.lastCheckedHand = play.prevHand ? play.prevHand.idx : null;
-                            yield gameloop._onTurn(play, newHandJustStarted);
-                        }
-                        catch (e) {
-                            console.error("GAME LOOP ERROR", e);
-                        }
-                        play.player.setTurn(false);
-                        continue;
-                    }
-                }
-                gameloop.winner = match.winner;
-                gameloop.currentPlayer = null;
-                yield gameloop._onWinner(match.winner, match.teams);
-            });
-        },
-    };
-    return gameloop;
-};
-exports.GameLoop = GameLoop;
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GameLoop = void 0;
+const types_1 = require("../../types");
+const GameLoop = (match) => {
+    let gameloop = {
+        _onEnvido: () => Promise.resolve(),
+        _onTruco: () => Promise.resolve(),
+        _onTurn: () => Promise.resolve(),
+        _onWinner: () => Promise.resolve(),
+        teams: [],
+        winner: null,
+        currentPlayer: null,
+        currentHand: null,
+        lastCheckedHand: null,
+        onTruco: (callback) => {
+            gameloop._onTruco = callback;
+            return gameloop;
+        },
+        onTurn: (callback) => {
+            gameloop._onTurn = callback;
+            return gameloop;
+        },
+        onWinner: (callback) => {
+            gameloop._onWinner = callback;
+            return gameloop;
+        },
+        onEnvido: (callback) => {
+            gameloop._onEnvido = callback;
+            return gameloop;
+        },
+        begin() {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function* () {
+                gameloop.teams = match.teams;
+                while (!match.winner) {
+                    const play = match.play();
+                    gameloop.currentHand = match.currentHand;
+                    if (!play || !play.player) {
+                        continue;
+                    }
+                    gameloop.currentPlayer = play.player;
+                    if (play.state === types_1.EHandState.WAITING_ENVIDO_ANSWER) {
+                        try {
+                            play.player.setTurn(true);
+                            yield gameloop._onEnvido(play, false);
+                            play.player.setTurn(false);
+                        }
+                        catch (e) {
+                            console.error("GAME LOOP ERROR - WAITING ENVIDO ANSWER", e);
+                        }
+                        continue;
+                    }
+                    if (play.state === types_1.EHandState.WAITING_ENVIDO_POINTS_ANSWER) {
+                        try {
+                            play.player.setEnvidoTurn(true);
+                            yield gameloop._onEnvido(play, true);
+                            play.player.setEnvidoTurn(false);
+                        }
+                        catch (e) {
+                            console.error("GAME LOOP ERROR - WAITING ENVIDO POINTS ANSWER", e);
+                        }
+                        continue;
+                    }
+                    if (play.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
+                        try {
+                            yield gameloop._onTruco(play);
+                        }
+                        catch (e) {
+                            console.error("GAME LOOP ERROR - WAITING TRUCO ANSWER", e);
+                        }
+                        continue;
+                    }
+                    if (play.state === types_1.EHandState.WAITING_PLAY) {
+                        try {
+                            play.player.setTurn(true);
+                            const newHandJustStarted = gameloop.lastCheckedHand !== ((_a = play.prevHand) === null || _a === void 0 ? void 0 : _a.idx) &&
+                                ((_b = gameloop.currentHand) === null || _b === void 0 ? void 0 : _b.rounds[0].cards.length) === 0;
+                            gameloop.lastCheckedHand = play.prevHand ? play.prevHand.idx : null;
+                            yield gameloop._onTurn(play, newHandJustStarted);
+                            play.player.setTurn(false);
+                        }
+                        catch (e) {
+                            console.error("GAME LOOP ERROR - WAITING PLAY", e);
+                        }
+                        continue;
+                    }
+                }
+                gameloop.winner = match.winner;
+                gameloop.currentPlayer = null;
+                yield gameloop._onWinner(match.winner, match.teams);
+            });
+        },
+    };
+    return gameloop;
+};
+exports.GameLoop = GameLoop;

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

@@ -1,39 +1,43 @@
-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;
-    started: boolean;
-    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(prevHand: IHand | null): 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;
+import { EHandState, IHandCommands } from "../../types";
+import { ICard, IDeck } from "./Deck";
+import { IEnvido } from "./Envido";
+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;
+    started: boolean;
+    points: IHandPoints;
+    truco: ITruco;
+    envido: IEnvido;
+    rounds: Array<IRound>;
+    _currentPlayer: IPlayer | null;
+    get currentPlayer(): IPlayer | null;
+    set currentPlayer(player: IPlayer | null);
+    currentRound: IRound | null;
+    say: IHandCommands;
+    finished: () => boolean;
+    setTurnCommands(): void;
+    play(prevHand: IHand | null): IPlayInstance | null;
+    nextTurn(): void;
+    endEnvido(): void;
+    sayEnvidoPoints(player: IPlayer, points: number): IEnvido;
+    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;