trucoshi 0.2.10 → 0.2.12

package/dist/lib/classes/Player.js

@@ -1,78 +1,79 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Player = void 0;
-function Player(key, id, teamIdx, isOwner = false) {
-    const player = {
-        key,
-        id,
-        session: undefined,
-        teamIdx,
-        hand: [],
-        _commands: new Set(),
-        usedHand: [],
-        prevHand: [],
-        isOwner,
-        isTurn: false,
-        disabled: false,
-        connected: false,
-        ready: false,
-        get commands() {
-            return Array.from(player._commands.values());
-        },
-        setOwner(owner) {
-            player.isOwner = owner;
-        },
-        setTurn(turn) {
-            player.isTurn = turn;
-        },
-        getPublicPlayer() {
-            const { id, key, commands, connected, disabled, ready, usedHand, prevHand, teamIdx, isTurn, isOwner, } = player;
-            return {
-                id,
-                key,
-                connected,
-                commands,
-                disabled,
-                ready,
-                usedHand,
-                prevHand,
-                teamIdx,
-                isTurn,
-                isOwner,
-                hand: player.hand.map(() => "xx"),
-                session: undefined,
-            };
-        },
-        setSession(session) {
-            player.session = session;
-        },
-        enable() {
-            player.disabled = false;
-        },
-        disable() {
-            player.disabled = true;
-        },
-        setConnected(connected) {
-            player.connected = connected;
-        },
-        setReady(ready) {
-            player.ready = ready;
-        },
-        setHand(hand) {
-            player.prevHand = [...player.usedHand];
-            player.hand = hand;
-            player.usedHand = [];
-            return hand;
-        },
-        useCard(idx, card) {
-            if (player.hand[idx] && player.hand[idx] === card) {
-                const card = player.hand.splice(idx, 1)[0];
-                player.usedHand.push(card);
-                return card;
-            }
-            return null;
-        },
-    };
-    return player;
-}
-exports.Player = Player;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Player = void 0;
+function Player(key, id, teamIdx, isOwner = false) {
+    const player = {
+        key,
+        id,
+        session: undefined,
+        teamIdx,
+        hand: [],
+        _commands: new Set(),
+        usedHand: [],
+        prevHand: [],
+        isOwner,
+        isTurn: false,
+        disabled: false,
+        connected: false,
+        ready: false,
+        get commands() {
+            return Array.from(player._commands.values());
+        },
+        setOwner(owner) {
+            player.isOwner = owner;
+        },
+        setTurn(turn) {
+            player.isTurn = turn;
+        },
+        getPublicPlayer() {
+            const { id, key, commands, connected, disabled, ready, usedHand, prevHand, teamIdx, isTurn, isOwner, } = player;
+            return {
+                id,
+                key,
+                connected,
+                commands,
+                disabled,
+                ready,
+                usedHand,
+                prevHand,
+                teamIdx,
+                isTurn,
+                isOwner,
+                hand: player.hand.map(() => "xx"),
+                session: undefined,
+            };
+        },
+        setSession(session) {
+            player.session = session;
+        },
+        enable() {
+            player.disabled = false;
+        },
+        disable() {
+            player.disabled = true;
+        },
+        setConnected(connected) {
+            player.connected = connected;
+        },
+        setReady(ready) {
+            player.ready = ready;
+        },
+        setHand(hand) {
+            player.prevHand = [...player.usedHand];
+            player.hand = hand;
+            player.usedHand = [];
+            return hand;
+        },
+        useCard(idx, card) {
+            if (player.hand[idx] && player.hand[idx] === card) {
+                const card = player.hand.splice(idx, 1)[0];
+                player.usedHand.push(card);
+                player.isTurn = false;
+                return card;
+            }
+            return null;
+        },
+    };
+    return player;
+}
+exports.Player = Player;

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

