trucoshi 0.3.4 → 0.3.5

package/dist/lib/classes/Player.js

@@ -1,126 +1,126 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Player = void 0;
-const types_1 = require("../../types");
-const filterEnvidoCommands = (command) => Object.values(types_1.EEnvidoCommand).includes(command) ||
-    Object.values(types_1.EAnswerCommand).includes(command) ||
-    Object.values(types_1.EEnvidoAnswerCommand).includes(command);
-const filterNotEnvidoCommands = (command) => !Object.values(types_1.EEnvidoCommand).includes(command) &&
-    !Object.values(types_1.EEnvidoAnswerCommand).includes(command);
-function Player(key, id, teamIdx, isOwner = false) {
-    const player = {
-        key,
-        id,
-        session: undefined,
-        teamIdx,
-        hand: [],
-        _commands: new Set(),
-        usedHand: [],
-        prevHand: [],
-        envido: [],
-        isOwner,
-        isTurn: false,
-        hasFlor: false,
-        isEnvidoTurn: false,
-        disabled: false,
-        ready: false,
-        get commands() {
-            return Array.from(player._commands.values());
-        },
-        resetCommands() {
-            player._commands = new Set();
-        },
-        setTurn(turn) {
-            player.isTurn = turn;
-        },
-        setEnvidoTurn(turn) {
-            player.isTurn = turn;
-            player.isEnvidoTurn = turn;
-        },
-        getPublicPlayer() {
-            const { id, key, commands, disabled, ready, usedHand, prevHand, teamIdx, hasFlor, isTurn, isEnvidoTurn, isOwner, envido, } = player;
-            return {
-                id,
-                key,
-                commands,
-                disabled,
-                ready,
-                envido,
-                usedHand,
-                prevHand,
-                teamIdx,
-                hasFlor,
-                isTurn,
-                isEnvidoTurn,
-                isOwner,
-                hand: player.hand.map(() => "xx"),
-                session: undefined,
-            };
-        },
-        setSession(session) {
-            player.session = session;
-        },
-        enable() {
-            player.disabled = false;
-        },
-        disable() {
-            player.disabled = true;
-        },
-        setReady(ready) {
-            player.ready = ready;
-        },
-        calculateEnvido() {
-            let flor = null;
-            const hand = player.hand.map((c) => {
-                let num = c.charAt(0);
-                const palo = c.charAt(1);
-                if (num === "p") {
-                    num = "10";
-                }
-                if (num === "c") {
-                    num = "11";
-                }
-                if (num === "r") {
-                    num = "12";
-                }
-                if (flor === null || flor === palo) {
-                    flor = palo;
-                }
-                else {
-                    flor = null;
-                }
-                return [num, palo];
-            });
-            player.hasFlor = Boolean(flor);
-            const possibles = hand.flatMap((v, i) => hand.slice(i + 1).map((w) => [v, w]));
-            const actual = possibles.filter((couple) => couple[0][1] === couple[1][1]);
-            player.envido = actual.map((couple) => {
-                const n1 = couple[0][0].at(-1);
-                const n2 = couple[1][0].at(-1);
-                return Number(n1) + Number(n2) + 20;
-            });
-            if (player.envido.length) {
-                return player.envido;
-            }
-            player.envido = Array.from(new Set(hand.map((c) => Number(c[0].at(-1)))));
-            return player.envido;
-        },
-        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 playedCard = player.hand.splice(idx, 1)[0];
-                player.usedHand.push(playedCard);
-                player.isTurn = false;
-                return playedCard;
-            }
-            return null;
-        },
-    };
-    return player;
-}
-exports.Player = Player;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Player = void 0;
+const types_1 = require("../../types");
+const filterEnvidoCommands = (command) => Object.values(types_1.EEnvidoCommand).includes(command) ||
+    Object.values(types_1.EAnswerCommand).includes(command) ||
+    Object.values(types_1.EEnvidoAnswerCommand).includes(command);
+const filterNotEnvidoCommands = (command) => !Object.values(types_1.EEnvidoCommand).includes(command) &&
+    !Object.values(types_1.EEnvidoAnswerCommand).includes(command);
+function Player(key, id, teamIdx, isOwner = false) {
+    const player = {
+        key,
+        id,
+        session: undefined,
+        teamIdx,
+        hand: [],
+        _commands: new Set(),
+        usedHand: [],
+        prevHand: [],
+        envido: [],
+        isOwner,
+        isTurn: false,
+        hasFlor: false,
+        isEnvidoTurn: false,
+        disabled: false,
+        ready: false,
+        get commands() {
+            return Array.from(player._commands.values());
+        },
+        resetCommands() {
+            player._commands = new Set();
+        },
+        setTurn(turn) {
+            player.isTurn = turn;
+        },
+        setEnvidoTurn(turn) {
+            player.isTurn = turn;
+            player.isEnvidoTurn = turn;
+        },
+        getPublicPlayer() {
+            const { id, key, commands, disabled, ready, usedHand, prevHand, teamIdx, hasFlor, isTurn, isEnvidoTurn, isOwner, envido, } = player;
+            return {
+                id,
+                key,
+                commands,
+                disabled,
+                ready,
+                envido,
+                usedHand,
+                prevHand,
+                teamIdx,
+                hasFlor,
+                isTurn,
+                isEnvidoTurn,
+                isOwner,
+                hand: player.hand.map(() => "xx"),
+                session: undefined,
+            };
+        },
+        setSession(session) {
+            player.session = session;
+        },
+        enable() {
+            player.disabled = false;
+        },
+        disable() {
+            player.disabled = true;
+        },
+        setReady(ready) {
+            player.ready = ready;
+        },
+        calculateEnvido() {
+            let flor = null;
+            const hand = player.hand.map((c) => {
+                let num = c.charAt(0);
+                const palo = c.charAt(1);
+                if (num === "p") {
+                    num = "10";
+                }
+                if (num === "c") {
+                    num = "11";
+                }
+                if (num === "r") {
+                    num = "12";
+                }
+                if (flor === null || flor === palo) {
+                    flor = palo;
+                }
+                else {
+                    flor = null;
+                }
+                return [num, palo];
+            });
+            player.hasFlor = Boolean(flor);
+            const possibles = hand.flatMap((v, i) => hand.slice(i + 1).map((w) => [v, w]));
+            const actual = possibles.filter((couple) => couple[0][1] === couple[1][1]);
+            player.envido = actual.map((couple) => {
+                const n1 = couple[0][0].at(-1);
+                const n2 = couple[1][0].at(-1);
+                return Number(n1) + Number(n2) + 20;
+            });
+            if (player.envido.length) {
+                return player.envido;
+            }
+            player.envido = Array.from(new Set(hand.map((c) => Number(c[0].at(-1)))));
+            return player.envido;
+        },
+        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 playedCard = player.hand.splice(idx, 1)[0];
+                player.usedHand.push(playedCard);
+                player.isTurn = false;
+                return playedCard;
+            }
+            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";
-export interface ITable {
-    forehandIdx: number;
-    cards: Array<Array<IPlayedCard>>;
-    players: Array<IPlayer>;
-    nextTurn(): IPlayer;
-    getPlayer(idx?: number, forehandFirst?: boolean): IPlayer;
-    getPlayerPosition(key: string, forehandFirst?: boolean): number;
-    getPlayersForehandFirst(forehandIdx?: number): Array<IPlayer>;
-}
-export declare function Table(players: Array<IPlayer>): ITable;
+import { IPlayedCard } from "./Deck";
+import { IPlayer } from "./Player";
+export interface ITable {
+    forehandIdx: number;
+    cards: Array<Array<IPlayedCard>>;
+    players: Array<IPlayer>;
+    nextTurn(): IPlayer;
+    getPlayer(idx?: number, forehandFirst?: boolean): IPlayer;
+    getPlayerPosition(key: string, forehandFirst?: boolean): number;
+    getPlayersForehandFirst(forehandIdx?: number): Array<IPlayer>;
+}
+export declare function Table(players: Array<IPlayer>): ITable;

package/dist/lib/classes/Table.js

@@ -1,38 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Table = void 0;
-function Table(players) {
-    const table = {
-        players,
-        cards: [],
-        forehandIdx: 0,
-        nextTurn() {
-            if (table.forehandIdx < table.players.length - 1) {
-                table.forehandIdx++;
-            }
-            else {
-                table.forehandIdx = 0;
-            }
-            return table.getPlayer();
-        },
-        getPlayerPosition(key, forehandFirst = false) {
-            const array = forehandFirst ? table.getPlayersForehandFirst() : table.players;
-            return array.findIndex((p) => p.key === key);
-        },
-        getPlayersForehandFirst(forehand) {
-            const idx = forehand !== undefined ? forehand : table.forehandIdx;
-            const cut = players.slice(idx, table.players.length);
-            const end = players.slice(0, idx);
-            return cut.concat(end);
-        },
-        getPlayer(idx, forehandFirst = false) {
-            const array = forehandFirst ? table.getPlayersForehandFirst() : table.players;
-            if (idx !== undefined) {
-                return array[idx];
-            }
-            return array[0];
-        },
-    };
-    return table;
-}
-exports.Table = Table;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Table = void 0;
+function Table(players) {
+    const table = {
+        players,
+        cards: [],
+        forehandIdx: 0,
+        nextTurn() {
+            if (table.forehandIdx < table.players.length - 1) {
+                table.forehandIdx++;
+            }
+            else {
+                table.forehandIdx = 0;
+            }
+            return table.getPlayer();
+        },
+        getPlayerPosition(key, forehandFirst = false) {
+            const array = forehandFirst ? table.getPlayersForehandFirst() : table.players;
+            return array.findIndex((p) => p.key === key);
+        },
+        getPlayersForehandFirst(forehand) {
+            const idx = forehand !== undefined ? forehand : table.forehandIdx;
+            const cut = players.slice(idx, table.players.length);
+            const end = players.slice(0, idx);
+            return cut.concat(end);
+        },
+        getPlayer(idx, forehandFirst = false) {
+            const array = forehandFirst ? table.getPlayersForehandFirst() : table.players;
+            if (idx !== undefined) {
+                return array[idx];
+            }
+            return array[0];
+        },
+    };
+    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;