game/tictactoe: Expand player to include a team property

[lmno-server] / game.js

/* A single player can have multiple connections, (think, multiple
 * browser windows with a common session cookie). */
class Player {
  constructor(id, session_id, name, connection) {
    this.id = id;
    this.session_id = session_id;
    this.name = name;
    this.connections = [connection];
    this.team = "";
  }

  add_connection(connection) {
    /* Don't add a duplicate connection if this player already has it. */
    for (let c of this.connections) {
      if (c === connection)
        return;
    }

    this.connections.push(connection);
  }

  /* Returns the number of remaining connections after this one is removed. */
  remove_connection(connection) {
    this.connections.filter(c => c !== connection);
    return this.connections.length;
  }

  /* Send a string to all connections for this player. */
  send(data) {
    this.connections.forEach(connection => connection.write(data));
  }

  info_json() {
    return JSON.stringify({
      id: this.id,
      name: this.name,
      team: this.team
    });
  }
}

/* Base class providing common code for game engine implementations. */
class Game {
  constructor(id) {
    this.id = id;
    this.players = [];
    this.next_player_id = 1;
    this.teams = [];

    /* Send a comment to every connected client every 15 seconds. */
    setInterval(() => {this.broadcast_string(":");}, 15000);
  }

  /* Suport for game meta-data.
   *
   * What we want here is an effectively static field that is
   * accessible through either the class name (SomeGame.meta) or an
   * instance (some_game.meta). To pull this off we do keep two copies
   * of the data. But the game classes can just set SomeGame.meta once
   * and then reference it either way.
   */
  static set meta(data) {
    /* This allows class access (SomeGame.meta) via the get method below. */
    this._meta = data;

    /* While this allows access via an instance (some_game.meta). */
    this.prototype.meta = data;
  }

  static get meta() {
    return this._meta;
  }

  add_player(session, connection) {
    /* First see if we already have a player object for this session. */
    const existing_index = this.players.findIndex(
      player => player.session_id === session.id);
    if (existing_index >= 0) {
      const player = this.players[existing_index];
      player.add_connection(connection);
      return player;
    }

    /* No existing player. Add a new one. */
    const id = this.next_player_id;
    const player = new Player(id, session.id, session.nickname, connection);

    /* Broadcast before adding player to list (to avoid announcing the
     * new player to itself). */
    const player_data = JSON.stringify({ id: player.id, name: player.name });
    this.broadcast_event("player-enter", player_data);

    this.players.push(player);
    this.next_player_id++;

    return player;
  }

  find_player(session) {
    const existing_index = this.players.findIndex(
      player => player.session_id === session.id);
    if (existing_index >= 0)
      return this.players[existing_index];

    return null;
  }

  /* Drop a connection object from a player, and if it's the last one,
   * then drop that player from the game's list of players. */
  remove_player_connection(player, connection) {
    const remaining = player.remove_connection(connection);
    if (remaining === 0) {
      const player_data = JSON.stringify({ id: player.id });
      this.players.filter(p => p !== player);
      this.broadcast_event("player-exit", player_data);
    }
  }

  /* Send a string to all players */
  broadcast_string(str) {
    this.players.forEach(player => player.send(str + '\n'));
  }

  /* Send an event to all players.
   *
   * An event has both a declared type and a separate data block.
   * It also ends with two newlines (to mark the end of the event).
   */
  broadcast_event(type, data) {
    this.broadcast_string(`event: ${type}\ndata: ${data}\n`);
  }

  handle_events(request, response) {
    /* These headers will keep the connection open so we can stream events. */
    const headers = {
      "Content-type": "text/event-stream",
      "Connection": "keep-alive",
      "Cache-Control": "no-cache"
    };
    response.writeHead(200, headers);

    /* Add this new player. */
    const player = this.add_player(request.session, response);

    /* And queue up cleanup to be triggered on client close. */
    request.on('close', () => {
      this.remove_player_connection(player, response);
    });

    /* Give the client the game-info event. */
    const game_info_json = JSON.stringify({
      id: this.id,
      url: `${request.protocol}://${request.hostname}/${this.id}`
    });
    response.write(`event: game-info\ndata: ${game_info_json}\n\n`);

    /* And the player-info event. */
    response.write(`event: player-info\ndata: ${player.info_json()}\n\n`);

    /* Finally, if this game class has a "state" property, stream that
     * current state to the client. */
    if (this.state) {
      const state_json = JSON.stringify(this.state);
      response.write(`event: game-state\ndata: ${state_json}\n\n`);
    }
  }

  handle_player(request, response) {
    const player = this.find_player(request.session);
    const name = request.body.name;
    const team = request.body.team;
    var updated = false;
    if (! player) {
      response.sendStatus(404);
      return;
    }

    if (name && (player.name !== name)) {
      player.name = name;

      /* In addition to setting the name within this game's player
       * object, also set the name in the session. */
      request.session.nickname = name;
      request.session.save();

      updated = true;
    }

    if (team !== null && (player.team !== team) &&
        (team === "" || this.teams.includes(team)))
    {
      player.team = team;

      updated = true;
    }

    if (updated)
      this.broadcast_event("player-update", player.info_json());

    response.send("");
  }

  broadcast_move(move) {
    this.broadcast_event("move", move);
  }

}

module.exports = Game;