[xogo.git] / server.js

const params = require("./parameters.js");
const WebSocket = require('ws');
const wss = new WebSocket.Server(
  {port: params.socket_port, path: params.socket_path});

let challenges = {}; //variantName --> socketId, name
let games = {}; //gameId --> gameInfo (vname, fen, players, options)
let sockets = {}; //socketId --> socket
let sendmoveTimeout1 = {},
    sendmoveTimeout2 = {},
    sendmoveRetry = {},
    stopRetry = {};
const variants = require("./variants.js");

const clearTrySendMove = (gid) => {
  clearTimeout(sendmoveTimeout1[gid]);
  clearTimeout(sendmoveTimeout2[gid]);
  clearInterval(sendmoveRetry[gid]);
  clearTimeout(stopRetry[gid]);
};

const send = (sid, code, data) => {
  const socket = sockets[sid];
  // If a player delete local infos and then try to resume a game,
  // sockets[oppSid] will probably not exist anymore:
  if (socket) socket.send(JSON.stringify(Object.assign({ code: code }, data)));
}

const Crypto = require('crypto')
function randomString(size = 8) {
  return Crypto.randomBytes(size).toString('hex').slice(0, size);
}

wss.on('connection', function connection(socket, req) {
  const sid = req.url.split("=")[1]; //...?sid=...
  sockets[sid] = socket;
  socket.isAlive = true;
  socket.on('pong', () => socket.isAlive = true);

  function launchGame(vname, players, options) {
    const gid = randomString(8);
    games[gid] = {
      vname: vname,
      players: players.map(p => {
                 return (!p ? null : {sid: p.sid, name: p.name});
               }),
      options: options
    };
    if (players.every(p => p)) {
      const gameInfo = Object.assign(
        // Provide seed so that both players initialize with same FEN
        {seed: Math.floor(Math.random() * 1984), gid: gid},
        games[gid]);
      for (let i of [0, 1]) {
        send(players[i].sid, "gamestart",
             Object.assign({randvar: players[i].randvar}, gameInfo));
      }
    }
    else {
      // Incomplete players array: do not start game yet
      send(sid, "gamecreated", {gid: gid});
      // If nobody joins within a minute, delete game
      setTimeout(
        () => {
          if (games[gid] && games[gid].players.some(p => !p))
            delete games[gid];
        },
        60000
      );
    }
  }

  socket.on('message', (msg) => {
    const obj = JSON.parse(msg);
    switch (obj.code) {
      // Send challenge (may trigger game creation)
      case "seekgame": {
        // Only one challenge per player:
        if (Object.keys(challenges).some(k => challenges[k].sid == sid))
          return;
        let opponent = undefined,
            choice = undefined;
        const vname = obj.vname,
              randvar = (obj.vname == "_random");
        if (vname == "_random") {
          // Pick any current challenge if any
          const currentChalls = Object.keys(challenges);
          if (currentChalls.length >= 1) {
            choice =
              currentChalls[Math.floor(Math.random() * currentChalls.length)];
            opponent = challenges[choice];
          }
        }
        else if (challenges[vname]) {
          opponent = challenges[vname];
          choice = vname;
        }
        if (opponent) {
          delete challenges[choice];
          if (choice == "_random") {
            // Pick a variant at random in the list
            const index = Math.floor(Math.random() * variants.length);
            choice = variants[index].name;
          }
          // Launch game
          let players = [
            {sid: sid, name: obj.name, randvar: randvar},
            opponent
          ];
          if (Math.random() < 0.5) players = players.reverse();
          launchGame(choice, players, {}); //empty options => default
        }
        else
          // Place challenge and wait. 'randvar' indicate if we play anything
          challenges[vname] = {sid: sid, name: obj.name, randvar: randvar};
        break;
      }
      // Set FEN after game was created
      case "setfen":
        games[obj.gid].fen = obj.fen;
        break;
      // Send back game informations
      case "getgame": {
        if (!games[obj.gid]) send(sid, "nogame");
        else send(sid, "gameinfo", games[obj.gid]);
        break;
      }
      // Cancel challenge
      case "cancelseek":
        delete challenges[obj.vname];
        break;
      // Receive rematch
      case "rematch":
        if (!games[obj.gid]) send(sid, "closerematch");
        else {
          const myIndex = (games[obj.gid].players[0].sid == sid ? 0 : 1);
          if (!games[obj.gid].rematch) games[obj.gid].rematch = [false, false];
          games[obj.gid].rematch[myIndex] = true;
          if (games[obj.gid].rematch[1-myIndex]) {
            // Launch new game, colors reversed
            launchGame(games[obj.gid].vname,
                       games[obj.gid].players.reverse(),
                       games[obj.gid].options);
          }
        }
        break;
      // Rematch cancellation
      case "norematch":
        if (games[obj.gid]) {
          const myIndex = (games[obj.gid].players[0].sid == sid ? 0 : 1);
          send(games[obj.gid].players[1-myIndex].sid, "closerematch");
        }
        break;
      // Create game vs. friend
      case "creategame": {
        let players = [
          { sid: obj.player.sid, name: obj.player.name },
          undefined
        ];
        if (
          obj.player.color == 'b' ||
          (obj.player.color == '' && Math.random() < 0.5)
        ) {
          players = players.reverse();
        }
        launchGame(obj.vname, players, obj.options);
        break;
      }
      // Join game vs. friend
      case "joingame":
        if (!games[obj.gid]) send(sid, "jointoolate");
        else {
          // Join a game (started by some other player)
          const emptySlot = games[obj.gid].players.findIndex(p => !p);
          if (emptySlot < 0) send(sid, "jointoolate");
          games[obj.gid].players[emptySlot] = {sid: sid, name: obj.name};
          const gameInfo = Object.assign(
            // Provide seed so that both players initialize with same FEN
            {seed: Math.floor(Math.random()*1984), gid: obj.gid},
            games[obj.gid]);
          for (let i of [0, 1])
            send(games[obj.gid].players[i].sid, "gamestart", gameInfo);
        }
        break;
      // Relay a move + update games object
      case "newmove":
        // If already received this move: skip
        if (games[obj.gid].fen == obj.fen) break;
        // Notify sender that the move is received:
        send(sid, "gotmove", {fen: obj.fen});
        games[obj.gid].fen = obj.fen;
        const playingWhite = (games[obj.gid].players[0].sid == sid);
        const oppSid = games[obj.gid].players[playingWhite ? 1 : 0].sid;
        const sendMove =
          // NOTE: sending FEN also, to check it in "gotmove" below
          () => send(oppSid, "newmove", {moves: obj.moves, fen: obj.fen});
        sendMove();
        sendmoveTimeout1[obj.gid] = setTimeout(sendMove, 500);
        sendmoveTimeout2[obj.gid] = setTimeout(sendMove, 1500);
        sendmoveRetry[obj.gid] = setInterval(sendMove, 5000);
        stopRetry[obj.gid] = setTimeout(clearTrySendMove, 31000);
        break;
      case "gotmove":
        if (games[obj.gid].fen == obj.fen) clearTrySendMove(obj.gid);
        break;
      // Relay "game ends" message
      case "gameover": {
        const playingWhite = (games[obj.gid].players[0].sid == sid);
        const oppSid = games[obj.gid].players[playingWhite ? 1 : 0].sid;
        if (obj.relay) send(oppSid, "gameover", { gid: obj.gid });
        games[obj.gid].over = true;
        setTimeout( () => delete games[obj.gid], 60000 );
        break;
      }
    }
  });
  socket.on("close", () => {
    delete sockets[sid];
    for (const [key, value] of Object.entries(challenges)) {
      if (value.sid == sid) {
        delete challenges[key];
        break; //only one challenge per player
      }
    }
  });
});

