trucoshi 0.0.12 → 0.0.14

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;
 }
-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,7 +100,7 @@ var GameLoop = function (match) {
     };
     return gameloop;
 };
-function Trucoshi(teamSize) {
+function Lobby(teamSize) {
     var trucoshi = {
         lastTeamIdx: 1,
         _players: new Map(),
@@ -106,6 +112,7 @@ function Trucoshi(teamSize) {
         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;
@@ -114,12 +121,13 @@ function Trucoshi(teamSize) {
             trucoshi.full = trucoshi._players.size >= trucoshi.maxPlayers;
             return trucoshi.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) {
                 throw new Error(constants_1.GAME_ERROR.TEAM_IS_FULL);
             }
             var player = (0, Player_1.Player)(id, teamIdx !== undefined ? teamIdx : Number(!trucoshi.lastTeamIdx));
+            player.setSession(session);
             trucoshi.lastTeamIdx = Number(!trucoshi.lastTeamIdx);
             trucoshi._players.set(id, player);
             trucoshi.calculateFull();
@@ -142,20 +150,29 @@ function Trucoshi(teamSize) {
             if (!trucoshi.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; })));
+            trucoshi.teams = [
+                (0, Team_1.Team)(trucoshi.players.filter(function (p) { return p.teamIdx === 0; })),
+                (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) {
                 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));
+            trucoshi.gameLoop = GameLoop((0, Match_1.Match)(trucoshi.table, trucoshi.teams, matchPoint));
+            return trucoshi.gameLoop;
         },
     };
     return {
         addPlayer: trucoshi.addPlayer,
         removePlayer: trucoshi.removePlayer,
         startMatch: trucoshi.startMatch,
+        teams: trucoshi.teams,
+        get players() {
+            return Array.from(trucoshi._players.values());
+        },
+        full: trucoshi.full,
+        ready: trucoshi.ready,
     };
 }
-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"> {
 }
 export interface ITable {
     forehandIdx: number;

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

@@ -0,0 +1,21 @@
+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>;
+    hands: Array<Array<Array<IPlayedCard>>>;
+}
+export interface IMatchTable {
+    matchSessionId: string;
+    lobby: ILobby;
+    state: EMatchTableState;
+    setState(state: EMatchTableState): void;
+    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,48 @@
+"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,
+        lobby: (0, lib_1.Lobby)(teamSize),
+        state: EMatchTableState.UNREADY,
+        setState: function (state) {
+            matchTable.state = state;
+        },
+        getPublicMatch: function (userSession) {
+            var _a;
+            console.log(matchTable.lobby.gameLoop);
+            return {
+                matchSessionId: matchSessionId,
+                teams: [],
+                players: matchTable.lobby.players.map(function (player) {
+                    return player.session === userSession
+                        ? player
+                        : __assign(__assign({}, player), { hand: player.hand.map(function () { return "xx"; }) });
+                }),
+                hands: ((_a = matchTable.lobby.gameLoop) === null || _a === void 0 ? void 0 : _a.hands.map(function (hand) { return hand.rounds.map(function (round) { return round.cards; }); })) ||
+                    [],
+            };
+        },
+    };
+    return matchTable;
+}
+exports.MatchTable = MatchTable;

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

@@ -0,0 +1,5 @@
+export interface IUser {
+    id: string;
+    socketId: string;
+}
+export declare function User(id: string, socketId: string): IUser;

package/dist/server/classes/user.js

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

package/dist/server/index.js

@@ -1,7 +1,46 @@
 "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 MatchTable_1 = require("./classes/MatchTable");
+var user_1 = require("./classes/user");
 var types_1 = require("./types");
 var PORT = 4001;
 var httpServer = (0, http_1.createServer)();
@@ -11,15 +50,222 @@ var io = new socket_io_1.Server(httpServer, {
         methods: ["GET", "POST"],
     },
 });
