trucoshi 0.2.5 → 0.2.7

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

@@ -1,18 +1,18 @@
-import { IHand, IHandPoints } from "./Hand";
-import { IPlayInstance } from "./Play";
-import { ITable } from "./Table";
-import { ITeam } from "./Team";
-export interface IMatch {
-    teams: [ITeam, ITeam];
-    hands: Array<IHand>;
-    winner: ITeam | null;
-    currentHand: IHand | null;
-    table: ITable;
-    play(): IPlayInstance | null;
-    addPoints(points: IHandPoints): [ITeam, ITeam];
-    pushHand(hand: IHand): void;
-    setCurrentHand(hand: IHand | null): IHand | null;
-    setWinner(winner: ITeam): void;
-    getNextTurn(): IteratorResult<IMatch | null, IMatch | null | void>;
-}
-export declare function Match(table: ITable, teams?: Array<ITeam>, matchPoint?: number): IMatch;
+import { IHand, IHandPoints } from "./Hand";
+import { IPlayInstance } from "./Play";
+import { ITable } from "./Table";
+import { ITeam } from "./Team";
+export interface IMatch {
+    teams: [ITeam, ITeam];
+    hands: Array<IHand>;
+    winner: ITeam | null;
+    currentHand: IHand | null;
+    table: ITable;
+    play(): IPlayInstance | null;
+    addPoints(points: IHandPoints): [ITeam, ITeam];
+    pushHand(hand: IHand): void;
+    setCurrentHand(hand: IHand | null): IHand | null;
+    setWinner(winner: ITeam): void;
+    getNextTurn(): IteratorResult<IMatch | null, IMatch | null | void>;
+}
+export declare function Match(table: ITable, teams?: Array<ITeam>, matchPoint?: number): IMatch;

package/dist/lib/classes/Match.js

@@ -1,81 +1,81 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Match = void 0;
-const Deck_1 = require("./Deck");
-const Hand_1 = require("./Hand");
-const playerIsNotReady = (player) => !player.ready;
-function Match(table, teams = [], matchPoint = 9) {
-    const deck = (0, Deck_1.Deck)().shuffle();
-    const size = teams[0].players.length;
-    if (size !== teams[1].players.length) {
-        throw new Error("Team size mismatch");
-    }
-    function* handsGeneratorSequence() {
-        while (!match.winner) {
-            if (match.teams[0].players.every(playerIsNotReady)) {
-                match.setWinner(match.teams[1]);
-                break;
-            }
-            if (match.teams[1].players.every(playerIsNotReady)) {
-                match.setWinner(match.teams[0]);
-                break;
-            }
-            deck.shuffle();
-            const hand = match.setCurrentHand((0, Hand_1.Hand)(match, deck, match.hands.length + 1));
-            match.pushHand(hand);
-            while (!hand.finished()) {
-                const { value } = hand.getNextPlayer();
-                if (value && value.finished()) {
-                    continue;
-                }
-                match.setCurrentHand(value);
-                yield match;
-            }
-            match.setCurrentHand(null);
-            const teams = match.addPoints(hand.points);
-            const winner = teams.find((team) => team.points.winner);
-            if (winner) {
-                match.setWinner(winner);
-                match.setCurrentHand(null);
-                break;
-            }
-            match.table.nextTurn();
-        }
-        yield match;
-    }
-    const handsGenerator = handsGeneratorSequence();
-    const match = {
-        winner: null,
-        teams: teams,
-        hands: [],
-        table,
-        currentHand: null,
-        play() {
-            match.getNextTurn();
-            if (!match.currentHand) {
-                return null;
-            }
-            return match.currentHand.play();
-        },
-        addPoints(points) {
-            match.teams[0].addPoints(matchPoint, points[0]);
-            match.teams[1].addPoints(matchPoint, points[1]);
-            return match.teams;
-        },
-        pushHand(hand) {
-            match.hands.push(hand);
-        },
-        setCurrentHand(hand) {
-            match.currentHand = hand;
-            return match.currentHand;
-        },
-        setWinner(winner) {
-            match.winner = winner;
-        },
-        getNextTurn() {
-            return handsGenerator.next();
-        },
-    };
-    return match;
-}
-exports.Match = Match;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Match = void 0;
+const Deck_1 = require("./Deck");
+const Hand_1 = require("./Hand");
+const playerIsNotReady = (player) => !player.ready;
+function Match(table, teams = [], matchPoint = 9) {
+    const deck = (0, Deck_1.Deck)().shuffle();
+    const size = teams[0].players.length;
+    if (size !== teams[1].players.length) {
+        throw new Error("Team size mismatch");
+    }
+    function* handsGeneratorSequence() {
+        while (!match.winner) {
+            if (match.teams[0].players.every(playerIsNotReady)) {
+                match.setWinner(match.teams[1]);
+                break;
+            }
+            if (match.teams[1].players.every(playerIsNotReady)) {
+                match.setWinner(match.teams[0]);
+                break;
+            }
+            deck.shuffle();
+            const hand = match.setCurrentHand((0, Hand_1.Hand)(match, deck, match.hands.length + 1));
+            match.pushHand(hand);
+            while (!hand.finished()) {
+                const { value } = hand.getNextPlayer();
+                if (value && value.finished()) {
+                    continue;
+                }
+                match.setCurrentHand(value);
+                yield match;
+            }
+            match.setCurrentHand(null);
+            const teams = match.addPoints(hand.points);
+            const winner = teams.find((team) => team.points.winner);
+            if (winner) {
+                match.setWinner(winner);
+                match.setCurrentHand(null);
+                break;
+            }
+            match.table.nextTurn();
+        }
+        yield match;
+    }
+    const handsGenerator = handsGeneratorSequence();
+    const match = {
+        winner: null,
+        teams: teams,
+        hands: [],
+        table,
+        currentHand: null,
+        play() {
+            match.getNextTurn();
+            if (!match.currentHand) {
+                return null;
+            }
+            return match.currentHand.play();
+        },
+        addPoints(points) {
+            match.teams[0].addPoints(matchPoint, points[0]);
+            match.teams[1].addPoints(matchPoint, points[1]);
+            return match.teams;
+        },
+        pushHand(hand) {
+            match.hands.push(hand);
+        },
+        setCurrentHand(hand) {
+            match.currentHand = hand;
+            return match.currentHand;
+        },
+        setWinner(winner) {
+            match.winner = winner;
+        },
+        getNextTurn() {
+            return handsGenerator.next();
+        },
+    };
+    return match;
+}
+exports.Match = Match;

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