@@ -1,17 +1,17 @@
-import { ICard, IPlayedCard } from "./Deck";
-import { IPlayer } from "./Player";
-export interface IRound {
-    tie: boolean;
-    winner: IPlayer | null;
-    highest: number;
-    cards: Array<IPlayedCard>;
-    turn: number;
-    nextTurn(): void;
-    use(playedCard: IPlayedCard): ICard;
-}
-export interface IRoundPoints {
-    0: number;
-    1: number;
-    ties: number;
-}
-export declare function Round(): IRound;
+import { ICard, IPlayedCard } from "./Deck";
+import { IPlayer } from "./Player";
+export interface IRound {
+    tie: boolean;
+    winner: IPlayer | null;
+    highest: number;
+    cards: Array<IPlayedCard>;
+    turn: number;
+    nextTurn(): void;
+    use(playedCard: IPlayedCard): ICard;
+}
+export interface IRoundPoints {
+    0: number;
+    1: number;
+    ties: number;
+}
+export declare function Round(): IRound;

package/dist/lib/classes/Round.js

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

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

@@ -1,12 +1,12 @@
-import { IPlayedCard } from "./Deck";
-import { IPlayer } from "./Player";
-import { ITeam } from "./Team";
-export interface ITable {
-    forehandIdx: number;
-    cards: Array<Array<IPlayedCard>>;
-    players: Array<IPlayer>;
-    nextTurn(): IPlayer;
-    player(idx?: number): IPlayer;
-    getPlayerPosition(id: string): number;
-}
-export declare function Table(players: Array<IPlayer>, teams: Array<ITeam>): ITable;
+import { IPlayedCard } from "./Deck";
+import { IPlayer } from "./Player";
+import { ITeam } from "./Team";
+export interface ITable {
+    forehandIdx: number;
+    cards: Array<Array<IPlayedCard>>;
+    players: Array<IPlayer>;
+    nextTurn(): IPlayer;
+    player(idx?: number): IPlayer;
+    getPlayerPosition(id: string): number;
+}
+export declare function Table(players: Array<IPlayer>, teams: Array<ITeam>): ITable;

package/dist/lib/classes/Table.js

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

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

@@ -1,20 +1,20 @@
-import { IPlayer, IPublicPlayer } from "./Player";
-export interface ITeam {
-    _players: Map<string, IPlayer>;
-    players: Array<IPlayer>;
-    points: ITeamPoints;
-    getPublicTeam(playerSession?: string): IPublicTeam;
-    isTeamDisabled(): boolean;
-    disable(player: IPlayer): boolean;
-    enable(player?: IPlayer): boolean;
-    addPoints(matchPoint: number, points: number): ITeamPoints;
-}
-export type IPublicTeam = Pick<ITeam, "points"> & {
-    players: Array<IPublicPlayer>;
-};
-export interface ITeamPoints {
-    buenas: number;
-    malas: number;
-    winner: boolean;
-}
-export declare function Team(players: Array<IPlayer>): ITeam;
+import { IPlayer, IPublicPlayer } from "./Player";
+export interface ITeam {
+    _players: Map<string, IPlayer>;
+    players: Array<IPlayer>;
+    points: ITeamPoints;
+    getPublicTeam(playerSession?: string): IPublicTeam;
+    isTeamDisabled(): boolean;
+    disable(player: IPlayer): boolean;
+    enable(player?: IPlayer): boolean;
+    addPoints(matchPoint: number, points: number): ITeamPoints;
+}
+export type IPublicTeam = Pick<ITeam, "points"> & {
+    players: Array<IPublicPlayer>;
+};
+export interface ITeamPoints {
+    buenas: number;
+    malas: number;
+    winner: boolean;
+}
+export declare function Team(players: Array<IPlayer>): ITeam;

package/dist/lib/classes/Team.js

