+#!/usr/bin/env bash

+

+heroku logs --tail --app=gd-chess-server | while read -r LINE; do

+ echo -ne "\e[0;36m$(date -d "$(echo "$LINE" | cut -d ' ' -f 1)" +%X): \e[0m"

+ echo "$LINE" | cut -d ' ' -f 3-

+done

+import { Chess } from "chess.js";

+import { Infos } from "./infos.js";

+import { str_obj, flip_int, send_group_packet } from "./utils.js";

+

+export class Game {

+ constructor(data, ws, wss) {

+ this.wss = wss;

+ this.hosterIndex = Number(!data.team);

+ this.clients = [undefined, undefined];

+ this.clients[this.hosterIndex] = ws; // team === true : 0 ? 1

+ this.gamecode = data.gamecode;

+ this.ids = [undefined, undefined]; // not a set so i can play against myself

+ this.ids[this.hosterIndex] = data.id;

+ this.infos = new Infos(this.hosterIndex, data.name, data.country);

+ this.spectators = [];

+ this.game = new Chess();

+ if (data.hasOwnProperty("moves")) this.game.load_pgn(data.moves.join(" "));

+ }

+ get pgn() {

+ return this.game.pgn();

+ }

+

+ get players() {

+ let players = 0;

+ this.ids.forEach((id) => {

+ if (id !== undefined) players++;

+ });

+ return players;

+ }

+

+ get client_count() {

+ let clients = 0;

+ this.clients.forEach((client) => {

+ if (client !== undefined) clients++;

+ });

+ return clients;

+ }

+

+ get joinerIndex() {

+ return flip_int(this.hosterIndex);

+ }

+ //true for valid

+ validate_move(move) {

+ const res = this.game.move(move);

+ if (str_obj(res) == "{}") return false;

+ this.game.undo();

+ return true;

+ }

+ move(move) {

+ this.game.move(move);

+ }

+ undo() {

+ this.game.undo();

+ }

+ remove_client(ws) {

+ this.clients[this.clients.indexOf(ws)] = undefined;

+ }

+

+ add_client(ws, data) {

+ this.clients[this.joinerIndex] = ws;

+ this.ids[this.joinerIndex] = data.id;

+ this.infos.add(data.name, data.country);

+ }

+

+ clean_clients(set_is_alive = true) {

+ function remove_client(c, wss, removal_func) {

+ if (c) {

+ if (c.is_alive === false) {

+ removal_func(c);

+ c.terminate();

+ wss.clients.delete(c);

+ } else if (set_is_alive) c.is_alive = false; // becomes true on next ping

+ }

+ }

+

+ this.spectators.forEach((spec) => {

+ remove_client(spec, this.wss, this.remove_spectator.bind(this));

+ });

+

+ this.clients.forEach((client) => {

+ remove_client(client, this.wss, this.remove_client.bind(this));

+ });

+ }

+

+ get dead() {

+ return this.client_count === 0 && this.spectators.length == 0;

+ }

+

+ add_spectator(ws) {

+ this.spectators.push(ws);

+ }

+ remove_spectator(ws) {

+ this.spectators.slice(this.spectators.indexOf(ws));

+ }

+ send_group_packet(packet, header) {

+ delete packet.gamecode;

+ send_group_packet(packet, header, this.clients);

+ send_group_packet(packet, header, this.spectators);

+ }

+ send_signal_packet(data, ws, header) {

+ let i = this.clients.indexOf(ws);

+ if (i !== -1) {

+ let sendto = this.clients[i ? 0 : 1];

+ delete data.gamecode; // dont send the gamecode to the other player: waste of bytes

+ if (sendto) {

+ sendto.send_packet(data, header);

+ send_group_packet(data, header, this.spectators); // give it to the specs

+ return true;

+ }

+ } else console.log(`could not find client in game ${data.gamecode}`);

+ return false;

+ }

+ is_game_over() {

+ return this.game.game_over();

+ }

+ reset_game() {

+ this.game = new Chess();

+ }

+}

+import { Game } from "./game.js";

+import { str_obj, flip_int, send_group_packet } from "./utils.js";

+ console.log(

+ `client connected (${

+ req.headers["x-forwarded-for"] || req.socket.remoteAddress

+ })`

+ );

+// hoster does *not* call this function with itself. joiner must tell hoster about itself

+ function send_info(they_know_about_me = false) {

+ const us = game.ids.indexOf(data.id);

+ const them = flip_int(us);

+ // in a ideal world, clients dont disconnect and become undefined. we do not live in a ideal world. (sadly) (or they just left the game :/)

+ if (game.clients[them] !== undefined && !they_know_about_me) {

+ game.clients[them].send_packet(game.infos.get(us), HEADERS.info);

+ }

+ game.clients[us].send_packet(game.infos.get(them), HEADERS.info);

+ if (data.gamecode !== undefined && data.id) {

+ if (game.players < 2) {

+ // hoster is waiting for someone to join

+ game.add_client(ws, data);

+ ws.send_packet({ idx: game.joinerIndex }, HEADERS.joinrequest); // tell them what team they are

+ send_group_packet(game.pgn, HEADERS.loadpgn, game.clients); // hoster doesnt send a joinrequest, so tell it to load pgn too

+ send_info();

+ console.log(`${data.name} joined ${data.gamecode}`);

+ } else if (game.ids.includes(data.id)) {

+ // someone is trying to rejoin

+ console.log(

+ `rejoin ${data.name} to ${

+ game.ids.indexOf(data.id) === 0 ? "white" : "black"

+ }`

+ );

+ game.clients[game.ids.indexOf(data.id)] = ws;

+ ws.send_packet(game.pgn, HEADERS.loadpgn); // pass them the pgn

+ send_info(true); // and send them their opponents info

+ } else {

+ console.log(

+ `rejected join to ${data.gamecode} (by ${data.name}): game full / id(${data.id}) not included in ${game.ids}`

+ );

+ ws.send_packet("err: game full", HEADERS.joinrequest);

+ }

+ games[data.gamecode] = new Game(data, ws, wss);

+ console.log("made move", data.move, "on", gc);

+ games[gc].move(data.move);

+ signal_other(data, ws, HEADERS.rematch);

+ // check if its a request, and if the request is accepted

+ if (data.accepted === true) games[gc].reset_game(); // reset if it is

+import { flip_int } from "./utils.js";

+

+export class Infos {

+ constructor(hosterIndex, hosterName, hosterCountry) {

+ this.hosterIndex = hosterIndex;

+ this.names = ["Anonymous", "Anonymous"];

+ this.names[hosterIndex] = hosterName;

+ this.countrys = ["rainbow", "rainbow"];

+ this.countrys[hosterIndex] = hosterCountry;

+ }

+ get(index) {

+ return {

+ name: this.names[index],

+ country: this.countrys[index],

+ };

+ }

+

+ get_all() {

+ return { w: this.get(0), b: this.get(1) };

+ }

+

+ get joinerIndex() {

+ return flip_int(this.hosterIndex);

+ }

+

+ add(name, country) {

+ this.names[this.joinerIndex] = name;

+ this.countrys[this.joinerIndex] = country;

+ }

+}

+export function str_obj(obj) {

+ return JSON.stringify(obj, null, 0);

+}

+

+export function flip_int(int) {

+ return int === 0 ? 1 : 0;

+}

+

+export function send_group_packet(data, header, clients) {

+ clients.forEach((client) => {

+ if (client) client.send_packet(data, header);

+ });

+}