trucoshi 0.0.13 → 0.0.15

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

@@ -1,2 +1,3 @@
 import { IPlayer } from "../types";
+export type IPublicPlayer = Pick<IPlayer, "id" | "disabled" | "ready" | "hand" | "usedHand" | "teamIdx" | "session">;
 export declare function Player(id: string, teamIdx: number): IPlayer;

package/dist/lib/classes/Player.js

@@ -4,12 +4,16 @@ exports.Player = void 0;
 function Player(id, teamIdx) {
     var player = {
         id: id,
+        session: undefined,
         teamIdx: teamIdx,
         hand: [],
         commands: [],
         usedHand: [],
         disabled: false,
         ready: false,
+        setSession: function (session) {
+            player.session = session;
+        },
         enable: function () {
             player.disabled = false;
         },

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

@@ -1,2 +1,3 @@
 import { IPlayer, ITeam } from "../types";
+export type IPublicTeam = Pick<ITeam, "players" | "points">;
 export declare function Team(players: Array<IPlayer>): ITeam;

package/dist/lib/index.d.ts

@@ -1,4 +1,4 @@
-import { IPlayInstance, ITeam, ITrucoshi } from "./types";
+import { IHand, IPlayInstance, ITeam, ILobby } from "./types";
 export type IWinnerCallback = (winner: ITeam, teams: [ITeam, ITeam]) => Promise<void>;
 export type ITurnCallback = (play: IPlayInstance) => Promise<void>;
 export type ITrucoCallback = (play: IPlayInstance) => Promise<void>;
@@ -6,13 +6,11 @@ export interface IGameLoop {
     _onTruco: ITrucoCallback;
     _onTurn: ITurnCallback;
     _onWinner: IWinnerCallback;
+    teams: Array<ITeam>;
+    hands: Array<IHand>;
     onTurn: (callback: ITurnCallback) => IGameLoop;
     onWinner: (callback: IWinnerCallback) => IGameLoop;
     onTruco: (callback: ITrucoCallback) => IGameLoop;
-    begin: () => void;
+    begin: () => Promise<void>;
 }
-export declare function Trucoshi(teamSize?: 1 | 2 | 3): {
-    addPlayer: (id: string, teamIdx?: 0 | 1 | undefined) => import("./types").IPlayer;
-    removePlayer: (id: string) => ITrucoshi;
-    startMatch: (matchPoint?: 9 | 12 | 15 | undefined) => IGameLoop;
-};
+export declare function Lobby(teamSize?: 1 | 2 | 3): ILobby;

package/dist/lib/index.js

@@ -36,7 +36,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Trucoshi = void 0;
+exports.Lobby = void 0;
 var Match_1 = require("./classes/Match");
 var Player_1 = require("./classes/Player");
 var Table_1 = require("./classes/Table");
@@ -48,6 +48,8 @@ var GameLoop = function (match) {
         _onTruco: function () { return Promise.resolve(); },
         _onTurn: function () { return Promise.resolve(); },
         _onWinner: function () { return Promise.resolve(); },
+        teams: [],
+        hands: [],
         onTruco: function (callback) {
             gameloop._onTruco = callback;
             return gameloop;
@@ -66,25 +68,29 @@ var GameLoop = function (match) {
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
-                            if (!!match.winner) return [3 /*break*/, 5];
+                            gameloop.teams = match.teams;
+                            _a.label = 1;
+                        case 1:
+                            if (!!match.winner) return [3 /*break*/, 6];
                             play = match.play();
+                            gameloop.hands = match.hands;
                             if (!play || !play.player) {
-                                return [3 /*break*/, 0];
+                                return [3 /*break*/, 1];
                             }
-                            if (!(play.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER)) return [3 /*break*/, 2];
+                            if (!(play.state === types_1.EHandState.WAITING_FOR_TRUCO_ANSWER)) return [3 /*break*/, 3];
                             return [4 /*yield*/, gameloop._onTruco(play)];
-                        case 1:
-                            _a.sent();
-                            return [3 /*break*/, 0];
                         case 2:
-                            if (!(play.state === types_1.EHandState.WAITING_PLAY)) return [3 /*break*/, 4];
-                            return [4 /*yield*/, gameloop._onTurn(play)];
+                            _a.sent();
+                            return [3 /*break*/, 1];
                         case 3:
+                            if (!(play.state === types_1.EHandState.WAITING_PLAY)) return [3 /*break*/, 5];
+                            return [4 /*yield*/, gameloop._onTurn(play)];
+                        case 4:
                             _a.sent();
-                            return [3 /*break*/, 0];
-                        case 4: return [3 /*break*/, 0];
-                        case 5: return [4 /*yield*/, gameloop._onWinner(match.winner, match.teams)];
-                        case 6:
+                            return [3 /*break*/, 1];
+                        case 5: return [3 /*break*/, 1];
+                        case 6: return [4 /*yield*/, gameloop._onWinner(match.winner, match.teams)];
+                        case 7:
                             _a.sent();
                             return [2 /*return*/];
                     }
@@ -94,68 +100,69 @@ var GameLoop = function (match) {
     };
     return gameloop;
 };
-function Trucoshi(teamSize) {
-    var trucoshi = {
+function Lobby(teamSize) {
+    var lobby = {
         lastTeamIdx: 1,
         _players: new Map(),
         get players() {
-            return Array.from(trucoshi._players.values());
+            return Array.from(lobby._players.values());
         },
         teams: [],
         table: null,
         maxPlayers: teamSize ? teamSize * 2 : 6,
         full: false,
         ready: false,
+        gameLoop: undefined,
         calculateReady: function () {
-            trucoshi.ready = trucoshi.players.reduce(function (prev, curr) { return prev && curr.ready; }, true);
-            return trucoshi.ready;
+            lobby.ready = lobby.players.reduce(function (prev, curr) { return prev && curr.ready; }, true);
+            return lobby.ready;
         },
         calculateFull: function () {
-            trucoshi.full = trucoshi._players.size >= trucoshi.maxPlayers;
-            return trucoshi.full;
+            lobby.full = lobby._players.size >= lobby.maxPlayers;
+            return lobby.full;
         },
-        addPlayer: function (id, teamIdx) {
+        addPlayer: function (id, session, teamIdx) {
             var maxSize = teamSize ? teamSize : 3;
-            if (trucoshi.full || trucoshi.players.filter(function (p) { return p.teamIdx === teamIdx; }).length > maxSize) {
+            if (lobby.full || lobby.players.filter(function (p) { return p.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(!trucoshi.lastTeamIdx));
-            trucoshi.lastTeamIdx = Number(!trucoshi.lastTeamIdx);
-            trucoshi._players.set(id, player);
-            trucoshi.calculateFull();
-            trucoshi.calculateReady();
+            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);
+            lobby.calculateFull();
+            lobby.calculateReady();
             return player;
         },
         removePlayer: function (id) {
-            trucoshi._players.delete(id);
-            trucoshi.calculateFull();
-            trucoshi.calculateReady();
-            return trucoshi;
+            lobby._players.delete(id);
+            lobby.calculateFull();
+            lobby.calculateReady();
+            return lobby;
         },
         startMatch: function (matchPoint) {
             if (matchPoint === void 0) { matchPoint = 9; }
-            trucoshi.calculateReady();
-            var teamSize = trucoshi._players.size / 2;
+            lobby.calculateReady();
+            var teamSize = lobby._players.size / 2;
             if (!constants_1.TEAM_SIZE_VALUES.includes(teamSize)) {
                 throw new Error(constants_1.GAME_ERROR.UNEXPECTED_TEAM_SIZE);
             }
-            if (!trucoshi.ready) {
+            if (!lobby.ready) {
                 throw new Error(constants_1.GAME_ERROR.TEAM_NOT_READY);
             }
-            trucoshi.teams.push((0, Team_1.Team)(trucoshi.players.filter(function (p) { return p.teamIdx === 0; })));
-            trucoshi.teams.push((0, Team_1.Team)(trucoshi.players.filter(function (p) { return p.teamIdx === 1; })));
-            if (trucoshi.teams[0].players.length !== teamSize ||
-                trucoshi.teams[1].players.length !== teamSize) {
+            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; })),
+            ];
+            if (lobby.teams[0].players.length !== teamSize ||
+                lobby.teams[1].players.length !== teamSize) {
                 throw new Error(constants_1.GAME_ERROR.UNEXPECTED_TEAM_SIZE);
             }
-            trucoshi.table = (0, Table_1.Table)(trucoshi.players, trucoshi.teams);
-            return GameLoop((0, Match_1.Match)(trucoshi.table, trucoshi.teams, matchPoint));
+            lobby.table = (0, Table_1.Table)(lobby.players, lobby.teams);
+            lobby.gameLoop = GameLoop((0, Match_1.Match)(lobby.table, lobby.teams, matchPoint));
+            return lobby.gameLoop;
         },
     };
-    return {
-        addPlayer: trucoshi.addPlayer,
-        removePlayer: trucoshi.removePlayer,
-        startMatch: trucoshi.startMatch,
-    };
+    return lobby;
 }
-exports.Trucoshi = Trucoshi;
+exports.Lobby = Lobby;

package/dist/lib/types.d.ts

@@ -1,4 +1,5 @@
 import { IGameLoop } from ".";
+import { IPublicPlayer } from "./classes/Player";
 import { CARDS } from "./constants";
 export type ICard = keyof typeof CARDS;
 export interface IDeck {
@@ -8,17 +9,19 @@ export interface IDeck {
     shuffle(): IDeck;
 }
 export interface IPlayedCard {
-    player: IPlayer;
+    player: IPlayer & IPublicPlayer;
     card: ICard;
 }
 export interface IPlayer {
     teamIdx: number;
     id: string;
+    session?: string;
     hand: Array<ICard>;
     commands: Array<ECommand>;
     usedHand: Array<ICard>;
     disabled: boolean;
     ready: boolean;
+    setSession(session: string): void;
     enable(): void;
     disable(): void;
     setReady(ready: boolean): void;
@@ -144,7 +147,8 @@ export interface IHand {
     setState(state: EHandState): EHandState;
     getNextPlayer(): IteratorResult<IHand, IHand | void>;
 }
-export interface IPrivateTrucoshi {
+export interface IPrivateLobby {
+    gameLoop?: IGameLoop;
     lastTeamIdx: 0 | 1;
     _players: Map<string, IPlayer>;
     get players(): Array<IPlayer>;
@@ -153,13 +157,13 @@ export interface IPrivateTrucoshi {
     table: ITable | null;
     ready: boolean;
     full: boolean;
-    addPlayer(id: string, teamIdx?: 0 | 1): IPlayer;
-    removePlayer(id: string): ITrucoshi;
+    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 ITrucoshi extends Pick<IPrivateTrucoshi, 'addPlayer' | 'removePlayer' | 'startMatch'> {
+export interface ILobby extends Pick<IPrivateLobby, "addPlayer" | "removePlayer" | "startMatch" | "ready" | "full" | "teams" | "players" | "gameLoop" | "table"> {
 }
 export interface ITable {
     forehandIdx: number;

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

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

package/dist/server/classes/MatchTable.js

@@ -0,0 +1,59 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchTable = exports.EMatchTableState = void 0;
+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 = 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;
+        },
+        setCurrentPlayer: function (player) {
+            matchTable.currentPlayer = player;
+        },
+        isSessionPlaying: function (session) {
+            var lobby = matchTable.lobby;
+            var search = lobby.players.find(function (player) { return player.session === session; });
+            return search || null;
+        },
+        getPublicMatch: function (userSession) {
+            var _a, _b, _c;
+            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; });
+            return {
+                matchSessionId: 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"; }) });
+                }),
+                rounds: rounds || [[]],
+            };
+        },
+    };
+    return matchTable;
+}
+exports.MatchTable = MatchTable;

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

@@ -1,5 +1,5 @@
 export interface IUser {
     id: string;
-    session: string;
+    socketId: string;
 }
-export declare function User(id: string, session: string): IUser;
+export declare function User(id: string, socketId: 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, session) {
+function User(id, socketId) {
     var user = {
         id: id,
-        session: session,
+        socketId: socketId,
     };
     return user;
 }

package/dist/server/index.js

@@ -1,9 +1,45 @@
 "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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 var crypto_1 = require("crypto");
 var http_1 = require("http");
 var socket_io_1 = require("socket.io");
-var lib_1 = require("../lib");
+var MatchTable_1 = require("./classes/MatchTable");
 var user_1 = require("./classes/user");
 var types_1 = require("./types");
 var PORT = 4001;
@@ -14,48 +50,306 @@ var io = new socket_io_1.Server(httpServer, {
         methods: ["GET", "POST"],
     },
 });
-var sessions = new Map();
-var tables = new Map();
-var matches = new Map();
+var users = new Map(); // sessionId, user
+var tables = new Map(); // sessionId, table
+var turns = new Map(); // sessionId, play instance
+var getUser = function (session) {
+    var user = users.get(session);
+    if (user) {
+        return user;
+    }
+    throw new Error("User not found");
+};
+var getTable = function (matchSessionId) {
+    var table = tables.get(matchSessionId);
+    if (table) {
+        return table;
+    }
+    throw new Error("Match Session not found");
+};
 io.on("connection", function (_socket) {
     var socket = _socket;
+    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;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, io.sockets.adapter.fetchSockets({
+                            rooms: new Set([table.matchSessionId]),
+                        })];
+                    case 1:
+                        sockets = _a.sent();
+                        _i = 0, sockets_1 = sockets;
+                        _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)];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        resolve();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    };
+    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));
+            }
+        });
+    };
     socket.on(types_1.EClientEvent.PING, function (msg) {
         socket.emit(types_1.EServerEvent.PONG, msg);
     });
