trucoshi 0.2.18 → 0.3.0

package/bin/trucoshi-server

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+const trucoshi = require("../dist/index")
+
+trucoshi.default()

package/dist/server/classes/Chat.d.ts

@@ -0,0 +1,7 @@
+import { IChatRoom, TMap } from "../../types";
+import { TrucoshiServer } from "./SocketServer";
+export interface IChat {
+    rooms: TMap<string, IChatRoom>;
+    create(id: string): void;
+}
+export declare const Chat: (io: TrucoshiServer) => IChat;

package/dist/server/classes/Chat.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chat = void 0;
+const types_1 = require("../../types");
+const SYSTEM_ID = "system";
+const ChatUser = (id) => {
+    return {
+        id,
+        key: id,
+    };
+};
+const ChatMessage = ({ user, system, command, content, }) => {
+    return {
+        date: Date.now() / 1000,
+        user,
+        content,
+        system: system || false,
+        command: command || false,
+    };
+};
+const ChatRoom = (io, id) => {
+    const room = {
+        id,
+        messages: [],
+        send(user, content) {
+            room.messages.push(ChatMessage({
+                user,
+                content,
+            }));
+            room.emit();
+        },
+        system(content) {
+            room.messages.push(ChatMessage({
+                user: ChatUser(SYSTEM_ID),
+                content,
+                system: true,
+            }));
+            room.emit();
+        },
+        command(team, command) {
+            room.messages.push(ChatMessage({
+                user: ChatUser(types_1.EChatSystem[team]),
+                content: command,
+                command: true,
+            }));
+            room.emit();
+        },
+        emit() {
+            io.sockets.adapter
+                .fetchSockets({
+                rooms: new Set([room.id]),
+            })
+                .then((sockets) => {
+                for (const playerSocket of sockets) {
+                    playerSocket.emit(types_1.EServerEvent.UPDATE_CHAT, { id: room.id, messages: room.messages });
+                }
+            });
+        },
+    };
+    return room;
+};
+const Chat = (io) => {
+    const chat = {
+        rooms: new types_1.TMap(),
+        create(id) {
+            const room = ChatRoom(io, id);
+            const exists = chat.rooms.get(id);
+            if (exists) {
+                return;
+            }
+            chat.rooms.set(id, room);
+        },
+    };
+    const adapter = io.of("/").adapter;
+    adapter.on("join-room", (room, socketId) => {
+        var _a;
+        const userSocket = io.sockets.sockets.get(socketId);
+        if (!userSocket || !userSocket.data.user) {
+            return;
+        }
+        const { id, key } = userSocket.data.user;
+        (_a = chat.rooms.get(room)) === null || _a === void 0 ? void 0 : _a.system(`${id} entro a la sala`);
+        userSocket.on(types_1.EClientEvent.CHAT, (matchId, message, callback) => {
+            if (matchId !== room || !userSocket.data.user) {
+                return;
+            }
+            const chatroom = chat.rooms.get(matchId);
+            if (chatroom) {
+                chatroom.send({ id, key }, message);
+            }
+            callback();
+        });
+    });
+    adapter.on("leave-room", (room, socketId) => {
+        var _a;
+        const userSocket = io.sockets.sockets.get(socketId);
+        if (!userSocket || !userSocket.data.user) {
+            return;
+        }
+        const { id } = userSocket.data.user;
+        (_a = chat.rooms.get(room)) === null || _a === void 0 ? void 0 : _a.system(`${id} salio de la sala`);
+    });
+    return chat;
+};
+exports.Chat = Chat;

package/dist/server/classes/MatchTable.d.ts

@@ -0,0 +1,15 @@
+import { IHand, ILobby, IPlayedCard, IPlayer } from "../../lib";
+import { EMatchTableState, IMatchPreviousHand, IPublicMatch, IPublicMatchInfo } from "../../types";
+export interface IMatchTable {
+    ownerSession: string;
+    matchSessionId: string;
+    lobby: ILobby;
+    state(): EMatchTableState;
+    isSessionPlaying(session: string): IPlayer | null;
+    getPreviousHand(hand: IHand): IMatchPreviousHand;
+    getHandRounds(hand: IHand): IPlayedCard[][];
+    getPublicMatch(session?: string): IPublicMatch;
+    getPublicMatchInfo(): IPublicMatchInfo;
+    waitPlayerReconnection(player: IPlayer, callback: (onReconnect: () => void, onAbandon: () => void) => void, update: () => void): Promise<void>;
+}
+export declare function MatchTable(matchSessionId: string, ownerSession: string, teamSize?: 1 | 2 | 3): IMatchTable;

package/dist/server/classes/MatchTable.js

