trucoshi 0.0.14 → 0.0.15

package/dist/lib/index.d.ts

@@ -11,6 +11,6 @@ export interface IGameLoop {
     onTurn: (callback: ITurnCallback) => IGameLoop;
     onWinner: (callback: IWinnerCallback) => IGameLoop;
     onTruco: (callback: ITrucoCallback) => IGameLoop;
-    begin: () => void;
+    begin: () => Promise<void>;
 }
 export declare function Lobby(teamSize?: 1 | 2 | 3): ILobby;

package/dist/lib/index.js

@@ -101,11 +101,11 @@ var GameLoop = function (match) {
     return gameloop;
 };
 function Lobby(teamSize) {
-    var trucoshi = {
+    var lobby = {
         lastTeamIdx: 1,
         _players: new Map(),
         get players() {
-            return Array.from(trucoshi._players.values());
+            return Array.from(lobby._players.values());
         },
         teams: [],
         table: null,
@@ -114,65 +114,55 @@ function Lobby(teamSize) {
         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, 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));
+            var player = (0, Player_1.Player)(id, teamIdx !== undefined ? teamIdx : Number(!lobby.lastTeamIdx));
             player.setSession(session);
-            trucoshi.lastTeamIdx = Number(!trucoshi.lastTeamIdx);
-            trucoshi._players.set(id, player);
-            trucoshi.calculateFull();
-            trucoshi.calculateReady();
+            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 = [
-                (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; })),
+            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 (trucoshi.teams[0].players.length !== teamSize ||
-                trucoshi.teams[1].players.length !== teamSize) {
+            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);
-            trucoshi.gameLoop = GameLoop((0, Match_1.Match)(trucoshi.table, trucoshi.teams, matchPoint));
-            return trucoshi.gameLoop;
+            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,
-        teams: trucoshi.teams,
-        get players() {
-            return Array.from(trucoshi._players.values());
-        },
-        full: trucoshi.full,
-        ready: trucoshi.ready,
-    };
+    return lobby;
 }
 exports.Lobby = Lobby;

package/dist/lib/types.d.ts

@@ -163,7 +163,7 @@ export interface IPrivateLobby {
     calculateFull(): boolean;
     startMatch(matchPoint?: 9 | 12 | 15): IGameLoop;
 }
-export interface ILobby extends Pick<IPrivateLobby, "addPlayer" | "removePlayer" | "startMatch" | "ready" | "full" | "teams" | "players" | "gameLoop"> {
+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

@@ -4,13 +4,17 @@ import { ILobby, IPlayedCard } from "../../lib/types";
 export interface IPublicMatch {
     teams: Array<IPublicTeam>;
     players: Array<IPublicPlayer>;
-    hands: Array<Array<Array<IPlayedCard>>>;
+    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 {

package/dist/server/classes/MatchTable.js

@@ -22,24 +22,35 @@ var 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;
-            console.log(matchTable.lobby.gameLoop);
+            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: matchTable.lobby.players.map(function (player) {
+                players: 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; }); })) ||
-                    [],
+                rounds: rounds || [[]],
             };
         },
     };

package/dist/server/index.js

@@ -52,6 +52,7 @@ var io = new socket_io_1.Server(httpServer, {
 });
 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) {
@@ -68,7 +69,6 @@ var getTable = function (matchSessionId) {
 };
 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;
@@ -114,19 +114,18 @@ io.on("connection", function (_socket) {
      */
     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 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);
-                console.log("creating match", socket.session, table.state);
                 return callback({ success: true, match: table.getPublicMatch(user.id) });
             }
             catch (e) {
@@ -136,54 +135,95 @@ io.on("connection", function (_socket) {
         }
         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)) {
+    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 {
-                var table_1 = getTable(socket.session);
+                tableId_1 = socket.session;
+                table_1 = getTable(tableId_1);
                 if (table_1 && !table_1.lobby.gameLoop) {
                     table_1.setState(MatchTable_1.EMatchTableState.STARTED);
-                    var game = table_1.lobby
+                    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*/];
-                            }
-                        });
-                    }); })
+                        .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*/];
                     }); }); })
@@ -191,16 +231,22 @@ io.on("connection", function (_socket) {
                         return [2 /*return*/];
                     }); }); })
                         .begin();
-                    emitMatchUpdate(table_1);
-                    return callback({ success: true, match: table_1.getPublicMatch(socket.session) });
+                    return [2 /*return*/, tables.set(socket.session, table_1)];
                 }
                 console.error("ASL:KDJALSk");
-                callback({ success: false, match: table_1.getPublicMatch(socket.session) });
             }
             catch (e) {
                 console.error("ERROR", e);
-                callback({ success: false, error: e });
             }
+            return [2 /*return*/];
+        });
+    }); };
+    /**
+     * Start Match
+     */
+    socket.on(types_1.EClientEvent.START_MATCH, function () {
+        if (socket.session && users.has(socket.session)) {
+            startMatch();
         }
     });
     /**
@@ -242,6 +288,43 @@ io.on("connection", function (_socket) {
             };
             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)();

package/dist/server/types.d.ts

@@ -1,4 +1,5 @@
 import { Socket } from "socket.io";
+import { ECommand } from "../lib/types";
 export declare enum EClientEvent {
     PING = "PING",
     PLAY = "PLAY",
@@ -11,7 +12,8 @@ export declare enum EClientEvent {
 }
 export declare enum EServerEvent {
     PONG = "PONG",
-    UPDATE_MATCH = "UPDATE_MATCH"
+    UPDATE_MATCH = "UPDATE_MATCH",
+    WAITING_PLAY = "WAITING_PLAY"
 }
 export interface TrucoshiSocket extends Socket {
     session?: string;
@@ -21,3 +23,11 @@ export declare enum ETrucoshiMatchState {
     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

@@ -16,6 +16,7 @@ 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) {

package/package.json

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