+    /**
+     * Create Match
+     */
     socket.on(types_1.EClientEvent.CREATE_MATCH, function (callback) {
-        var _a;
-        if ((_a = socket.user) === null || _a === void 0 ? void 0 : _a.session) {
-            var trucoshi = (0, lib_1.Trucoshi)();
-            tables.set(socket.user.session, trucoshi);
-            return callback({ success: true });
+        if (socket.session) {
+            try {
+                var user = getUser(socket.session);
+                var existingTable = tables.get(socket.session);
+                if (existingTable) {
+                    return callback({
+                        success: false,
+                        match: existingTable.getPublicMatch(socket.session),
+                    });
+                }
+                var table = (0, MatchTable_1.MatchTable)(socket.session);
+                table.lobby.addPlayer(user.id, socket.session);
+                tables.set(socket.session, table);
+                return callback({ success: true, match: table.getPublicMatch(user.id) });
+            }
+            catch (e) {
+                console.error("ERROR", e);
+                return callback({ success: false, error: e });
+            }
         }
-        callback({ success: false });
+        callback({ success: false, error: new Error("Can't create match without an ID") });
     });
-    socket.on(types_1.EClientEvent.START_MATCH, function () {
-        var _a, _b;
-        if ((_a = socket.user) === null || _a === void 0 ? void 0 : _a.session) {
-            var table = tables.get((_b = socket.user) === null || _b === void 0 ? void 0 : _b.session);
-            if (table) {
-                matches.set(socket.user.session, table.startMatch());
+    var sendWaitingForPlay = function (table, session, 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"));
+                                        }
+                                        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("Play callback didn't have data"));
+                                    });
+                                }
+                                else {
+                                    resolve();
+                                }
+                            });
+                        })];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    var startMatch = function () { return __awaiter(void 0, void 0, void 0, function () {
+        var tableId_1, table_1;
+        return __generator(this, function (_a) {
+            try {
+                tableId_1 = socket.session;
+                table_1 = getTable(tableId_1);
+                if (table_1 && !table_1.lobby.gameLoop) {
+                    table_1.setState(MatchTable_1.EMatchTableState.STARTED);
+                    table_1.lobby
+                        .startMatch()
+                        .onTurn(function (play) {
+                        return new Promise(function (resolve) { return __awaiter(void 0, void 0, void 0, function () {
+                            var session, user, e_1;
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        table_1.setCurrentPlayer(play.player);
+                                        turns.set(tableId_1, { play: play, resolve: resolve });
+                                        _b.label = 1;
+                                    case 1:
+                                        _b.trys.push([1, 3, , 4]);
+                                        session = (_a = play.player) === null || _a === void 0 ? void 0 : _a.session;
+                                        if (!session) {
+                                            throw new Error("Unexpected Error");
+                                        }
+                                        user = users.get(session);
+                                        if (!user) {
+                                            throw new Error("Unexpected Error");
+                                        }
+                                        return [4 /*yield*/, sendWaitingForPlay(table_1, session, play)];
+                                    case 2:
+                                        _b.sent();
+                                        resolve();
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        e_1 = _b.sent();
+                                        console.error("ERROR", e_1);
+                                        return [3 /*break*/, 4];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                    })
+                        .onTruco(function (play) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/];
+                    }); }); })
+                        .onWinner(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/];
+                    }); }); })
+                        .begin();
+                    return [2 /*return*/, tables.set(socket.session, table_1)];
+                }
+                console.error("ASL:KDJALSk");
+            }
+            catch (e) {
+                console.error("ERROR", e);
             }
