trucoshi 0.0.17 → 0.0.18

package/dist/lib/classes/Team.js

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

package/dist/lib/constants.d.ts

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

package/dist/lib/constants.js

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

package/dist/lib/index.d.ts

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

package/dist/lib/index.js

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

package/dist/lib/types.d.ts

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

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

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

package/dist/server/classes/MatchTable.js

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

package/dist/server/index.js

@@ -53,11 +53,12 @@ var socket_io_1 = require("socket.io");
 var MatchTable_1 = require("./classes/MatchTable");
 var User_1 = require("./classes/User");
 var types_1 = require("./types");
-var PORT = 4001;
+var PORT = process.env.NODE_PORT || 4001;
+var ORIGIN = process.env.NODE_ORIGIN || "http://localhost:3000";
 var httpServer = (0, http_1.createServer)();
 var io = new socket_io_1.Server(httpServer, {
     cors: {
-        origin: "http://localhost:3000",
+        origin: ORIGIN,
         methods: ["GET", "POST"],
     },
 });
@@ -114,8 +115,19 @@ io.on("connection", function (_socket) {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0: return [4 /*yield*/, getTableSockets(table, function (playerSocket) { return __awaiter(void 0, void 0, void 0, function () {
+                        var tmp, save;
                         return __generator(this, function (_a) {
-                            playerSocket.emit(types_1.EServerEvent.UPDATE_MATCH, table.getPublicMatch(playerSocket.session));
+                            tmp = table.getPublicMatch(playerSocket.session);
+                            save = function () { return playerSocket.emit(types_1.EServerEvent.UPDATE_MATCH, tmp); };
+                            // if (tmp.prevRounds && tmp.rounds[0].length === 0) {
+                            //   playerSocket.emit(EServerEvent.UPDATE_MATCH, {
+                            //     ...tmp,
+                            //     rounds: tmp.prevRounds,
+                            //   })
+                            //   setTimeout(save, 4500)
+                            //   return
+                            // }
+                            save();
                             return [2 /*return*/];
                         });
                     }); })];
@@ -143,7 +155,7 @@ io.on("connection", function (_socket) {
                     });
                 }
                 var table = (0, MatchTable_1.MatchTable)(socket.session);
-                table.lobby.addPlayer(user.id, socket.session);
+                table.lobby.addPlayer(user.id, socket.session, 0);
                 socket.join(socket.session);
                 addSocketToUser(socket.session, socket.id, table);
                 tables.set(socket.session, table);
@@ -202,7 +214,6 @@ io.on("connection", function (_socket) {
             try {
                 table_1 = getTable(tableId);
                 if (table_1 && !table_1.lobby.gameLoop) {
-                    table_1.setState(MatchTable_1.EMatchTableState.STARTED);
                     table_1.lobby
                         .startMatch()
                         .onTurn(function (play) {
@@ -277,15 +288,21 @@ io.on("connection", function (_socket) {
     /**
      * Join Match
      */
-    socket.on(types_1.EClientEvent.JOIN_MATCH, function (matchSessionId, callback) {
+    socket.on(types_1.EClientEvent.JOIN_MATCH, function (matchSessionId, teamIdx, callback) {
         if (!socket.session) {
             return callback({ success: false });
         }
         var user = getUser(socket.session);
         var table = tables.get(matchSessionId);
-        if (table && table.state === MatchTable_1.EMatchTableState.UNREADY) {
+        if (table) {
+            try {
+                table.lobby.addPlayer(user.id || "satoshi", socket.session, teamIdx);
+            }
+            catch (e) {
+                console.error(e);
+                return callback({ success: false });
+            }
             socket.join(matchSessionId);
-            table.lobby.addPlayer(user.id || "satoshi", socket.session);
             addSocketToUser(socket.session, socket.id, table);
             emitMatchUpdate(table);
             return callback({ success: true, match: table.getPublicMatch(socket.session) });
@@ -348,7 +365,7 @@ io.on("connection", function (_socket) {
     socket.on(types_1.EClientEvent.SET_PLAYER_READY, function (matchSessionId, ready) {
         try {
             var table = getTable(matchSessionId);
-            var player = table.lobby.players.find(function (player) { return player.session === socket.session; });
+            var player = table.lobby.players.find(function (player) { return player && player.session === socket.session; });
             if (player) {
                 player.setReady(ready);
                 emitMatchUpdate(table);

package/package.json

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