@@ -0,0 +1,113 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchTable = void 0;
+const lib_1 = require("../../lib");
+const types_1 = require("../../types");
+function MatchTable(matchSessionId, ownerSession, teamSize) {
+    const matchTable = {
+        ownerSession,
+        matchSessionId,
+        lobby: (0, lib_1.Lobby)(teamSize),
+        state() {
+            var _a;
+            matchTable.lobby.calculateReady();
+            if ((_a = matchTable.lobby.gameLoop) === null || _a === void 0 ? void 0 : _a.winner) {
+                return types_1.EMatchTableState.FINISHED;
+            }
+            if (matchTable.lobby.started) {
+                return types_1.EMatchTableState.STARTED;
+            }
+            if (matchTable.lobby.ready) {
+                return types_1.EMatchTableState.READY;
+            }
+            return types_1.EMatchTableState.UNREADY;
+        },
+        isSessionPlaying(session) {
+            const { lobby } = matchTable;
+            const search = lobby.players.find((player) => player && player.session === session);
+            return search || null;
+        },
+        getPublicMatchInfo() {
+            var _a;
+            const { matchSessionId, state, lobby: { players, maxPlayers }, } = matchTable;
+            return {
+                ownerId: (_a = players.find((player) => player.isOwner)) === null || _a === void 0 ? void 0 : _a.id,
+                matchSessionId,
+                maxPlayers,
+                players: players.length,
+                state: state(),
+            };
+        },
+        waitPlayerReconnection(player, callback, update) {
+            return __awaiter(this, void 0, void 0, function* () {
+                player.setReady(false);
+                update();
+                try {
+                    yield new Promise(callback);
+                }
+                catch (e) {
+                    if (matchTable.state() !== types_1.EMatchTableState.STARTED &&
+                        matchTable.state() !== types_1.EMatchTableState.FINISHED) {
+                        player.setReady(false);
+                        matchTable.lobby.removePlayer(player.session);
+                    }
+                    else {
+                        player.setReady(true);
+                    }
+                }
+                update();
+            });
+        },
+        getHandRounds(hand) {
+            if (!hand) {
+                return [];
+            }
+            return hand.rounds.map((round) => round.cards) || [];
+        },
+        getPreviousHand(hand) {
+            return {
+                rounds: matchTable.getHandRounds(hand),
+                points: hand.points,
+                matchSessionId: matchTable.matchSessionId,
+            };
+        },
+        getPublicMatch(userSession) {
+            var _a, _b, _c, _d;
+            const { lobby } = matchTable;
+            const winner = ((_a = lobby.gameLoop) === null || _a === void 0 ? void 0 : _a.winner) || null;
+            const rounds = ((_b = lobby.gameLoop) === null || _b === void 0 ? void 0 : _b.currentHand)
+                ? matchTable.getHandRounds((_c = lobby.gameLoop) === null || _c === void 0 ? void 0 : _c.currentHand)
+                : [];
+            const players = lobby.players.filter((player) => Boolean(player));
+            const currentPlayerIdx = players.findIndex((player) => player && player.session === userSession);
+            const me = players[currentPlayerIdx];
+            const cut = players.slice(currentPlayerIdx, players.length);
+            const end = players.slice(0, currentPlayerIdx);
+            const publicPlayers = cut
+                .concat(end)
+                .map((player) => ((player === null || player === void 0 ? void 0 : player.session) === userSession ? player : player.getPublicPlayer()));
+            const teams = ((_d = lobby.gameLoop) === null || _d === void 0 ? void 0 : _d.teams) || lobby.teams;
+            const publicTeams = teams.map((team) => team.getPublicTeam(userSession));
+            return {
+                me,
+                winner,
+                matchSessionId: matchTable.matchSessionId,
+                state: matchTable.state(),
+                teams: publicTeams,
+                players: publicPlayers,
+                rounds,
+            };
+        },
+    };
+    return matchTable;
+}
+exports.MatchTable = MatchTable;

package/dist/server/classes/SocketServer.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+import { Server as HttpServer } from "http";
+import { Server, Socket } from "socket.io";
+import { IPlayer, IPlayInstance, IPublicPlayer, ITeam } from "../../lib";
+import { ClientToServerEvents, ECommand, IEventCallback, IPublicMatch, ServerToClientEvents } from "../../types";
+import { IChat } from "./Chat";
+import { IMatchTable } from "./MatchTable";
+import { ITrucoshi } from "./Trucoshi";
+import { IUser } from "./User";
+interface InterServerEvents {
+}
+interface SocketData {
+    user?: IUser;
+}
+export type TrucoshiServer = Server<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>;
+export type TrucoshiSocket = Socket<ClientToServerEvents, ServerToClientEvents, InterServerEvents, SocketData>;
+export interface ISocketServer extends ITrucoshi {
+    io: TrucoshiServer;
+    httpServer: HttpServer;
+    chat: IChat;
+    getTableSockets(table: IMatchTable, callback?: (playerSocket: TrucoshiSocket, player: IPlayer | null) => Promise<void>): Promise<{
+        sockets: any[];
+        players: IPublicPlayer[];
+    }>;
+    setOrGetSession(socket: TrucoshiSocket, id: string | null, session: string | null, callback: IEventCallback<{
+        session?: string;
+    }>): Promise<IUser>;
+    leaveMatch(matchId: string, socketId: string, mayReconnect?: boolean): Promise<void>;
+    emitWaitingPossibleSay(play: IPlayInstance, table: IMatchTable): Promise<ECommand>;
+    emitWaitingForPlay(play: IPlayInstance, table: IMatchTable): Promise<void>;
+    emitMatchUpdate(table: IMatchTable, skipSocketIds?: Array<string>): Promise<void>;
+    emitPreviousHand(play: IPlayInstance, table: IMatchTable): Promise<void>;
+    emitSocketMatch(socket: TrucoshiSocket, currentMatchId: string | null): IPublicMatch | null;
+    startMatch(matchSessionId: string): Promise<void>;
+    onTurn(table: IMatchTable, play: IPlayInstance, newHandJustStarted: boolean): Promise<void>;
+    onTruco(table: IMatchTable, play: IPlayInstance): Promise<void>;
+    onWinner(table: IMatchTable, winner: ITeam): Promise<void>;
+    cleanupMatchTable(match: IMatchTable): void;
+    listen: (callback: (io: TrucoshiServer) => void) => void;
+}
+export declare const SocketServer: (trucoshi: ITrucoshi, port: number, origin?: string | Array<string>) => ISocketServer;
+export {};