+            return [2 /*return*/];
+        });
+    }); };
+    /**
+     * Start Match
+     */
+    socket.on(types_1.EClientEvent.START_MATCH, function () {
+        if (socket.session && users.has(socket.session)) {
+            startMatch();
         }
     });
-    socket.on(types_1.EClientEvent.SET_SESSION, function (session, id, callback) {
-        var _a;
-        if ((_a = socket.user) === null || _a === void 0 ? void 0 : _a.session) {
-            socket.user.id = id;
-            return callback({ success: true });
+    /**
+     * Join Match
+     */
+    socket.on(types_1.EClientEvent.JOIN_MATCH, function (matchSessionId, callback) {
+        if (!socket.session) {
+            return callback({ success: false });
         }
-        var storedSession = sessions.get(session);
-        if (storedSession) {
-            storedSession.id = id;
-            socket.user = storedSession;
-            return callback({ success: true });
+        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);
+            emitMatchUpdate(table);
+            return callback({ success: true, match: table.getPublicMatch(socket.session) });
+        }
+        callback({ success: false });
+    });
+    /**
+     * Get Match
+     */
+    socket.on(types_1.EClientEvent.GET_MATCH, function (matchSessionId, callback) {
+        var table = tables.get(matchSessionId);
+        if (table) {
+            return callback({ success: true, match: table.getPublicMatch(socket.session) });
+        }
+        callback({ success: false });
+    });
+    /**
+     * Set Session
+     */
+    socket.on(types_1.EClientEvent.SET_SESSION, function (session, id, callback) {
+        if (id === void 0) { id = "satoshi"; }
+        var user = users.get(session);
+        if (user) {
+            var updatedUser = {
+                id: id,
+                socketId: socket.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_2, 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_2 = users.get(session_1);
+                            if (!user_2) {
+                                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*/];
+                    }
+                });
+            }); });
+            return callback({ success: true, session: session });
         }
         var newSession = (0, crypto_1.randomUUID)();