const interval = setInterval(() => {
  wss.clients.forEach((ws) => {
    if (ws.isAlive === false) return ws.terminate();
    ws.isAlive = false;
    ws.ping();
  });
}, 30000);
wss.on('close', () => clearInterval(interval));
Commit	Line	Data
41534b92 BA	1	const params = require("./parameters.js");
	2	const WebSocket = require('ws');
	3	const wss = new WebSocket.Server(
	4	{port: params.socket_port, path: params.socket_path});
	5
	6	let challenges = {}; //variantName --> socketId, name
	7	let games = {}; //gameId --> gameInfo (vname, fen, players, options)
	8	let sockets = {}; //socketId --> socket
8a9f61ce BA	9	let sendmoveTimeout1 = {},
	10	sendmoveTimeout2 = {},
	11	sendmoveRetry = {},
	12	stopRetry = {};
41534b92 BA	13	const variants = require("./variants.js");
41534b92 BA	14
8a9f61ce BA	15	const clearTrySendMove = (gid) => {
	16	clearTimeout(sendmoveTimeout1[gid]);
	17	clearTimeout(sendmoveTimeout2[gid]);
	18	clearInterval(sendmoveRetry[gid]);
	19	clearTimeout(stopRetry[gid]);
	20	};
	21
41534b92 BA	22	const send = (sid, code, data) => {
	23	const socket = sockets[sid];
	24	// If a player delete local infos and then try to resume a game,
	25	// sockets[oppSid] will probably not exist anymore:
	26	if (socket) socket.send(JSON.stringify(Object.assign({ code: code }, data)));
	27	}
	28
	29	const Crypto = require('crypto')
	30	function randomString(size = 8) {
	31	return Crypto.randomBytes(size).toString('hex').slice(0, size);
	32	}
	33
	34	wss.on('connection', function connection(socket, req) {
	35	const sid = req.url.split("=")[1]; //...?sid=...
	36	sockets[sid] = socket;
	37	socket.isAlive = true;
	38	socket.on('pong', () => socket.isAlive = true);
	39
	40	function launchGame(vname, players, options) {
	41	const gid = randomString(8);
	42	games[gid] = {
	43	vname: vname,
	44	players: players.map(p => {
	45	return (!p ? null : {sid: p.sid, name: p.name});
	46	}),
	47	options: options
	48	};
	49	if (players.every(p => p)) {
	50	const gameInfo = Object.assign(
	51	// Provide seed so that both players initialize with same FEN
	52	{seed: Math.floor(Math.random() * 1984), gid: gid},
	53	games[gid]);
	54	for (let i of [0, 1]) {
	55	send(players[i].sid, "gamestart",
	56	Object.assign({randvar: players[i].randvar}, gameInfo));
	57	}
	58	}
	59	else {
	60	// Incomplete players array: do not start game yet
	61	send(sid, "gamecreated", {gid: gid});
	62	// If nobody joins within a minute, delete game
	63	setTimeout(
	64	() => {
	65	if (games[gid] && games[gid].players.some(p => !p))
	66	delete games[gid];
	67	},
	68	60000
	69	);
	70	}
	71	}
	72
	73	socket.on('message', (msg) => {
	74	const obj = JSON.parse(msg);
	75	switch (obj.code) {
	76	// Send challenge (may trigger game creation)
	77	case "seekgame": {
	78	// Only one challenge per player:
	79	if (Object.keys(challenges).some(k => challenges[k].sid == sid))
	80	return;
	81	let opponent = undefined,
	82	choice = undefined;
	83	const vname = obj.vname,
	84	randvar = (obj.vname == "_random");
	85	if (vname == "_random") {
86	// Pick any current challenge if any
87	const currentChalls = Object.keys(challenges);
88	if (currentChalls.length >= 1) {
89	choice =
90	currentChalls[Math.floor(Math.random() * currentChalls.length)];
91	opponent = challenges[choice];
92	}
93	}
94	else if (challenges[vname]) {
95	opponent = challenges[vname];
96	choice = vname;
97	}
98	if (opponent) {
99	delete challenges[choice];
100	if (choice == "_random") {
101	// Pick a variant at random in the list
102	const index = Math.floor(Math.random() * variants.length);
103	choice = variants[index].name;
104	}
105	// Launch game
106	let players = [
107	{sid: sid, name: obj.name, randvar: randvar},
108	opponent
109	];
110	if (Math.random() < 0.5) players = players.reverse();
111	launchGame(choice, players, {}); //empty options => default
112	}
113	else
114	// Place challenge and wait. 'randvar' indicate if we play anything
115	challenges[vname] = {sid: sid, name: obj.name, randvar: randvar};
116	break;
117	}
118	// Set FEN after game was created
119	case "setfen":
120	games[obj.gid].fen = obj.fen;
121	break;
122	// Send back game informations
123	case "getgame": {
124	if (!games[obj.gid]) send(sid, "nogame");
125	else send(sid, "gameinfo", games[obj.gid]);
126	break;
127	}
128	// Cancel challenge
129	case "cancelseek":
130	delete challenges[obj.vname];
131	break;
132	// Receive rematch
8a9f61ce	133	case "rematch":
41534b92 BA	134	if (!games[obj.gid]) send(sid, "closerematch");
	135	else {
	136	const myIndex = (games[obj.gid].players[0].sid == sid ? 0 : 1);
	137	if (!games[obj.gid].rematch) games[obj.gid].rematch = [false, false];
	138	games[obj.gid].rematch[myIndex] = true;
	139	if (games[obj.gid].rematch[1-myIndex]) {
	140	// Launch new game, colors reversed
	141	launchGame(games[obj.gid].vname,
	142	games[obj.gid].players.reverse(),
	143	games[obj.gid].options);
	144	}
	145	}
	146	break;
8a9f61ce BA	147	// Rematch cancellation
8a9f61ce BA	148	case "norematch":
41534b92 BA	149	if (games[obj.gid]) {
	150	const myIndex = (games[obj.gid].players[0].sid == sid ? 0 : 1);
	151	send(games[obj.gid].players[1-myIndex].sid, "closerematch");
	152	}
	153	break;
41534b92	154	// Create game vs. friend
8a9f61ce	155	case "creategame": {
41534b92 BA	156	let players = [
	157	{ sid: obj.player.sid, name: obj.player.name },
	158	undefined
	159	];
	160	if (
	161	obj.player.color == 'b' \|\|
	162	(obj.player.color == '' && Math.random() < 0.5)
	163	) {
	164	players = players.reverse();
	165	}
	166	launchGame(obj.vname, players, obj.options);
	167	break;
8a9f61ce	168	}
41534b92	169	// Join game vs. friend
8a9f61ce	170	case "joingame":
41534b92 BA	171	if (!games[obj.gid]) send(sid, "jointoolate");
	172	else {
	173	// Join a game (started by some other player)
	174	const emptySlot = games[obj.gid].players.findIndex(p => !p);
	175	if (emptySlot < 0) send(sid, "jointoolate");
	176	games[obj.gid].players[emptySlot] = {sid: sid, name: obj.name};
	177	const gameInfo = Object.assign(
	178	// Provide seed so that both players initialize with same FEN
	179	{seed: Math.floor(Math.random()*1984), gid: obj.gid},
	180	games[obj.gid]);
	181	for (let i of [0, 1])
	182	send(games[obj.gid].players[i].sid, "gamestart", gameInfo);
	183	}
	184	break;
41534b92	185	// Relay a move + update games object
8a9f61ce BA	186	case "newmove":
	187	// If already received this move: skip
	188	if (games[obj.gid].fen == obj.fen) break;
	189	// Notify sender that the move is received:
	190	send(sid, "gotmove", {fen: obj.fen});
41534b92 BA	191	games[obj.gid].fen = obj.fen;
	192	const playingWhite = (games[obj.gid].players[0].sid == sid);
	193	const oppSid = games[obj.gid].players[playingWhite ? 1 : 0].sid;
8a9f61ce BA	194	const sendMove =
	195	// NOTE: sending FEN also, to check it in "gotmove" below
	196	() => send(oppSid, "newmove", {moves: obj.moves, fen: obj.fen});
	197	sendMove();
	198	sendmoveTimeout1[obj.gid] = setTimeout(sendMove, 500);
	199	sendmoveTimeout2[obj.gid] = setTimeout(sendMove, 1500);
	200	sendmoveRetry[obj.gid] = setInterval(sendMove, 5000);
	201	stopRetry[obj.gid] = setTimeout(clearTrySendMove, 31000);
	202	break;
	203	case "gotmove":
	204	if (games[obj.gid].fen == obj.fen) clearTrySendMove(obj.gid);
41534b92	205	break;
41534b92 BA	206	// Relay "game ends" message
	207	case "gameover": {
	208	const playingWhite = (games[obj.gid].players[0].sid == sid);
	209	const oppSid = games[obj.gid].players[playingWhite ? 1 : 0].sid;
	210	if (obj.relay) send(oppSid, "gameover", { gid: obj.gid });
	211	games[obj.gid].over = true;
	212	setTimeout( () => delete games[obj.gid], 60000 );
	213	break;
	214	}
	215	}
	216	});
	217	socket.on("close", () => {
	218	delete sockets[sid];
	219	for (const [key, value] of Object.entries(challenges)) {
	220	if (value.sid == sid) {
	221	delete challenges[key];
	222	break; //only one challenge per player
	223	}
	224	}
	225	});
	226	});
	227
	228	const interval = setInterval(() => {
	229	wss.clients.forEach((ws) => {
	230	if (ws.isAlive === false) return ws.terminate();
	231	ws.isAlive = false;
	232	ws.ping();
	233	});
	234	}, 30000);
	235	wss.on('close', () => clearInterval(interval));