sam-ecs/dist/ServerManager.js

A specialized entity component system

'use strict';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

//ServerManager.js//

/**
 * @description - Specialized manager for use with the server
 * @author - Sam Faulkner
 */

//user imports
var Manager = require('./Manager.js');

var ServerManager = function (_Manager) {
  _inherits(ServerManager, _Manager);

  function ServerManager() {
    _classCallCheck(this, ServerManager);

    var _this2 = _possibleConstructorReturn(this, (ServerManager.__proto__ || Object.getPrototypeOf(ServerManager)).call(this));

    _this2._clients = {};
    _this2._maxBufferSize = 8;
    return _this2;
  }

  _createClass(ServerManager, [{
    key: 'addClient',
    value: function addClient(id, socket) {
      this._clients[id] = {
        'socket': socket,
        'lastAcknowledgedState': -1,
        'ready': true
      };

      var _this = this;
      socket.on('BUFFER', function (num) {
        _this._clients[id].bufferSize = num;
        if (num < _this._maxBufferSize) {
          _this._maxBufferSize = num;
        }
      });
      socket.on('EVENT', function (event) {
        _this._eventManager.emit(event.type, Object.assign(event, { 'sid': id }));
      });
      socket.on('ACKNOWLEDGE', function (data) {
        _this._clients[id].ready = true;
        _this._clients[id].lastAcknowledgedState = data.tick;
      });

      socket.emit('CONNECTION');
    }
  }, {
    key: 'getClient',
    value: function getClient(id) {
      return this._clients[id];
    }
  }, {
    key: 'update',
    value: function update() {
      _get(ServerManager.prototype.__proto__ || Object.getPrototypeOf(ServerManager.prototype), 'update', this).call(this);

      for (var clientID in this._clients) {
        var clientObject = this._clients[clientID];
        if (this._currentTick >= clientObject.lastAcknowledgedState + clientObject.bufferSize) {
          this.sendStateUpdate(clientID);
          continue;
        }
        var oldStateObject = this._stateManager.getBufferedState(clientObject.lastAcknowledgedState);
        if (oldStateObject) {
          var oldState = oldStateObject.state;
          var deltaState = this._stateManager.getDeltaState(oldState);
          //there have been changes
          if (deltaState.length > 0) {
            this.sendStateUpdate(clientID, deltaState);
          }
        }
        // send the client state for sure
        else {
            this.sendStateUpdate(clientID);
          }
      }

      this._currentTick++;
    }

    /** 
     * @description - This function is responsible for sending a particular client an update
     * in state
     * @param {String} clientID - the ID of the client within the _clients
     * @param {Dict} deltaState - an optional parameter for the new state to send
     * to the client
     */

  }, {
    key: 'sendStateUpdate',
    value: function sendStateUpdate(clientID, deltaState) {
      //not going to check if this is valid here because it should be
      var clientObject = this._clients[clientID];
      if (!clientObject.ready) {
        return;
      }
      var state = deltaState;
      if (!state) {
        var oldStateObject = this._stateManager.getBufferedState(clientObject.lastAcknowledgedState);
        if (oldStateObject) {
          state = this._stateManager.getDeltaState(oldStateObject.state);
        } else {
          state = this._stateManager.getSubState();
        }
      }

      this._clients[clientID].ready = false;
      this._clients[clientID].socket.emit('UPDATE', {
        'tick': this._currentTick,
        'state': this._stateManager._serializeState(state)
      });
    }
  }]);

  return ServerManager;
}(Manager);

module.exports = ServerManager;