trucoshi 0.1.7 → 0.2.0

package/dist/lib/classes/Match.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Match = void 0;
+const Deck_1 = require("./Deck");
+const Hand_1 = require("./Hand");
+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) {
+            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

@@ -0,0 +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;

package/dist/lib/classes/Play.js

@@ -0,0 +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;

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

@@ -0,0 +1,26 @@
+import { ECommand } from "../../types";
+import { ICard } from "./Deck";
+export interface IPlayer {
+    teamIdx: number;
+    id: string;
+    session?: string;
+    hand: Array<ICard>;
+    commands: Array<ECommand>;
+    usedHand: Array<ICard>;
+    prevHand: Array<ICard>;
+    isTurn: boolean;
+    isOwner: boolean;
+    disabled: boolean;
+    ready: boolean;
+    setTurn(turn: boolean): void;
+    getPublicPlayer(): IPublicPlayer;
+    setSession(session: string): void;
+    enable(): void;
+    disable(): 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" | "disabled" | "ready" | "hand" | "usedHand" | "prevHand" | "teamIdx" | "session" | "isTurn" | "isOwner">;
+export declare function Player(id: string, teamIdx: number, isOwner?: boolean): IPlayer;

package/dist/lib/classes/Player.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Player = void 0;
+function Player(id, teamIdx, isOwner = false) {
+    const player = {
+        id,
+        session: undefined,
+        teamIdx,
+        hand: [],
+        commands: [],
+        usedHand: [],
+        prevHand: [],
+        isOwner,
+        isTurn: false,
+        disabled: false,
+        ready: false,
+        setOwner(owner) {
+            player.isOwner = owner;
+        },
+        setTurn(turn) {
+            player.isTurn = turn;
+        },
+        getPublicPlayer() {
+            const { id, disabled, ready, usedHand, prevHand, teamIdx, isTurn, isOwner } = player;
+            return {
+                id,
+                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;
+        },
+        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

@@ -0,0 +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;

package/dist/lib/classes/Round.js

@@ -0,0 +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;

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

@@ -0,0 +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;

package/dist/lib/classes/Table.js

@@ -0,0 +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;

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

@@ -0,0 +1,19 @@
+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;
+    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

@@ -0,0 +1,48 @@
+"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);
+        },
+        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

@@ -0,0 +1,18 @@
+import { IPlayer } from "./Player";
+export interface ITruco {
+    state: 1 | 2 | 3 | 4;
+    teamIdx: 0 | 1 | null;
+    answer: boolean | null;
+    turn: number;
+    players: Array<IPlayer>;
+    currentPlayer: IPlayer | null;
+    generator: Generator<ITruco, void, unknown>;
+    sayTruco(teamIdx: 0 | 1, players: Array<IPlayer>): ITruco;
+    setPlayers(players: Array<IPlayer>): void;
+    setAnswer(answer: boolean | null): 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(): ITruco;

package/dist/lib/classes/Truco.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Truco = void 0;
+function Truco() {
+    function* trucoAnswerGeneratorSequence() {
+        let i = 0;
+        while (i < truco.players.length && truco.answer === null) {
+            const player = truco.players[truco.turn];
+            truco.setCurrentPlayer(player);
+            if (player.disabled) {
+                truco.setCurrentPlayer(null);
+            }
+            if (truco.turn >= truco.players.length - 1) {
+                truco.setTurn(0);
+            }
+            else {
+                truco.setTurn(truco.turn + 1);
+            }
+            i++;
+            yield truco;
+        }
+        yield truco;
+    }
+    const truco = {
+        turn: 0,
+        state: 1,
+        teamIdx: null,
+        answer: null,
+        currentPlayer: null,
+        generator: trucoAnswerGeneratorSequence(),
+        players: [],
+        sayTruco(teamIdx, players) {
+            truco.teamIdx = teamIdx;
+            truco.answer = null;
+            truco.players = players;
+            truco.generator = trucoAnswerGeneratorSequence();
+            return truco;
+        },
+        setPlayers(players) {
+            truco.players = players;
+        },
+        setAnswer(answer) {
+            if (answer) {
+                truco.state++;
+            }
+            if (answer !== null) {
+                truco.teamIdx = null;
+            }
+            truco.answer = answer;
+            return truco;
+        },
+        setTeam(idx) {
+            truco.teamIdx = idx;
+            return truco.teamIdx;
+        },
+        setTurn(turn) {
+            truco.turn = turn;
+            return truco.turn;
+        },
+        setCurrentPlayer(player) {
+            truco.currentPlayer = player;
+            return truco.currentPlayer;
+        },
+        getNextPlayer() {
+            return truco.generator.next();
+        },
+    };
+    return truco;
+}
+exports.Truco = Truco;

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

@@ -0,0 +1,11 @@
+export * from "./Deck";
+export * from "./GameLoop";
+export * from "./Hand";
+export * from "./Lobby";
+export * from "./Match";
+export * from "./Play";
+export * from "./Player";
+export * from "./Round";
+export * from "./Table";
+export * from "./Team";
+export * from "./Truco";

package/dist/lib/classes/index.js

@@ -0,0 +1,27 @@
+"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("./Deck"), exports);
+__exportStar(require("./GameLoop"), exports);
+__exportStar(require("./Hand"), exports);
+__exportStar(require("./Lobby"), exports);
+__exportStar(require("./Match"), exports);
+__exportStar(require("./Play"), exports);
+__exportStar(require("./Player"), exports);
+__exportStar(require("./Round"), exports);
+__exportStar(require("./Table"), exports);
+__exportStar(require("./Team"), exports);
+__exportStar(require("./Truco"), exports);

package/dist/lib/constants.d.ts

@@ -0,0 +1,45 @@
+import { IEnvidoCalculator } from "../types";
+export declare const CARDS: {
+    "1e": number;
+    "1b": number;
+    "7e": number;
+    "7o": number;
+    "3e": number;
+    "3o": number;
+    "3b": number;
+    "3c": number;
+    "2e": number;
+    "2o": number;
+    "2b": number;
+    "2c": number;
+    "1o": number;
+    "1c": number;
+    re: number;
+    ro: number;
+    rb: number;
+    rc: number;
+    ce: number;
+    co: number;
+    cb: number;
+    cc: number;
+    pe: number;
+    po: number;
+    pb: number;
+    pc: number;
+    "7b": number;
+    "7c": number;
+    "6e": number;
+    "6o": number;
+    "6b": number;
+    "6c": number;
+    "5e": number;
+    "5o": number;
+    "5b": number;
+    "5c": number;
+    "4e": number;
+    "4o": number;
+    "4b": number;
+    "4c": number;
+};
+export declare const TEAM_SIZE_VALUES: number[];
+export declare const EnvidoCalculator: IEnvidoCalculator;

package/dist/lib/constants.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvidoCalculator = exports.TEAM_SIZE_VALUES = exports.CARDS = void 0;
+const types_1 = require("../types");
+const utils_1 = require("./utils");
+exports.CARDS = {
+    "1e": 14,
+    "1b": 13,
+    "7e": 12,
+    "7o": 11,
+    "3e": 10,
+    "3o": 10,
+    "3b": 10,
+    "3c": 10,
+    "2e": 9,
+    "2o": 9,
+    "2b": 8,
+    "2c": 8,
+    "1o": 7,
+    "1c": 7,
+    re: 6,
+    ro: 6,
+    rb: 6,
+    rc: 6,
+    ce: 5,
+    co: 5,
+    cb: 5,
+    cc: 5,
+    pe: 4,
+    po: 4,
+    pb: 4,
+    pc: 4,
+    "7b": 3,
+    "7c": 3,
+    "6e": 2,
+    "6o": 2,
+    "6b": 2,
+    "6c": 2,
+    "5e": 1,
+    "5o": 1,
+    "5b": 1,
+    "5c": 1,
+    "4e": 0,
+    "4o": 0,
+    "4b": 0,
+    "4c": 0,
+};
+exports.TEAM_SIZE_VALUES = [1, 2, 3];
+exports.EnvidoCalculator = {
+    [types_1.EEnvidoCommand.ENVIDO]: () => ({
+        accept: 2,
+        decline: 1,
+        next: [types_1.EEnvidoCommand.ENVIDO_ENVIDO, types_1.EEnvidoCommand.REAL_ENVIDO, types_1.EEnvidoCommand.FALTA_ENVIDO],
+    }),
+    [types_1.EEnvidoCommand.ENVIDO_ENVIDO]: () => ({
+        accept: 4,
+        decline: 2,
+        next: [types_1.EEnvidoCommand.REAL_ENVIDO, types_1.EEnvidoCommand.FALTA_ENVIDO],
+    }),
+    [types_1.EEnvidoCommand.REAL_ENVIDO]: () => ({
+        accept: 3,
+        decline: 1,
+        next: [types_1.EEnvidoCommand.FALTA_ENVIDO],
+    }),
+    [types_1.EEnvidoCommand.FALTA_ENVIDO]: (args) => {
+        if (!args || !args.teams || !args.matchPoint) {
+            return {
+                accept: 1,
+                decline: 1,
+                next: [],
+            };
+        }
+        const { teams, matchPoint } = args;
+        const totals = teams.map((team) => team.points.malas + team.points.buenas);
+        const higher = (0, utils_1.getMaxNumberIndex)(totals);
+        const points = teams[higher].points;
+        const accept = points.buenas > 0 ? matchPoint - points.buenas : matchPoint - points.malas;
+        return {
+            accept,
+            decline: 2,
+            next: [],
+        };
+    },
+};

package/dist/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./classes";
+export * from "./constants";

package/dist/lib/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("./classes"), exports);
+__exportStar(require("./constants"), exports);