docs: function Game(node) {
  
          this.node = node;
  
          // This updates are never published.
          this.setStateLevel(constants.stateLevels.UNINITIALIZED, 'S');
          this.setStageLevel(constants.stageLevels.UNINITIALIZED, 'S');
  
          // ## Properties
  
          /**
           * ### Game.metadata
           *
           * The game's metadata
           *
           * This object is normally filled-in automatically with data
           * from the file `package.json` inside the game folder.
           *
           * Contains at least the following properties:
           *
           *  - name,
           *  - description,
           *  - version
           */
          this.metadata = {
              name:        'A nodeGame game',
              description: 'No description',
              version:     '0.0.1'
          };
  
          /**
           * ### Game.settings
           *
           * The game's settings
           *
           * This object is normally filled-in automatically with the settings
           * contained in the game folder: `game/game.settings`,
           * depending also on the chosen treatment.
           */
          this.settings = {};
  
          /**
           * ### Game.pl | playerList
           *
           * The list of players connected to the game
           *
           * The list may be empty, depending on the server settings.
           *
           * Two players with the same id, or any player with id equal to
           * `node.player.id` is not allowed, and it will throw an error.
           */
          this.playerList = this.pl = new PlayerList({
              log: this.node.log,
              logCtx: this.node,
              name: 'pl_' + this.node.nodename
          });
  
          this.pl.on('insert', function(p) {
              if (p.id === node.player.id) {
                  throw new Error('node.game.pl.on.insert: cannot add player ' +
                                  'with id equal to node.player.id.');
              }
          });
  
          /**
           * ### Game.ml | monitorList
           *
           * The list of monitor clients connected to the game
           *
           * The list may be empty, depending on the server settings
           */
          this.monitorList = this.ml = new PlayerList({
              log: this.node.log,
              logCtx: this.node,
              name: 'ml_' + this.node.nodename
          });
  
          /**
           * ### Game.memory
           *
           * A storage database for the game
           *
           * In the server logic the content of SET messages are
           * automatically inserted in this object
           *
           * @see NodeGameClient.set
           */
          this.memory = new GameDB({
              log: this.node.log,
              logCtx: this.node,
              shared: { node: this.node }
          });
  
          /**
           * ### Game.plot
           *
           * The Game plot
           *
           * @see GamePlot
           */
          this.plot = new GamePlot(this.node, new Stager());
  
  // TODO: check if we need this.
  //        // Overriding stdout for game plot and stager.
  //        this.plot.setDefaultLog(function() {
  //            // Must use apply, else will be executed in the wrong context.
  //            node.log.apply(node, arguments);
  //        });
  
          /**
           * ### Game.role
           *
           * The "role" currently held in this game (if any)
           *
           * @see Game.gotoStep
           * @see Game.setRole
           * @see processGotoStepOptions
           */
          this.role = null;
  
          /**
           * ### Game.partner
           *
           * The id or alias of the "partner" in this game (if any)
           *
           * Some games are played in pairs, this variable holds the id
           * of the partner player.
           *
           * @see Game.setPartner
           * @see processGotoStepOptions
           */
          this.partner = null;
  
          /**
           * ### Game.matcher
           *
           * Handles assigning matching tasks
           *
           * Assigns roles to players, players to players, etc.
           *
           * @see Game.gotoStep
           */
          this.matcher = MatcherManager ? new MatcherManager(this.node) : null;
  
          /**
           * ### Game.timer
           *
           * Default game timer synced with stager 'timer' property
           *
           * @see GameTimer
           * @see GameTimer.syncWithStager
           */
          this.timer = this.node.timer.createTimer({
              name: 'game_timer',
              stagerSync: true
          });
  
  
  
          // Setting to stage 0.0.0 and starting.
          this.setCurrentGameStage(new GameStage(), 'S');
          this.setStateLevel(constants.stateLevels.STARTING, 'S');
  
          /**
           * ### Game.paused
           *
           * TRUE, if the game is paused
           *
           * @see Game.pause
           * @see Game.resume
           */
          this.paused = false;
  
          /**
           * ### Game.pauseCounter
           *
           * Counts the number of times the game was paused
           *
           * @see Game.pause
           * @see Game.resume
           */
          this.pauseCounter = 0;
  
          /**
           * ### Game.willBeDone
           *
           * TRUE, if DONE was emitted and evaluated successfully
           *
           * If TRUE, when PLAYING is emitted `node.done` is called
           * immediately, and the game tries to step forward.
           *
           * @see NodeGameClient.done
           */
          this.willBeDone = false;
  
          /**
           * ### Game.globals
           *
           * Object pointing to the current step _globals_ properties
           *
           * Whenever a new step is executed the _globals_ properties of
           * the step are copied here. The _globals_ properties of the previous
           * stage are deleted.
           *
           * @see GamePlot
           * @see Stager
           */
          this.globals = {};
  
          /**
           * ### Game._steppedSteps
           *
           * Array of steps previously played
           *
           * @see Game.step
           */
          this._steppedSteps = [ new GameStage() ];
  
          /**
           * ### Game._breakStage
           *
           * Flags to break current stage at next node.done call
           *
           * @see Game.breakStage
           */
          this._breakStage = false;
  
          /** ### Game.pushManager
           *
           * Handles pushing client to advance to next step
           *
           * @see PushManager
           */
          this.pushManager = new PushManager(this.node);
  
          /** ### Game.sizeManager
           *
           * Handles changes in the number of connected players
           *
           * @see SizeManager
           */
          this.sizeManager = new SizeManager(this.node);
      }