server/sockets.js

   1 const Discord = require('discord.js');
   2 const { token, channel } = require('./config/discord.json');
   3
   4 // Node version in Ubuntu 16.04 does not know about URL class
   5 function getJsonFromUrl(url) {
   6   const query = url.substr(2); //starts with "/?"
   7   let result = {};
   8   query.split("&").forEach((part) => {
   9     const item = part.split("=");
  10     result[item[0]] = decodeURIComponent(item[1]);
  11   });
  12   return result;
  13 }
  14
  15 // Helper to safe-send some message through a (web-)socket:
  16 function send(socket, message) {
  17   if (!!socket && socket.readyState == 1)
  18     socket.send(JSON.stringify(message));
  19 }
  20
  21 module.exports = function(wss) {
  22   // Associative array page --> sid --> tmpId --> socket
  23   // "page" is either "/" for hall or "/game/some_gid" for Game,
  24   // or "/mygames" for Mygames page (simpler: no 'people' array).
  25   // tmpId is required if a same user (browser) has different tabs
  26   let clients = {};
  27   // NOTE: only purpose of sidToPages = know when to delete keys in idToSid
  28   let sidToPages = {};
  29   let idToSid = {};
  30   const discordClient = new Discord.Client();
  31   let discordChannel = null;
  32   if (token.length > 0) {
  33     discordClient.login(token);
  34     discordClient.once("ready", () => {
  35       discordChannel = discordClient.channels.cache.get(channel);
  36     });
  37   }
  38   wss.on("connection", (socket, req) => {
  39     const query = getJsonFromUrl(req.url);
  40     const sid = query["sid"];
  41     const id = query["id"];
  42     const tmpId = query["tmpId"];
  43     const page = query["page"];
  44     const notifyRoom = (page, code, obj={}, except) => {
  45       if (!clients[page]) return;
  46       except = except || [];
  47       Object.keys(clients[page]).forEach(k => {
  48         if (except.includes(k)) return;
  49         Object.keys(clients[page][k]).forEach(x => {
  50           if (k == sid && x == tmpId) return;
  51           send(
  52             clients[page][k][x].socket,
  53             Object.assign({ code: code, from: [sid, tmpId] }, obj)
  54           );
  55         });
  56       });
  57     };
  58     const deleteConnexion = () => {
  59       if (!clients[page] || !clients[page][sid] || !clients[page][sid][tmpId])
  60         return; //job already done
  61       delete clients[page][sid][tmpId];
  62       if (Object.keys(clients[page][sid]).length == 0) {
  63         delete clients[page][sid];
  64         const pgIndex = sidToPages[sid].findIndex(pg => pg == page);
  65         sidToPages[sid].splice(pgIndex, 1);
  66         if (Object.keys(clients[page]).length == 0)
  67           delete clients[page];
  68         // Am I totally offline?
  69         if (sidToPages[sid].length == 0) {
  70           delete sidToPages[sid];
  71           delete idToSid[id];
  72         }
  73       }
  74     };
  75
  76     const doDisconnect = () => {
  77       deleteConnexion();
  78       // Nothing to notify when disconnecting from MyGames page:
  79       if (page != "/mygames") {
  80         notifyRoom(page, "disconnect");
  81         if (page.indexOf("/game/") >= 0)
  82           notifyRoom("/", "gdisconnect", { page: page });
  83       }
  84     };
  85     const messageListener = (objtxt) => {
  86       let obj = JSON.parse(objtxt);
  87       switch (obj.code) {
  88         // Wait for "connect" message to notify connection to the room,
  89         // because if game loading is slow the message listener might
  90         // not be ready too early.
  91         case "connect": {
  92           notifyRoom(page, "connect");
  93           if (page.indexOf("/game/") >= 0)
  94             notifyRoom("/", "gconnect", { page: page });
  95           break;
  96         }
  97         case "disconnect":
  98           // When page changes:
  99           doDisconnect();
 100           break;
 101         case "pollclients": {
 102           // From Game
 103           let sockIds = {};
 104           Object.keys(clients[page]).forEach(k => {
 105             sockIds[k] = {};
 106             Object.keys(clients[page][k]).forEach(x => {
 107               // Avoid polling my tmpId: no information to get
 108               if (k != sid || x != tmpId)
 109                 sockIds[k][x] = { focus: clients[page][k][x].focus };
 110             });
 111           });
 112           send(socket, { code: "pollclients", sockIds: sockIds });
 113           break;
 114         }
 115         case "pollclientsandgamers": {
 116           // From Hall
 117           let sockIds = {};
 118           Object.keys(clients["/"]).forEach(k => {
 119             sockIds[k] = {};
 120             Object.keys(clients[page][k]).forEach(x => {
 121               // Avoid polling my tmpId: no information to get
 122               if (k != sid || x != tmpId) {
 123                 sockIds[k][x] = {
 124                   page: "/",
 125                   focus: clients[page][k][x].focus
 126                 };
 127               }
 128             });
 129           });
 130           // NOTE: a "gamer" could also just be an observer
 131           Object.keys(clients).forEach(p => {
 132             if (p.indexOf("/game/") >= 0) {
 133               Object.keys(clients[p]).forEach(k => {
 134                 if (!sockIds[k]) sockIds[k] = {};
 135                 Object.keys(clients[p][k]).forEach(x => {
 136                   if (k != sid || x != tmpId) {
 137                     sockIds[k][x] = {
 138                       page: p,
 139                       focus: clients[p][k][x].focus
 140                     };
 141                   }
 142                 });
 143               });
 144             }
 145           });
 146           send(socket, { code: "pollclientsandgamers", sockIds: sockIds });
 147           break;
 148         }
 149
 150         // Asking something: from is fully identified,
 151         // but the requested resource can be from any tmpId (except current!)
 152         case "askidentity":
 153         case "asklastate":
 154         case "askchallenges":
 155         case "askgame": {
 156           const pg = obj.page || page; //required for askidentity and askgame
 157           if (!!clients[pg] && !!clients[pg][obj.target]) {
 158             let tmpIds = Object.keys(clients[pg][obj.target]);
 159             if (obj.target == sid) {
 160               // Targetting myself
 161               const idx_myTmpid = tmpIds.findIndex(x => x == tmpId);
 162               if (idx_myTmpid >= 0) tmpIds.splice(idx_myTmpid, 1);
 163             }
 164             if (tmpIds.length > 0) {
 165               const ttmpId = tmpIds[Math.floor(Math.random() * tmpIds.length)];
 166               send(
 167                 clients[pg][obj.target][ttmpId].socket,
 168                 { code: obj.code, from: [sid,tmpId,page] }
 169               );
 170             }
 171           }
 172           break;
 173         }
 174
 175         // Special situation of the previous "case":
 176         // Full game can be asked to any observer.
 177         case "askfullgame": {
 178           if (!!clients[page]) {
 179             let sids = Object.keys(clients[page]).filter(k => k != sid);
 180             if (sids.length > 0) {
 181               // Pick a SID at random in this set, and ask full game:
 182               const rid = sids[Math.floor(Math.random() * sids.length)];
 183               // ..to a random tmpId:
 184               const tmpIds = Object.keys(clients[page][rid]);
 185               const rtmpId = tmpIds[Math.floor(Math.random() * tmpIds.length)];
 186               send(
 187                 clients[page][rid][rtmpId].socket,
 188                 { code: "askfullgame", from: [sid,tmpId] }
 189               );
 190             } else {
 191               // I'm the only person who have the game for the moment:
 192               send(socket, { code: "fullgame", data: { empty: true } });
 193             }
 194           }
 195           break;
 196         }
 197
 198         // Some Hall events: target all tmpId's (except mine),
 199         case "refusechallenge":
 200         case "startgame":
 201           Object.keys(clients[page][obj.target]).forEach(x => {
 202             if (obj.target != sid || x != tmpId)
 203               send(
 204                 clients[page][obj.target][x].socket,
 205                 { code: obj.code, data: obj.data }
 206               );
 207           });
 208           break;
 209
 210         // Notify all room: mostly game events
 211         case "newchat":
 212         case "newchallenge":
 213         case "deletechallenge_s":
 214         case "newgame":
 215         case "resign":
 216         case "abort":
 217         case "drawoffer":
 218         case "rematchoffer":
 219         case "draw":
 220           // "newgame" message can provide a page (corr Game --> Hall)
 221           if (obj.code == "newchallenge") {
 222             // Filter out targeted challenges and correspondance games:
 223             if (!obj.data.to && obj.data.cadence.indexOf('d') < 0) {
 224               const challMsg = (
 225                 (obj.data.sender || "@nonymous") + " : " +
 226                 "**" + obj.data.vname + "** " +
 227                 "[" + obj.data.cadence + "] "
 228               );
 229               if (!!discordChannel) discordChannel.send(challMsg);
 230               else
 231                 // Log when running locally (dev, debug):
 232                 console.log(challMsg);
 233             }
 234             delete obj.data["sender"];
 235           }
 236           notifyRoom(
 237             obj.page || page, obj.code, {data: obj.data}, obj.excluded);
 238           break;
 239
 240         case "rnewgame":
 241           // A rematch game started:
 242           notifyRoom(page, "newgame", {data: obj.data});
 243           // Explicitely notify Hall if gametype == corr.
 244           // Live games will be polled from Hall after gconnect event.
 245           if (obj.data.cadence.indexOf('d') >= 0)
 246             notifyRoom("/", "newgame", {data: obj.data});
 247           break;
 248
 249         case "newmove": {
 250           const dataWithFrom = { from: [sid,tmpId], data: obj.data };
 251           // Special case re-send newmove only to opponent:
 252           if (!!obj.target && !!clients[page][obj.target]) {
 253             Object.keys(clients[page][obj.target]).forEach(x => {
 254               send(
 255                 clients[page][obj.target][x].socket,
 256                 Object.assign({ code: "newmove" }, dataWithFrom)
 257               );
 258             });
 259           } else {
 260             // NOTE: data.from is useful only to opponent
 261             notifyRoom(page, "newmove", dataWithFrom);
 262           }
 263           break;
 264         }
 265         case "gotmove":
 266           if (
 267             !!clients[page][obj.target[0]] &&
 268             !!clients[page][obj.target[0]][obj.target[1]]
 269           ) {
 270             send(
 271               clients[page][obj.target[0]][obj.target[1]].socket,
 272               { code: "gotmove" }
 273             );
 274           }
 275           break;
 276
 277         case "result":
 278           // Special case: notify all, 'transroom': Game --> Hall
 279           notifyRoom("/", "result", { gid: obj.gid, score: obj.score });
 280           break;
 281
 282         case "mabort": {
 283           const gamePg = "/game/" + obj.gid;
 284           if (!!clients[gamePg] && !!clients[gamePg][obj.target]) {
 285             Object.keys(clients[gamePg][obj.target]).forEach(x => {
 286               send(
 287                 clients[gamePg][obj.target][x].socket,
 288                 { code: "abort" }
 289               );
 290             });
 291           }
 292           break;
 293         }
 294
 295         case "notifyscore":
 296         case "notifyturn":
 297         case "notifynewgame":
 298           if (!!clients["/mygames"]) {
 299             obj.targets.forEach(t => {
 300               const k = t.sid || idToSid[t.id];
 301               if (!!clients["/mygames"][k]) {
 302                 Object.keys(clients["/mygames"][k]).forEach(x => {
 303                   send(
 304                     clients["/mygames"][k][x].socket,
 305                     { code: obj.code, data: obj.data }
 306                   );
 307                 });
 308               }
 309             });
 310           }
 311           break;
 312
 313         case "getfocus":
 314         case "losefocus":
 315           if (
 316             !!clients[page] &&
 317             !!clients[page][sid] &&
 318             !!clients[page][sid][tmpId]
 319           ) {
 320             clients[page][sid][tmpId].focus = (obj.code == "getfocus");
 321           }
 322           if (page == "/") notifyRoom("/", obj.code, { page: "/" }, [sid]);
 323           else {
 324             // Notify game room + Hall:
 325             notifyRoom(page, obj.code, {}, [sid]);
 326             notifyRoom("/", obj.code, { page: page }, [sid]);
 327           }
 328           break;
 329
 330         // Passing, relaying something: from isn't needed,
 331         // but target is fully identified (sid + tmpId)
 332         case "challenges":
 333         case "fullgame":
 334         case "game":
 335         case "identity":
 336         case "lastate":
 337         {
 338           const pg = obj.target[2] || page; //required for identity and game
 339           // NOTE: if in game we ask identity to opponent still in Hall, but
 340           // leaving Hall, clients[pg] or clients[pg][target] could be undef.
 341           if (!!clients[pg] && !!clients[pg][obj.target[0]]) {
 342             send(
 343               clients[pg][obj.target[0]][obj.target[1]].socket,
 344               { code:obj.code, data:obj.data }
 345             );
 346           }
 347           break;
 348         }
 349       }
 350     };
 351     const closeListener = () => {
 352       // For browser or tab closing (including page reload):
 353       doDisconnect();
 354     };
 355     // Update clients object: add new connexion
 356     const newElt = { socket: socket, focus: true };
 357     if (!clients[page])
 358       clients[page] = { [sid]: {[tmpId]: newElt } };
 359     else if (!clients[page][sid])
 360       clients[page][sid] = { [tmpId]: newElt };
 361     else
 362       clients[page][sid][tmpId] = newElt;
 363     // Also update helper correspondances
 364     if (!idToSid[id]) idToSid[id] = sid;
 365     if (!sidToPages[sid]) sidToPages[sid] = [];
 366     const pgIndex = sidToPages[sid].findIndex(pg => pg == page);
 367     if (pgIndex === -1) sidToPages[sid].push(page);
 368     socket.on("message", messageListener);
 369     socket.on("close", closeListener);
 370   });
 371 }