trucoshi 0.2.13 → 0.2.14

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,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chat = void 0;
+const types_1 = require("../../types");
+const SYSTEM_ID = "system";
+const ChatMessage = (user, message, system = false) => {
+    return {
+        date: Date.now() / 1000,
+        user,
+        system,
+        content: message,
+    };
+};
+const ChatRoom = (io, id) => {
+    const room = {
+        id,
+        messages: [],
+        send(user, message) {
+            room.messages.push(ChatMessage(user, message));
+            room.emit();
+        },
+        system(message) {
+            room.messages.push(ChatMessage({ id: SYSTEM_ID, key: SYSTEM_ID }, message, 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,112 @@
+"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() {
+            const { matchSessionId, state, lobby: { players, maxPlayers }, } = matchTable;
+            return {
+                matchSessionId,
+                maxPlayers,
+                players: players.length,
+                state: state(),
+            };
+        },
+        waitPlayerReconnection(player, callback, update) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (matchTable.state() !== types_1.EMatchTableState.STARTED) {
+                    player.setReady(false);
+                }
+                update();
+                try {
+                    yield new Promise(callback);
+                }
+                catch (e) {
+                    if (matchTable.state() !== types_1.EMatchTableState.STARTED) {
+                        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,34 @@
+/// <reference types="node" />
+import { Server as HttpServer } from "http";
+import { Server, Socket } from "socket.io";
+import { IPlayer, IPlayInstance } 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<void>;
+    setOrGetSession(socket: TrucoshiSocket, id: string | null, session: string | null, callback: IEventCallback<{
+        session?: string;
+    }>): 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>;
+    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,304 @@
+"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;
+                        return callback({ success: true, session });
+                    }
+                }
+                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 });
+            });
+        },
+        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]),
+                    });
+                    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);
+                        yield callback(playerSocket, player);
+                    }
+                    resolve();
+                }));
+            });
+        },
+        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) => {
+                            var _a;
+                            if (!data) {
+                                return;
+                            }
+                            if (someoneSaidSomething) {
+                                return;
+                            }
+                            const { command } = data;
+                            try {
+                                if (command) {
+                                    const saidCommand = play.say(command, player);
+                                    if (saidCommand) {
+                                        someoneSaidSomething = true;
+                                        (_a = server.chat.rooms
+                                            .get(table.matchSessionId)) === null || _a === void 0 ? void 0 : _a.send({ id: player.id, key: player.key }, 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);
+                    }
+                }));
+            });
+        },
+        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((play) => {
+                        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                            var _a, _b;
+                            const currentTurn = server.turns.get(table.matchSessionId);
+                            const emitPreviousHand = currentTurn
+                                ? currentTurn.previousHandIdx !== ((_a = play.prevHand) === null || _a === void 0 ? void 0 : _a.idx)
+                                : false;
+                            server.turns.set(table.matchSessionId, {
+                                play,
+                                resolve,
+                                previousHandIdx: play.prevHand ? play.prevHand.idx : null,
+                            });
+                            try {
+                                const session = (_b = play.player) === null || _b === void 0 ? void 0 : _b.session;
+                                if (!session || !play) {
+                                    throw new Error("Unexpected Error");
+                                }
+                                server.users.getOrThrow(session);
+                                if (emitPreviousHand) {
+                                    yield server.emitPreviousHand(play, table);
+                                }
+                                yield server.emitWaitingForPlay(play, table);
+                                return resolve();
+                            }
+                            catch (e) {
+                                reject(e);
+                            }
+                        }));
+                    })
+                        .onTruco((play) => {
+                        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                            server.turns.update(table.matchSessionId, {
+                                play,
+                                resolve,
+                            });
+                            try {
+                                yield server.emitWaitingPossibleSay(play, table);
+                                return resolve();
+                            }
+                            catch (e) {
+                                reject(e);
+                            }
+                        }));
+                    })
+                        .onWinner(() => __awaiter(this, void 0, void 0, function* () {
+                        yield server.emitMatchUpdate(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;
+        },
+    };
+    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) => {
+        const playingMatch = getPossiblePlayingMatch(room, socketId);
+        if (!playingMatch) {
+            return;
+        }
+        const { player, table, user } = playingMatch;
+        table.waitPlayerReconnection(player, (reconnect, abandon) => {
+            user.waitReconnection(table.matchSessionId, reconnect, abandon);
+        }, () => {
+            server.emitMatchUpdate(table, []);
+        });
+    });
+    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,23 @@
+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 {
+    previousHandIdx: number | null;
+    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): 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,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+const PLAYER_ABANDON_TIMEOUT = 10000;
+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);
+            }, 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() {
+            user.online = false;
+        },
+        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 @@
+export declare const PREVIOUS_HAND_ACK_TIMEOUT = 5000;

package/dist/server/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PREVIOUS_HAND_ACK_TIMEOUT = void 0;
+exports.PREVIOUS_HAND_ACK_TIMEOUT = 5000;

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,148 @@
+"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, (matchSessionId, ready, callback) => {
+        var _a;
+        try {
+            if (!socket.data.user) {
+                throw new Error("Session not found");
+            }
+            const table = server.tables.getOrThrow(matchSessionId);
+            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 });
+        }
+    });
+    next();
+};
+exports.trucoshiEvents = trucoshiEvents;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trucoshi",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "main": "dist/index.js",
   "license": "GPL-3.0",
   "scripts": {
@@ -28,6 +28,7 @@
     "dist/index.d.ts",
     "dist/types.js",
     "dist/types.d.ts",
+    "dist/server/**/*",
     "dist/lib/**/*"
   ],
   "dependencies": {