-var sessions = new Map();
-io.on("connection", function (socket) {
+var users = new Map(); // sessionId, user
+var tables = new Map(); // sessionId, table
+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;
+    console.error("New connection");
+    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) {
-        io.emit(types_1.EServerEvent.PONG, msg);
+        socket.emit(types_1.EServerEvent.PONG, msg);
+    });
+    /**
+     * Create Match
+     */
+    socket.on(types_1.EClientEvent.CREATE_MATCH, function (callback) {
+        if (socket.session) {
+            var user = getUser(socket.session);
+            var existingTable = tables.get(socket.session);
+            if (existingTable) {
+                return callback({
+                    success: false,
+                    match: existingTable.getPublicMatch(socket.session),
+                });
+            }
+            try {
+                var table = (0, MatchTable_1.MatchTable)(socket.session);
+                table.lobby.addPlayer(user.id, socket.session);
+                tables.set(socket.session, table);
+                console.log("creating match", socket.session, table.state);
+                return callback({ success: true, match: table.getPublicMatch(user.id) });
+            }
+            catch (e) {
+                console.error("ERROR", e);
+                return callback({ success: false, error: e });
+            }
+        }
+        callback({ success: false, error: new Error("Can't create match without an ID") });
+    });
+    /**
+     * Start Match
+     */
+    socket.on(types_1.EClientEvent.START_MATCH, function (callback) {
+        if (socket.session && users.has(socket.session)) {
+            try {
+                var table_1 = getTable(socket.session);
+                if (table_1 && !table_1.lobby.gameLoop) {
+                    table_1.setState(MatchTable_1.EMatchTableState.STARTED);
+                    var game = table_1.lobby
+                        .startMatch()
+                        .onTurn(function (play) { return __awaiter(void 0, void 0, void 0, function () {
+                        var session, user;
+                        var _a;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0: return [4 /*yield*/, getTableSockets(table_1, function (socket) { return __awaiter(void 0, void 0, void 0, function () {
+                                        return __generator(this, function (_a) {
+                                            socket.emit(types_1.EServerEvent.UPDATE_MATCH, table_1.getPublicMatch(socket.session));
+                                            return [2 /*return*/];
+                                        });
+                                    }); })];
+                                case 1:
+                                    _b.sent();
+                                    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*/, getTableSockets(table_1, function (socket) {
+                                            return new Promise(function (resolve) {
+                                                if (socket.session === session) {
+                                                    socket.emit(types_1.EServerEvent.UPDATE_MATCH, table_1.getPublicMatch(session));
+                                                    socket.on(types_1.EClientEvent.PLAY, function () {
+                                                        resolve();
+                                                    });
+                                                }
+                                            });
+                                        })];
+                                case 2:
+                                    _b.sent();
+                                    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();
+                    emitMatchUpdate(table_1);
+                    return callback({ success: true, match: table_1.getPublicMatch(socket.session) });
+                }
+                console.error("ASL:KDJALSk");
+                callback({ success: false, match: table_1.getPublicMatch(socket.session) });
+            }
+            catch (e) {
+                console.error("ERROR", e);
+                callback({ success: false, error: e });
+            }
+        }
+    });
+    /**
+     * Join Match
+     */
+    socket.on(types_1.EClientEvent.JOIN_MATCH, function (matchSessionId, 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);
+            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 });
     });
-    socket.on(types_1.EClientEvent.CREATE_MATCH, function (msg) {
+    /**
+     * 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;
+            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));
+        callback({ success: true, session: newSession });
     });
-    socket.on(types_1.EClientEvent.SET_PLAYER_ID, function (msg) {
-        if (typeof msg === 'string' && msg.length < 32) {
+    /**
+     * 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);
         }
     });
 });

package/dist/server/types.d.ts

@@ -1,11 +1,23 @@
+import { Socket } from "socket.io";
 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_PLAYER_ID = "SET_PLAYER_ID"
+    SET_PLAYER_READY = "SET_PLAYER_READY",
+    SET_SESSION = "SET_SESSION"
 }
 export declare enum EServerEvent {
-    SET_SESSION_ID = "SET_SESSION_ID",
-    PONG = "PONG"
+    PONG = "PONG",
+    UPDATE_MATCH = "UPDATE_MATCH"
+}
+export interface TrucoshiSocket extends Socket {
+    session?: string;
+}
+export declare enum ETrucoshiMatchState {
+    UNREADY = 0,
+    STARTED = 1,
+    FINISHED = 2
 }

package/dist/server/types.js

@@ -1,16 +1,25 @@
 "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_PLAYER_ID"] = "SET_PLAYER_ID";
+    EClientEvent["SET_PLAYER_READY"] = "SET_PLAYER_READY";
+    EClientEvent["SET_SESSION"] = "SET_SESSION";
 })(EClientEvent = exports.EClientEvent || (exports.EClientEvent = {}));
 var EServerEvent;
 (function (EServerEvent) {
-    EServerEvent["SET_SESSION_ID"] = "SET_SESSION_ID";
     EServerEvent["PONG"] = "PONG";
+    EServerEvent["UPDATE_MATCH"] = "UPDATE_MATCH";
 })(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.12",
+  "version": "0.0.14",
   "main": "build/lib/trucoshi.js",
   "license": "GPL-3.0",
   "scripts": {