@@ -1,59 +1,59 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Team = void 0;
-function Team(players) {
-    const team = {
-        _players: new Map(),
-        get players() {
-            return Array.from(team._players.values());
-        },
-        points: {
-            buenas: 0,
-            malas: 0,
-            winner: false,
-        },
-        getPublicTeam(playerSession) {
-            return {
-                points: team.points,
-                players: team.players.map((player) => player.session === playerSession ? player : player.getPublicPlayer()),
-            };
-        },
-        isTeamDisabled() {
-            return team.players.reduce((prev, curr) => prev && curr.disabled, true);
-        },
-        enable(player) {
-            var _a;
-            if (player) {
-                (_a = team._players.get(player.session)) === null || _a === void 0 ? void 0 : _a.enable();
-                return team.isTeamDisabled();
-            }
-            for (const player of team.players) {
-                player.enable();
-            }
-            return team.isTeamDisabled();
-        },
-        disable(player) {
-            var _a;
-            (_a = team._players.get(player.session)) === null || _a === void 0 ? void 0 : _a.disable();
-            return team.isTeamDisabled();
-        },
-        addPoints(matchPoint, points) {
-            const malas = team.points.malas + points;
-            const 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((player) => team._players.set(player.session, player));
-    return team;
-}
-exports.Team = Team;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Team = void 0;
+function Team(players) {
+    const team = {
+        _players: new Map(),
+        get players() {
+            return Array.from(team._players.values());
+        },
+        points: {
+            buenas: 0,
+            malas: 0,
+            winner: false,
+        },
+        getPublicTeam(playerSession) {
+            return {
+                points: team.points,
+                players: team.players.map((player) => player.session === playerSession ? player : player.getPublicPlayer()),
+            };
+        },
+        isTeamDisabled() {
+            return team.players.reduce((prev, curr) => prev && curr.disabled, true);
+        },
+        enable(player) {
+            var _a;
+            if (player) {
+                (_a = team._players.get(player.session)) === null || _a === void 0 ? void 0 : _a.enable();
+                return team.isTeamDisabled();
+            }
+            for (const player of team.players) {
+                player.enable();
+            }
+            return team.isTeamDisabled();
+        },
+        disable(player) {
+            var _a;
+            (_a = team._players.get(player.session)) === null || _a === void 0 ? void 0 : _a.disable();
+            return team.isTeamDisabled();
+        },
+        addPoints(matchPoint, points) {
+            const malas = team.points.malas + points;
+            const 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((player) => team._players.set(player.session, player));
+    return team;
+}
+exports.Team = Team;

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

@@ -1,19 +1,21 @@
-import { IPlayer } from "./Player";
-import { ITeam } from "./Team";
-export interface ITruco {
-    state: 1 | 2 | 3 | 4;
-    teamIdx: 0 | 1 | null;
-    answer: boolean | null;
-    turn: number;
-    teams: [ITeam, ITeam];
-    players: Array<IPlayer>;
-    currentPlayer: IPlayer | null;
-    generator: Generator<ITruco, void, unknown>;
-    sayTruco(player: IPlayer, callback: () => void): ITruco;
-    sayAnswer(player: IPlayer, answer: boolean | null, callback: () => void): ITruco;
-    setTurn(turn: number): number;
-    setTeam(idx: 0 | 1): 0 | 1;
-    setCurrentPlayer(player: IPlayer | null): IPlayer | null;
-    getNextPlayer(): IteratorResult<ITruco, ITruco | void>;
-}
-export declare function Truco(teams: [ITeam, ITeam]): ITruco;
+import { IPlayer } from "./Player";
+import { ITeam } from "./Team";
+export interface ITruco {
+    state: 1 | 2 | 3 | 4;
+    teamIdx: 0 | 1 | null;
+    waitingAnswer: boolean;
+    answer: boolean | null;
+    turn: number;
+    teams: [ITeam, ITeam];
+    players: Array<IPlayer>;
+    currentPlayer: IPlayer | null;
+    generator: Generator<ITruco, void, unknown>;
+    sayTruco(player: IPlayer, callback: () => void): ITruco;
+    sayAnswer(player: IPlayer, answer: boolean | null, callback: () => void): ITruco;
+    setTurn(turn: number): number;
+    setTeam(idx: 0 | 1): 0 | 1;
+    setCurrentPlayer(player: IPlayer | null): IPlayer | null;
+    getNextPlayer(): IteratorResult<ITruco, ITruco | void>;
+    reset(): void;
+}
+export declare function Truco(teams: [ITeam, ITeam]): ITruco;