trucoshi 0.0.16 → 0.0.18

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

@@ -1,2 +1,3 @@
-import { IDeck } from "../types";
+import { ICard, IDeck, IPlayedCard, IPlayer } from "../types";
 export declare function Deck(): IDeck;
+export declare function PlayedCard(player: IPlayer, card: ICard): IPlayedCard;

package/dist/lib/classes/Deck.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Deck = void 0;
+exports.PlayedCard = exports.Deck = void 0;
 var constants_1 = require("../constants");
 var utils_1 = require("../utils");
 function Deck() {
@@ -25,3 +25,14 @@ function Deck() {
     return deck;
 }
 exports.Deck = Deck;
+function PlayedCard(player, card) {
+    var pc = {
+        player: player,
+        card: card,
+        get key() {
+            return card + player.session;
+        },
+    };
+    return pc;
+}
+exports.PlayedCard = PlayedCard;

package/dist/lib/classes/Hand.js

@@ -30,6 +30,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hand = void 0;
 var types_1 = require("../types");
 var utils_1 = require("../utils");
+var Deck_1 = require("./Deck");
 var Play_1 = require("./Play");
 var Round_1 = require("./Round");
 var Truco_1 = require("./Truco");
@@ -72,7 +73,6 @@ function Hand(match, deck, idx) {
                     if (!(hand.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER)) return [3 /*break*/, 6];
                     value = hand.truco.getNextPlayer().value;
                     if (!(value && value.currentPlayer)) return [3 /*break*/, 5];
-                    console.log({ value: value.currentPlayer });
                     hand.setCurrentPlayer(value.currentPlayer);
                     return [4 /*yield*/, hand];
                 case 4:
@@ -181,7 +181,7 @@ function Hand(match, deck, idx) {
             var card = player.useCard(idx);
             if (card) {
                 hand.nextTurn();
-                return round.use({ player: player, card: card });
+                return round.use((0, Deck_1.PlayedCard)(player, card));
             }
             return null;
         },

package/dist/lib/classes/Round.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Round = void 0;
 var utils_1 = require("../utils");
+var Deck_1 = require("./Deck");
 function Round(turn) {
     var round = {
         turn: turn,
@@ -24,7 +25,7 @@ function Round(turn) {
                 round.highest = value;
                 round.winner = player;
             }
-            round.cards.push({ card: card, player: player });
+            round.cards.push((0, Deck_1.PlayedCard)(player, card));
             return card;
         },
     };

package/dist/lib/classes/Team.js

@@ -17,7 +17,7 @@ function Team(players) {
         },
         disable: function (player) {
             var _a;
-            (_a = team._players.get(player.id)) === null || _a === void 0 ? void 0 : _a.disable();
+            (_a = team._players.get(player.session)) === null || _a === void 0 ? void 0 : _a.disable();
             return team.isTeamDisabled();
         },
         addPoints: function (matchPoint, points) {
@@ -36,7 +36,7 @@ function Team(players) {
             return team.points;
         },
     };
-    players.forEach(function (player) { return team._players.set(player.id, player); });
+    players.forEach(function (player) { return team._players.set(player.session, player); });
     return team;
 }
 exports.Team = Team;

package/dist/lib/constants.d.ts

@@ -41,9 +41,10 @@ export declare const CARDS: {
     "4b": number;
     "4c": number;
 };
-export declare const COLORS: string[];
 export declare const TEAM_SIZE_VALUES: number[];
 export declare enum GAME_ERROR {
+    MATCH_ALREADY_STARTED = "MATCH_ALREADY_STARTED",
+    LOBBY_IS_FULL = "LOBBY_IS_FULL",
     UNEXPECTED_TEAM_SIZE = "UNEXPECTED_TEAM_SIZE",
     TEAM_NOT_READY = "TEAM_NOT_READY",
     TEAM_IS_FULL = "TEAM_IS_FULL"

package/dist/lib/constants.js

@@ -1,7 +1,7 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnvidoCalculator = exports.GAME_ERROR = exports.TEAM_SIZE_VALUES = exports.COLORS = exports.CARDS = void 0;
+exports.EnvidoCalculator = exports.GAME_ERROR = exports.TEAM_SIZE_VALUES = exports.CARDS = void 0;
 var types_1 = require("./types");
 var utils_1 = require("./utils");
 exports.CARDS = {
@@ -46,19 +46,11 @@ exports.CARDS = {
     "4b": 0,
     "4c": 0,
 };
-exports.COLORS = [
-    "#9b111",
-    "#17c6c6",
-    "#8c1d1d",
-    "#9f9b9b",
-    "#a5a5a5",
-    "#f5a623",
-    "#f44336",
-    "#c2185b",
-];
 exports.TEAM_SIZE_VALUES = [1, 2, 3];
 var GAME_ERROR;
 (function (GAME_ERROR) {
+    GAME_ERROR["MATCH_ALREADY_STARTED"] = "MATCH_ALREADY_STARTED";
+    GAME_ERROR["LOBBY_IS_FULL"] = "LOBBY_IS_FULL";
     GAME_ERROR["UNEXPECTED_TEAM_SIZE"] = "UNEXPECTED_TEAM_SIZE";
     GAME_ERROR["TEAM_NOT_READY"] = "TEAM_NOT_READY";
     GAME_ERROR["TEAM_IS_FULL"] = "TEAM_IS_FULL";

package/dist/lib/index.d.ts

@@ -8,6 +8,7 @@ export interface IGameLoop {
     _onWinner: IWinnerCallback;
     teams: Array<ITeam>;
     hands: Array<IHand>;
+    winner: ITeam | null;
     onTurn: (callback: ITurnCallback) => IGameLoop;
     onWinner: (callback: IWinnerCallback) => IGameLoop;
     onTruco: (callback: ITrucoCallback) => IGameLoop;

package/dist/lib/index.js

@@ -49,6 +49,7 @@ var GameLoop = function (match) {
         _onTurn: function () { return Promise.resolve(); },
         _onWinner: function () { return Promise.resolve(); },
         teams: [],
+        winner: null,
         hands: [],
         onTruco: function (callback) {
             gameloop._onTruco = callback;
@@ -89,7 +90,9 @@ var GameLoop = function (match) {
                             _a.sent();
                             return [3 /*break*/, 1];
                         case 5: return [3 /*break*/, 1];
-                        case 6: return [4 /*yield*/, gameloop._onWinner(match.winner, match.teams)];
+                        case 6:
+                            gameloop.winner = match.winner;
+                            return [4 /*yield*/, gameloop._onWinner(match.winner, match.teams)];
                         case 7:
                             _a.sent();
                             return [2 /*return*/];
@@ -103,66 +106,104 @@ var GameLoop = function (match) {
 function Lobby(teamSize) {
     var lobby = {
         lastTeamIdx: 1,
-        _players: new Map(),
+        _players: [],
         get players() {
-            return Array.from(lobby._players.values());
+            return lobby._players.filter(function (player) { return Boolean(player && player.id); });
         },
         teams: [],
         table: null,
         maxPlayers: teamSize ? teamSize * 2 : 6,
         full: false,
         ready: false,
+        started: false,
         gameLoop: undefined,
         calculateReady: function () {
-            lobby.ready = lobby.players.reduce(function (prev, curr) { return prev && curr.ready; }, true);
+            var allPlayersReady = lobby.players.reduce(function (prev, curr) { return Boolean(prev && curr && curr.ready); }, true);
+            var teamsSameSize = lobby.players.filter(function (player) { return player.teamIdx === 0; }).length ===
+                lobby.players.filter(function (player) { return player.teamIdx === 1; }).length;
+            var allTeamsComplete = lobby.players.length % 2 === 0;
+            lobby.ready = allPlayersReady && allTeamsComplete && teamsSameSize;
             return lobby.ready;
         },
         calculateFull: function () {
-            lobby.full = lobby._players.size >= lobby.maxPlayers;
+            lobby.full = lobby.players.length >= lobby.maxPlayers;
             return lobby.full;
         },
         addPlayer: function (id, session, teamIdx) {
+            var exists = lobby.players.find(function (player) { return player.session === session; });
+            if (exists) {
+                if (exists.teamIdx === teamIdx) {
+                    return exists;
+                }
+                console.log({ session: session, ex: exists.session });
+                lobby.removePlayer(exists.session);
+            }
+            if (lobby.started) {
+                throw new Error(constants_1.GAME_ERROR.MATCH_ALREADY_STARTED);
+            }
+            if (lobby.full) {
+                throw new Error(constants_1.GAME_ERROR.LOBBY_IS_FULL);
+            }
             var maxSize = teamSize ? teamSize : 3;
-            if (lobby.full || lobby.players.filter(function (p) { return p.teamIdx === teamIdx; }).length > maxSize) {
+            if (lobby.full ||
+                lobby.players.filter(function (player) { return player.teamIdx === teamIdx; }).length > maxSize) {
                 throw new Error(constants_1.GAME_ERROR.TEAM_IS_FULL);
             }
             var player = (0, Player_1.Player)(id, teamIdx !== undefined ? teamIdx : Number(!lobby.lastTeamIdx));
             player.setSession(session);
             lobby.lastTeamIdx = Number(!lobby.lastTeamIdx);
-            lobby._players.set(id, player);
+            for (var i = 0; i < lobby._players.length; i++) {
+                if (!lobby._players[i].id) {
+                    if (player.teamIdx === 0 && i % 2 === 0) {
+                        lobby._players[i] = player;
+                        break;
+                    }
+                    if (player.teamIdx === 1 && i % 2 !== 0) {
+                        lobby._players[i] = player;
+                        break;
+                    }
+                }
+            }
             lobby.calculateFull();
             lobby.calculateReady();
             return player;
         },
-        removePlayer: function (id) {
-            lobby._players.delete(id);
-            lobby.calculateFull();
-            lobby.calculateReady();
+        removePlayer: function (session) {
+            var idx = lobby._players.findIndex(function (player) { return player && player.session === session; });
+            if (idx !== -1) {
+                lobby._players[idx] = {};
+                lobby.calculateFull();
+                lobby.calculateReady();
+            }
             return lobby;
         },
         startMatch: function (matchPoint) {
             if (matchPoint === void 0) { matchPoint = 9; }
             lobby.calculateReady();
-            var teamSize = lobby._players.size / 2;
-            if (!constants_1.TEAM_SIZE_VALUES.includes(teamSize)) {
+            var actualTeamSize = lobby.players.length / 2;
+            if (!constants_1.TEAM_SIZE_VALUES.includes(actualTeamSize)) {
                 throw new Error(constants_1.GAME_ERROR.UNEXPECTED_TEAM_SIZE);
             }
             if (!lobby.ready) {
                 throw new Error(constants_1.GAME_ERROR.TEAM_NOT_READY);
             }
             lobby.teams = [
-                (0, Team_1.Team)(lobby.players.filter(function (p) { return p.teamIdx === 0; })),
-                (0, Team_1.Team)(lobby.players.filter(function (p) { return p.teamIdx === 1; })),
+                (0, Team_1.Team)(lobby.players.filter(function (player) { return player.teamIdx === 0; })),
+                (0, Team_1.Team)(lobby.players.filter(function (player) { return player.teamIdx === 1; })),
             ];
-            if (lobby.teams[0].players.length !== teamSize ||
-                lobby.teams[1].players.length !== teamSize) {
+            if (lobby.teams[0].players.length !== actualTeamSize ||
+                lobby.teams[1].players.length !== actualTeamSize) {
                 throw new Error(constants_1.GAME_ERROR.UNEXPECTED_TEAM_SIZE);
             }
             lobby.table = (0, Table_1.Table)(lobby.players, lobby.teams);
             lobby.gameLoop = GameLoop((0, Match_1.Match)(lobby.table, lobby.teams, matchPoint));
+            lobby.started = true;
             return lobby.gameLoop;
         },
     };
+    for (var i = 0; i < lobby.maxPlayers; i++) {
+        lobby._players.push({});
+    }
     return lobby;
 }
 exports.Lobby = Lobby;

package/dist/lib/types.d.ts

@@ -9,6 +9,7 @@ export interface IDeck {
     shuffle(): IDeck;
 }
 export interface IPlayedCard {
+    get key(): string;
     player: IPlayer & IPublicPlayer;
     card: ICard;
 }
@@ -150,20 +151,24 @@ export interface IHand {
 export interface IPrivateLobby {
     gameLoop?: IGameLoop;
     lastTeamIdx: 0 | 1;
-    _players: Map<string, IPlayer>;
+    _players: Array<IPlayer | {
+        id?: undefined;
+        session?: undefined;
+    }>;
     get players(): Array<IPlayer>;
     teams: Array<ITeam>;
     maxPlayers: number;
     table: ITable | null;
-    ready: boolean;
     full: boolean;
+    ready: boolean;
+    started: boolean;
     addPlayer(id: string, session: string, teamIdx?: 0 | 1): IPlayer;
     removePlayer(id: string): ILobby;
     calculateReady(): boolean;
     calculateFull(): boolean;
     startMatch(matchPoint?: 9 | 12 | 15): IGameLoop;
 }
-export interface ILobby extends Pick<IPrivateLobby, "addPlayer" | "removePlayer" | "startMatch" | "ready" | "full" | "teams" | "players" | "gameLoop" | "table"> {
+export interface ILobby extends Pick<IPrivateLobby, "addPlayer" | "removePlayer" | "startMatch" | "ready" | "full" | "started" | "teams" | "players" | "gameLoop" | "table" | "calculateReady"> {
 }
 export interface ITable {
     forehandIdx: number;

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

@@ -1,25 +1,29 @@
 import { IPublicPlayer } from "../../lib/classes/Player";
 import { IPublicTeam } from "../../lib/classes/Team";
-import { ILobby, IPlayedCard } from "../../lib/types";
+import { ILobby, IPlayedCard, ITeam } from "../../lib/types";
 export interface IPublicMatch {
+    winner: ITeam | null;
+    matchSessionId: string;
     teams: Array<IPublicTeam>;
     players: Array<IPublicPlayer>;
+    me: IPublicPlayer;
     rounds: IPlayedCard[][];
+    prevRounds: IPlayedCard[][] | null;
     state: EMatchTableState;
 }
 export interface IMatchTable {
     matchSessionId: string;
     currentPlayer: IPublicPlayer | null;
     lobby: ILobby;
-    state: EMatchTableState;
-    setState(state: EMatchTableState): void;
+    state(): EMatchTableState;
     setCurrentPlayer(player: IPublicPlayer): void;
     isSessionPlaying(session: string): IPublicPlayer | null;
     getPublicMatch(session?: string): IPublicMatch;
 }
 export declare enum EMatchTableState {
     UNREADY = 0,
-    STARTED = 1,
-    FINISHED = 2
+    READY = 1,
+    STARTED = 2,
+    FINISHED = 3
 }
 export declare function MatchTable(matchSessionId: string, teamSize?: 1 | 2 | 3): IMatchTable;

package/dist/server/classes/MatchTable.js

@@ -16,41 +16,66 @@ var lib_1 = require("../../lib");
 var EMatchTableState;
 (function (EMatchTableState) {
     EMatchTableState[EMatchTableState["UNREADY"] = 0] = "UNREADY";
-    EMatchTableState[EMatchTableState["STARTED"] = 1] = "STARTED";
-    EMatchTableState[EMatchTableState["FINISHED"] = 2] = "FINISHED";
+    EMatchTableState[EMatchTableState["READY"] = 1] = "READY";
+    EMatchTableState[EMatchTableState["STARTED"] = 2] = "STARTED";
+    EMatchTableState[EMatchTableState["FINISHED"] = 3] = "FINISHED";
 })(EMatchTableState = exports.EMatchTableState || (exports.EMatchTableState = {}));
 function MatchTable(matchSessionId, teamSize) {
     var matchTable = {
         matchSessionId: matchSessionId,
         currentPlayer: null,
         lobby: (0, lib_1.Lobby)(teamSize),
-        state: EMatchTableState.UNREADY,
-        setState: function (state) {
-            matchTable.state = state;
+        state: function () {
+            var _a;
+            matchTable.lobby.calculateReady();
+            if ((_a = matchTable.lobby.gameLoop) === null || _a === void 0 ? void 0 : _a.winner) {
+                return EMatchTableState.FINISHED;
+            }
+            if (matchTable.lobby.started) {
+                return EMatchTableState.STARTED;
+            }
+            if (matchTable.lobby.ready) {
+                return EMatchTableState.READY;
+            }
+            return EMatchTableState.UNREADY;
         },
         setCurrentPlayer: function (player) {
             matchTable.currentPlayer = player;
         },
         isSessionPlaying: function (session) {
             var lobby = matchTable.lobby;
-            var search = lobby.players.find(function (player) { return player.session === session; });
+            var search = lobby.players.find(function (player) { return player && player.session === session; });
             return search || null;
         },
         getPublicMatch: function (userSession) {
-            var _a, _b, _c;
+            var _a, _b, _c, _d, _e, _f;
             var lobby = matchTable.lobby;
-            var lastHand = (((_a = lobby.gameLoop) === null || _a === void 0 ? void 0 : _a.hands.length) || 1) - 1;
-            var rounds = (_c = (_b = lobby.gameLoop) === null || _b === void 0 ? void 0 : _b.hands[lastHand]) === null || _c === void 0 ? void 0 : _c.rounds.map(function (round) { return round.cards; });
+            var winner = ((_a = lobby.gameLoop) === null || _a === void 0 ? void 0 : _a.winner) || null;
+            var lastHandIdx = (((_b = lobby.gameLoop) === null || _b === void 0 ? void 0 : _b.hands.length) || 1) - 1;
+            var rounds = (_d = (_c = lobby.gameLoop) === null || _c === void 0 ? void 0 : _c.hands[lastHandIdx]) === null || _d === void 0 ? void 0 : _d.rounds.map(function (round) { return round.cards; });
+            var prevHandIdx = lastHandIdx - 1;
+            var prevRounds = prevHandIdx !== -1
+                ? (_f = (_e = lobby.gameLoop) === null || _e === void 0 ? void 0 : _e.hands[prevHandIdx]) === null || _f === void 0 ? void 0 : _f.rounds.map(function (round) { return round.cards; })
+                : null;
+            var players = lobby.players.filter(function (player) { return Boolean(player); });
+            var currentPlayerIdx = players.findIndex(function (player) { return player && player.session === userSession; });
+            var me = players[currentPlayerIdx];
+            var cut = players.slice(currentPlayerIdx, players.length);
+            var end = players.slice(0, currentPlayerIdx);
+            var publicPlayers = cut.concat(end).map(function (player) {
+                return (player === null || player === void 0 ? void 0 : player.session) === userSession
+                    ? player
+                    : __assign(__assign({}, player), { session: undefined, hand: player === null || player === void 0 ? void 0 : player.hand.map(function () { return "xx"; }) });
+            });
             return {
-                matchSessionId: matchSessionId,
-                state: matchTable.state,
+                me: me,
+                winner: winner,
+                matchSessionId: matchTable.matchSessionId,
+                state: matchTable.state(),
                 teams: [],
-                players: lobby.players.map(function (player) {
-                    return player.session === userSession
-                        ? player
-                        : __assign(__assign({}, player), { hand: player.hand.map(function () { return "xx"; }) });
-                }),
+                players: publicPlayers,
                 rounds: rounds || [[]],
+                prevRounds: prevRounds || null,
             };
         },
     };

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

@@ -1,5 +1,5 @@
 export interface IUser {
     id: string;
-    socketId: string;
+    matchSocketIds: Map<string, Set<string>>;
 }
-export declare function User(id: string, socketId: string): IUser;
+export declare function User(id: string): IUser;

package/dist/server/classes/User.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.User = void 0;
-function User(id, socketId) {
+function User(id) {
     var user = {
         id: id,
-        socketId: socketId,
+        matchSocketIds: new Map()
     };
     return user;
 }

package/dist/server/index.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 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) {
@@ -42,11 +53,12 @@ var socket_io_1 = require("socket.io");
 var MatchTable_1 = require("./classes/MatchTable");
 var User_1 = require("./classes/User");
 var types_1 = require("./types");
-var PORT = 4001;
+var PORT = process.env.NODE_PORT || 4001;
+var ORIGIN = process.env.NODE_ORIGIN || "http://localhost:3000";
 var httpServer = (0, http_1.createServer)();
 var io = new socket_io_1.Server(httpServer, {
     cors: {
-        origin: "http://localhost:3000",
+        origin: ORIGIN,
         methods: ["GET", "POST"],
     },
 });
@@ -69,9 +81,10 @@ var getTable = function (matchSessionId) {
 };
 io.on("connection", function (_socket) {
     var socket = _socket;
+    console.log("New socket", socket.id);
     var getTableSockets = function (table, callback) {
         return new Promise(function (resolve) { return __awaiter(void 0, void 0, void 0, function () {
-            var sockets, _i, sockets_1, socket_1;
+            var sockets, _i, sockets_1, playerSocket;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, io.sockets.adapter.fetchSockets({
@@ -83,8 +96,8 @@ io.on("connection", function (_socket) {
                         _a.label = 2;
                     case 2:
                         if (!(_i < sockets_1.length)) return [3 /*break*/, 5];
-                        socket_1 = sockets_1[_i];
-                        return [4 /*yield*/, callback(socket_1)];
+                        playerSocket = sockets_1[_i];
+                        return [4 /*yield*/, callback(playerSocket)];
                     case 3:
                         _a.sent();
                         _a.label = 4;
@@ -98,14 +111,32 @@ io.on("connection", function (_socket) {
             });
         }); });
     };
-    var emitMatchUpdate = function (table) {
-        table.lobby.players.map(function (player) {
-            var user = users.get(player.session);
-            if (user && user.socketId) {
-                io.to(user.socketId).emit(types_1.EServerEvent.UPDATE_MATCH, table.getPublicMatch(player.session));
+    var emitMatchUpdate = function (table) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, getTableSockets(table, function (playerSocket) { return __awaiter(void 0, void 0, void 0, function () {
+                        var tmp, save;
+                        return __generator(this, function (_a) {
+                            tmp = table.getPublicMatch(playerSocket.session);
+                            save = function () { return playerSocket.emit(types_1.EServerEvent.UPDATE_MATCH, tmp); };
+                            // if (tmp.prevRounds && tmp.rounds[0].length === 0) {
+                            //   playerSocket.emit(EServerEvent.UPDATE_MATCH, {
+                            //     ...tmp,
+                            //     rounds: tmp.prevRounds,
+                            //   })
+                            //   setTimeout(save, 4500)
+                            //   return
+                            // }
+                            save();
+                            return [2 /*return*/];
+                        });
+                    }); })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
             }
         });
-    };
+    }); };
     socket.on(types_1.EClientEvent.PING, function (msg) {
         socket.emit(types_1.EServerEvent.PONG, msg);
     });
@@ -124,7 +155,9 @@ io.on("connection", function (_socket) {
                     });
                 }
                 var table = (0, MatchTable_1.MatchTable)(socket.session);
-                table.lobby.addPlayer(user.id, socket.session);
+                table.lobby.addPlayer(user.id, socket.session, 0);
+                socket.join(socket.session);
+                addSocketToUser(socket.session, socket.id, table);
                 tables.set(socket.session, table);
                 return callback({ success: true, match: table.getPublicMatch(user.id) });
             }
@@ -135,59 +168,52 @@ io.on("connection", function (_socket) {
         }
         callback({ success: false, error: new Error("Can't create match without an ID") });
     });
-    var sendWaitingForPlay = function (table, session, play) { return __awaiter(void 0, void 0, void 0, function () {
+    var sendWaitingForPlay = function (table, play) { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
-                case 0: return [4 /*yield*/, getTableSockets(table, function (playerSocket) { return __awaiter(void 0, void 0, void 0, function () {
-                        return __generator(this, function (_a) {
-                            playerSocket.emit(types_1.EServerEvent.UPDATE_MATCH, table.getPublicMatch(playerSocket.session));
-                            return [2 /*return*/];
-                        });
-                    }); })];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, getTableSockets(table, function (playerSocket) {
-                            return new Promise(function (resolve) {
-                                if (playerSocket.session === session) {
-                                    playerSocket.emit(types_1.EServerEvent.WAITING_PLAY, table.getPublicMatch(session));
-                                    playerSocket.once(types_1.EClientEvent.PLAY, function (_a) {
-                                        var cardIdx = _a.cardIdx, command = _a.command;
-                                        if (cardIdx !== undefined) {
-                                            var playedCard = play.use(cardIdx);
-                                            if (playedCard) {
-                                                return resolve();
-                                            }
-                                            return console.error("ERROR", new Error("Couldnt play card"));
+                case 0: return [4 /*yield*/, getTableSockets(table, function (playerSocket) {
+                        return new Promise(function (resolve) {
+                            var _a;
+                            if (playerSocket.session && playerSocket.session === ((_a = play.player) === null || _a === void 0 ? void 0 : _a.session)) {
+                                playerSocket.emit(types_1.EServerEvent.WAITING_PLAY, table.getPublicMatch(playerSocket.session), function (data) {
+                                    if (!data) {
+                                        return;
+                                    }
+                                    var cardIdx = data.cardIdx, command = data.command;
+                                    if (cardIdx !== undefined) {
+                                        var playedCard = play.use(cardIdx);
+                                        if (playedCard) {
+                                            return resolve();
                                         }
-                                        if (command) {
-                                            var saidCommand = play.say(command);
-                                            if (saidCommand) {
-                                                return resolve();
-                                            }
-                                            return console.error("ERROR", new Error("Couldnt say command"));
+                                        return console.error("ERROR", new Error("Couldnt play card"));
+                                    }
+                                    if (command) {
+                                        var saidCommand = play.say(command);
+                                        if (saidCommand) {
+                                            return resolve();
                                         }
-                                        return console.error("ERROR", new Error("Play callback didn't have data"));
-                                    });
-                                }
-                                else {
-                                    resolve();
-                                }
-                            });
-                        })];
-                case 2:
+                                        return console.error("ERROR", new Error("Couldnt say command"));
+                                    }
+                                    return console.error("ERROR", new Error("Play callback didn't have data"));
+                                });
+                            }
+                            else {
+                                resolve();
+                            }
+                        });
+                    })];
+                case 1:
                     _a.sent();
                     return [2 /*return*/];
             }
         });
     }); };
-    var startMatch = function () { return __awaiter(void 0, void 0, void 0, function () {
-        var tableId_1, table_1;
+    var startMatch = function (tableId) { return __awaiter(void 0, void 0, void 0, function () {
+        var table_1;
         return __generator(this, function (_a) {
             try {
-                tableId_1 = socket.session;
-                table_1 = getTable(tableId_1);
+                table_1 = getTable(tableId);
                 if (table_1 && !table_1.lobby.gameLoop) {
-                    table_1.setState(MatchTable_1.EMatchTableState.STARTED);
                     table_1.lobby
                         .startMatch()
                         .onTurn(function (play) {
@@ -198,28 +224,30 @@ io.on("connection", function (_socket) {
                                 switch (_b.label) {
                                     case 0:
                                         table_1.setCurrentPlayer(play.player);
-                                        turns.set(tableId_1, { play: play, resolve: resolve });
+                                        turns.set(table_1.matchSessionId, { play: play, resolve: resolve });
                                         _b.label = 1;
                                     case 1:
-                                        _b.trys.push([1, 3, , 4]);
+                                        _b.trys.push([1, 4, , 5]);
                                         session = (_a = play.player) === null || _a === void 0 ? void 0 : _a.session;
-                                        if (!session) {
+                                        if (!session || !play) {
                                             throw new Error("Unexpected Error");
                                         }
                                         user = users.get(session);
                                         if (!user) {
                                             throw new Error("Unexpected Error");
                                         }
-                                        return [4 /*yield*/, sendWaitingForPlay(table_1, session, play)];
+                                        return [4 /*yield*/, emitMatchUpdate(table_1)];
                                     case 2:
                                         _b.sent();
-                                        resolve();
-                                        return [3 /*break*/, 4];
+                                        return [4 /*yield*/, sendWaitingForPlay(table_1, play)];
                                     case 3:
+                                        _b.sent();
+                                        return [2 /*return*/, resolve()];
+                                    case 4:
                                         e_1 = _b.sent();
                                         console.error("ERROR", e_1);
-                                        return [3 /*break*/, 4];
-                                    case 4: return [2 /*return*/];
+                                        return [3 /*break*/, 5];
+                                    case 5: return [2 /*return*/];
                                 }
                             });
                         }); });
@@ -246,20 +274,36 @@ io.on("connection", function (_socket) {
      */
     socket.on(types_1.EClientEvent.START_MATCH, function () {
         if (socket.session && users.has(socket.session)) {
-            startMatch();
+            startMatch(socket.session);
         }
     });
+    var addSocketToUser = function (session, socketId, table) {
+        var user = getUser(session);
+        console.log("User got new match socket", { socketId: socketId, session: session, matchId: table.matchSessionId });
+        var currentMatchSockets = user.matchSocketIds.has(table.matchSessionId)
+            ? user.matchSocketIds.get(table.matchSessionId)
+            : new Set();
+        users.set(session, __assign(__assign({}, user), { matchSocketIds: user.matchSocketIds.set(table.matchSessionId, currentMatchSockets.add(socketId)) }));
+    };
     /**
      * Join Match
      */
-    socket.on(types_1.EClientEvent.JOIN_MATCH, function (matchSessionId, callback) {
+    socket.on(types_1.EClientEvent.JOIN_MATCH, function (matchSessionId, teamIdx, callback) {
         if (!socket.session) {
             return callback({ success: false });
         }
         var user = getUser(socket.session);
         var table = tables.get(matchSessionId);
-        if (table && table.state === MatchTable_1.EMatchTableState.UNREADY) {
-            table.lobby.addPlayer(user.id || "satoshi", socket.session);
+        if (table) {
+            try {
+                table.lobby.addPlayer(user.id || "satoshi", socket.session, teamIdx);
+            }
+            catch (e) {
+                console.error(e);
+                return callback({ success: false });
+            }
+            socket.join(matchSessionId);
+            addSocketToUser(socket.session, socket.id, table);
             emitMatchUpdate(table);
             return callback({ success: true, match: table.getPublicMatch(socket.session) });
         }
@@ -278,58 +322,41 @@ io.on("connection", function (_socket) {
     /**
      * Set Session
      */
-    socket.on(types_1.EClientEvent.SET_SESSION, function (session, id, callback) {
+    socket.on(types_1.EClientEvent.SET_SESSION, function (session, id, currentMatchId, callback) {
+        var _a;
         if (id === void 0) { id = "satoshi"; }
+        if (currentMatchId === void 0) { currentMatchId = null; }
+        if (callback === void 0) { callback = function () { }; }
         var user = users.get(session);
         if (user) {
-            var updatedUser = {
-                id: id,
-                socketId: socket.id,
-            };
+            var updatedUser = __assign(__assign({}, user), { id: id });
             users.set(session, updatedUser);
             socket.session = session;
-            tables.forEach(function (table, id) { return __awaiter(void 0, void 0, void 0, function () {
-                var _a, play, resolve, session_1, user_1, e_2;
-                var _b, _c;
-                return __generator(this, function (_d) {
-                    switch (_d.label) {
-                        case 0:
-                            if (!table.isSessionPlaying(session)) return [3 /*break*/, 5];
-                            socket.join(id);
-                            if (!(session === ((_b = table.currentPlayer) === null || _b === void 0 ? void 0 : _b.session))) return [3 /*break*/, 4];
-                            _d.label = 1;
-                        case 1:
-                            _d.trys.push([1, 3, , 4]);
-                            _a = turns.get(id) || {}, play = _a.play, resolve = _a.resolve;
-                            session_1 = (_c = play === null || play === void 0 ? void 0 : play.player) === null || _c === void 0 ? void 0 : _c.session;
-                            if (!play || !session_1) {
-                                throw new Error("Unexpected Error");
-                            }
-                            user_1 = users.get(session_1);
-                            if (!user_1) {
-                                throw new Error("Unexpected Error");
-                            }
-                            return [4 /*yield*/, sendWaitingForPlay(table, session_1, play)];
-                        case 2:
-                            _d.sent();
-                            resolve === null || resolve === void 0 ? void 0 : resolve();
-                            return [3 /*break*/, 4];
-                        case 3:
-                            e_2 = _d.sent();
-                            console.error("ERROR", e_2);
-                            return [3 /*break*/, 4];
-                        case 4:
-                            socket.emit(types_1.EServerEvent.UPDATE_MATCH, table.getPublicMatch(session));
-                            _d.label = 5;
-                        case 5: return [2 /*return*/];
+            var currentTable = currentMatchId ? tables.get(currentMatchId) : null;
+            if (currentTable && currentTable.isSessionPlaying(session)) {
+                addSocketToUser(session, socket.id, currentTable);
+                socket.join(currentTable.matchSessionId);
+                if (session === ((_a = currentTable.currentPlayer) === null || _a === void 0 ? void 0 : _a.session)) {
+                    try {
+                        var _b = turns.get(currentTable.matchSessionId) || {}, play = _b.play, resolve = _b.resolve;
+                        if (!play) {
+                            throw new Error("Unexpected Error");
+                        }
+                        sendWaitingForPlay(currentTable, play).then(resolve);
                     }
-                });
-            }); });
+                    catch (e) {
+                        console.error("ERROR", e);
+                    }
+                }
+                else {
+                    socket.emit(types_1.EServerEvent.UPDATE_MATCH, currentTable.getPublicMatch(session));
+                }
+            }
             return callback({ success: true, session: session });
         }
         var newSession = (0, crypto_1.randomUUID)();
         socket.session = newSession;
-        users.set(newSession, (0, User_1.User)(id, socket.id));
+        users.set(newSession, (0, User_1.User)(id));
         callback({ success: true, session: newSession });
     });
     /**
@@ -338,12 +365,9 @@ io.on("connection", function (_socket) {
     socket.on(types_1.EClientEvent.SET_PLAYER_READY, function (matchSessionId, ready) {
         try {
             var table = getTable(matchSessionId);
-            var player = table.lobby.players.find(function (player) { return player.session === socket.session; });
+            var player = table.lobby.players.find(function (player) { return player && player.session === socket.session; });
             if (player) {
                 player.setReady(ready);
-                if (ready) {
-                    socket.join(matchSessionId);
-                }
                 emitMatchUpdate(table);
             }
         }

package/package.json

@@ -1,28 +1,29 @@
-{
-  "name": "trucoshi",
-  "version": "0.0.16",
-  "main": "build/lib/trucoshi.js",
-  "license": "GPL-3.0",
-  "scripts": {
-    "prepublishOnly": "yarn build",
-    "dev": "nodemon",
-    "test:autoplay": "yarn run ts-node src/test/autoplay",
-    "test:play": "yarn run ts-node src/test/play",
-    "test:legacy": "yarn run ts-node src/test/legacy",
-    "build": "yarn run rimraf ./dist && yarn run tsc --project ."
-  },
-  "devDependencies": {
-    "@types/node": "^18.11.18",
-    "nodemon": "^2.0.20"
-  },
-  "files": [
-    "dist"
-  ],
-  "dependencies": {
-    "rimraf": "^4.1.1",
-    "socket.io": "^4.5.4",
-    "ts-node": "^10.9.1",
-    "tsc": "^2.0.4",
-    "typescript": "^4.9.4"
-  }
-}
+{
+  "name": "trucoshi",
+  "version": "0.0.18",
+  "main": "build/lib/trucoshi.js",
+  "license": "GPL-3.0",
+  "scripts": {
+    "start": "node ./dist/server/index.js",
+    "prepublishOnly": "yarn build",
+    "dev": "nodemon",
+    "test:autoplay": "yarn run ts-node src/test/autoplay",
+    "test:play": "yarn run ts-node src/test/play",
+    "test:legacy": "yarn run ts-node src/test/legacy",
+    "build": "yarn run rimraf ./dist && yarn run tsc --project ."
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.18",
+    "nodemon": "^2.0.20"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "rimraf": "^4.1.1",
+    "socket.io": "^4.5.4",
+    "ts-node": "^10.9.1",
+    "tsc": "^2.0.4",
+    "typescript": "^4.9.4"
+  }
+}