package/dist/server/classes/SocketServer.js

@@ -0,0 +1,358 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketServer = void 0;
+const crypto_1 = require("crypto");
+const http_1 = require("http");
+const socket_io_1 = require("socket.io");
+const types_1 = require("../../types");
+const constants_1 = require("../constants");
+const Chat_1 = require("./Chat");
+const User_1 = require("./User");
+const SocketServer = (trucoshi, port, origin) => {
+    const httpServer = (0, http_1.createServer)();
+    const io = new socket_io_1.Server(httpServer, {
+        cors: {
+            origin,
+            methods: ["GET", "POST"],
+        },
+    });
+    const server = {
+        io,
+        httpServer,
+        turns: trucoshi.turns,
+        tables: trucoshi.tables,
+        users: trucoshi.users,
+        chat: (0, Chat_1.Chat)(io),
+        listen(callback) {
+            httpServer.listen(port, undefined, undefined, () => callback(server.io));
+        },
+        setOrGetSession(socket, id, session, callback = () => { }) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (session) {
+                    const user = server.users.get(session);
+                    if (user) {
+                        const newId = id || user.id || "Satoshi";
+                        user.connect();
+                        user.setId(newId);
+                        socket.data.user = user;
+                        callback({ success: true, session });
+                        return user;
+                    }
+                }
+                const newSession = (0, crypto_1.randomUUID)();
+                const userKey = (0, crypto_1.randomUUID)();
+                const newId = id || "Satoshi";
+                const newUser = (0, User_1.User)(userKey, newId, newSession);
+                socket.data.user = newUser;
+                server.users.set(newSession, newUser);
+                callback({ success: false, session: newSession });
+                return newUser;
+            });
+        },
+        getTableSockets(table, callback) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    const sockets = yield server.io.sockets.adapter.fetchSockets({
+                        rooms: new Set([table.matchSessionId]),
+                    });
+                    const players = [];
+                    for (const playerSocket of sockets) {
+                        if (!((_a = playerSocket.data.user) === null || _a === void 0 ? void 0 : _a.session)) {
+                            continue;
+                        }
+                        const player = table.isSessionPlaying(playerSocket.data.user.session);
+                        if (player) {
+                            players.push(player);
+                        }
+                        if (callback) {
+                            yield callback(playerSocket, player);
+                        }
+                    }
+                    resolve({ sockets, players });
+                }));
+            });
+        },
+        emitMatchUpdate(table, skipSocketIds = []) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield server.getTableSockets(table, (playerSocket) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    if (skipSocketIds.includes(playerSocket.id)) {
+                        return;
+                    }
+                    playerSocket.emit(types_1.EServerEvent.UPDATE_MATCH, table.getPublicMatch((_a = playerSocket.data.user) === null || _a === void 0 ? void 0 : _a.session));
+                }));
+            });
+        },
+        emitWaitingPossibleSay(play, table) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let someoneSaidSomething = false;
+                return new Promise((resolve, reject) => {
+                    return server.getTableSockets(table, (playerSocket, player) => __awaiter(this, void 0, void 0, function* () {
+                        if (!player) {
+                            return;
+                        }
+                        playerSocket.emit(types_1.EServerEvent.WAITING_POSSIBLE_SAY, table.getPublicMatch(player.session), (data) => {
+                            if (!data) {
+                                return;
+                            }
+                            if (someoneSaidSomething) {
+                                return;
+                            }
+                            const { command } = data;
+                            try {
+                                if (command) {
+                                    const saidCommand = play.say(command, player);
+                                    if (saidCommand) {
+                                        someoneSaidSomething = true;
+                                        server.chat.rooms
+                                            .getOrThrow(table.matchSessionId)
+                                            .command(player.teamIdx, saidCommand);
+                                        return resolve(saidCommand);
+                                    }
+                                }
+                            }
+                            catch (e) {
+                                reject(e);
+                            }
+                        });
+                    }));
+                });
+            });
+        },
+        emitWaitingForPlay(play, table) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return new Promise((resolve, reject) => {
+                    server
+                        .emitWaitingPossibleSay(play, table)
+                        .then(() => {
+                        resolve();
+                    })
+                        .catch(console.error);
+                    return server.getTableSockets(table, (playerSocket, player) => __awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        if (!player) {
+                            return;
+                        }
+                        if (player.session === ((_a = play.player) === null || _a === void 0 ? void 0 : _a.session)) {
+                            playerSocket.emit(types_1.EServerEvent.WAITING_PLAY, table.getPublicMatch(player.session), (data) => {
+                                if (!data) {
+                                    return reject(new Error(types_1.EServerEvent.WAITING_PLAY + " callback returned empty"));
+                                }
+                                const { cardIdx, card } = data;
+                                if (cardIdx !== undefined && card) {
+                                    const playedCard = play.use(cardIdx, card);
+                                    if (playedCard) {
+                                        return resolve();
+                                    }
+                                    return reject(new Error("Invalid Card"));
+                                }
+                                return reject(new Error("Invalid Callback Response"));
+                            });
+                        }
+                    }));
+                });
+            });
+        },
+        emitPreviousHand(play, table) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const promises = [];
+                        yield server.getTableSockets(table, (playerSocket, player) => __awaiter(this, void 0, void 0, function* () {
+                            promises.push(new Promise((resolvePlayer, rejectPlayer) => {
+                                if (!player || !play.prevHand) {
+                                    return rejectPlayer();
+                                }
+                                playerSocket.emit(types_1.EServerEvent.PREVIOUS_HAND, table.getPreviousHand(play.prevHand), resolvePlayer);
+                                setTimeout(() => {
+                                    rejectPlayer();
+                                }, constants_1.PREVIOUS_HAND_ACK_TIMEOUT);
+                            }));
+                        }));
+                        yield Promise.allSettled(promises);
+                        resolve();
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                }));
+            });
+        },
+        onTurn(table, play, newHandJustStarted) {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                server.turns.set(table.matchSessionId, {
+                    play,
+                    resolve,
+                });
+                try {
+                    const session = (_a = play.player) === null || _a === void 0 ? void 0 : _a.session;
+                    if (!session || !play) {
+                        throw new Error("Unexpected Error");
+                    }
+                    server.users.getOrThrow(session);
+                    if (newHandJustStarted) {
+                        yield server.emitPreviousHand(play, table);
+                    }
+                    yield server.emitWaitingForPlay(play, table);
+                    return resolve();
+                }
+                catch (e) {
+                    reject(e);
+                }
+            }));
+        },
+        onTruco(table, play) {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                server.turns.set(table.matchSessionId, {
+                    play,
+                    resolve,
+                });
+                try {
+                    yield server.emitWaitingPossibleSay(play, table);
+                    return resolve();
+                }
+                catch (e) {
+                    reject(e);
+                }
+            }));
+        },
+        onWinner(table, _winner) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield server.emitMatchUpdate(table);
+            });
+        },
+        startMatch(matchSessionId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const table = server.tables.getOrThrow(matchSessionId);
+                if (table && !table.lobby.gameLoop) {
+                    table.lobby
+                        .startMatch()
+                        .onTurn(server.onTurn.bind(this, table))
+                        .onTruco(server.onTruco.bind(this, table))
+                        .onWinner(server.onWinner.bind(this, table))
+                        .begin();
+                    server.tables.set(matchSessionId, table);
+                    return;
+                }
+            });
+        },
+        emitSocketMatch(socket, matchId) {
+            var _a;
+            if (!matchId || !((_a = socket.data.user) === null || _a === void 0 ? void 0 : _a.session)) {
+                return null;
+            }
+            const currentTable = server.tables.get(matchId);
+            if (currentTable) {
+                socket.join(currentTable.matchSessionId);
+                const { play, resolve } = server.turns.get(currentTable.matchSessionId) || {};
+                if (play && play.player && currentTable.isSessionPlaying(socket.data.user.session)) {
+                    if (play.state === types_1.EHandState.WAITING_PLAY &&
+                        socket.data.user.session === play.player.session) {
+                        server.emitWaitingForPlay(play, currentTable).then(resolve).catch(console.error);
+                    }
+                    else {
+                        server.emitWaitingPossibleSay(play, currentTable).then(resolve).catch(console.error);
+                    }
+                }
+                else {
+                    socket.emit(types_1.EServerEvent.UPDATE_MATCH, currentTable.getPublicMatch(socket.data.user.session));
+                }
+                return currentTable.getPublicMatch(socket.data.user.session);
+            }
+            return null;
+        },
+        leaveMatch(matchId, socketId, mayReconnect) {
+            return new Promise((resolve, reject) => {
+                var _a;
+                const _abandon = (table, player, abandon) => {
+                    try {
+                        const { play, resolve: playResolve } = server.turns.getOrThrow(table.matchSessionId);
+                        play.say(types_1.ESayCommand.MAZO, player);
+                        playResolve();
+                        abandon();
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                };
+                const playingMatch = _getPossiblePlayingMatch(matchId, socketId);
+                if (!playingMatch) {
+                    return resolve();
+                }
+                const { player, table, user } = playingMatch;
+                if (table.state() === types_1.EMatchTableState.FINISHED && ((_a = table.lobby.gameLoop) === null || _a === void 0 ? void 0 : _a.winner)) {
+                    server.cleanupMatchTable(table);
+                    return resolve();
+                }
+                if (!mayReconnect) {
+                    return _abandon(table, player, resolve);
+                }
+                server.getTableSockets(table).then(({ players }) => {
+                    const find = players.find((p) => p.key === player.key);
+                    if (find) {
+                        return resolve();
+                    }
+                    table.waitPlayerReconnection(player, (reconnect, abandon) => {
+                        user.waitReconnection(table.matchSessionId, reconnect, _abandon.bind({}, table, player, abandon));
+                    }, () => {
+                        server.emitMatchUpdate(table, []);
+                    });
+                    resolve();
+                });
+            });
+        },
+        cleanupMatchTable(table) {
+            try {
+                for (const player of table.lobby.players) {
+                    const user = server.users.getOrThrow(player.session);
+                    user.reconnect(table.matchSessionId); // resolve promises and timeouts
+                    server.tables.delete(table.matchSessionId);
+                    if (player.isOwner) {
+                        user.setOwnedMatch(null);
+                    }
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+        },
+    };
+    const _getPossiblePlayingMatch = (room, socketId) => {
+        const socket = server.io.sockets.sockets.get(socketId);
+        if (!socket || !socket.data.user) {
+            return null;
+        }
+        const table = server.tables.get(room);
+        if (table) {
+            const player = table.isSessionPlaying(socket.data.user.session);
+            if (player) {
+                return { table, player, user: socket.data.user };
+            }
+        }
+        return null;
+    };
+    io.of("/").adapter.on("leave-room", (room, socketId) => {
+        server.leaveMatch(room, socketId, true).then().catch(console.error);
+    });
+    io.of("/").adapter.on("join-room", (room, socketId) => {
+        const playingMatch = _getPossiblePlayingMatch(room, socketId);
+        if (!playingMatch) {
+            return;
+        }
+        const { table, user } = playingMatch;
+        user.reconnect(table.matchSessionId);
+    });
+    return server;
+};
+exports.SocketServer = SocketServer;

package/dist/server/classes/Trucoshi.d.ts

@@ -0,0 +1,22 @@
+import { IPlayInstance } from "../../lib";
+import { EMatchTableState, IPublicMatchInfo, TMap } from "../../types";
+import { IMatchTable } from "./MatchTable";
+import { IUser } from "./User";
+export interface ITrucoshi {
+    users: TMap<string, IUser>;
+    tables: MatchTableMap;
+    turns: TMap<string, ITrucoshiTurn>;
+}
+interface ITrucoshiTurn {
+    play: IPlayInstance;
+    resolve(): void;
+}
+interface MatchTableMap extends TMap<string, IMatchTable> {
+    getAll(filters: {
+        state?: Array<EMatchTableState>;
+    }): Array<IPublicMatchInfo>;
+}
+declare class MatchTableMap extends TMap<string, IMatchTable> {
+}
+export declare const Trucoshi: () => ITrucoshi;
+export {};

package/dist/server/classes/Trucoshi.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trucoshi = void 0;
+const types_1 = require("../../types");
+class MatchTableMap extends types_1.TMap {
+    getAll(filters = {}) {
+        let results = [];
+        for (let value of this.values()) {
+            if (!filters.state || !filters.state.length || filters.state.includes(value.state())) {
+                results.push(value.getPublicMatchInfo());
+            }
+        }
+        return results;
+    }
+}
+const Trucoshi = () => {
+    const users = new types_1.TMap(); // sessionId, user
+    const tables = new MatchTableMap(); // sessionId, table
+    const turns = new types_1.TMap(); // sessionId, play instance, play promise resolve and type
+    const trucoshi = {
+        users,
+        tables,
+        turns,
+    };
+    return trucoshi;
+};
+exports.Trucoshi = Trucoshi;

package/dist/server/classes/User.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+export interface IUser {
+    key: string;
+    id: string;
+    session: string;
+    online: boolean;
+    ownedMatchId: string | null;
+    waitingTimeouts: Map<string, NodeJS.Timeout | null>;
+    waitingPromises: Map<string, () => void>;
+    waitReconnection(room: string, reconnect: () => void, abandon: () => void): void;
+    setOwnedMatch(id: string | null): void;
+    connect(): void;
+    disconnect(): void;
+    reconnect(room: string): void;
+    setId(id: string): void;
+}
+export declare function User(key: string, id: string, session: string): IUser;

package/dist/server/classes/User.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+const constants_1 = require("../constants");
+function User(key, id, session) {
+    const user = {
+        id,
+        key,
+        session,
+        online: true,
+        ownedMatchId: null,
+        waitingTimeouts: new Map(),
+        waitingPromises: new Map(),
+        waitReconnection(room, reconnect, abandon) {
+            user.waitingTimeouts.set(room, setTimeout(() => {
+                abandon();
+                user.waitingPromises.delete(room);
+            }, constants_1.PLAYER_ABANDON_TIMEOUT));
+            user.waitingPromises.set(room, reconnect);
+        },
+        reconnect(room) {
+            const promise = user.waitingPromises.get(room);
+            if (promise) {
+                promise();
+                user.waitingPromises.delete(room);
+            }
+            const timeout = user.waitingTimeouts.get(room);
+            if (timeout) {
+                clearTimeout(timeout);
+                user.waitingTimeouts.delete(room);
+            }
+        },
+        setOwnedMatch(id) {
+            user.ownedMatchId = id;
+        },
+        connect() {
+            user.online = true;
+        },
+        disconnect() { },
+        setId(id) {
+            user.id = id;
+        },
+    };
+    return user;
+}
+exports.User = User;

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

@@ -0,0 +1,5 @@
+export * from "./Chat";
+export * from "./MatchTable";
+export * from "./SocketServer";
+export * from "./Trucoshi";
+export * from "./User";

package/dist/server/classes/index.js

@@ -0,0 +1,21 @@
+"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("./Chat"), exports);
+__exportStar(require("./MatchTable"), exports);
+__exportStar(require("./SocketServer"), exports);
+__exportStar(require("./Trucoshi"), exports);
+__exportStar(require("./User"), exports);

package/dist/server/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const PREVIOUS_HAND_ACK_TIMEOUT: number;
+export declare const PLAYER_ABANDON_TIMEOUT: number;

package/dist/server/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLAYER_ABANDON_TIMEOUT = exports.PREVIOUS_HAND_ACK_TIMEOUT = void 0;
+exports.PREVIOUS_HAND_ACK_TIMEOUT = 1000 * 5;
+exports.PLAYER_ABANDON_TIMEOUT = 1000 * 60;

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export * from './classes';

package/dist/server/index.js

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

package/dist/server/middlewares/trucoshiEvents.d.ts

@@ -0,0 +1,3 @@
+import { ExtendedError } from "socket.io/dist/namespace";
+import { ISocketServer, TrucoshiSocket } from "../classes";
+export declare const trucoshiEvents: (server: ISocketServer) => (socket: TrucoshiSocket, next: (err?: ExtendedError) => void) => void;

package/dist/server/middlewares/trucoshiEvents.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trucoshiEvents = void 0;
+const crypto_1 = require("crypto");
+const types_1 = require("../../types");
+const classes_1 = require("../classes");
+const trucoshiEvents = (server) => (socket, next) => {
+    socket.on("disconnect", (_reason) => {
+        var _a;
+        try {
+            const user = server.users.getOrThrow((_a = socket.data.user) === null || _a === void 0 ? void 0 : _a.session);
+            if (user) {
+                user.disconnect();
+            }
+        }
+        catch (e) {
+            // noop
+        }
+    });
+    socket.on(types_1.EClientEvent.PING, (msg) => {
+        socket.emit(types_1.EServerEvent.PONG, msg);
+    });
+    /**
+     * Create Match
+     */
+    socket.on(types_1.EClientEvent.CREATE_MATCH, (callback) => {
+        try {
+            if (!socket.data.user) {
+                throw new Error("Session not found");
+            }
+            const user = server.users.getOrThrow(socket.data.user.session);
+            const existingTable = user.ownedMatchId && server.tables.get(user.ownedMatchId);
+            if (existingTable) {
+                return callback({
+                    success: false,
+                    match: existingTable.getPublicMatch(socket.data.user.session),
+                });
+            }
+            const matchId = (0, crypto_1.randomUUID)();
+            const table = (0, classes_1.MatchTable)(matchId, socket.data.user.session);
+            user.ownedMatchId = matchId;
+            table.lobby.addPlayer(user.key, user.id, socket.data.user.session, 0, true);
+            server.chat.create(matchId);
+            socket.join(matchId);
+            server.tables.set(matchId, table);
+            return callback({ success: true, match: table.getPublicMatch(user.id) });
+        }
+        catch (e) {
+            return callback({ success: false });
+        }
+    });
+    /**
+     * Start Match
+     */
+    socket.on(types_1.EClientEvent.START_MATCH, (callback) => {
+        var _a;
+        try {
+            const user = server.users.getOrThrow((_a = socket.data.user) === null || _a === void 0 ? void 0 : _a.session);
+            const matchId = user.ownedMatchId;
+            if (matchId) {
+                server.startMatch(matchId);
+                return callback({ success: true, matchSessionId: matchId });
+            }
+        }
+        catch (e) {
+            callback({ success: false });
+        }
+        callback({ success: false });
+    });
+    /**
+     * Join Match
+     */
+    socket.on(types_1.EClientEvent.JOIN_MATCH, (matchSessionId, teamIdx, callback) => {
+        var _a, _b;
+        try {
+            const user = server.users.getOrThrow((_a = socket.data.user) === null || _a === void 0 ? void 0 : _a.session);
+            const table = server.tables.get(matchSessionId);
+            if (table) {
+                table.lobby.addPlayer(user.key, user.id, user.session, teamIdx, user.ownedMatchId === matchSessionId);
+                socket.join(table.matchSessionId);
+                server.emitMatchUpdate(table, []);
+                return callback({ success: true, match: table.getPublicMatch((_b = socket.data.user) === null || _b === void 0 ? void 0 : _b.session) });
+            }
+            callback({ success: false });
+        }
+        catch (e) {
+            callback({ success: false });
+        }
+    });
+    /**
+     * Get public matches
+     */
+    socket.on(types_1.EClientEvent.LIST_MATCHES, (filters = {}, callback) => {
+        const publicMatches = server.tables.getAll(filters);
+        callback({ success: true, matches: publicMatches });
+    });
+    /**
+     * Set Session
+     */
+    socket.on(types_1.EClientEvent.SET_SESSION, (id, session, callback = () => { }) => {
+        server.setOrGetSession(socket, id, session, ({ success, session }) => {
+            if (session && success) {
+                const activeMatches = server.tables
+                    .findAll((table) => Boolean(table.isSessionPlaying(session)))
+                    .map((match) => match.getPublicMatchInfo());
+                return callback({ success, session, activeMatches });
+            }
+            callback({ success, session, activeMatches: [] });
+        });
+    });
+    /**
+     * Fetch match with session
+     */
+    socket.on(types_1.EClientEvent.FETCH_MATCH, (session, matchId, callback) => {
+        return server.setOrGetSession(socket, null, session, ({ success }) => {
+            var _a;
+            if (!success) {
+                return callback({ success: false, match: null });
+            }
+            (_a = server.chat.rooms.get(matchId)) === null || _a === void 0 ? void 0 : _a.emit();
+            const match = server.emitSocketMatch(socket, matchId);
+            callback({ success: Boolean(match), match });
+        });
+    });
+    /**
+     * Set Player Ready
+     */
+    socket.on(types_1.EClientEvent.SET_PLAYER_READY, (matchId, ready, callback) => {
+        var _a;
+        try {
+            if (!socket.data.user) {
+                throw new Error("Session not found");
+            }
+            const table = server.tables.getOrThrow(matchId);
+            const player = table.lobby.players.find((player) => { var _a; return player && player.session === ((_a = socket.data.user) === null || _a === void 0 ? void 0 : _a.session); });
+            if (player) {
+                player.setReady(ready);
+                server.emitMatchUpdate(table, [socket.id]);
+                callback({ success: true, match: table.getPublicMatch((_a = socket.data.user) === null || _a === void 0 ? void 0 : _a.session) });
+            }
+        }
+        catch (e) {
+            callback({ success: false });
+        }
+    });
+    /**
+     * Leave Match
+     */
+    socket.on(types_1.EClientEvent.LEAVE_MATCH, (matchId) => {
+        server.leaveMatch(matchId, socket.id, false);
+    });
+    next();
+};
+exports.trucoshiEvents = trucoshiEvents;

package/dist/test/autoplay.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/autoplay.js

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lib_1 = require("../lib");
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    const trucoshi = (0, lib_1.Lobby)();
+    trucoshi.addPlayer("lukini", "lukini", "lukini").setReady(true);
+    trucoshi.addPlayer("denoph", "denoph", "denoph").setReady(true);
+    trucoshi.addPlayer("guada", "guada", "guada").setReady(true);
+    trucoshi.addPlayer("juli", "juli", "juli").setReady(true);
+    trucoshi.addPlayer("day", "day", "day").setReady(true);
+    trucoshi.addPlayer("fran", "fran", "fran").setReady(true);
+    trucoshi
+        .startMatch()
+        .onTurn((play) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        if (!play.player) {
+            return;
+        }
+        const name = (_a = play.player) === null || _a === void 0 ? void 0 : _a.id.toUpperCase();
+        console.log(`=== Mano ${play.handIdx} === Ronda ${play.roundIdx} === Turno de ${name} ===`);
+        play.teams.map((team, id) => console.log(`=== Team ${id} = ${team.points.malas} malas ${team.points.buenas} buenas ===`));
+        console.log(play.rounds && play.rounds.length
+            ? play.rounds.map((round) => round.cards.length ? round.cards.map((c) => [c.player.id, c.card]) : "")
+            : "");
+        const randomIdx = Math.round(Math.random() * (play.player.hand.length - 1));
+        const handString = JSON.stringify(play.player.hand);
+        const card = play.use(randomIdx, play.player.hand[randomIdx]);
+        console.log(`\n${handString}\nUsing ${card}`);
+        console.log(play.rounds && play.rounds.length
+            ? play.rounds.map((round) => round.cards.length ? round.cards.map((c) => [c.player.id, c.card]) : "")
+            : "");
+    }))
+        .onWinner((winner, teams) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log("\n");
+        teams.map((t, i) => console.log(`Equipo ${i}: ${t.players.map((p) => ` ${p.id}`)} === ${t.points.malas} malas ${t.points.buenas} buenas`));
+        console.log(`\nEquipo Ganador:${winner.players.map((p) => ` ${p.id}`)}`);
+    }))
+        .begin();
+}))();

