client/src/views/Hall.vue

   1 <template lang="pug">
   2 main
   3   input#modalInfo.modal(type="checkbox")
   4   div#infoDiv(
   5     role="dialog"
   6     data-checkbox="modalInfo"
   7   )
   8     .card.text-center
   9       label.modal-close(for="modalInfo")
  10       p(v-html="infoMessage")
  11   input#modalAccept.modal(type="checkbox")
  12   div#acceptDiv(role="dialog")
  13     .card
  14       p.text-center
  15         span.variantName {{ curChallToAccept.vname }}
  16         span {{ curChallToAccept.cadence }}
  17         span {{ st.tr["with"] + " " + curChallToAccept.from.name }}
  18       .diagram(v-html="tchallDiag")
  19       .button-group#buttonsTchall
  20         button.acceptBtn(@click="decisionChallenge(true)")
  21           span {{ st.tr["Accept challenge?"] }}
  22         button.refuseBtn(@click="decisionChallenge(false)")
  23           span {{ st.tr["Refuse"] }}
  24   input#modalNewgame.modal(
  25     type="checkbox"
  26     @change="cadenceFocusIfOpened($event)"
  27   )
  28   div#newgameDiv(
  29     role="dialog"
  30     data-checkbox="modalNewgame"
  31   )
  32     .card
  33       label#closeNewgame.modal-close(for="modalNewgame")
  34       div(@keyup.enter="newChallenge()")
  35         fieldset
  36           label(for="selectVariant") {{ st.tr["Variant"] }} *
  37           select#selectVariant(
  38             @change="loadNewchallVariant(trySetNewchallDiag)"
  39             v-model="newchallenge.vid"
  40           )
  41             option(
  42               v-for="v in st.variants"
  43               :value="v.id"
  44               :selected="newchallenge.vid==v.id"
  45             )
  46               | {{ v.name }}
  47         fieldset
  48           label(for="cadence") {{ st.tr["Cadence"] }} *
  49           div#predefinedCadences
  50             button(type="button") 15+5
  51             button(type="button") 45+30
  52             button(type="button") 3d
  53             button(type="button") 7d
  54           input#cadence(
  55             type="text"
  56             v-model="newchallenge.cadence"
  57             placeholder="5+0, 1h+30s, 5d ..."
  58           )
  59         fieldset
  60           label(for="selectRandomLevel") {{ st.tr["Randomness"] }} *
  61           select#selectRandomLevel(v-model="newchallenge.randomness")
  62             option(value="0") {{ st.tr["Deterministic"] }}
  63             option(value="1") {{ st.tr["Symmetric random"] }}
  64             option(value="2") {{ st.tr["Asymmetric random"] }}
  65         fieldset(v-if="st.user.id > 0")
  66           label(for="selectPlayers") {{ st.tr["Play with?"] }}
  67           input#selectPlayers(
  68             type="text"
  69             v-model="newchallenge.to"
  70           )
  71         fieldset(v-if="st.user.id > 0 && newchallenge.to.length > 0")
  72           input#inputFen(
  73             placeholder="FEN"
  74             @input="trySetNewchallDiag()"
  75             type="text"
  76             v-model="newchallenge.fen"
  77           )
  78         .diagram(v-html="newchallenge.diag")
  79       button(@click="newChallenge()") {{ st.tr["Send challenge"] }}
  80   input#modalPeople.modal(
  81     type="checkbox"
  82     @click="resetSocialColor()"
  83   )
  84   div#peopleWrap(
  85     role="dialog"
  86     data-checkbox="modalPeople"
  87   )
  88     .card
  89       label.modal-close(for="modalPeople")
  90       #people
  91         #players
  92           p(
  93             v-for="sid in Object.keys(people)"
  94             v-if="!!people[sid].name"
  95           )
  96             span {{ people[sid].name }}
  97             button.player-action(
  98               v-if="isGamer(sid)"
  99               @click="watchGame(sid)"
 100             )
 101               | {{ st.tr["Observe"] }}
 102             button.player-action(
 103               v-else-if="isFocusedOnHall(sid)"
 104               @click="challenge(sid)"
 105             )
 106               | {{ st.tr["Challenge"] }}
 107           p.anonymous @nonymous ({{ anonymousCount }})
 108         #chat
 109           Chat(
 110             :newChat="newChat"
 111             @mychat="processChat"
 112             :pastChats="[]"
 113           )
 114         .clearer
 115   .row
 116     .col-sm-12.col-md-10.col-md-offset-1.col-lg-8.col-lg-offset-2
 117       .button-group
 118         button#peopleBtn(onClick="window.doClick('modalPeople')")
 119           | {{ st.tr["Who's there?"] }}
 120         button(onClick="window.doClick('modalNewgame')")
 121           | {{ st.tr["New game"] }}
 122   .row
 123     .col-sm-12.col-md-10.col-md-offset-1.col-lg-8.col-lg-offset-2
 124       div#div2
 125         .button-group
 126           button.tabbtn#btnClive(@click="setDisplay('c','live',$event)")
 127             | {{ st.tr["Live challenges"] }}
 128           button.tabbtn#btnCcorr(@click="setDisplay('c','corr',$event)")
 129             | {{ st.tr["Correspondance challenges"] }}
 130         ChallengeList(
 131           v-show="cdisplay=='live'"
 132           :challenges="filterChallenges('live')"
 133           @click-challenge="clickChallenge"
 134         )
 135         ChallengeList(
 136           v-show="cdisplay=='corr'"
 137           :challenges="filterChallenges('corr')"
 138           @click-challenge="clickChallenge"
 139         )
 140       div#div3
 141         .button-group
 142           button.tabbtn#btnGlive(@click="setDisplay('g','live',$event)")
 143             | {{ st.tr["Live games"] }}
 144           button.tabbtn#btnGcorr(@click="setDisplay('g','corr',$event)")
 145             | {{ st.tr["Correspondance games"] }}
 146         GameList(
 147           v-show="gdisplay=='live'"
 148           :games="filterGames('live')"
 149           :showBoth="true"
 150           @show-game="showGame"
 151         )
 152         GameList(
 153           v-show="gdisplay=='corr'"
 154           :games="filterGames('corr')"
 155           :showBoth="true"
 156           @show-game="showGame"
 157         )
 158 </template>
 159
 160 <script>
 161 import { store } from "@/store";
 162 import { checkChallenge } from "@/data/challengeCheck";
 163 import { ArrayFun } from "@/utils/array";
 164 import { ajax } from "@/utils/ajax";
 165 import params from "@/parameters";
 166 import { getRandString, shuffle } from "@/utils/alea";
 167 import { getDiagram } from "@/utils/printDiagram";
 168 import Chat from "@/components/Chat.vue";
 169 import GameList from "@/components/GameList.vue";
 170 import ChallengeList from "@/components/ChallengeList.vue";
 171 import { GameStorage } from "@/utils/gameStorage";
 172 import { processModalClick } from "@/utils/modalClick";
 173 export default {
 174   name: "my-hall",
 175   components: {
 176     Chat,
 177     GameList,
 178     ChallengeList
 179   },
 180   data: function() {
 181     return {
 182       st: store.state,
 183       cdisplay: "live", //or corr
 184       gdisplay: "live",
 185       games: [],
 186       challenges: [],
 187       people: {},
 188       infoMessage: "",
 189       newchallenge: {
 190         fen: "",
 191         vid: parseInt(localStorage.getItem("vid")) || 0,
 192         to: "", //name of challenged player (if any)
 193         cadence: localStorage.getItem("cadence") || "",
 194         randomness: parseInt(localStorage.getItem("randomness")) || 2,
 195         // VariantRules object, stored to not interfere with
 196         // diagrams of targetted challenges:
 197         V: null,
 198         vname: "",
 199         diag: "" //visualizing FEN
 200       },
 201       tchallDiag: "",
 202       curChallToAccept: {from: {}},
 203       newChat: "",
 204       conn: null,
 205       connexionString: "",
 206       // Related to (killing of) self multi-connects:
 207       newConnect: {},
 208       killed: {}
 209     };
 210   },
 211   watch: {
 212     // st.variants changes only once, at loading from [] to [...]
 213     "st.variants": function() {
 214       // Set potential challenges and games variant names:
 215       this.challenges.concat(this.games).forEach(o => {
 216         if (!o.vname) o.vname = this.getVname(o.vid);
 217       });
 218       if (!this.newchallenge.V && this.newchallenge.vid > 0)
 219         this.loadNewchallVariant();
 220     }
 221   },
 222   computed: {
 223     anonymousCount: function() {
 224       let count = 0;
 225       Object.values(this.people).forEach(p => {
 226         // Do not cound people who did not send their identity yet:
 227         count += (!p.name && p.id === 0) ? 1 : 0;
 228       });
 229       return count;
 230     }
 231   },
 232   created: function() {
 233     if (this.st.variants.length > 0 && this.newchallenge.vid > 0)
 234       this.loadNewchallVariant();
 235     const my = this.st.user;
 236     this.$set(
 237       this.people,
 238       my.sid,
 239       {
 240         id: my.id,
 241         name: my.name,
 242         pages: [{ path: "/", focus: true }]
 243       }
 244     );
 245     // Ask server for current corr games (all but mines)
 246     ajax(
 247       "/games",
 248       "GET",
 249       {
 250         data: { uid: this.st.user.id, excluded: true },
 251         success: (response) => {
 252           this.games = this.games.concat(
 253             response.games.map(g => {
 254               const type = this.classifyObject(g);
 255               const vname = this.getVname(g.vid);
 256               return Object.assign({}, g, { type: type, vname: vname });
 257             })
 258           );
 259         }
 260       }
 261     );
 262     // Also ask for corr challenges (open + sent by/to me)
 263     ajax(
 264       "/challenges",
 265       "GET",
 266       {
 267         data: { uid: this.st.user.id },
 268         success: (response) => {
 269           // Gather all senders names, and then retrieve full identity:
 270           // (TODO [perf]: some might be online...)
 271           let names = {};
 272           response.challenges.forEach(c => {
 273             if (c.uid != this.st.user.id) names[c.uid] = "";
 274             else if (!!c.target && c.target != this.st.user.id)
 275               names[c.target] = "";
 276           });
 277           const addChallenges = () => {
 278             names[this.st.user.id] = this.st.user.name; //in case of
 279             this.challenges = this.challenges.concat(
 280               response.challenges.map(c => {
 281                 const from = { name: names[c.uid], id: c.uid }; //or just name
 282                 const type = this.classifyObject(c);
 283                 const vname = this.getVname(c.vid);
 284                 return Object.assign(
 285                   {},
 286                   {
 287                     type: type,
 288                     vname: vname,
 289                     from: from,
 290                     to: c.target ? names[c.target] : ""
 291                   },
 292                   c
 293                 );
 294               })
 295             );
 296           };
 297           if (Object.keys(names).length > 0) {
 298             ajax(
 299               "/users",
 300               "GET",
 301               {
 302                 data: { ids: Object.keys(names).join(",") },
 303                 success: (response2) => {
 304                   response2.users.forEach(u => {
 305                     names[u.id] = u.name;
 306                   });
 307                   addChallenges();
 308                 }
 309               }
 310             );
 311           } else addChallenges();
 312         }
 313       }
 314     );
 315     const connectAndPoll = () => {
 316       this.send("connect");
 317       this.send("pollclientsandgamers");
 318     };
 319     // Initialize connection
 320     this.connexionString =
 321       params.socketUrl +
 322       "/?sid=" +
 323       this.st.user.sid +
 324       "&tmpId=" +
 325       getRandString() +
 326       "&page=" +
 327       // Hall: path is "/" (could be hard-coded as well)
 328       encodeURIComponent(this.$route.path);
 329     this.conn = new WebSocket(this.connexionString);
 330     this.conn.onopen = connectAndPoll;
 331     this.conn.onmessage = this.socketMessageListener;
 332     this.conn.onclose = this.socketCloseListener;
 333   },
 334   mounted: function() {
 335     document.addEventListener('visibilitychange', this.visibilityChange);
 336     ["peopleWrap", "infoDiv", "newgameDiv"].forEach(eltName => {
 337       let elt = document.getElementById(eltName);
 338       elt.addEventListener("click", processModalClick);
 339     });
 340     document.querySelectorAll("#predefinedCadences > button").forEach(b => {
 341       b.addEventListener("click", () => {
 342         this.newchallenge.cadence = b.innerHTML;
 343       });
 344     });
 345     const dispCorr = this.$route.query["disp"];
 346     const showCtype =
 347       dispCorr || localStorage.getItem("type-challenges") || "live";
 348     const showGtype =
 349       dispCorr || localStorage.getItem("type-games") || "live";
 350     this.setDisplay("c", showCtype);
 351     this.setDisplay("g", showGtype);
 352   },
 353   beforeDestroy: function() {
 354     document.removeEventListener('visibilitychange', this.visibilityChange);
 355     this.send("disconnect");
 356   },
 357   methods: {
 358     visibilityChange: function() {
 359       // TODO: Use document.hidden? https://webplatform.news/issues/2019-03-27
 360       this.send(
 361         document.visibilityState == "visible"
 362           ? "getfocus"
 363           : "losefocus"
 364       );
 365     },
 366     // Helpers:
 367     cadenceFocusIfOpened: function() {
 368       if (event.target.checked)
 369         document.getElementById("cadence").focus();
 370     },
 371     send: function(code, obj) {
 372       if (!!this.conn) {
 373         this.conn.send(JSON.stringify(Object.assign({ code: code }, obj)));
 374       }
 375     },
 376     getVname: function(vid) {
 377       const variant = this.st.variants.find(v => v.id == vid);
 378       // this.st.variants might be uninitialized (variant == null)
 379       return variant ? variant.name : "";
 380     },
 381     filterChallenges: function(type) {
 382       return this.challenges.filter(c => c.type == type);
 383     },
 384     filterGames: function(type) {
 385       return this.games.filter(g => g.type == type);
 386     },
 387     classifyObject: function(o) {
 388       //challenge or game
 389       return o.cadence.indexOf("d") === -1 ? "live" : "corr";
 390     },
 391     setDisplay: function(letter, type, e) {
 392       this[letter + "display"] = type;
 393       localStorage.setItem(
 394         "type-" + (letter == "c" ? "challenges" : "games"),
 395         type
 396       );
 397       let elt = e
 398         ? e.target
 399         : document.getElementById("btn" + letter.toUpperCase() + type);
 400       elt.classList.add("active");
 401       elt.classList.remove("somethingnew"); //in case of
 402       if (!!elt.previousElementSibling)
 403         elt.previousElementSibling.classList.remove("active");
 404       else elt.nextElementSibling.classList.remove("active");
 405     },
 406     isGamer: function(sid) {
 407       return this.people[sid].pages
 408         .some(p => p.focus && p.path.indexOf("/game/") >= 0);
 409     },
 410     isFocusedOnHall: function(sid) {
 411       return (
 412         // This is meant to challenge people, thus the next 2 conditions:
 413         this.st.user.id > 0 &&
 414         sid != this.st.user.sid &&
 415         this.people[sid].pages.some(p => p.path == "/" && p.focus)
 416       );
 417     },
 418     challenge: function(sid) {
 419       // Available, in Hall (only)
 420       this.newchallenge.to = this.people[sid].name;
 421       document.getElementById("modalPeople").checked = false;
 422       window.doClick("modalNewgame");
 423     },
 424     watchGame: function(sid) {
 425       // In some game, maybe playing maybe not: show a random one
 426       let gids = [];
 427       this.people[sid].pages.forEach(p => {
 428         if (p.focus) {
 429           const matchGid = p.path.match(/[a-zA-Z0-9]+$/);
 430           if (!!matchGid) gids.push(matchGid[0]);
 431         }
 432       });
 433       const gid = gids[Math.floor(Math.random() * gids.length)];
 434       const game = this.games.find(g => g.id == gid);
 435       if (!!game) this.showGame(game);
 436       else this.$router.push("/game/" + gid); //game vs. me
 437     },
 438     showGame: function(g) {
 439       // NOTE: we are an observer, since only games I don't play are shown here
 440       // ==> Moves sent by connected remote player(s) if live game
 441       let url = "/game/" + g.id;
 442       if (g.type == "live")
 443         url += "?rid=" + g.rids[Math.floor(Math.random() * g.rids.length)];
 444       this.$router.push(url);
 445     },
 446     resetSocialColor: function() {
 447       // TODO: this is called twice, once on opening an once on closing
 448       document.getElementById("peopleBtn").classList.remove("somethingnew");
 449     },
 450     processChat: function(chat) {
 451       this.send("newchat", { data: chat });
 452     },
 453     getOppsid: function(c) {
 454       let oppsid = c.from.sid; //may not be defined if corr + offline opp
 455       if (!oppsid) {
 456         oppsid = Object.keys(this.people).find(
 457           sid => this.people[sid].id == c.from.id
 458         );
 459       }
 460       return oppsid;
 461     },
 462     // Messaging center:
 463     socketMessageListener: function(msg) {
 464       if (!this.conn) return;
 465       const data = JSON.parse(msg.data);
 466       switch (data.code) {
 467         case "pollclientsandgamers": {
 468           // Since people can be both in Hall and Game,
 469           // need to track "askIdentity" requests:
 470           let identityAsked = {};
 471           data.sockIds.forEach(s => {
 472             const page = s.page || "/";
 473             if (s.sid != this.st.user.sid && !identityAsked[s.sid]) {
 474               this.send("askidentity", { target: s.sid, page: page });
 475               identityAsked[s.sid] = true;
 476             }
 477             if (!this.people[s.sid]) {
 478               // Do not set name or id: identity unknown yet
 479               this.people[s.sid] = { pages: [{path: page, focus: true}] };
 480             }
 481             else if (!(this.people[s.sid].pages.find(p => p.path == page)))
 482               this.people[s.sid].pages.push({ path: page, focus: true });
 483             if (!s.page)
 484               // Peer is in Hall
 485               this.send("askchallenge", { target: s.sid });
 486             // Peer is in Game
 487             else this.send("askgame", { target: s.sid, page: page });
 488           });
 489           break;
 490         }
 491         case "connect":
 492         case "gconnect": {
 493           const page = data.page || "/";
 494           // Only ask game / challenge if first connexion:
 495           if (!this.people[data.from]) {
 496             this.people[data.from] = { pages: [{ path: page, focus: true }] };
 497             if (data.code == "connect")
 498               this.send("askchallenge", { target: data.from });
 499             else this.send("askgame", { target: data.from, page: page });
 500           } else {
 501             // Append page if not already in list
 502             if (!(this.people[data.from].pages.find(p => p.path == page)))
 503               this.people[data.from].pages.push({ path: page, focus: true });
 504           }
 505           if (!this.people[data.from].name && this.people[data.from].id !== 0) {
 506             // Identity not known yet
 507             this.newConnect[data.from] = true; //for self multi-connects tests
 508             this.send("askidentity", { target: data.from, page: page });
 509           }
 510           break;
 511         }
 512         case "disconnect":
 513         case "gdisconnect": {
 514           // If the user reloads the page twice very quickly (experienced with Firefox),
 515           // the first reload won't have time to connect but will trigger a "close" event anyway.
 516           // ==> Next check is required.
 517           if (!this.people[data.from]) return;
 518           // Disconnect means no more tmpIds:
 519           if (data.code == "disconnect") {
 520             // Remove the live challenge sent by this player:
 521             ArrayFun.remove(
 522               this.challenges,
 523               c => c.type == "live" && c.from.sid == data.from
 524             );
 525           } else {
 526             // Remove the matching live game if now unreachable
 527             const gid = data.page.match(/[a-zA-Z0-9]+$/)[0];
 528             const gidx = this.games.findIndex(g => g.id == gid);
 529             if (gidx >= 0) {
 530               const game = this.games[gidx];
 531               if (
 532                 game.type == "live" &&
 533                 game.rids.length == 1 &&
 534                 game.rids[0] == data.from
 535               ) {
 536                 this.games.splice(gidx, 1);
 537               }
 538             }
 539           }
 540           const page = data.page || "/";
 541           ArrayFun.remove(this.people[data.from].pages, p => p.path == page);
 542           if (this.people[data.from].pages.length == 0)
 543             this.$delete(this.people, data.from);
 544           break;
 545         }
 546         case "getfocus":
 547           // If user reload a page, focus may arrive earlier than connect
 548           if (!!this.people[data.from]) {
 549             this.people[data.from].pages
 550               .find(p => p.path == data.page).focus = true;
 551             this.$forceUpdate(); //TODO: shouldn't be required
 552           }
 553           break;
 554         case "losefocus":
 555           if (!!this.people[data.from]) {
 556             this.people[data.from].pages
 557               .find(p => p.path == data.page).focus = false;
 558             this.$forceUpdate(); //TODO: shouldn't be required
 559           }
 560           break;
 561         case "killed":
 562           // I logged in elsewhere:
 563           this.conn = null;
 564           alert(this.st.tr["New connexion detected: tab now offline"]);
 565           break;
 566         case "askidentity": {
 567           // Request for identification (TODO: anonymous shouldn't need to reply)
 568           const me = {
 569             // Decompose to avoid revealing email
 570             name: this.st.user.name,
 571             sid: this.st.user.sid,
 572             id: this.st.user.id
 573           };
 574           this.send("identity", { data: me, target: data.from });
 575           break;
 576         }
 577         case "identity": {
 578           const user = data.data;
 579           let player = this.people[user.sid];
 580           // player.pages is already set
 581           player.id = user.id;
 582           player.name = user.name;
 583           // TODO: this.$set(people, ...) fails. So forceUpdate.
 584           //       But this shouldn't be like that!
 585           this.$forceUpdate();
 586           // If I multi-connect, kill current connexion if no mark (I'm older)
 587           if (this.newConnect[user.sid]) {
 588             if (
 589               user.id > 0 &&
 590               user.id == this.st.user.id &&
 591               user.sid != this.st.user.sid &&
 592               !this.killed[this.st.user.sid]
 593             ) {
 594                 this.send("killme", { sid: this.st.user.sid });
 595                 this.killed[this.st.user.sid] = true;
 596             }
 597             delete this.newConnect[user.sid];
 598           }
 599           break;
 600         }
 601         case "askchallenge": {
 602           // Send my current live challenge (if any)
 603           const cIdx = this.challenges.findIndex(
 604             c => c.from.sid == this.st.user.sid && c.type == "live"
 605           );
 606           if (cIdx >= 0) {
 607             const c = this.challenges[cIdx];
 608             // NOTE: in principle, should only send targeted challenge to the target.
 609             // But we may not know yet the identity of the target (just name),
 610             // so cannot decide if data.from is the target or not.
 611             const myChallenge = {
 612               id: c.id,
 613               from: this.st.user.sid,
 614               to: c.to,
 615               randomness: c.randomness,
 616               fen: c.fen,
 617               vid: c.vid,
 618               cadence: c.cadence,
 619               added: c.added
 620             };
 621             this.send("challenge", { data: myChallenge, target: data.from });
 622           }
 623           break;
 624         }
 625         case "challenge": //after "askchallenge"
 626         case "newchallenge": {
 627           // NOTE about next condition: see "askchallenge" case.
 628           const chall = data.data;
 629           if (
 630             !chall.to ||
 631             (this.people[chall.from].id > 0 &&
 632               (chall.from == this.st.user.sid || chall.to == this.st.user.name))
 633           ) {
 634             let newChall = Object.assign({}, chall);
 635             newChall.type = this.classifyObject(chall);
 636             newChall.randomness = chall.randomness;
 637             newChall.added = Date.now();
 638             let fromValues = Object.assign({}, this.people[chall.from]);
 639             delete fromValues["pages"]; //irrelevant in this context
 640             newChall.from = Object.assign({ sid: chall.from }, fromValues);
 641             newChall.vname = this.getVname(newChall.vid);
 642             this.challenges.push(newChall);
 643             if (
 644               (newChall.type == "live" && this.cdisplay == "corr") ||
 645               (newChall.type == "corr" && this.cdisplay == "live")
 646             ) {
 647               document
 648                 .getElementById("btnC" + newChall.type)
 649                 .classList.add("somethingnew");
 650             }
 651           }
 652           break;
 653         }
 654         case "refusechallenge": {
 655           const cid = data.data;
 656           ArrayFun.remove(this.challenges, c => c.id == cid);
 657           alert(this.st.tr["Challenge declined"]);
 658           break;
 659         }
 660         case "deletechallenge": {
 661           // NOTE: the challenge may be already removed
 662           const cid = data.data;
 663           ArrayFun.remove(this.challenges, c => c.id == cid);
 664           break;
 665         }
 666         case "game": //individual request
 667         case "newgame": {
 668           // NOTE: it may be live or correspondance
 669           const game = data.data;
 670           // Ignore games where I play (corr games)
 671           if (game.players.every(p =>
 672             p.sid != this.st.user.sid || p.id != this.st.user.id))
 673           {
 674             let locGame = this.games.find(g => g.id == game.id);
 675             if (!locGame) {
 676               let newGame = game;
 677               newGame.type = this.classifyObject(game);
 678               newGame.vname = this.getVname(game.vid);
 679               if (!game.score)
 680                 //if new game from Hall
 681                 newGame.score = "*";
 682               newGame.rids = [game.rid];
 683               delete newGame["rid"];
 684               this.games.push(newGame);
 685               if (
 686                 (newGame.type == "live" && this.gdisplay == "corr") ||
 687                 (newGame.type == "corr" && this.gdisplay == "live")
 688               ) {
 689                 document
 690                   .getElementById("btnG" + newGame.type)
 691                   .classList.add("somethingnew");
 692               }
 693             } else {
 694               // Append rid (if not already in list)
 695               if (!locGame.rids.includes(game.rid)) locGame.rids.push(game.rid);
 696             }
 697           }
 698           break;
 699         }
 700         case "result": {
 701           let g = this.games.find(g => g.id == data.gid);
 702           if (!!g) g.score = data.score;
 703           break;
 704         }
 705         case "startgame": {
 706           // New game just started: data contain all information
 707           const gameInfo = data.data;
 708           if (this.classifyObject(gameInfo) == "live")
 709             this.startNewGame(gameInfo);
 710           else {
 711             this.infoMessage =
 712               this.st.tr["New correspondance game:"] +
 713               " <a href='#/game/" +
 714               gameInfo.id +
 715               "'>" +
 716               "#/game/" +
 717               gameInfo.id +
 718               "</a>";
 719             let modalBox = document.getElementById("modalInfo");
 720             modalBox.checked = true;
 721           }
 722           break;
 723         }
 724         case "newchat":
 725           this.newChat = data.data;
 726           if (!document.getElementById("modalPeople").checked)
 727             document.getElementById("peopleBtn").classList.add("somethingnew");
 728           break;
 729       }
 730     },
 731     socketCloseListener: function() {
 732       if (!this.conn) return;
 733       this.conn = new WebSocket(this.connexionString);
 734       this.conn.addEventListener("message", this.socketMessageListener);
 735       this.conn.addEventListener("close", this.socketCloseListener);
 736     },
 737     // Challenge lifecycle:
 738     loadNewchallVariant: async function(cb) {
 739       const vname = this.getVname(this.newchallenge.vid);
 740       const vModule = await import("@/variants/" + vname + ".js");
 741       this.newchallenge.V = vModule.VariantRules;
 742       this.newchallenge.vname = vname;
 743       if (!!cb)
 744         cb();
 745     },
 746     trySetNewchallDiag: function() {
 747       if (!this.newchallenge.fen) {
 748         this.newchallenge.diag = "";
 749         return;
 750       }
 751       // If vid > 0 then the variant is loaded (function above):
 752       window.V = this.newchallenge.V;
 753       if (
 754         this.newchallenge.vid > 0 &&
 755         !!this.newchallenge.fen &&
 756         V.IsGoodFen(this.newchallenge.fen)
 757       ) {
 758         const parsedFen = V.ParseFen(this.newchallenge.fen);
 759         this.newchallenge.diag = getDiagram({
 760           position: parsedFen.position,
 761           orientation: parsedFen.turn
 762         });
 763       }
 764     },
 765     newChallenge: async function() {
 766       if (!!(this.newchallenge.cadence.match(/^[0-9]+$/)))
 767         this.newchallenge.cadence += "+0"; //assume minutes, no increment
 768       const ctype = this.classifyObject(this.newchallenge);
 769       // TODO: cadence still unchecked so ctype could be wrong...
 770       let error = "";
 771       if (!this.newchallenge.vid)
 772         error = this.st.tr["Please select a variant"];
 773       else if (ctype == "corr" && this.st.user.id <= 0)
 774         error = this.st.tr["Please log in to play correspondance games"];
 775       else if (!!this.newchallenge.to) {
 776         if (this.newchallenge.to == this.st.user.name)
 777           error = this.st.tr["Self-challenge is forbidden"];
 778         else if (
 779           ctype == "live" &&
 780           Object.values(this.people).every(p => p.name != this.newchallenge.to)
 781         )
 782           error = this.newchallenge.to + " " + this.st.tr["is not online"];
 783       }
 784       if (error) {
 785         alert(error);
 786         return;
 787       }
 788       window.V = this.newchallenge.V;
 789       error = checkChallenge(this.newchallenge);
 790       if (error) {
 791         alert(error);
 792         return;
 793       }
 794       // NOTE: "from" information is not required here
 795       let chall = Object.assign({}, this.newchallenge);
 796       delete chall["V"];
 797       delete chall["diag"];
 798       const finishAddChallenge = cid => {
 799         chall.id = cid || "c" + getRandString();
 800         // Remove old challenge if any (only one at a time of a given type):
 801         const cIdx = this.challenges.findIndex(
 802           c =>
 803             (c.from.sid == this.st.user.sid || c.from.id == this.st.user.id) &&
 804             c.type == ctype
 805         );
 806         if (cIdx >= 0) {
 807           // Delete current challenge (will be replaced now)
 808           this.send("deletechallenge", { data: this.challenges[cIdx].id });
 809           if (ctype == "corr") {
 810             ajax(
 811               "/challenges",
 812               "DELETE",
 813               { data: { id: this.challenges[cIdx].id } }
 814             );
 815           }
 816           this.challenges.splice(cIdx, 1);
 817         }
 818         this.send("newchallenge", {
 819           data: Object.assign({ from: this.st.user.sid }, chall)
 820         });
 821         // Add new challenge:
 822         chall.from = {
 823           // Decompose to avoid revealing email
 824           sid: this.st.user.sid,
 825           id: this.st.user.id,
 826           name: this.st.user.name
 827         };
 828         chall.added = Date.now();
 829         // NOTE: vname and type are redundant (can be deduced from cadence + vid)
 830         chall.type = ctype;
 831         chall.vname = this.newchallenge.vname;
 832         this.challenges.push(chall);
 833         // Remember cadence  + vid for quicker further challenges:
 834         localStorage.setItem("cadence", chall.cadence);
 835         localStorage.setItem("vid", chall.vid);
 836         localStorage.setItem("randomness", chall.randomness);
 837         document.getElementById("modalNewgame").checked = false;
 838         // Show the challenge if not on current display
 839         if (
 840           (ctype == "live" && this.cdisplay == "corr") ||
 841           (ctype == "corr" && this.cdisplay == "live")
 842         ) {
 843           this.setDisplay('c', ctype);
 844         }
 845       };
 846       if (ctype == "live") {
 847         // Live challenges have a random ID
 848         finishAddChallenge(null);
 849       } else {
 850         // Correspondance game: send challenge to server
 851         ajax(
 852           "/challenges",
 853           "POST",
 854           {
 855             data: { chall: chall },
 856             success: (response) => {
 857               finishAddChallenge(response.cid);
 858             }
 859           }
 860         );
 861       }
 862     },
 863     // Callback function after a diagram was showed to accept
 864     // or refuse targetted challenge:
 865     decisionChallenge: function(accepted) {
 866       this.curChallToAccept.accepted = accepted;
 867       this.finishProcessingChallenge(this.curChallToAccept);
 868       document.getElementById("modalAccept").checked = false;
 869     },
 870     finishProcessingChallenge: function(c) {
 871       if (c.accepted) {
 872         c.seat = {
 873           // Again, avoid c.seat = st.user to not reveal email
 874           sid: this.st.user.sid,
 875           id: this.st.user.id,
 876           name: this.st.user.name
 877         };
 878         this.launchGame(c);
 879       } else {
 880         const oppsid = this.getOppsid(c);
 881         if (!!oppsid)
 882           this.send("refusechallenge", { data: c.id, target: oppsid });
 883         if (c.type == "corr") {
 884           ajax(
 885             "/challenges",
 886             "DELETE",
 887             { data: { id: c.id } }
 888           );
 889         }
 890       }
 891       this.send("deletechallenge", { data: c.id });
 892     },
 893     clickChallenge: async function(c) {
 894       const myChallenge =
 895         c.from.sid == this.st.user.sid || //live
 896         (this.st.user.id > 0 && c.from.id == this.st.user.id); //corr
 897       if (!myChallenge) {
 898         if (c.type == "corr" && this.st.user.id <= 0) {
 899           alert(this.st.tr["Please log in to accept corr challenges"]);
 900           return;
 901         }
 902         c.accepted = true;
 903         const vModule = await import("@/variants/" + c.vname + ".js");
 904         window.V = vModule.VariantRules;
 905         if (!!c.to) {
 906           // c.to == this.st.user.name (connected)
 907           if (!!c.fen) {
 908             const parsedFen = V.ParseFen(c.fen);
 909             c.mycolor = V.GetOppCol(parsedFen.turn);
 910             this.tchallDiag = getDiagram({
 911               position: parsedFen.position,
 912               orientation: c.mycolor
 913             });
 914             this.curChallToAccept = c;
 915             document.getElementById("modalAccept").checked = true;
 916           }
 917           else {
 918             if (!confirm(this.st.tr["Accept challenge?"]))
 919               c.accepted = false;
 920             this.finishProcessingChallenge(c);
 921           }
 922         }
 923         else
 924           this.finishProcessingChallenge(c);
 925       }
 926       else {
 927         // My challenge
 928         if (c.type == "corr") {
 929           ajax(
 930             "/challenges",
 931             "DELETE",
 932             { data: { id: c.id } }
 933           );
 934         }
 935         this.send("deletechallenge", { data: c.id });
 936       }
 937       // In all cases, the challenge is consumed:
 938       ArrayFun.remove(this.challenges, ch => ch.id == c.id);
 939     },
 940     // NOTE: when launching game, the challenge is already being deleted
 941     launchGame: function(c) {
 942       // These game informations will be shared
 943       let gameInfo = {
 944         id: getRandString(),
 945         fen: c.fen || V.GenRandInitFen(c.randomness),
 946         // White player index 0, black player index 1:
 947         players: c.mycolor
 948           ? (c.mycolor == "w" ? [c.seat, c.from] : [c.from, c.seat])
 949           : shuffle([c.from, c.seat]),
 950         vid: c.vid,
 951         cadence: c.cadence
 952       };
 953       const notifyNewgame = () => {
 954         const oppsid = this.getOppsid(c);
 955         if (!!oppsid)
 956           //opponent is online
 957           this.send("startgame", { data: gameInfo, target: oppsid });
 958         // Send game info (only if live) to everyone except me in this tab
 959         this.send("newgame", { data: gameInfo });
 960       };
 961       if (c.type == "live") {
 962         notifyNewgame();
 963         this.startNewGame(gameInfo);
 964       } //corr: game only on server
 965       else {
 966         ajax(
 967           "/games",
 968           "POST",
 969           {
 970             // cid is useful to delete the challenge:
 971             data: { gameInfo: gameInfo, cid: c.id },
 972             success: (response) => {
 973               gameInfo.id = response.gameId;
 974               notifyNewgame();
 975               this.$router.push("/game/" + response.gameId);
 976             }
 977           }
 978         );
 979       }
 980     },
 981     // NOTE: for live games only (corr games start on the server)
 982     startNewGame: function(gameInfo) {
 983       const game = Object.assign({}, gameInfo, {
 984         // (other) Game infos: constant
 985         fenStart: gameInfo.fen,
 986         vname: this.getVname(gameInfo.vid),
 987         created: Date.now(),
 988         // Game state (including FEN): will be updated
 989         moves: [],
 990         clocks: [-1, -1], //-1 = unstarted
 991         initime: [0, 0], //initialized later
 992         score: "*"
 993       });
 994       GameStorage.add(game, (err) => {
 995         // If an error occurred, game is not added: abort
 996         if (!err) {
 997           if (this.st.settings.sound)
 998             new Audio("/sounds/newgame.flac").play().catch(() => {});
 999           this.$router.push("/game/" + gameInfo.id);
1000         }
1001       });
1002     }
1003   }
1004 };
1005 </script>
1006
1007 <style lang="sass" scoped>
1008 .active
1009   color: #42a983
1010
1011 #infoDiv > .card
1012   padding: 15px 0
1013   max-width: 430px
1014
1015 #newgameDiv > .card, #acceptDiv > .card
1016   max-width: 767px
1017   max-height: 100%
1018
1019 div#peopleWrap > .card
1020   max-height: 100%
1021
1022 @media screen and (min-width: 1281px)
1023   div#peopleWrap > .card
1024     max-width: 66.67%
1025
1026 @media screen and (max-width: 1280px)
1027   div#peopleWrap > .card
1028     max-width: 83.33%
1029
1030 @media screen and (max-width: 767px)
1031   div#peopleWrap > .card
1032     max-width: 100%
1033
1034 #players
1035   width: 50%
1036   position: relative
1037   float: left
1038
1039 #chat
1040   width: 50%
1041   float: left
1042   position: relative
1043
1044 @media screen and (max-width: 767px)
1045   #players, #chats
1046     width: 100%
1047
1048 #chat > .card
1049   max-width: 100%
1050   margin: 0;
1051   border: none;
1052
1053 #players > p
1054   margin-left: 5px
1055
1056 .anonymous
1057   font-style: italic
1058
1059 button.player-action
1060   margin-left: 32px
1061
1062 .somethingnew
1063   background-color: #c5fefe !important
1064
1065 .tabbtn
1066   background-color: #f9faee
1067
1068 button.acceptBtn
1069   background-color: lightgreen
1070 button.refuseBtn
1071   background-color: red
1072
1073 #buttonsTchall
1074   margin-top: 10px
1075   & > button > span
1076     width: 100%
1077     text-align: center
1078
1079 .variantName
1080   font-weight: bold
1081
1082 .diagram
1083   margin: 0 auto
1084   max-width: 400px
1085   // width: 100% required for Firefox
1086   width: 100%
1087
1088 #inputFen
1089   width: 100%
1090
1091 #div2, #div3
1092   margin-top: 15px
1093 @media screen and (max-width: 767px)
1094   #div2, #div3
1095     margin-top: 0
1096 </style>