docs: function GameStage(gameStage) {
          var tokens, stageNum, stepNum, roundNum, err;
  
          // ## Public properties
  
          /**
           * ### GameStage.stage
           *
           * The N-th game-block (stage) in the game-plot currently being executed
           */
          this.stage = 0;
  
          /**
           * ### GameStage.step
           *
           * The N-th game-block (step) nested in the current stage
           */
          this.step = 0;
  
          /**
           * ### GameStage.round
           *
           * The number of times the current stage was repeated
           */
          this.round = 0;
  
          // String.
          if ('string' === typeof gameStage) {
              if (gameStage === '') {
                  throw new Error('GameStage constructor: gameStage name ' +
                                  'cannot be an empty string.');
              }
              if (gameStage.charAt(0) === '.') {
                  throw new Error('GameStage constructor: gameStage name ' +
                                  'cannot start with a dot. Name: ' + gameStage);
              }
  
              tokens = gameStage.split('.');
  
              stageNum = parseInt(tokens[0], 10);
              this.stage = !isNaN(stageNum) ? stageNum : tokens[0];
  
              if ('string' === typeof tokens[1]) {
                  if (!tokens[1].length) {
                      throw new Error('GameStage constructor: gameStage ' +
                                      'contains empty step: ' + gameStage);
                  }
                  stepNum = parseInt(tokens[1], 10);
                  this.step = !isNaN(stepNum) ? stepNum : tokens[1];
              }
              else if (this.stage !== 0) {
                  this.step = 1;
              }
              if ('string' === typeof tokens[2]) {
                  if (!tokens[2].length) {
                      throw new Error('GameStage constructor: gameStage ' +
                                      'contains empty round: ' + gameStage);
                  }
                  roundNum = parseInt(tokens[2], 10);
                  this.round = roundNum;
              }
              else if (this.stage !== 0) {
                  this.round = 1;
              }
          }
          // Not null object.
          else if (gameStage && 'object' === typeof gameStage) {
              this.stage = gameStage.stage;
              this.step = 'undefined' !== typeof gameStage.step ?
                  gameStage.step : this.stage === 0 ? 0 : 1;
              this.round = 'undefined' !== typeof gameStage.round ?
                  gameStage.round : this.stage === 0 ? 0 : 1;
          }
          // Number.
          else if ('number' === typeof gameStage) {
              if (gameStage % 1 !== 0) {
                 throw new TypeError('GameStage constructor: gameStage ' +
                                     'cannot be a non-integer number. Found: ' +
                                     gameStage);
              }
              this.stage = gameStage;
              if (this.stage === 0) {
                  this.step = 0;
                  this.round = 0;
              }
              else {
                  this.step = 1;
                  this.round = 1;
              }
          }
          // Defaults or error.
          else if (gameStage !== null && 'undefined' !== typeof gameStage) {
              throw new TypeError('GameStage constructor: gameStage must be ' +
                                  'string, object, number, undefined, or null. ' +
                                  'Found: ' + gameStage);
          }
  
          // At this point we must have positive numbers, or strings for step
          // and stage, round can be only a positive number, or 0.0.0.
          if ('number' === typeof this.stage) {
              if (this.stage < 0) err = 'stage';
          }
          else if ('string' !== typeof this.stage) {
              throw new Error('GameStage constructor: gameStage.stage must be ' +
                              'number or string: ' + typeof this.stage);
          }
  
          if ('number' === typeof this.step) {
              if (this.step < 0) err = err ? err + ', step' : 'step';
          }
          else if ('string' !== typeof this.step) {
              throw new Error('GameStage constructor: gameStage.step must be ' +
                              'number or string: ' + typeof this.step);
          }
  
          if ('number' === typeof this.round) {
              if (this.round < 0) err = err ? err + ', round' : 'round';
          }
          else {
              throw new Error('GameStage constructor: gameStage.round must ' +
                              'be number. Found: ' + this.round);
          }
  
          if (err) {
              throw new TypeError('GameStage constructor: ' + err + ' field/s ' +
                                  'contain/s negative numbers.');
          }
  
          // Either 0.0.0 or no 0 is allowed.
          if (!(this.stage === 0 && this.step === 0 && this.round === 0)) {
              if (this.stage === 0 || this.step === 0 || this.round === 0) {
                  throw new Error('GameStage constructor: malformed game ' +
                                  'stage: ' + this.toString());
              }
          }
      }