trucoshi 7.0.0-alpha.2 → 7.0.0-rc.11

package/README.md

@@ -48,7 +48,7 @@ Proba la demo actual en [Trucoshi](https://trucoshi.com)
     [x] Unit tests
     [x] Bitcoin Lightning integration
     [x] Historial de partidas
-    [ ] Cantar flor
+    [x] Cantar flor
     [ ] Torneos
 
 # Donations

package/dist/lib/classes/Deck.js

@@ -1,4 +1,4 @@
-import { BURNT_CARD, CARDS } from "../../types";
+import { BURNT_CARD, CARDS } from "../constants";
 import { Random } from "./Random";
 export function Deck() {
     const deck = {
@@ -37,6 +37,8 @@ export function Deck() {
 export const getAllCards = () => Object.keys(CARDS);
 export function dealCards(table, deck) {
     const cheat_lots_of_flowers = process.env.APP_CHEAT_LOTS_OF_FLOWERS_FOR_TESTING === "1";
+    const cheat_cards = process.env.APP_CHEAT_CARDS &&
+        JSON.parse(process.env.APP_CHEAT_CARDS);
     const playerHands = [];
     const players = table.getPlayersForehandFirst();
     for (let i = 0; i < 3; i++) {
@@ -44,13 +46,25 @@ export function dealCards(table, deck) {
             playerHands[player.idx] = [...(playerHands[player.idx] || []), deck.takeCard()];
         }
     }
-    if (cheat_lots_of_flowers && table.forehandIdx % 2 === 0) {
+    if (cheat_cards) {
+        deck.shuffle(players[0].idx);
+        for (const [key, player] of players.entries()) {
+            playerHands[player.idx] = cheat_cards[key]
+                ? cheat_cards[key].map((c) => deck.pick(c) || deck.takeCard())
+                : deck.takeThree();
+        }
+    }
+    if (cheat_lots_of_flowers) {
         deck.shuffle(players[0].idx);
         for (const player of players) {
-            const first = deck.takeCard();
-            const second = deck.pick(deck.cards.find((c) => c.charAt(1) === first.charAt(1)));
-            const third = deck.pick(deck.cards.find((c) => c.charAt(1) === first.charAt(1)));
-            playerHands[player.idx] = [first, second, third];
+            if (Math.random() > 0.5) {
+                const first = deck.takeCard();
+                const second = deck.pick(deck.cards.find((c) => c.charAt(1) === first.charAt(1)));
+                const third = deck.pick(deck.cards.find((c) => c.charAt(1) === first.charAt(1)));
+                playerHands[player.idx] = [first, second, third];
+                continue;
+            }
+            playerHands[player.idx] = deck.takeThree();
         }
     }
     for (const [key, player] of table.players.entries()) {

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

@@ -1,5 +1,5 @@
 export interface IQueue {
     promise: Promise<void>;
-    queue(operation: () => any): Promise<void>;
+    queue<T>(operation: () => Promise<T>): Promise<T>;
 }
 export declare const Queue: () => IQueue;

package/dist/lib/classes/Queue.js

@@ -1,15 +1,16 @@
 import logger from "../../utils/logger";
+const log = logger.child({ class: "Queue" });
 export const Queue = () => {
     const queue = {
         promise: Promise.resolve(),
         queue(operation) {
-            return new Promise((resolve) => {
+            return new Promise((resolve, reject) => {
                 queue.promise = queue.promise
                     .then(operation)
                     .then(resolve)
                     .catch((e) => {
-                    logger.error(e, "Error in queue operation %o", operation);
-                    resolve();
+                    log.error(e, "Error in queue operation %o", operation);
+                    reject(e);
                 });
             });
         },

package/dist/lib/classes/Table.js

@@ -1,34 +1,48 @@
+import logger from "../../utils/logger";
+const log = logger.child({ class: "Table" });
 export function Table(players) {
+    log.trace({ playerKeys: players.map((p) => p.key) }, "Creating new table");
     const table = {
         players,
         cards: [],
         forehandIdx: 0,
         nextHand() {
+            log.trace({ currentForehandIdx: table.forehandIdx }, "nextHand called");
             if (table.forehandIdx < table.players.length - 1) {
                 table.forehandIdx++;
             }
             else {
                 table.forehandIdx = 0;
             }
-            return table.getPlayerByPosition();
+            log.trace({ newForehandIdx: table.forehandIdx }, "nextHand updated");
+            const nextPlayer = table.getPlayerByPosition();
+            log.trace({ playerKey: nextPlayer.key }, "nextHand returning player");
+            return nextPlayer;
         },
         getPlayerPosition(key, forehandFirst = false) {
+            log.trace({ key, forehandFirst }, "getPlayerPosition called");
             const array = forehandFirst ? table.getPlayersForehandFirst() : table.players;
-            return array.findIndex((p) => p.key === key);
+            const position = array.findIndex((p) => p.key === key);
+            log.trace({ key, position }, "getPlayerPosition result");
+            return position;
         },
         getPlayersForehandFirst(forehand) {
             const idx = forehand !== undefined ? forehand : table.forehandIdx;
+            log.trace({ forehandIdx: idx }, "getPlayersForehandFirst called");
             const cut = players.slice(idx, table.players.length);
             const end = players.slice(0, idx);
-            return cut.concat(end);
+            const result = cut.concat(end);
+            log.trace({ playerKeys: result.map((p) => p.key) }, "getPlayersForehandFirst result");
+            return result;
         },
         getPlayerByPosition(idx, forehandFirst = false) {
+            log.trace({ idx, forehandFirst }, "getPlayerByPosition called");
             const array = forehandFirst ? table.getPlayersForehandFirst() : table.players;
-            if (idx !== undefined) {
-                return array[idx];
-            }
-            return array[0];
+            const player = idx !== undefined ? array[idx] : array[0];
+            log.trace({ playerKey: player.key }, "getPlayerByPosition result");
+            return player;
         },
     };
+    log.trace({ forehandIdx: table.forehandIdx }, "Table initialization complete");
     return table;
 }

package/dist/lib/utils.d.ts

@@ -1,6 +1,5 @@
 import { IRound } from "../truco";
-import { ICard, IPlayer } from "../types";
-export declare function calculateFlorPoints(player: IPlayer): number;
+import { ICard } from "../types";
 export declare function getMaxNumberIndex<T = number>(array: Array<T>): number;
 export declare function getMinNumberIndex<T = number>(array: Array<T>): number;
 export declare function getCardValue(card: ICard): number;

package/dist/lib/utils.js

@@ -1,21 +1,4 @@
-import { splitCardvalues } from "../truco";
 import { CARDS } from "./constants";
-// Calculates the Flor points for a player's hand.
-// Returns the sum of the envidoValue of three cards of the same suit plus 20, or 0 if no Flor exists.
-export function calculateFlorPoints(player) {
-    if (!player.hasFlor) {
-        return 0;
-    }
-    const hand = [...player.hand, ...player.usedHand].map(splitCardvalues);
-    // Verify that all cards share the same suit (should be true if player.hasFlor is set)
-    const sameSuit = hand.every((card) => card.palo === hand[0].palo);
-    if (!sameSuit) {
-        return 0;
-    }
-    // Sum the envidoValue of all cards (figures are 0)
-    const points = hand.reduce((sum, card) => sum + card.value, 20);
-    return points;
-}
 export function getMaxNumberIndex(array) {
     return array.reduce((accumulator, current, index) => {
         return current > array[accumulator] ? index : accumulator;

package/dist/types.d.ts

@@ -1,9 +1,9 @@
 export * from "./events";
 export { CARDS, CARDS_HUMAN_READABLE, BURNT_CARD } from "./lib/constants";
 import { User } from "lightning-accounts";
-import { CARDS } from "./lib";
 import { Match, MatchPlayer, MatchHand, UserStats } from "@trucoshi/prisma";
 import { IHand } from "./truco";
+import { CARDS } from "./lib";
 export declare enum EMatchState {
     UNREADY = "UNREADY",
     READY = "READY",
@@ -39,6 +39,16 @@ export interface ISaidCommand {
     player: IPlayer | IPublicPlayer;
     command: ECommand | number;
 }
+export interface IMatchFlorBattle {
+    matchSessionId: string;
+    playersWithFlor: {
+        idx: number;
+        cards?: ICard[];
+        points: number;
+    }[];
+    winnerTeamIdx: 0 | 1 | null;
+    winner: IPublicPlayer | null;
+}
 export interface IMatchPreviousHand {
     envido: {
         winner: IPublicPlayer;
@@ -48,6 +58,7 @@ export interface IMatchPreviousHand {
         };
     } | null;
     flor: {
+        winner: IPublicPlayer | null;
         data: Array<{
             idx: number;
             value: number;
@@ -64,8 +75,10 @@ export interface IPublicMatch {
     busy: boolean;
     state: EMatchState;
     handState: EHandState | null;
+    florBattle: IMatchFlorBattle | null;
     winner: ITeam | null;
     matchSessionId: string;
+    forehandIdx: number;
     ownerKey: string;
     teams: Array<IPublicTeam>;
     players: Array<IPublicPlayer>;
@@ -89,11 +102,13 @@ export interface IChatMessage {
     user: {
         name: string;
         key: string;
+        teamIdx?: 0 | 1;
     };
     system?: boolean;
     command?: boolean;
     card?: boolean;
     content: string;
+    sound: string | boolean;
 }
 export interface IChatRoom {
     id: string;
@@ -101,10 +116,10 @@ export interface IChatRoom {
     socket: {
         emit(socket: string): void;
     };
-    send(user: IChatMessage["user"], message: string): void;
-    card(user: IChatMessage["user"], card: ICard): void;
-    command(team: 0 | 1, command: ECommand | number): void;
-    system(message: string): void;
+    send(user: IChatMessage["user"], message: string, sound?: string | boolean): void;
+    card(user: IChatMessage["user"], card: ICard, sound?: string | boolean): void;
+    command(team: 0 | 1, command: ECommand | number, sound?: string | boolean): void;
+    system(message: string, sound?: string | boolean): void;
     emit(message?: IChatMessage): void;
 }
 export declare enum EChatSystem {
@@ -134,9 +149,9 @@ export declare enum EEnvidoAnswerCommand {
     SON_BUENAS = "SON_BUENAS"
 }
 export declare enum EEnvidoCommand {
-    ENVIDO = "ENVIDO",
+    FALTA_ENVIDO = "FALTA_ENVIDO",
     REAL_ENVIDO = "REAL_ENVIDO",
-    FALTA_ENVIDO = "FALTA_ENVIDO"
+    ENVIDO = "ENVIDO"
 }
 export declare enum EHandState {
     WAITING_PLAY = "WAITING_PLAY",
@@ -144,6 +159,7 @@ export declare enum EHandState {
     WAITING_ENVIDO_ANSWER = "WAITING_ENVIDO_ANSWER",
     WAITING_ENVIDO_POINTS_ANSWER = "WAITING_ENVIDO_POINTS_ANSWER",
     WAITING_FLOR_ANSWER = "WAITING_FLOR_ANSWER",
+    DISPLAY_FLOR_BATTLE = "DISPLAY_FLOR_BATTLE",
     BEFORE_FINISHED = "BEFORE_FINISHED",
     FINISHED = "FINISHED"
 }
@@ -248,10 +264,10 @@ export type IPublicTeam = Pick<ITeam, "points" | "id" | "name"> & {
 export interface IPlayer {
     idx: number;
     secret: string;
-    teamIdx: number;
+    teamIdx: 0 | 1;
     accountId: number | undefined;
     matchPlayerId: number | undefined;
-    avatarUrl: string | undefined;
+    avatarUrl: string | undefined | null;
     name: string;
     key: string;
     session: string;
@@ -270,15 +286,21 @@ export interface IPlayer {
     turnExpiresAt: number | null;
     turnExtensionExpiresAt: number | null;
     hasFlor: boolean;
-    hasSaidFlorPoints: boolean;
+    flor: {
+        value: number;
+        cards: ICard[];
+    } | null;
+    hasSaidFlor: boolean;
     hasSaidEnvidoPoints: boolean;
+    hasSaidTruco: boolean;
     isEnvidoTurn: boolean;
     isOwner: boolean;
     disabled: boolean;
     abandoned: boolean;
     ready: boolean;
     saidEnvidoPoints(): void;
-    saidFlorPoints(): void;
+    saidFlor(): void;
+    saidTruco(): void;
     resetCommands(): void;
     calculateEnvido(): Array<{
         value: number;
@@ -307,6 +329,7 @@ export interface ITeam {
     name: string;
     players: Array<IPlayer>;
     points: ITeamPoints;
+    setPlayers(players: IPlayer[]): ITeam;
     pointsToWin(matchPoint: number): number;
     getPublicTeam(playerSession?: string): IPublicTeam;
     isTeamDisabled(): boolean;

package/dist/types.js

@@ -41,9 +41,9 @@ export var EEnvidoAnswerCommand;
 })(EEnvidoAnswerCommand || (EEnvidoAnswerCommand = {}));
 export var EEnvidoCommand;
 (function (EEnvidoCommand) {
-    EEnvidoCommand["ENVIDO"] = "ENVIDO";
-    EEnvidoCommand["REAL_ENVIDO"] = "REAL_ENVIDO";
     EEnvidoCommand["FALTA_ENVIDO"] = "FALTA_ENVIDO";
+    EEnvidoCommand["REAL_ENVIDO"] = "REAL_ENVIDO";
+    EEnvidoCommand["ENVIDO"] = "ENVIDO";
 })(EEnvidoCommand || (EEnvidoCommand = {}));
 export var EHandState;
 (function (EHandState) {
@@ -52,6 +52,7 @@ export var EHandState;
     EHandState["WAITING_ENVIDO_ANSWER"] = "WAITING_ENVIDO_ANSWER";
     EHandState["WAITING_ENVIDO_POINTS_ANSWER"] = "WAITING_ENVIDO_POINTS_ANSWER";
     EHandState["WAITING_FLOR_ANSWER"] = "WAITING_FLOR_ANSWER";
+    EHandState["DISPLAY_FLOR_BATTLE"] = "DISPLAY_FLOR_BATTLE";
     EHandState["BEFORE_FINISHED"] = "BEFORE_FINISHED";
     EHandState["FINISHED"] = "FINISHED";
 })(EHandState || (EHandState = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trucoshi",
-  "version": "7.0.0-alpha.2",
+  "version": "7.0.0-rc.11",
   "description": "Lightning Truco Server",
   "main": "dist/types.js",
   "license": "GPL-3.0",
@@ -33,8 +33,8 @@
     "test:e2e": "prisma db push --force-reset && dotenv -e .env.test -- ts-mocha --exit ./test/**/*.ts -t 60000",
     "profiler": "node --prof ./bin/trucoshi-server",
     "prepublishOnly": "yarn test && yarn build:dist",
-    "cli:autoplay": "yarn run ts-node src/cli/autoplay",
-    "cli:play": "yarn run ts-node src/cli/play",
+    "cli:autoplay": "APP_DEBUG_LEVEL=warn yarn run ts-node src/utils/scripts/autoplay",
+    "cli:play": "APP_DEBUG_LEVEL=warn yarn run ts-node src/utils/scripts/play",
     "db:push": "prisma db push",
     "db:studio": "prisma studio",
     "db:migrate": "prisma migrate dev"

package/dist/server/constants.d.ts

@@ -1,3 +0,0 @@
-export declare const PLAYER_TIMEOUT_GRACE = 500;
-export declare const PLAYER_LOBBY_TIMEOUT: number;
-export declare const MATCH_FINISHED_CLEANUP_TIMEOUT: number;

package/dist/server/constants.js

@@ -1,3 +0,0 @@
-export const PLAYER_TIMEOUT_GRACE = 500;
-export const PLAYER_LOBBY_TIMEOUT = 1000 * 10;
-export const MATCH_FINISHED_CLEANUP_TIMEOUT = 1000 * 60 * 2;