trucoshi 0.2.7 → 0.2.9

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

@@ -4,6 +4,7 @@ export interface IDeck {
     cards: Array<ICard>;
     usedCards: Array<ICard>;
     takeCard(): ICard;
+    takeThree(): [ICard, ICard, ICard];
     shuffle(): IDeck;
 }
 export type ICard = keyof typeof CARDS;

package/dist/lib/classes/Deck.js

@@ -12,6 +12,9 @@ function Deck() {
             deck.usedCards.push(card);
             return card;
         },
+        takeThree() {
+            return [deck.takeCard(), deck.takeCard(), deck.takeCard()];
+        },
         shuffle() {
             deck.cards = deck.cards.concat(deck.usedCards);
             deck.usedCards = [];

package/dist/lib/classes/Hand.js

@@ -8,19 +8,17 @@ const Play_1 = require("./Play");
 const Round_1 = require("./Round");
 const Truco_1 = require("./Truco");
 function Hand(match, deck, idx) {
-    match.teams.forEach((team) => {
-        team.players.forEach((player) => {
-            const playerHand = [deck.takeCard(), deck.takeCard(), deck.takeCard()];
-            player.setHand(playerHand);
+    for (const team of match.teams) {
+        for (const player of team.players) {
             player.enable();
-            // player.setHand(["5c", "4c", "6c"])
-        });
-    });
+            player.setHand(deck.takeThree());
+        }
+    }
     function* roundsGeneratorSequence() {
         let currentRoundIdx = 0;
         let forehandTeamIdx = match.table.player(hand.turn).teamIdx;
         while (currentRoundIdx < 3 && !hand.finished()) {
-            const round = (0, Round_1.Round)(0);
+            const round = (0, Round_1.Round)();
             hand.setCurrentRound(round);
             hand.pushRound(round);
             let previousRound = hand.rounds[currentRoundIdx - 1];
@@ -39,10 +37,15 @@ function Hand(match, deck, idx) {
                         yield hand;
                     }
                 }
+                if (hand.truco.answer === false) {
+                    hand.setState(types_1.EHandState.FINISHED);
+                    break;
+                }
                 const player = match.table.player(hand.turn);
                 hand.setCurrentPlayer(player);
                 if (player.disabled || !player.ready) {
                     hand.setCurrentPlayer(null);
+                    hand.nextTurn();
                 }
                 yield hand;
             }
@@ -69,24 +72,25 @@ function Hand(match, deck, idx) {
     const commands = {
         [types_1.ESayCommand.MAZO]: (player) => {
             hand.disablePlayer(player);
+            hand.nextTurn();
         },
         [types_1.ESayCommand.TRUCO]: (player) => {
-            const { teamIdx } = hand.truco;
-            if (teamIdx === null || teamIdx !== player.teamIdx) {
+            hand.truco.sayTruco(player, () => {
                 hand.setState(types_1.EHandState.WAITING_FOR_TRUCO_ANSWER);
-                hand.truco.sayTruco(player.teamIdx, match.teams[Number(!player.teamIdx)].players);
-            }
+            });
         },
-        [types_1.ESayCommand.QUIERO]: () => {
+        [types_1.ESayCommand.QUIERO]: (player) => {
             if (hand.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
-                hand.truco.setAnswer(true);
-                hand.setState(types_1.EHandState.WAITING_PLAY);
+                hand.truco.sayAnswer(player, true, () => {
+                    hand.setState(types_1.EHandState.WAITING_PLAY);
+                });
             }
         },
         [types_1.ESayCommand.NO_QUIERO]: (player) => {
             if (hand.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER) {
-                hand.truco.setAnswer(false);
-                hand.setState(types_1.EHandState.WAITING_PLAY);
+                hand.truco.sayAnswer(player, false, () => {
+                    hand.setState(types_1.EHandState.WAITING_PLAY);
+                });
             }
         },
         [types_1.ESayCommand.FLOR]: () => { },
@@ -101,7 +105,7 @@ function Hand(match, deck, idx) {
         turn: Number(match.table.forehandIdx),
         state: types_1.EHandState.WAITING_PLAY,
         rounds: [],
-        truco: (0, Truco_1.Truco)(),
+        truco: (0, Truco_1.Truco)(match.teams),
         envido: {
             accept: 1,
             decline: 2,

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

@@ -13,9 +13,8 @@ export interface IPlayInstance {
     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;
+    say(command: ECommand, player: IPlayer): ECommand | null;
 }
 export declare function PlayInstance(hand: IHand, teams: [ITeam, ITeam]): IPlayInstance;

package/dist/lib/classes/Play.js

@@ -3,7 +3,6 @@ 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,
@@ -12,28 +11,16 @@ function PlayInstance(hand, teams) {
         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);
+        say(command, player) {
+            hand.commands[command](player);
             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];
-    }
+    teams.forEach((team) => team.players.forEach((player) => player._commands.add(types_1.ESayCommand.MAZO)));
     return instance;
 }
 exports.PlayInstance = PlayInstance;

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

@@ -6,7 +6,8 @@ export interface IPlayer {
     key: string;
     session?: string;
     hand: Array<ICard>;
-    commands: Array<ECommand>;
+    _commands: Set<ECommand>;
+    get commands(): Array<ECommand>;
     usedHand: Array<ICard>;
     prevHand: Array<ICard>;
     isTurn: boolean;
@@ -25,5 +26,7 @@ export interface IPlayer {
     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 type IPublicPlayer = Pick<IPlayer, "id" | "key" | "disabled" | "ready" | "connected" | "hand" | "usedHand" | "prevHand" | "teamIdx" | "session" | "isTurn" | "isOwner"> & {
+    commands: Array<ECommand>;
+};
 export declare function Player(key: string, id: string, teamIdx: number, isOwner?: boolean): IPlayer;

package/dist/lib/classes/Player.js

@@ -8,7 +8,7 @@ function Player(key, id, teamIdx, isOwner = false) {
         session: undefined,
         teamIdx,
         hand: [],
-        commands: [],
+        _commands: new Set(),
         usedHand: [],
         prevHand: [],
         isOwner,
@@ -16,6 +16,9 @@ function Player(key, id, teamIdx, isOwner = false) {
         disabled: false,
         connected: false,
         ready: false,
+        get commands() {
+            return Array.from(player._commands.values());
+        },
         setOwner(owner) {
             player.isOwner = owner;
         },
@@ -23,11 +26,12 @@ function Player(key, id, teamIdx, isOwner = false) {
             player.isTurn = turn;
         },
         getPublicPlayer() {
-            const { id, key, connected, disabled, ready, usedHand, prevHand, teamIdx, isTurn, isOwner } = player;
+            const { id, key, commands, connected, disabled, ready, usedHand, prevHand, teamIdx, isTurn, isOwner, } = player;
             return {
                 id,
                 key,
                 connected,
+                commands,
                 disabled,
                 ready,
                 usedHand,

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

@@ -14,4 +14,4 @@ export interface IRoundPoints {
     1: number;
     ties: number;
 }
-export declare function Round(turn: number): IRound;
+export declare function Round(): IRound;

package/dist/lib/classes/Round.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Round = void 0;
 const utils_1 = require("../utils");
 const Deck_1 = require("./Deck");
-function Round(turn) {
+function Round() {
     const round = {
-        turn,
+        turn: 0,
         highest: -1,
         winner: null,
         cards: [],

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

@@ -6,6 +6,7 @@ export interface ITeam {
     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"> & {

package/dist/lib/classes/Team.js

@@ -21,6 +21,17 @@ function Team(players) {
         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();

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

@@ -1,18 +1,19 @@
 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(teamIdx: 0 | 1, players: Array<IPlayer>): ITruco;
-    setPlayers(players: Array<IPlayer>): void;
-    setAnswer(answer: boolean | null): ITruco;
+    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(): ITruco;
+export declare function Truco(teams: [ITeam, ITeam]): ITruco;

package/dist/lib/classes/Truco.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Truco = void 0;
-function Truco() {
+const types_1 = require("../../types");
+function Truco(teams) {
     function* trucoAnswerGeneratorSequence() {
         let i = 0;
         while (i < truco.players.length && truco.answer === null) {
@@ -24,29 +25,78 @@ function Truco() {
     const truco = {
         turn: 0,
         state: 1,
+        teams,
         teamIdx: null,
         answer: null,
         currentPlayer: null,
         generator: trucoAnswerGeneratorSequence(),
         players: [],
-        sayTruco(teamIdx, players) {
-            truco.teamIdx = teamIdx;
-            truco.answer = null;
-            truco.players = players;
-            truco.generator = trucoAnswerGeneratorSequence();
+        sayTruco(player, callback) {
+            if (truco.state === 4) {
+                return truco;
+            }
+            const playerTeamIdx = player.teamIdx;
+            const teamIdx = truco.teamIdx;
+            if (teamIdx === null || teamIdx !== playerTeamIdx) {
+                truco.state++;
+                const opponentIdx = Number(!playerTeamIdx);
+                truco.teamIdx = playerTeamIdx;
+                truco.answer = null;
+                truco.players = teams[opponentIdx].players;
+                truco.generator = trucoAnswerGeneratorSequence();
+                teams[playerTeamIdx].players.forEach((player) => {
+                    player._commands.delete(types_1.ESayCommand.TRUCO);
+                    player._commands.delete(types_1.ESayCommand.QUIERO);
+                    player._commands.delete(types_1.ESayCommand.NO_QUIERO);
+                });
+                teams[opponentIdx].players.forEach((player) => {
+                    if (truco.state < 4) {
+                        player._commands.add(types_1.ESayCommand.TRUCO);
+                    }
+                    else {
+                        player._commands.delete(types_1.ESayCommand.TRUCO);
+                    }
+                    player._commands.add(types_1.ESayCommand.QUIERO);
+                    player._commands.add(types_1.ESayCommand.NO_QUIERO);
+                });
+                callback();
+                return truco;
+            }
             return truco;
         },
-        setPlayers(players) {
-            truco.players = players;
-        },
-        setAnswer(answer) {
+        sayAnswer(player, answer, callback) {
+            const opponentIdx = Number(!player.teamIdx);
+            if (player.teamIdx === truco.teamIdx) {
+                return truco;
+            }
             if (answer) {
-                truco.state++;
+                teams[player.teamIdx].players.forEach((player) => {
+                    player._commands.add(types_1.ESayCommand.TRUCO);
+                    player._commands.delete(types_1.ESayCommand.NO_QUIERO);
+                    player._commands.delete(types_1.ESayCommand.QUIERO);
+                    if (truco.state > 3) {
+                        player._commands.delete(types_1.ESayCommand.TRUCO);
+                    }
+                });
+                teams[opponentIdx].players.forEach((player) => {
+                    player._commands.delete(types_1.ESayCommand.TRUCO);
+                });
+            }
+            if (answer === false) {
+                truco.state--;
+                const playerTeam = teams[player.teamIdx];
+                playerTeam.players.forEach((player) => playerTeam.disable(player));
+                teams[player.teamIdx].players.forEach((player) => {
+                    player._commands.delete(types_1.ESayCommand.QUIERO);
+                    player._commands.delete(types_1.ESayCommand.TRUCO);
+                    player._commands.delete(types_1.ESayCommand.NO_QUIERO);
+                });
             }
             if (answer !== null) {
-                truco.teamIdx = null;
+                truco.teamIdx = Number(!player.teamIdx);
+                truco.answer = answer;
+                callback();
             }
-            truco.answer = answer;
             return truco;
         },
         setTeam(idx) {
@@ -65,6 +115,9 @@ function Truco() {
             return truco.generator.next();
         },
     };
+    teams.forEach((team) => team.players.forEach((player) => {
+        player._commands.add(types_1.ESayCommand.TRUCO);
+    }));
     return truco;
 }
 exports.Truco = Truco;

package/dist/types.d.ts

@@ -1,5 +1,4 @@
 import { ICard, IHandPoints, IPlayedCard, IPlayer, IPublicPlayer, IPublicTeam, ITeam } from "./lib";
-import { IChatRoom } from "./server/classes/Chat";
 export interface IPublicMatch {
     state: EMatchTableState;
     winner: ITeam | null;
@@ -18,6 +17,22 @@ export interface IPublicMatchInfo {
     state: EMatchTableState;
 }
 export type IPublicChatRoom = Pick<IChatRoom, "id" | "messages">;
+export interface IChatMessage {
+    date: number;
+    user: {
+        id: string;
+        key: string;
+    };
+    system: boolean;
+    content: string;
+}
+export interface IChatRoom {
+    id: string;
+    messages: Array<IChatMessage>;
+    send(user: IChatMessage["user"], message: string): void;
+    system(message: string): void;
+    emit(): void;
+}
 export declare enum EMatchTableState {
     UNREADY = 0,
     READY = 1,
@@ -74,7 +89,7 @@ export type IEnvidoCalculator = {
 };
 export declare enum EClientEvent {
     PING = "PING",
-    PLAY = "PLAY",
+    SAY = "SAY",
     CREATE_MATCH = "CREATE_MATCH",
     LIST_MATCHES = "LIST_MATCHES",
     JOIN_MATCH = "JOIN_MATCH",
@@ -89,6 +104,7 @@ export type IEventCallback<T = {}> = (args: {
 } & T) => void;
 export interface ServerToClientEvents {
     [EServerEvent.PONG]: (msg: string) => void;
+    [EServerEvent.WAITING_POSSIBLE_SAY]: (match: IPublicMatch, callback: (data: IWaitingSayData) => void) => void;
     [EServerEvent.UPDATE_CHAT]: (room: IPublicChatRoom) => void;
     [EServerEvent.UPDATE_MATCH]: (match: IPublicMatch) => void;
     [EServerEvent.WAITING_PLAY]: (match: IPublicMatch, callback: (data: IWaitingPlayData) => void) => void;
@@ -125,6 +141,7 @@ export declare enum EServerEvent {
     PONG = "PONG",
     UPDATE_MATCH = "UPDATE_MATCH",
     WAITING_PLAY = "WAITING_PLAY",
+    WAITING_POSSIBLE_SAY = "WAITING_POSSIBLE_SAY",
     UPDATE_CHAT = "UPDAET_CHAT"
 }
 export declare enum ETrucoshiMatchState {
@@ -135,13 +152,12 @@ export declare enum ETrucoshiMatchState {
 export type IWaitingPlayData = {
     cardIdx: number;
     card: ICard;
-    command?: undefined;
-} | {
-    cardIdx?: undefined;
-    card?: undefined;
-    command: ECommand;
 };
 export type IWaitingPlayCallback = (data: IWaitingPlayData) => void | null;
+export type IWaitingSayData = {
+    command: ECommand;
+};
+export type IWaitingSayCallback = (data: IWaitingSayData) => void | null;
 export interface TMap<K, V> extends Map<K, V> {
     find(finder: (value: V) => boolean): V | void;
 }

package/dist/types.js

@@ -42,7 +42,7 @@ var GAME_ERROR;
 var EClientEvent;
 (function (EClientEvent) {
     EClientEvent["PING"] = "PING";
-    EClientEvent["PLAY"] = "PLAY";
+    EClientEvent["SAY"] = "SAY";
     EClientEvent["CREATE_MATCH"] = "CREATE_MATCH";
     EClientEvent["LIST_MATCHES"] = "LIST_MATCHES";
     EClientEvent["JOIN_MATCH"] = "JOIN_MATCH";
@@ -57,6 +57,7 @@ var EServerEvent;
     EServerEvent["PONG"] = "PONG";
     EServerEvent["UPDATE_MATCH"] = "UPDATE_MATCH";
     EServerEvent["WAITING_PLAY"] = "WAITING_PLAY";
+    EServerEvent["WAITING_POSSIBLE_SAY"] = "WAITING_POSSIBLE_SAY";
     EServerEvent["UPDATE_CHAT"] = "UPDAET_CHAT";
 })(EServerEvent = exports.EServerEvent || (exports.EServerEvent = {}));
 var ETrucoshiMatchState;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trucoshi",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "main": "dist/index.js",
   "license": "GPL-3.0",
   "scripts": {