package/dist/test/play.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/play.js

@@ -0,0 +1,124 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline = __importStar(require("readline"));
+const lib_1 = require("../lib");
+const command = (title, onLine) => {
+    const promise = () => new Promise((resolve) => {
+        const rl = readline.createInterface(process.stdin, process.stdout);
+        rl.setPrompt(title);
+        rl.prompt();
+        rl.on("line", (line) => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                yield onLine(line, () => rl.close());
+                rl.close();
+                resolve();
+            }
+            catch (e) {
+                rl.close();
+                return (() => __awaiter(void 0, void 0, void 0, function* () {
+                    yield promise();
+                    resolve();
+                }))();
+            }
+        }));
+    });
+    return promise;
+};
+const playCommand = (play) => {
+    var _a, _b, _d;
+    return command(`${(_a = play.player) === null || _a === void 0 ? void 0 : _a.id} elije una carta [${(_b = play.player) === null || _b === void 0 ? void 0 : _b.hand.map((_c, i) => i + 1)}]: ${JSON.stringify((_d = play.player) === null || _d === void 0 ? void 0 : _d.hand)}\n`, (idx) => __awaiter(void 0, void 0, void 0, function* () {
+        var _e, _f;
+        const card = (_e = play.player) === null || _e === void 0 ? void 0 : _e.hand[Number(idx) - 1];
+        const playedCard = play.use(Number(idx) - 1, card);
+        if (!playedCard) {
+            return Promise.reject();
+        }
+        const handString = JSON.stringify((_f = play.player) === null || _f === void 0 ? void 0 : _f.hand);
+        console.log(`\n${handString}\nUsing ${playedCard}`);
+        console.log(play.rounds && play.rounds.length
+            ? play.rounds.map((round) => round.cards.length ? round.cards.map((c) => [c.player.id, c.card]) : "")
+            : "");
+        return Promise.resolve();
+    }));
+};
+const sayCommand = (play, canPlay) => {
+    var _a, _b, _d, _e;
+    if (!((_a = play.player) === null || _a === void 0 ? void 0 : _a._commands)) {
+        return () => { };
+    }
+    const commandsArr = Array.from((_d = (_b = play.player) === null || _b === void 0 ? void 0 : _b._commands) === null || _d === void 0 ? void 0 : _d.values());
+    return command(`${(_e = play.player) === null || _e === void 0 ? void 0 : _e.id} elije una accion [${canPlay ? "0," : ""}${commandsArr.map((_c, i) => i + 1)}]: ${canPlay ? JSON.stringify(["CARTA", ...(commandsArr || [])]) : JSON.stringify(commandsArr)}\n`, (idx, close) => __awaiter(void 0, void 0, void 0, function* () {
+        const selectedCommand = commandsArr[Number(idx) - 1];
+        if (selectedCommand) {
+            close();
+            const saidCommand = play.say(selectedCommand, play.player);
+            console.log({ saidCommand });
+            return Promise.resolve();
+        }
+        if (idx === "0" && canPlay) {
+            close();
+            yield playCommand(play)();
+            return Promise.resolve();
+        }
+        return Promise.reject();
+    }));
+};
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    const trucoshi = (0, lib_1.Lobby)();
+    trucoshi.addPlayer("lukini", "lukini", "lukini").setReady(true);
+    trucoshi.addPlayer("denoph", "denoph", "denoph").setReady(true);
+    trucoshi.addPlayer("guada", "guada", "guada").setReady(true);
+    trucoshi.addPlayer("juli", "juli", "juli").setReady(true);
+    trucoshi
+        .startMatch()
+        .onTruco((play) => __awaiter(void 0, void 0, void 0, function* () {
+        yield sayCommand(play, false)();
+    }))
+        .onTurn((play) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const name = (_a = play.player) === null || _a === void 0 ? void 0 : _a.id.toUpperCase();
+        console.log(`=== Mano ${play.handIdx} === Ronda ${play.roundIdx} === Turno de ${name} ===`);
+        play.teams.map((team, id) => console.log(`=== Team ${id} = ${team.points.malas} malas ${team.points.buenas} buenas`));
+        console.log(play.rounds && play.rounds.length
+            ? play.rounds.map((round) => round.cards.length ? round.cards.map((c) => [c.player.id, c.card]) : "")
+            : "");
+        yield sayCommand(play, true)();
+    }))
+        .onWinner((winner, teams) => __awaiter(void 0, void 0, void 0, function* () {
+        teams.map((t, i) => console.log(`Equipo ${i}: ${t.players.map((p) => ` ${p.id}`)} === ${t.points.malas} malas ${t.points.buenas} buenas`));
+        console.log(`\nEquipo Ganador:${winner === null || winner === void 0 ? void 0 : winner.players.map((p) => ` ${p.id}`)}`);
+    }))
+        .begin();
+}))();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trucoshi",
-  "version": "0.2.18",
+  "version": "0.3.0",
   "main": "dist/index.js",
   "license": "GPL-3.0",
   "scripts": {
@@ -24,11 +24,8 @@
     "ts-mocha": "^10.0.0"
   },
   "files": [
-    "dist/index.js",
-    "dist/index.d.ts",
-    "dist/types.js",
-    "dist/types.d.ts",
-    "dist/lib/**/*"
+    "dist",
+    "bin"
   ],
   "dependencies": {
     "rimraf": "^4.1.1",