-        socket.user = (0, user_1.User)(id, newSession);
-        sessions.set(newSession, socket.user);
-        return callback({ success: true, session: newSession });
+        socket.session = newSession;
+        users.set(newSession, (0, user_1.User)(id, socket.id));
+        callback({ success: true, session: newSession });
+    });
+    /**
+     * Set Player Ready
+     */
+    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; });
+            if (player) {
+                player.setReady(ready);
+                if (ready) {
+                    socket.join(matchSessionId);
+                }
+                emitMatchUpdate(table);
+            }
+        }
+        catch (e) {
+            console.error("ERROR", e);
+        }
     });
 });
 httpServer.listen(PORT);

package/dist/server/types.d.ts

@@ -1,16 +1,33 @@
 import { Socket } from "socket.io";
-import { IUser } from "./classes/user";
+import { ECommand } from "../lib/types";
 export declare enum EClientEvent {
     PING = "PING",
+    PLAY = "PLAY",
     CREATE_MATCH = "CREATE_MATCH",
+    GET_MATCH = "GET_MATCH",
     JOIN_MATCH = "JOIN_MATCH",
     START_MATCH = "START_MATCH",
-    SET_USER_ID = "SET_USER_ID",
+    SET_PLAYER_READY = "SET_PLAYER_READY",
     SET_SESSION = "SET_SESSION"
 }
 export declare enum EServerEvent {
-    PONG = "PONG"
+    PONG = "PONG",
+    UPDATE_MATCH = "UPDATE_MATCH",
+    WAITING_PLAY = "WAITING_PLAY"
 }
 export interface TrucoshiSocket extends Socket {
-    user?: IUser;
+    session?: string;
 }