@@ -1,21 +1,21 @@
-import { ECommand, EHandState, EnvidoState } from "../../types";
-import { ICard } from "./Deck";
-import { IHand } from "./Hand";
-import { IPlayer } from "./Player";
-import { IRound } from "./Round";
-import { ITeam } from "./Team";
-import { ITruco } from "./Truco";
-export interface IPlayInstance {
-    teams: [ITeam, ITeam];
-    handIdx: number;
-    roundIdx: number;
-    state: EHandState;
-    truco: ITruco;
-    envido: EnvidoState;
-    player: IPlayer | null;
-    commands: Array<ECommand> | null;
-    rounds: Array<IRound> | null;
-    use(idx: number, card: ICard): ICard | null;
-    say(command: ECommand): ECommand | null;
-}
-export declare function PlayInstance(hand: IHand, teams: [ITeam, ITeam]): IPlayInstance;
+import { ECommand, EHandState, EnvidoState } from "../../types";
+import { ICard } from "./Deck";
+import { IHand } from "./Hand";
+import { IPlayer } from "./Player";
+import { IRound } from "./Round";
+import { ITeam } from "./Team";
+import { ITruco } from "./Truco";
+export interface IPlayInstance {
+    teams: [ITeam, ITeam];
+    handIdx: number;
+    roundIdx: number;
+    state: EHandState;
+    truco: ITruco;
+    envido: EnvidoState;
+    player: IPlayer | null;
+    commands: Array<ECommand> | null;
+    rounds: Array<IRound> | null;
+    use(idx: number, card: ICard): ICard | null;
+    say(command: ECommand): ECommand | null;
+}
+export declare function PlayInstance(hand: IHand, teams: [ITeam, ITeam]): IPlayInstance;

package/dist/lib/classes/Play.js