+export declare enum ETrucoshiMatchState {
+    UNREADY = 0,
+    STARTED = 1,
+    FINISHED = 2
+}
+export type IWaitingPlayData = {
+    cardIdx: number;
+    command?: undefined;
+} | {
+    cardIdx?: undefined;
+    command: ECommand;
+};
+export type IWaitingPlayCallback = (data: IWaitingPlayData) => void | null;

package/dist/server/types.js

@@ -1,16 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EServerEvent = exports.EClientEvent = void 0;
+exports.ETrucoshiMatchState = exports.EServerEvent = exports.EClientEvent = void 0;
 var EClientEvent;
 (function (EClientEvent) {
     EClientEvent["PING"] = "PING";
+    EClientEvent["PLAY"] = "PLAY";
     EClientEvent["CREATE_MATCH"] = "CREATE_MATCH";
+    EClientEvent["GET_MATCH"] = "GET_MATCH";
     EClientEvent["JOIN_MATCH"] = "JOIN_MATCH";
     EClientEvent["START_MATCH"] = "START_MATCH";
-    EClientEvent["SET_USER_ID"] = "SET_USER_ID";
+    EClientEvent["SET_PLAYER_READY"] = "SET_PLAYER_READY";
     EClientEvent["SET_SESSION"] = "SET_SESSION";
 })(EClientEvent = exports.EClientEvent || (exports.EClientEvent = {}));
 var EServerEvent;
 (function (EServerEvent) {
     EServerEvent["PONG"] = "PONG";
+    EServerEvent["UPDATE_MATCH"] = "UPDATE_MATCH";
+    EServerEvent["WAITING_PLAY"] = "WAITING_PLAY";
 })(EServerEvent = exports.EServerEvent || (exports.EServerEvent = {}));
+var ETrucoshiMatchState;
+(function (ETrucoshiMatchState) {
+    ETrucoshiMatchState[ETrucoshiMatchState["UNREADY"] = 0] = "UNREADY";
+    ETrucoshiMatchState[ETrucoshiMatchState["STARTED"] = 1] = "STARTED";
+    ETrucoshiMatchState[ETrucoshiMatchState["FINISHED"] = 2] = "FINISHED";
+})(ETrucoshiMatchState = exports.ETrucoshiMatchState || (exports.ETrucoshiMatchState = {}));

package/dist/test/autoplay.js

@@ -40,13 +40,13 @@ var lib_1 = require("../lib");
 (function () { return __awaiter(void 0, void 0, void 0, function () {
     var trucoshi;
     return __generator(this, function (_a) {
-        trucoshi = (0, lib_1.Trucoshi)();
-        trucoshi.addPlayer("lukini").setReady(true);
-        trucoshi.addPlayer("denoph").setReady(true);
-        trucoshi.addPlayer("guada").setReady(true);
-        trucoshi.addPlayer("juli").setReady(true);
-        trucoshi.addPlayer("day").setReady(true);
-        trucoshi.addPlayer("fran").setReady(true);
+        trucoshi = (0, lib_1.Lobby)();
+        trucoshi.addPlayer("lukini", "lukini").setReady(true);
+        trucoshi.addPlayer("denoph", "denoph").setReady(true);
+        trucoshi.addPlayer("guada", "guada").setReady(true);
+        trucoshi.addPlayer("juli", "juli").setReady(true);
+        trucoshi.addPlayer("day", "day").setReady(true);
+        trucoshi.addPlayer("fran", "fran").setReady(true);
         trucoshi
             .startMatch()
             .onTurn(function (play) { return __awaiter(void 0, void 0, void 0, function () {

package/dist/test/play.js

@@ -158,11 +158,11 @@ var sayCommand = function (play, canPlay) {
 (function () { return __awaiter(void 0, void 0, void 0, function () {
     var trucoshi;
     return __generator(this, function (_a) {
-        trucoshi = (0, lib_1.Trucoshi)();
-        trucoshi.addPlayer("lukini", 0).setReady(true);
-        trucoshi.addPlayer("guada", 0).setReady(true);
-        trucoshi.addPlayer("denoph", 1).setReady(true);
-        trucoshi.addPlayer("juli", 1).setReady(true);
+        trucoshi = (0, lib_1.Lobby)();
+        trucoshi.addPlayer("lukini", "lukini").setReady(true);
+        trucoshi.addPlayer("denoph", "denoph").setReady(true);
+        trucoshi.addPlayer("guada", "guada").setReady(true);
+        trucoshi.addPlayer("juli", "juli").setReady(true);
         trucoshi
             .startMatch()
             .onTruco(function (play) { return __awaiter(void 0, void 0, void 0, function () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trucoshi",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "main": "build/lib/trucoshi.js",
   "license": "GPL-3.0",
   "scripts": {