@@ -1,39 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlayInstance = void 0;
-const types_1 = require("../../types");
-function PlayInstance(hand, teams) {
-    var _a, _b, _c;
-    const instance = {
-        state: hand.state,
-        teams,
-        truco: hand.truco,
-        envido: hand.envido,
-        handIdx: hand.idx,
-        roundIdx: hand.rounds.length,
-        player: hand.currentPlayer,
-        commands: [],
-        rounds: hand.rounds,
-        use(idx, card) {
-            return hand.use(idx, card);
-        },
-        say(command) {
-            var _a;
-            if (!hand._currentPlayer || !((_a = instance.commands) === null || _a === void 0 ? void 0 : _a.includes(command))) {
-                return null;
-            }
-            hand.commands[command](hand._currentPlayer);
-            return command;
-        },
-    };
-    (_a = instance.commands) === null || _a === void 0 ? void 0 : _a.push(types_1.ESayCommand.MAZO);
-    (_b = instance.commands) === null || _b === void 0 ? void 0 : _b.push(types_1.ESayCommand.TRUCO);
-    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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayInstance = void 0;
+const types_1 = require("../../types");
+function PlayInstance(hand, teams) {
+    var _a, _b, _c;
+    const instance = {
+        state: hand.state,
+        teams,
+        truco: hand.truco,
+        envido: hand.envido,
+        handIdx: hand.idx,
+        roundIdx: hand.rounds.length,
+        player: hand.currentPlayer,
+        commands: [],
+        rounds: hand.rounds,
+        use(idx, card) {
+            return hand.use(idx, card);
+        },
+        say(command) {
+            var _a;
+            if (!hand._currentPlayer || !((_a = instance.commands) === null || _a === void 0 ? void 0 : _a.includes(command))) {
+                return null;
+            }
+            hand.commands[command](hand._currentPlayer);
+            return command;
+        },
+    };
+    (_a = instance.commands) === null || _a === void 0 ? void 0 : _a.push(types_1.ESayCommand.MAZO);
+    (_b = instance.commands) === null || _b === void 0 ? void 0 : _b.push(types_1.ESayCommand.TRUCO);
+    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/dist/lib/classes/Player.d.ts

@@ -1,29 +1,29 @@
-import { ECommand } from "../../types";
-import { ICard } from "./Deck";
-export interface IPlayer {
-    teamIdx: number;
-    id: string;
-    key: string;
-    session?: string;
-    hand: Array<ICard>;
-    commands: Array<ECommand>;
-    usedHand: Array<ICard>;
-    prevHand: Array<ICard>;
-    isTurn: boolean;
-    isOwner: boolean;
-    disabled: boolean;
-    ready: boolean;
-    connected: boolean;
-    setTurn(turn: boolean): void;
-    getPublicPlayer(): IPublicPlayer;
-    setSession(session: string): void;
-    enable(): void;
-    disable(): void;
-    setConnected(connected: boolean): void;
-    setOwner(owner: boolean): void;
-    setReady(ready: boolean): void;
-    setHand(hand: Array<ICard>): Array<ICard>;
-    useCard(idx: number, card: ICard): ICard | null;
-}
-export type IPublicPlayer = Pick<IPlayer, "id" | "key" | "disabled" | "ready" | "connected" | "hand" | "usedHand" | "prevHand" | "teamIdx" | "session" | "isTurn" | "isOwner">;
-export declare function Player(key: string, id: string, teamIdx: number, isOwner?: boolean): IPlayer;
+import { ECommand } from "../../types";
+import { ICard } from "./Deck";
+export interface IPlayer {
+    teamIdx: number;
+    id: string;
+    key: string;
+    session?: string;
+    hand: Array<ICard>;
+    commands: Array<ECommand>;
+    usedHand: Array<ICard>;
+    prevHand: Array<ICard>;
+    isTurn: boolean;
+    isOwner: boolean;
+    disabled: boolean;
+    ready: boolean;
+    connected: boolean;
+    setTurn(turn: boolean): void;
+    getPublicPlayer(): IPublicPlayer;
+    setSession(session: string): void;
+    enable(): void;
+    disable(): void;
+    setConnected(connected: boolean): void;
+    setOwner(owner: boolean): void;
+    setReady(ready: boolean): void;
+    setHand(hand: Array<ICard>): Array<ICard>;
+    useCard(idx: number, card: ICard): ICard | null;
+}
+export type IPublicPlayer = Pick<IPlayer, "id" | "key" | "disabled" | "ready" | "connected" | "hand" | "usedHand" | "prevHand" | "teamIdx" | "session" | "isTurn" | "isOwner">;
+export declare function Player(key: string, id: string, teamIdx: number, isOwner?: boolean): IPlayer;

package/dist/lib/classes/Player.js

@@ -1,74 +1,74 @@
-"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: [],
-        usedHand: [],
-        prevHand: [],
-        isOwner,
-        isTurn: false,
-        disabled: false,
-        connected: false,
-        ready: false,
-        setOwner(owner) {
-            player.isOwner = owner;
-        },
-        setTurn(turn) {
-            player.isTurn = turn;
-        },
-        getPublicPlayer() {
-            const { id, key, connected, disabled, ready, usedHand, prevHand, teamIdx, isTurn, isOwner } = player;
-            return {
-                id,
-                key,
-                connected,
-                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: [],
+        usedHand: [],
+        prevHand: [],
+        isOwner,
+        isTurn: false,
+        disabled: false,
+        connected: false,
+        ready: false,
+        setOwner(owner) {
+            player.isOwner = owner;
+        },
+        setTurn(turn) {
+            player.isTurn = turn;
+        },
+        getPublicPlayer() {
+            const { id, key, connected, disabled, ready, usedHand, prevHand, teamIdx, isTurn, isOwner } = player;
+            return {
+                id,
+                key,
+                connected,
+                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;

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(turn: number): 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(turn: number): 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(turn) {
-    const round = {
-        turn,
-        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(turn) {
+    const round = {
+        turn,
+        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;