var Component_MessageTextRenderer,
  extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  hasProp = {}.hasOwnProperty;

Component_MessageTextRenderer = (function(superClass) {
  extend(Component_MessageTextRenderer, superClass);

  Component_MessageTextRenderer.objectCodecBlackList = ["onLinkClick", "onBatchDisappear"];


  /**
  * Called if this object instance is restored from a data-bundle. It can be used
  * re-assign event-handler, anonymous functions, etc.
  * x
  * @method onDataBundleRestore.
  * @param Object data - The data-bundle
  * @param gs.ObjectCodecContext context - The codec-context.
   */

  Component_MessageTextRenderer.prototype.onDataBundleRestore = function(data, context) {
    var bitmap, customObject, j, l, len, len1, len2, line, m, message, n, ref, ref1, ref2;
    this.setupEventHandlers();
    l = 0;
    ref = this.object.messages;
    for (j = 0, len = ref.length; j < len; j++) {
      message = ref[j];
      if (this.object.settings.useCharacterColor) {
        this.object.font.color = new gs.Color(message.character.textColor);
      }
      this.lines = this.calculateLines(lcsm(message.text), true, 0);
      ref1 = this.lines;
      for (m = 0, len1 = ref1.length; m < len1; m++) {
        line = ref1[m];
        bitmap = this.createBitmap(line);
        if (line === this.line) {
          this.drawLineContent(line, bitmap, this.charIndex + 1);
        } else {
          this.drawLineContent(line, bitmap, -1);
        }
        this.allSprites[l].bitmap = bitmap;
        l++;
      }
    }
    ref2 = this.customObjects;
    for (n = 0, len2 = ref2.length; n < len2; n++) {
      customObject = ref2[n];
      SceneManager.scene.addObject(customObject);
    }
    return null;
  };


  /**
  *  A text-renderer component to render an animated and interactive message text using
  *  dimensions of the game object's destination-rectangle. The message is displayed
  *  using a sprite for each line instead of drawing to the game object's bitmap object.
  *
  *  @module gs
  *  @class Component_MessageTextRenderer
  *  @extends gs.Component_TextRenderer
  *  @memberof gs
  *  @constructor
   */

  function Component_MessageTextRenderer() {
    Component_MessageTextRenderer.__super__.constructor.apply(this, arguments);

    /**
    * An array containing all sprites of the current message.
    * @property sprites
    * @type gs.Sprite[]
    * @protected
     */
    this.sprites = [];

    /**
    * An array containing all sprites of all messages. In NVL mode
    * a page can contain multiple messages.
    * @property allSprites
    * @type gs.Sprite[]
    * @protected
     */
    this.allSprites = [];

    /**
    * An array containing all line-objects of the current message.
    * @property lines
    * @type gs.TextRendererLine[]
    * @readOnly
     */
    this.lines = null;

    /**
    * The line currently rendered.
    * @property line
    * @type number
    * @readOnly
     */
    this.line = 0;

    /**
    * The left and right padding per line.
    * @property padding
    * @type number
     */
    this.padding = 6;

    /**
    * The minimum height of the line currently rendered. If 0, the measured
    * height of the line will be used.
    * @property minLineHeight
    * @type number
     */
    this.minLineHeight = 0;

    /**
    * The spacing between text lines in pixels.
    * @property lineSpacing
    * @type number
     */
    this.lineSpacing = 2;

    /**
    * The line currently rendered.
    * @property currentLine
    * @type number
    * @protected
     */
    this.currentLine = 0;

    /**
    * The height of the line currently rendered.
    * @property currentLineHeight
    * @type number
    * @protected
     */
    this.currentLineHeight = 0;

    /**
    * Index of the current character to draw.
    * @property charIndex
    * @type number
    * @readOnly
     */
    this.charIndex = 0;

    /**
    * Position of the message caret. The caret is like an invisible
    * cursor pointing to the x/y coordinates of the last rendered character of
    * the message. That position can be used to display a waiting- or processing-animation for example.
    * @property caretPosition
    * @type gs.Point
    * @readOnly
     */
    this.caretPosition = new gs.Point();

    /**
    * Indicates that the a message is currently in progress.
    * @property isRunning
    * @type boolean
    * @readOnly
     */
    this.isRunning = false;

    /**
    * The current x-coordinate of the caret/cursor.
    * @property currentX
    * @type number
    * @readOnly
     */
    this.currentX = 0;

    /**
    * The current y-coordinate of the caret/cursor.
    * @property currentY
    * @type number
    * @readOnly
     */
    this.currentY = 0;

    /**
    * The current sprites used to display the current text-line/part.
    * @property currentSprite
    * @type gs.Sprite
    * @readOnly
     */
    this.currentSprite = null;

    /**
    * Indicates if the message-renderer is currently waiting like for a user-action.
    * @property isWaiting
    * @type boolean
    * @readOnly
     */
    this.isWaiting = false;

    /**
    * Indicates if the message-renderer is currently waiting for a key-press or mouse/touch action.
    * @property waitForKey
    * @type boolean
    * @readOnly
     */
    this.waitForKey = false;

    /**
    * Number of frames the message-renderer should wait before continue.
    * @property waitCounter
    * @type number
     */
    this.waitCounter = 0;

    /**
    * Speed of the message-drawing. The smaller the value, the faster the message is displayed.
    * @property speed
    * @type number
     */
    this.speed = 1;

    /**
    * Indicates if the message should be rendered immedialtely without any animation or delay.
    * @property drawImmediately
    * @type boolean
     */
    this.drawImmediately = false;

    /**
    * Indicates if the message should wait for a user-action or a certain amount of time
    * before finishing.
    * @property waitAtEnd
    * @type boolean
     */
    this.waitAtEnd = true;

    /**
    * The number of frames to wait before finishing a message.
    * before finishing.
    * @property waitAtEndTime
    * @type number
     */
    this.waitAtEndTime = 0;

    /**
    * Indicates if auto word-wrap should be used. Default is <b>true</b>
    * @property wordWrap
    * @type boolean
     */
    this.wordWrap = true;

    /**
    * Custom game objects which are alive until the current message is erased. Can be used to display
    * animated icons, etc.
    * @property customObjects
    * @type gs.Object_Base[]
     */
    this.customObjects = [];

    /**
    * A hashtable/dictionary object to store custom-data useful like for token-processing. The data must be
    * serializable.
    * @property customObjects
    * @type Object
     */
    this.customData = {};

    /**
    * A callback function called if the player clicks on a non-stylable link (LK text-code) to trigger
    * the specified common event.
    * @property onLinkClick
    * @type Function
     */
    this.onLinkClick = function(e) {
      var event, eventId;
      eventId = e.data.linkData.commonEventId;
      event = RecordManager.commonEvents[eventId];
      if (!event) {
        event = RecordManager.commonEvents.first((function(_this) {
          return function(x) {
            return x.name === eventId;
          };
        })(this));
        if (event) {
          eventId = event.index;
        }
      }
      if (!event) {
        return SceneManager.scene.interpreter.jumpToLabel(eventId);
      } else {
        return SceneManager.scene.interpreter.callCommonEvent(eventId, null, true);
      }
    };

    /**
    * A callback function called if a batched messsage has been faded out. It triggers the execution of
    * the next message.
    * @property onBatchDisappear
    * @type Function
     */
    this.onBatchDisappear = (function(_this) {
      return function(e) {
        _this.drawImmediately = false;
        _this.isWaiting = false;
        _this.object.opacity = 255;
        return _this.executeBatch();
      };
    })(this);
  }


  /**
  * Serializes the message text-renderer into a data-bundle.
  * @method toDataBundle
  * @return {Object} A data-bundle.
   */

  Component_MessageTextRenderer.prototype.toDataBundle = function() {
    var bundle, ignore, k;
    ignore = ["object", "font", "sprites", "allSprites", "currentSprite", "currentX"];
    bundle = {
      currentSpriteIndex: this.sprites.indexOf(this.currentSprite)
    };
    for (k in this) {
      if (ignore.indexOf(k) === -1) {
        bundle[k] = this[k];
      }
    }
    return bundle;
  };


  /**
  * Disposes the message text-renderer and all sprites used to display
  * the message.
  * @method dispose
   */

  Component_MessageTextRenderer.prototype.dispose = function() {
    var j, len, ref, ref1, results, sprite;
    Component_MessageTextRenderer.__super__.dispose.apply(this, arguments);
    this.disposeEventHandlers();
    ref = this.allSprites;
    results = [];
    for (j = 0, len = ref.length; j < len; j++) {
      sprite = ref[j];
      if ((ref1 = sprite.bitmap) != null) {
        ref1.dispose();
      }
      results.push(sprite.dispose());
    }
    return results;
  };


  /**
  * Removes all attached event handlers 
  * the message.
  * @method disposeEventHandlers
   */

  Component_MessageTextRenderer.prototype.disposeEventHandlers = function() {
    gs.GlobalEventManager.offByOwner("mouseUp", this.object);
    return gs.GlobalEventManager.offByOwner("keyUp", this.object);
  };


  /**
  * Adds event-handlers for mouse/touch events
  *
  * @method setupEventHandlers
   */

  Component_MessageTextRenderer.prototype.setupEventHandlers = function() {
    gs.GlobalEventManager.offByOwner("mouseUp", this.object);
    gs.GlobalEventManager.offByOwner("keyUp", this.object);
    gs.GlobalEventManager.on("mouseUp", ((function(_this) {
      return function(e) {
        if (_this.object.findComponentByName("animation") || (GameManager.settings.autoMessage.enabled && !GameManager.settings.autoMessage.stopOnAction)) {
          return;
        }
        if (_this.isWaiting && !(_this.waitCounter > 0 || _this.waitForKey)) {
          e.breakChain = true;
          _this["continue"]();
        } else {
          e.breakChain = _this.isRunning;
          _this.drawImmediately = !_this.waitForKey;
          _this.waitCounter = 0;
          _this.waitForKey = false;
          _this.isWaiting = false;
        }
        if (_this.waitForKey) {
          if (Input.Mouse.buttons[Input.Mouse.LEFT] === 2) {
            e.breakChain = true;
            Input.clear();
            _this.waitForKey = false;
            return _this.isWaiting = false;
          }
        }
      };
    })(this)), null, this.object);
    return gs.GlobalEventManager.on("keyUp", ((function(_this) {
      return function(e) {
        if (Input.keys[Input.C] && (!_this.isWaiting || (_this.waitCounter > 0 || _this.waitForKey))) {
          _this.drawImmediately = !_this.waitForKey;
          _this.waitCounter = 0;
          _this.waitForKey = false;
          _this.isWaiting = false;
        }
        if (_this.isWaiting && !_this.waitForKey && !_this.waitCounter && Input.keys[Input.C]) {
          _this["continue"]();
        }
        if (_this.waitForKey) {
          if (Input.keys[Input.C]) {
            Input.clear();
            _this.waitForKey = false;
            return _this.isWaiting = false;
          }
        }
      };
    })(this)), null, this.object);
  };


  /**
  * Sets up the renderer. Registers necessary event handlers.
  * @method setup
   */

  Component_MessageTextRenderer.prototype.setup = function() {
    return this.setupEventHandlers();
  };


  /**
  * Restores the message text-renderer's state from a data-bundle.
  * @method restore
  * @param {Object} bundle - A data-bundle containing message text-renderer state.
   */

  Component_MessageTextRenderer.prototype.restore = function(bundle) {
    var k;
    for (k in bundle) {
      if (k === "currentSpriteIndex") {
        this.currentSprite = this.sprites[bundle.currentSpriteIndex];
      } else {
        this[k] = bundle[k];
      }
    }
    if (this.sprites.length > 0) {
      this.currentY = this.sprites.last().y - this.object.origin.y - this.object.dstRect.y;
      this.line = this.maxLines;
      this.isWaiting = this.isWaiting || this.isRunning;
    }
    return null;
  };


  /**
  * Continues message-processing if currently waiting.
  * @method continue
   */

  Component_MessageTextRenderer.prototype["continue"] = function() {
    var duration, fading, ref, ref1;
    this.isWaiting = false;
    if (this.line >= this.lines.length) {
      this.isRunning = false;
      return (ref = this.object.events) != null ? ref.emit("messageFinish", this) : void 0;
    } else {
      if ((ref1 = this.object.events) != null) {
        ref1.emit("messageBatch", this);
      }
      fading = GameManager.tempSettings.messageFading;
      duration = GameManager.tempSettings.skip ? 0 : fading.duration;
      return this.object.animator.disappear(fading.animation, fading.easing, duration, gs.CallBack("onBatchDisappear", this));
    }
  };


  /**
  * Updates the text-renderer.
  * @method update
   */

  Component_MessageTextRenderer.prototype.update = function() {
    var j, len, len1, m, object, ref, ref1, ref2, sprite;
    ref = this.allSprites;
    for (j = 0, len = ref.length; j < len; j++) {
      sprite = ref[j];
      sprite.opacity = this.object.opacity;
      sprite.visible = this.object.visible;
      sprite.ox = -this.object.offset.x;
      sprite.oy = -this.object.offset.y;
      sprite.mask.value = this.object.mask.value;
      sprite.mask.vague = this.object.mask.vague;
      sprite.mask.source = this.object.mask.source;
      sprite.mask.type = this.object.mask.type;
    }
    ref1 = this.customObjects;
    for (m = 0, len1 = ref1.length; m < len1; m++) {
      object = ref1[m];
      object.opacity = this.object.opacity;
      object.visible = this.object.visible;
    }
    if (!this.isRunning && this.waitCounter > 0) {
      this.waitCounter--;
      if (this.waitCounter === 0) {
        this["continue"]();
      }
      return;
    }
    if (this.object.visible && ((ref2 = this.lines) != null ? ref2.length : void 0) > 0) {
      this.updateLineWriting();
      this.updateWaitForKey();
      this.updateWaitCounter();
      return this.updateCaretPosition();
    }
  };


  /**
  * Indicates if its a batched messages.
  *
  * @method isBatched
  * @return If <b>true</b> it is a batched message. Otherwise <b>false</b>.
   */

  Component_MessageTextRenderer.prototype.isBatched = function() {
    return this.lines.length > this.maxLines;
  };


  /**
  * Indicates if the batch is still in progress and not done.
  *
  * @method isBatchInProgress
  * @return If <b>true</b> the batched message is still not done. Otherwise <b>false</b>
   */

  Component_MessageTextRenderer.prototype.isBatchInProgress = function() {
    return this.lines.length - this.line > this.maxLines;
  };


  /**
  * Starts displaying the next page of text if a message is too long to fit
  * into one message box.
  *
  * @method executeBatch
   */

  Component_MessageTextRenderer.prototype.executeBatch = function() {
    this.clearAllSprites();
    this.lines = this.lines.slice(this.line);
    this.line = 0;
    this.currentX = 0;
    this.currentY = 0;
    this.currentLineHeight = 0;
    this.tokenIndex = 0;
    this.charIndex = 0;
    this.token = this.lines[this.line].content[this.tokenIndex] || new gs.RendererToken(null, "");
    this.maxLines = this.calculateMaxLines(this.lines);
    this.lineAnimationCount = this.speed;
    this.sprites = this.createSprites(this.lines);
    this.allSprites = this.allSprites.concat(this.sprites);
    this.currentSprite = this.sprites[this.line];
    this.currentSprite.x = this.currentX + this.object.origin.x + this.object.dstRect.x;
    return this.drawNext();
  };


  /**
  * Calculates the duration(in frames) the message-renderer needs to display
  * the message.
  *
  * @method calculateDuration
  * @return {number} The duration in frames.
   */

  Component_MessageTextRenderer.prototype.calculateDuration = function() {
    var duration, j, len, len1, line, m, ref, ref1, token;
    duration = 0;
    if (this.lines != null) {
      ref = this.lines;
      for (j = 0, len = ref.length; j < len; j++) {
        line = ref[j];
        ref1 = line.content;
        for (m = 0, len1 = ref1.length; m < len1; m++) {
          token = ref1[m];
          if (token != null) {
            duration += this.calculateDurationForToken(token);
          }
        }
      }
    }
    return duration;
  };


  /**
  * Calculates the duration(in frames) the message-renderer needs to display
  * the specified line.
  *
  * @method calculateDurationForLine
  * @param {gs.RendererTextLine} line The line to calculate the duration for.
  * @return {number} The duration in frames.
   */

  Component_MessageTextRenderer.prototype.calculateDurationForLine = function(line) {
    var duration, j, len, ref, token;
    duration = 0;
    if (line) {
      ref = line.content;
      for (j = 0, len = ref.length; j < len; j++) {
        token = ref[j];
        if (token != null) {
          duration += this.calculateDurationForToken(token);
        }
      }
    }
    return duration;
  };


  /**
  * Calculates the duration(in frames) the message-renderer needs to process
  * the specified token.
  *
  * @method calculateDurationForToken
  * @param {string|Object} token - The token.
  * @return {number} The duration in frames.
   */

  Component_MessageTextRenderer.prototype.calculateDurationForToken = function(token) {
    var duration;
    duration = 0;
    if (token.code != null) {
      switch (token.code) {
        case "W":
          if (token.value !== "A") {
            duration = token.value / 1000 * Graphics.frameRate;
          }
      }
    } else {
      duration = token.value.length * this.speed;
    }
    return duration;
  };


  /**
  * Calculates the maximum of lines which can be displayed in one message.
  *
  * @method calculateMaxLines
  * @param {Array} lines - An array of line-objects.
  * @return {number} The number of displayable lines.
   */

  Component_MessageTextRenderer.prototype.calculateMaxLines = function(lines) {
    var height, j, len, line, result;
    height = 0;
    result = 0;
    for (j = 0, len = lines.length; j < len; j++) {
      line = lines[j];
      height += line.height + this.lineSpacing;
      if (this.currentY + height > this.object.dstRect.height) {
        break;
      }
      result++;
    }
    return Math.min(lines.length, result || 1);
  };


  /**
  * Displays the character or processes the next control-token.
  *
  * @method drawNext
   */

  Component_MessageTextRenderer.prototype.drawNext = function() {
    var lineSpacing, size, token;
    token = this.processToken();
    if ((token != null ? token.value.length : void 0) > 0) {
      this.char = this.token.value.charAt(this.charIndex);
      size = this.font.measureTextPlain(this.char);
      lineSpacing = this.lineSpacing;
      if (this.currentLine !== this.line) {
        this.currentLine = this.line;
        this.currentLineHeight = 0;
      }
      this.currentSprite.y = this.object.origin.y + this.object.dstRect.y + this.currentY;
      this.currentSprite.visible = true;
      this.drawLineContent(this.lines[this.line], this.currentSprite.bitmap, this.charIndex + 1);
      this.currentSprite.srcRect.width = this.currentSprite.bitmap.width;
      this.currentLineHeight = this.lines[this.line].height;
      return this.currentX = Math.min(this.lines[this.line].width, this.currentX + size.width);
    }
  };


  /**
  * Processes the next character/token of the message.
  * @method nextChar
  * @private
   */

  Component_MessageTextRenderer.prototype.nextChar = function() {
    var base, base1, results;
    results = [];
    while (true) {
      this.charIndex++;
      this.lineAnimationCount = this.speed;
      if ((this.token.code != null) || this.charIndex >= this.token.value.length) {
        if (typeof (base = this.token).onEnd === "function") {
          base.onEnd();
        }
        this.tokenIndex++;
        if (this.tokenIndex >= this.lines[this.line].content.length) {
          this.tokenIndex = 0;
          this.line++;
          this.currentSprite.srcRect.width = this.currentSprite.bitmap.width;
          this.currentSprite = this.sprites[this.line];
          if (this.currentSprite != null) {
            this.currentSprite.x = this.object.origin.x + this.object.dstRect.x;
          }
          if (this.line < this.maxLines) {
            this.currentY += (this.currentLineHeight || this.font.lineHeight) + this.lineSpacing * Graphics.scale;
            this.charIndex = 0;
            this.currentX = 0;
            this.token = this.lines[this.line].content[this.tokenIndex] || new gs.RendererToken(null, "");
          }
        } else {
          this.charIndex = 0;
          this.token = this.lines[this.line].content[this.tokenIndex] || new gs.RendererToken(null, "");
        }
        if (typeof (base1 = this.token).onStart === "function") {
          base1.onStart();
        }
      }
      if (!this.token || this.token.value !== "\n" || !this.lines[this.line]) {
        break;
      } else {
        results.push(void 0);
      }
    }
    return results;
  };


  /**
  * Finishes the message. Depending on the message configuration, the
  * message text-renderer will now wait for a user-action or a certain amount
  * of time.
  *
  * @method finish
   */

  Component_MessageTextRenderer.prototype.finish = function() {
    var ref, ref1, ref2;
    if (this.waitAtEnd) {
      this.isWaiting = true;
      return (ref = this.object.events) != null ? ref.emit("messageWaiting", this) : void 0;
    } else if (this.waitAtEndTime > 0) {
      this.waitCounter = this.waitAtEndTime;
      this.isWaiting = false;
      return (ref1 = this.object.events) != null ? ref1.emit("messageWaiting", this) : void 0;
    } else {
      if ((ref2 = this.object.events) != null) {
        ref2.emit("messageWaiting", this);
      }
      return this["continue"]();
    }
  };


  /**
  * Returns the position of the caret in pixels. The caret is like an invisible
  * cursor pointing to the x/y coordinates of the last rendered character of
  * the message. That position can be used to display a waiting- or processing-animation for example.
  *
  * @method updateCaretPosition
   */

  Component_MessageTextRenderer.prototype.updateCaretPosition = function() {
    this.caretPosition.x = this.currentX + this.padding;
    return this.caretPosition.y = this.currentY + this.currentLineHeight / 2;
  };


  /**
  * Updates the line writing.
  *
  * @method updateLineWriting
  * @private
   */

  Component_MessageTextRenderer.prototype.updateLineWriting = function() {
    if (this.isRunning && !this.isWaiting && !this.waitForKey && this.waitCounter <= 0) {
      if (this.lineAnimationCount <= 0) {
        while (true) {
          if (this.line < this.maxLines) {
            this.nextChar();
          }
          if (this.line >= this.maxLines) {
            this.finish();
          } else {
            this.drawNext();
          }
          if (!((this.token.code || this.lineAnimationCount <= 0 || this.drawImmediately) && !this.waitForKey && this.waitCounter <= 0 && this.isRunning && this.line < this.maxLines)) {
            break;
          }
        }
      }
      if (GameManager.tempSettings.skip) {
        return this.lineAnimationCount = 0;
      } else {
        return this.lineAnimationCount--;
      }
    }
  };


  /**
  * Updates wait-for-key state. If skipping is enabled, the text renderer will
  * not wait for key press.
  *
  * @method updateWaitForKey
  * @private
   */

  Component_MessageTextRenderer.prototype.updateWaitForKey = function() {
    if (this.waitForKey) {
      this.isWaiting = !GameManager.tempSettings.skip;
      return this.waitForKey = this.isWaiting;
    }
  };


  /**
  * Updates wait counter if the text renderer is waiting for a certain amount of time to pass. If skipping is enabled, the text renderer will
  * not wait for the actual amount of time and sets the wait-counter to 1 frame instead.
  *
  * @method updateWaitForKey
  * @private
   */

  Component_MessageTextRenderer.prototype.updateWaitCounter = function() {
    if (this.waitCounter > 0) {
      if (GameManager.tempSettings.skip) {
        this.waitCounter = 1;
      }
      this.isWaiting = true;
      this.waitCounter--;
      if (this.waitCounter <= 0) {
        this.isWaiting = false;
        if (this.line >= this.maxLines) {
          return this["continue"]();
        }
      }
    }
  };


  /**
  * Creates a token-object for a specified text-code.
  * 
  * @method createToken
  * @param {string} code - The code/type of the text-code.
  * @param {string} value - The value of the text-code.
  * @return {Object} The token-object.
   */

  Component_MessageTextRenderer.prototype.createToken = function(code, value) {
    var data, i, j, ref, tokenObject;
    tokenObject = null;
    switch (code) {
      case "CE":
        data = value.split("/");
        value = data.shift();
        value = isNaN(value) ? value : parseInt(value);
        for (i = j = 0, ref = data; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
          if (data[i].startsWith('"') && data[i].endsWith('"')) {
            data[i] = data[i].substring(1, data[i].length - 1);
          } else {
            data[i] = isNaN(data[i]) ? data[i] : parseFloat(data[i]);
          }
        }
        tokenObject = {
          code: code,
          value: value,
          values: data
        };
        break;
      default:
        tokenObject = Component_MessageTextRenderer.__super__.createToken.call(this, code, value);
    }
    return tokenObject;
  };


  /**
  * <p>Measures a control-token. If a token produces a visual result like displaying an icon then it must return the size taken by
  * the visual result. If the token has no visual result, <b>null</b> must be returned. This method is called for every token when the message is initialized.</p> 
  *
  * <p>This method is not called while the message is running. For that case, see <i>processControlToken</i> method which is called
  * for every token while the message is running.</p>
  *
  * @param {Object} token - A control-token.
  * @return {gs.Size} The size of the area taken by the visual result of the token or <b>null</b> if the token has no visual result.
  * @method analyzeControlToken
  * @protected
   */

  Component_MessageTextRenderer.prototype.measureControlToken = function(token) {
    return Component_MessageTextRenderer.__super__.measureControlToken.call(this, token);
  };


  /**
  * <p>Draws the visual result of a token, like an icon for example, to the specified bitmap. This method is called for every token when the message is initialized and the sprites for each
  * text-line are created.</p> 
  *
  * <p>This method is not called while the message is running. For that case, see <i>processControlToken</i> method which is called
  * for every token while the message is running.</p>
  *
  * @param {Object} token - A control-token.
  * @param {gs.Bitmap} bitmap - The bitmap used for the current text-line. Can be used to draw something on it like an icon, etc.
  * @param {number} offset - An x-offset for the draw-routine.
  * @param {number} length - Determines how many characters of the token should be drawn. Can be ignored for tokens
  * not drawing any characters.
  * @method drawControlToken
  * @protected
   */

  Component_MessageTextRenderer.prototype.drawControlToken = function(token, bitmap, offset, length) {
    var data, j, len, linkData, results;
    switch (token.code) {
      case "RT":
        return Component_MessageTextRenderer.__super__.drawControlToken.call(this, token, bitmap, offset, length);
      case "SLK":
        if (token.customData.offsetX == null) {
          token.customData.offsetX = offset;
        }
        if (this.customData.linkData) {
          linkData = this.customData.linkData[this.line];
          if (linkData) {
            results = [];
            for (j = 0, len = linkData.length; j < len; j++) {
              data = linkData[j];
              results.push(this.sprites[this.line].bitmap.clearRect(data.cx, 0, data.width, data.height));
            }
            return results;
          }
        }
    }
  };


  /**
  * Processes a control-token. A control-token is a token which influences
  * the text-rendering like changing the fonts color, size or style. Changes 
  * will be automatically applied to the game object's font.
  *
  * For message text-renderer, a few additional control-tokens like
  * speed-change, waiting, etc. needs to be processed here.
  *
  * This method is called for each token while the message is initialized and
  * also while the message is running. See <i>formattingOnly</i> parameter.
  *
  * @param {Object} token - A control-token.
  * @param {boolean} formattingOnly - If <b>true</b> the message is initializing right now and only 
  * format-tokens should be processed which is necessary for the message to calculated sizes correctly.
  * @return {Object} A new token which is processed next or <b>null</b>.
  * @method processControlToken
  * @protected
   */

  Component_MessageTextRenderer.prototype.processControlToken = function(token, formattingOnly) {
    var animation, bitmap, character, duration, easing, expression, line, linkData, linkStart, object, params, ref, ref1, result, sound, textTokens, values;
    if (formattingOnly) {
      return Component_MessageTextRenderer.__super__.processControlToken.call(this, token);
    }
    result = null;
    switch (token.code) {
      case "CR":
        character = RecordManager.charactersArray.first(function(c) {
          var ref;
          return ((ref = c.name.defaultText) != null ? ref : c.name) === token.value;
        });
        if (character) {
          SceneManager.scene.currentCharacter = character;
        }
        break;
      case "CE":
        params = {
          "values": token.values
        };
        if ((ref = this.object.events) != null) {
          ref.emit("callCommonEvent", this.object, {
            commonEventId: token.value,
            params: params,
            finish: false,
            waiting: true
          });
        }
        break;
      case "X":
        if (typeof token.value === "function") {
          token.value(this.object);
        }
        break;
      case "A":
        animation = RecordManager.animationsArray.first(function(a) {
          return a.name === token.value;
        });
        if (!animation) {
          animation = RecordManager.animations[token.value];
        }
        if ((animation != null ? animation.graphic.name : void 0) != null) {
          bitmap = ResourceManager.getBitmap("Graphics/Pictures/" + animation.graphic.name);
          object = new gs.Object_Animation(animation);
          this.addCustomObject(object);
          this.currentX += Math.round(bitmap.width / animation.framesX);
          this.currentSprite.srcRect.width += Math.round(bitmap.width / animation.framesX);
        }
        break;
      case "RT":
        if (token.rtSize.width > token.rbSize.width) {
          this.currentX += token.rtSize.width;
          this.font.set(this.getRubyTextFont(token));
        } else {
          this.currentX += token.rbSize.width;
        }
        break;
      case "LK":
        if (token.value === 'E') {
          object = new ui.Object_Hotspot();
          object.enabled = true;
          object.setup();
          this.addCustomObject(object);
          object.dstRect.x = this.object.dstRect.x + this.object.origin.x + this.customData.linkData.cx;
          object.dstRect.y = this.object.dstRect.y + this.object.origin.y + this.customData.linkData.cy;
          object.dstRect.width = this.currentX - this.customData.linkData.cx;
          object.dstRect.height = this.currentLineHeight;
          object.events.on("click", gs.CallBack("onLinkClick", this), {
            linkData: this.customData.linkData
          }, this);
        } else {
          this.customData.linkData = {
            cx: this.currentX,
            cy: this.currentY,
            commonEventId: token.value,
            tokenIndex: this.tokenIndex
          };
        }
        break;
      case "SLK":
        if (token.value === 'E') {
          linkData = this.customData.linkData[this.line].last();
          line = this.lines[this.line].content;
          linkStart = this.findToken(this.tokenIndex - 1, "SLK", -1, line);
          textTokens = this.findTokensBetween(linkData.tokenIndex, this.tokenIndex, null, line);
          linkData.cx = linkStart.customData.offsetX;
          linkData.width = this.currentX - linkData.cx + this.padding;
          linkData.height = this.currentSprite.bitmap.height;
          object = new ui.Object_Text();
          object.text = textTokens.select((function(_this) {
            return function(x) {
              return x.value;
            };
          })(this)).join("");
          object.formatting = false;
          object.wordWrap = false;
          object.ui = new ui.Component_UIBehavior();
          object.enabled = true;
          object.addComponent(object.ui);
          object.addComponent(new gs.Component_HotspotBehavior());
          object.behavior.padding.left = 0;
          object.behavior.padding.right = 0;
          object.dstRect.width = linkData.width;
          object.dstRect.height = linkData.height;
          if (linkData.styleIndex === -1) {
            ui.UIManager.addControlStyles(object, ["hyperlink"]);
          } else {
            ui.UIManager.addControlStyles(object, ["hyperlink-" + linkData.styleIndex]);
          }
          object.setup();
          this.addCustomObject(object);
          object.dstRect.x = this.currentSprite.x + linkData.cx;
          object.dstRect.y = this.object.dstRect.y + this.object.origin.y + linkData.cy;
          object.events.on("click", gs.CallBack("onLinkClick", this), {
            linkData: linkData
          }, this);
        } else {
          if (!this.customData.linkData) {
            this.customData.linkData = [];
          }
          if (!this.customData.linkData[this.line]) {
            this.customData.linkData[this.line] = [];
          }
          if ((ref1 = token.value) != null ? ref1.contains(",") : void 0) {
            values = token.value.split(",");
            this.customData.linkData[this.line].push({
              cx: this.currentX,
              cy: this.currentY,
              commonEventId: values[0],
              styleIndex: parseInt(values[1]),
              tokenIndex: this.tokenIndex
            });
          } else {
            this.customData.linkData[this.line].push({
              cx: this.currentY,
              cy: this.currentY,
              commonEventId: token.value,
              tokenIndex: this.tokenIndex,
              styleIndex: -1
            });
          }
        }
        break;
      case "E":
        expression = RecordManager.characterExpressionsArray.first(function(c) {
          var ref2;
          return ((ref2 = c.name.defaultText) != null ? ref2 : c.name) === token.value;
        });
        if (!expression) {
          expression = RecordManager.characterExpressions[token.value];
        }
        character = SceneManager.scene.currentCharacter;
        if ((expression != null) && ((character != null ? character.index : void 0) != null)) {
          duration = GameManager.defaults.character.expressionDuration;
          easing = gs.Easings.fromObject(GameManager.defaults.character.changeEasing);
          animation = GameManager.defaults.character.changeAnimation;
          object = SceneManager.scene.characters.first(function(c) {
            return c.rid === character.index;
          });
          if (object != null) {
            object.behavior.changeExpression(expression, animation, easing, duration);
          }
        }
        break;
      case "SP":
        sound = RecordManager.system.sounds[token.value - 1];
        AudioManager.playSound(sound);
        break;
      case "S":
        GameManager.settings.messageSpeed = token.value;
        break;
      case "W":
        this.drawImmediately = false;
        if (!GameManager.tempSettings.skip) {
          if (token.value === "A") {
            this.waitForKey = true;
          } else {
            this.waitCounter = Math.round(token.value / 1000 * Graphics.frameRate);
          }
        }
        break;
      case "WE":
        this.waitAtEnd = token.value === "Y";
        break;
      case "DI":
        this.drawImmediately = token.value === 1 || token.value === "Y";
        break;
      default:
        result = Component_MessageTextRenderer.__super__.processControlToken.call(this, token);
    }
    return result;
  };


  /**
  * Clears/Resets the text-renderer.
  *
  * @method clear
   */

  Component_MessageTextRenderer.prototype.clear = function() {
    var j, len, ref, ref1, ref2, sprite;
    this.charIndex = 0;
    this.currentX = 0;
    this.currentY = 0;
    this.line = 0;
    this.lines = [];
    this.clearCustomObjects();
    if ((ref = this.object.bitmap) != null) {
      ref.clear();
    }
    ref1 = this.allSprites;
    for (j = 0, len = ref1.length; j < len; j++) {
      sprite = ref1[j];
      sprite.dispose();
      if ((ref2 = sprite.bitmap) != null) {
        ref2.dispose();
      }
    }
    this.allSprites = [];
    return null;
  };


  /**
  * Clears/Disposes all sprites used to display the text-lines/parts.
  *
  * @method clearAllSprites
   */

  Component_MessageTextRenderer.prototype.clearAllSprites = function() {
    var j, len, ref, ref1, sprite;
    ref = this.allSprites;
    for (j = 0, len = ref.length; j < len; j++) {
      sprite = ref[j];
      sprite.dispose();
      if ((ref1 = sprite.bitmap) != null) {
        ref1.dispose();
      }
    }
    return null;
  };


  /**
  * Clears/Disposes the sprites used to display the text-lines/parts of the current/last message.
  *
  * @method clearSprites
   */

  Component_MessageTextRenderer.prototype.clearSprites = function() {
    var j, len, ref, ref1, sprite;
    ref = this.sprites;
    for (j = 0, len = ref.length; j < len; j++) {
      sprite = ref[j];
      sprite.dispose();
      if ((ref1 = sprite.bitmap) != null) {
        ref1.dispose();
      }
    }
    return null;
  };


  /**
  * Removes a game object from the message.
  *
  * @method removeCustomObject
  * @param object {gs.Object_Base} The game object to remove.
   */

  Component_MessageTextRenderer.prototype.removeCustomObject = function(object) {
    SceneManager.scene.removeObject(object);
    object.dispose();
    return this.customObjects.remove(object);
  };


  /**
  * Adds a game object to the message which is alive until the message is
  * erased. Can be used to display animationed-icons, etc. in a message.
  *
  * @method addCustomObject
  * @param object {gs.Object_Base} The game object to add.
   */

  Component_MessageTextRenderer.prototype.addCustomObject = function(object) {
    object.dstRect.x = this.object.dstRect.x + this.object.origin.x + this.currentX;
    object.dstRect.y = this.object.dstRect.y + this.object.origin.y + this.currentY;
    object.zIndex = this.object.zIndex + 1;
    object.update();
    SceneManager.scene.addObject(object);
    return this.customObjects.push(object);
  };


  /**
  * Clears the list of custom game objects. All game objects are disposed and removed
  * from the scene.
  *
  * @method clearCustomObjects
  * @param object {Object} The game object to add.
   */

  Component_MessageTextRenderer.prototype.clearCustomObjects = function() {
    var j, len, object, ref;
    ref = this.customObjects;
    for (j = 0, len = ref.length; j < len; j++) {
      object = ref[j];
      object.dispose();
      SceneManager.scene.removeObject(object);
    }
    return this.customObjects = [];
  };


  /**
  * Creates the bitmap for a specified line-object.
  *
  * @method createBitmap
  * @private
  * @param {Object} line - A line-object.
  * @return {Bitmap} A newly created bitmap containing the line-text.
   */

  Component_MessageTextRenderer.prototype.createBitmap = function(line) {
    var bitmap;
    this.font = this.object.font;
    bitmap = new Bitmap(this.object.dstRect.width, Math.max(this.minLineHeight, line.height));
    bitmap.font = this.font;
    return bitmap;
  };


  /**
  * Draws the line's content on the specified bitmap.
  *
  * @method drawLineContent
  * @protected
  * @param {Object} line - A line-object which should be drawn on the bitmap.
  * @param {gs.Bitmap} bitmap - The bitmap to draw the line's content on.
  * @param {number} length - Determines how many characters of the specified line should be drawn. You can 
  * specify -1 to draw all characters.
   */

  Component_MessageTextRenderer.prototype.drawLineContent = function(line, bitmap, length) {
    var currentX, drawAll, i, j, len, ref, size, token, value;
    bitmap.clear();
    currentX = this.padding;
    drawAll = length === -1;
    ref = line.content;
    for (i = j = 0, len = ref.length; j < len; i = ++j) {
      token = ref[i];
      if (i > this.tokenIndex && !drawAll) {
        break;
      }
      if (token.code != null) {
        size = this.measureControlToken(token, bitmap);
        this.drawControlToken(token, bitmap, currentX);
        if (size) {
          currentX += size.width;
        }
        this.processControlToken(token, true, line);
      } else if (token.value.length > 0) {
        token.applyFormat(this.font);
        value = token.value;
        if (!drawAll && this.tokenIndex === i && value.length > length) {
          value = value.substring(0, length);
        }
        if (value !== "\n") {
          size = this.font.measureTextPlain(value);
          bitmap.drawText(currentX, line.height - (size.height - this.font.descent) - line.descent, size.width, bitmap.height, value, 0, 0);
          currentX += size.width;
        }
      }
    }
    return line.contentWidth = currentX + this.font.measureTextPlain(" ").width;
  };


  /**
  * Creates the sprite for a specified line-object.
  *
  * @method createSprite
  * @private
  * @param {Object} line - A line-object.
  * @return {Sprite} A newly created sprite object containing the line-text as bitmap.
   */

  Component_MessageTextRenderer.prototype.createSprite = function(line) {
    var bitmap, sprite;
    bitmap = this.createBitmap(line);
    this.currentX = 0;
    this.waitCounter = 0;
    this.waitForKey = false;
    sprite = new Sprite(Graphics.viewport);
    sprite.bitmap = bitmap;
    sprite.visible = true;
    sprite.z = this.object.zIndex + 1;
    sprite.srcRect = new Rect(0, 0, 0, bitmap.height);
    return sprite;
  };


  /**
  * Creates the sprites for a specified array of line-objects.
  *
  * @method createSprites
  * @private
  * @see gs.Component_MessageTextRenderer.createSprite.
  * @param {Array} lines - An array of line-objects.
  * @return {Array} An array of sprites.
   */

  Component_MessageTextRenderer.prototype.createSprites = function(lines) {
    var i, j, len, line, result, sprite;
    this.fontSize = this.object.font.size;
    result = [];
    for (i = j = 0, len = lines.length; j < len; i = ++j) {
      line = lines[i];
      sprite = this.createSprite(line);
      result.push(sprite);
    }
    return result;
  };


  /**
  * Starts a new line.
  *
  * @method newLine
   */

  Component_MessageTextRenderer.prototype.newLine = function() {
    this.currentX = 0;
    return this.currentY += this.currentLineHeight + this.lineSpacing;
  };


  /**
  * Displays a formatted text immediately without any delays or animations. The
  * Component_TextRenderer.drawFormattedText method from the base-class cannot
  * be used here because it would render to the game object's bitmap object while
  * this method is rendering to the sprites.
  *
  * @method drawFormattedTextImmediately
  * @param {number} x - The x-coordinate of the text's position.
  * @param {number} y - The y-coordinate of the text's position.
  * @param {number} width - Deprecated. Can be null.
  * @param {number} height - Deprecated. Can be null.
  * @param {string} text - The text to draw.
  * @param {boolean} wordWrap - If wordWrap is set to true, line-breaks are automatically created.
   */

  Component_MessageTextRenderer.prototype.drawFormattedTextImmediately = function(x, y, width, height, text, wordWrap) {
    this.drawFormattedText(x, y, width, height, text, wordWrap);
    while (true) {
      this.nextChar();
      if (this.line >= this.maxLines) {
        this.isRunning = false;
      } else {
        this.drawNext();
      }
      if (!this.isRunning) {
        break;
      }
    }
    this.currentY += this.currentLineHeight + this.lineSpacing;
    return null;
  };


  /**
  * Starts the rendering-process for the message.
  *
  * @method drawFormattedText
  * @param {number} x - The x-coordinate of the text's position.
  * @param {number} y - The y-coordinate of the text's position.
  * @param {number} width - Deprecated. Can be null.
  * @param {number} height - Deprecated. Can be null.
  * @param {string} text - The text to draw.
  * @param {boolean} wordWrap - If wordWrap is set to true, line-breaks are automatically created.
   */

  Component_MessageTextRenderer.prototype.drawFormattedText = function(x, y, width, height, text, wordWrap) {
    var currentX, ref;
    text = text || " ";
    this.font.set(this.object.font);
    this.speed = 11 - Math.round(GameManager.settings.messageSpeed * 2.5);
    this.isRunning = true;
    this.drawImmediately = false;
    this.lineAnimationCount = this.speed;
    this.currentLineHeight = 0;
    this.isWaiting = false;
    this.waitForKey = false;
    this.charIndex = 0;
    this.token = null;
    this.tokenIndex = 0;
    this.message = text;
    this.line = 0;
    this.currentLine = this.line;
    currentX = this.currentX;
    this.lines = this.calculateLines(lcsm(this.message), wordWrap, this.currentX);
    this.sprites = this.createSprites(this.lines);
    this.allSprites = this.allSprites.concat(this.sprites);
    this.currentX = currentX;
    this.currentSprite = this.sprites[this.line];
    this.currentSprite.x = this.currentX + this.object.origin.x + this.object.dstRect.x;
    this.maxLines = this.calculateMaxLines(this.lines);
    this.token = ((ref = this.lines[this.line]) != null ? ref.content[this.tokenIndex] : void 0) || new gs.RendererToken(null, "");
    return this.start();
  };


  /**
  * Starts the message-rendering process.
  *
  * @method start
  * @protected
   */

  Component_MessageTextRenderer.prototype.start = function() {
    var ref;
    if (GameManager.tempSettings.skip && GameManager.tempSettings.skipTime === 0) {
      return this.instantSkip();
    } else if (this.maxLines === 0) {
      if (((ref = this.lines[0]) != null ? ref.content : void 0) === "") {
        return this.finish();
      } else {
        this.maxLines = 1;
        return this.drawNext();
      }
    } else {
      return this.drawNext();
    }
  };


  /**
  * Skips the current message and finishes the message-processing immediately. The message
  * tokens are processed but not rendered.
  *
  * @method instantSkip
   */

  Component_MessageTextRenderer.prototype.instantSkip = function() {
    var ref;
    while (true) {
      if (this.line < this.maxLines) {
        this.nextChar();
      }
      if (this.line >= this.maxLines) {
        break;
      } else {
        this.processToken();
      }
      if (!(this.isRunning && this.line < this.maxLines)) {
        break;
      }
    }
    if ((ref = this.object.events) != null) {
      ref.emit("messageWaiting", this);
    }
    return this["continue"]();
  };


  /**
  * Processes the current token.
  *
  * @method processToken
   */

  Component_MessageTextRenderer.prototype.processToken = function() {
    var base, token;
    token = null;
    if (this.token.code != null) {
      token = this.processControlToken(this.token, false);
      if (token != null) {
        this.token = token;
        if (typeof (base = this.token).onStart === "function") {
          base.onStart();
        }
      }
    } else {
      token = this.token;
    }
    return token;
  };

  return Component_MessageTextRenderer;

})(gs.Component_TextRenderer);

gs.Component_MessageTextRenderer = Component_MessageTextRenderer;

//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"","sourceRoot":"","sources":[""],"names":[],"mappings":"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","sourcesContent":["# ===================================================================\n#\n#   Script: Component_MessageTextRenderer\n#\n#   $$COPYRIGHT$$\n#\n# ===================================================================\nclass Component_MessageTextRenderer extends gs.Component_TextRenderer\n    @objectCodecBlackList = [\"onLinkClick\", \"onBatchDisappear\"]\n    ###*\n    * Called if this object instance is restored from a data-bundle. It can be used\n    * re-assign event-handler, anonymous functions, etc.\n    * x\n    * @method onDataBundleRestore.\n    * @param Object data - The data-bundle\n    * @param gs.ObjectCodecContext context - The codec-context.\n    ###\n    onDataBundleRestore: (data, context) ->\n        @setupEventHandlers()\n        l = 0\n        \n        for message in @object.messages\n            if @object.settings.useCharacterColor\n                @object.font.color = new gs.Color(message.character.textColor)\n            @lines = @calculateLines(lcsm(message.text), yes, 0)\n            for line in @lines\n                bitmap = @createBitmap(line)\n                if line == @line\n                    @drawLineContent(line, bitmap, @charIndex+1)\n                else\n                    @drawLineContent(line, bitmap, -1)\n                @allSprites[l].bitmap = bitmap\n                l++\n                \n          \n        for customObject in @customObjects\n            SceneManager.scene.addObject(customObject)\n                \n        return null\n        \n    ###*\n    *  A text-renderer component to render an animated and interactive message text using\n    *  dimensions of the game object's destination-rectangle. The message is displayed\n    *  using a sprite for each line instead of drawing to the game object's bitmap object.\n    *\n    *  @module gs\n    *  @class Component_MessageTextRenderer\n    *  @extends gs.Component_TextRenderer\n    *  @memberof gs\n    *  @constructor\n    ###\n    constructor: ->\n        super\n        \n        ###*\n        * An array containing all sprites of the current message.\n        * @property sprites\n        * @type gs.Sprite[]\n        * @protected\n        ###\n        @sprites = []\n        \n        ###*\n        * An array containing all sprites of all messages. In NVL mode\n        * a page can contain multiple messages.\n        * @property allSprites\n        * @type gs.Sprite[]\n        * @protected\n        ###\n        @allSprites = []\n        ###*\n        * An array containing all line-objects of the current message.\n        * @property lines\n        * @type gs.TextRendererLine[]\n        * @readOnly\n        ###\n        @lines = null\n        \n        ###*\n        * The line currently rendered.\n        * @property line\n        * @type number\n        * @readOnly\n        ###\n        @line = 0\n        \n        ###*\n        * The left and right padding per line.\n        * @property padding\n        * @type number\n        ###\n        @padding = 6\n        \n        ###*\n        * The minimum height of the line currently rendered. If 0, the measured\n        * height of the line will be used.\n        * @property minLineHeight\n        * @type number\n        ###\n        @minLineHeight = 0\n        \n        ###*\n        * The spacing between text lines in pixels.\n        * @property lineSpacing\n        * @type number\n        ###\n        @lineSpacing = 2\n        \n        ###*\n        * The line currently rendered.\n        * @property currentLine\n        * @type number\n        * @protected\n        ###\n        @currentLine = 0\n        \n        ###*\n        * The height of the line currently rendered.\n        * @property currentLineHeight\n        * @type number\n        * @protected\n        ###\n        @currentLineHeight = 0\n        \n        ###*\n        * Index of the current character to draw.\n        * @property charIndex\n        * @type number\n        * @readOnly\n        ###\n        @charIndex = 0\n        \n        ###*\n        * Position of the message caret. The caret is like an invisible\n        * cursor pointing to the x/y coordinates of the last rendered character of\n        * the message. That position can be used to display a waiting- or processing-animation for example.\n        * @property caretPosition\n        * @type gs.Point\n        * @readOnly\n        ###\n        @caretPosition = new gs.Point()\n        \n        ###*\n        * Indicates that the a message is currently in progress.\n        * @property isRunning\n        * @type boolean\n        * @readOnly\n        ###\n        @isRunning = no\n        \n        ###*\n        * The current x-coordinate of the caret/cursor.\n        * @property currentX\n        * @type number\n        * @readOnly\n        ###\n        @currentX = 0\n        \n        ###*\n        * The current y-coordinate of the caret/cursor.\n        * @property currentY\n        * @type number\n        * @readOnly\n        ###\n        @currentY = 0\n        \n        ###*\n        * The current sprites used to display the current text-line/part.\n        * @property currentSprite\n        * @type gs.Sprite\n        * @readOnly\n        ###\n        @currentSprite = null\n        \n        ###*\n        * Indicates if the message-renderer is currently waiting like for a user-action.\n        * @property isWaiting\n        * @type boolean\n        * @readOnly\n        ###\n        @isWaiting = no\n        \n        ###*\n        * Indicates if the message-renderer is currently waiting for a key-press or mouse/touch action.\n        * @property waitForKey\n        * @type boolean\n        * @readOnly\n        ###\n        @waitForKey = no\n        \n        ###*\n        * Number of frames the message-renderer should wait before continue.\n        * @property waitCounter\n        * @type number\n        ###\n        @waitCounter = 0\n        \n        ###*\n        * Speed of the message-drawing. The smaller the value, the faster the message is displayed.\n        * @property speed\n        * @type number\n        ###\n        @speed = 1\n        \n        ###*\n        * Indicates if the message should be rendered immedialtely without any animation or delay.\n        * @property drawImmediately\n        * @type boolean\n        ###\n        @drawImmediately = no\n        \n        ###*\n        * Indicates if the message should wait for a user-action or a certain amount of time\n        * before finishing.\n        * @property waitAtEnd\n        * @type boolean\n        ###\n        @waitAtEnd = yes\n        \n        ###*\n        * The number of frames to wait before finishing a message.\n        * before finishing.\n        * @property waitAtEndTime\n        * @type number\n        ###\n        @waitAtEndTime = 0\n        \n        ###*\n        * Indicates if auto word-wrap should be used. Default is <b>true</b>\n        * @property wordWrap\n        * @type boolean\n        ###\n        @wordWrap = yes\n        \n        ###*\n        * Custom game objects which are alive until the current message is erased. Can be used to display\n        * animated icons, etc.\n        * @property customObjects\n        * @type gs.Object_Base[]\n        ###\n        @customObjects = []\n        \n        ###*\n        * A hashtable/dictionary object to store custom-data useful like for token-processing. The data must be\n        * serializable.\n        * @property customObjects\n        * @type Object\n        ###\n        @customData = {}\n        \n        ###*\n        * A callback function called if the player clicks on a non-stylable link (LK text-code) to trigger\n        * the specified common event.\n        * @property onLinkClick\n        * @type Function\n        ###\n        @onLinkClick = (e) ->\n            eventId = e.data.linkData.commonEventId\n            event = RecordManager.commonEvents[eventId]\n            if !event\n                event = RecordManager.commonEvents.first (x) => x.name == eventId\n                eventId = event.index if event\n            if !event\n                SceneManager.scene.interpreter.jumpToLabel(eventId)\n            else\n                SceneManager.scene.interpreter.callCommonEvent(eventId, null, yes)\n        \n        ###*\n        * A callback function called if a batched messsage has been faded out. It triggers the execution of\n        * the next message.\n        * @property onBatchDisappear\n        * @type Function\n        ###    \n        @onBatchDisappear = (e) => \n            @drawImmediately = no\n            @isWaiting = no\n            @object.opacity = 255\n            @executeBatch() \n            \n            \n    ###*\n    * Serializes the message text-renderer into a data-bundle.\n    * @method toDataBundle\n    * @return {Object} A data-bundle.\n    ###\n    toDataBundle: ->\n        ignore = [\"object\", \"font\", \"sprites\", \"allSprites\", \"currentSprite\", \"currentX\"]\n        bundle = { currentSpriteIndex: @sprites.indexOf(@currentSprite) }\n        \n        for k of this\n            if ignore.indexOf(k) == -1\n                bundle[k] = this[k]\n                \n        return bundle\n     \n    \n            \n    ###*\n    * Disposes the message text-renderer and all sprites used to display\n    * the message.\n    * @method dispose\n    ###\n    dispose: ->\n        super\n        \n        @disposeEventHandlers()\n        \n        for sprite in @allSprites\n            sprite.bitmap?.dispose()\n            sprite.dispose()\n     \n    ###*\n    * Removes all attached event handlers \n    * the message.\n    * @method disposeEventHandlers\n    ###       \n    disposeEventHandlers: ->\n        gs.GlobalEventManager.offByOwner(\"mouseUp\", @object)\n        gs.GlobalEventManager.offByOwner(\"keyUp\", @object)\n    \n    ###*\n    * Adds event-handlers for mouse/touch events\n    *\n    * @method setupEventHandlers\n    ### \n    setupEventHandlers: ->\n        gs.GlobalEventManager.offByOwner(\"mouseUp\", @object)\n        gs.GlobalEventManager.offByOwner(\"keyUp\", @object)\n        \n        gs.GlobalEventManager.on \"mouseUp\", ((e) =>\n            return if @object.findComponentByName(\"animation\") or (GameManager.settings.autoMessage.enabled and !GameManager.settings.autoMessage.stopOnAction)\n                \n            #if @object.dstRect.contains(Input.Mouse.x - @object.origin.x, Input.Mouse.y - @object.origin.y)\n            if @isWaiting and not (@waitCounter > 0 or @waitForKey)\n                e.breakChain = yes\n                @continue()\n            else\n                e.breakChain = @isRunning\n                @drawImmediately = !@waitForKey\n                @waitCounter = 0\n                @waitForKey = no\n                @isWaiting = no\n                \n            if @waitForKey\n                if Input.Mouse.buttons[Input.Mouse.LEFT] == 2\n                    e.breakChain = yes\n                    Input.clear()\n                    @waitForKey = no\n                    @isWaiting = no\n                        \n                \n                        \n                \n        ), null, @object\n        \n        gs.GlobalEventManager.on \"keyUp\", ((e) =>\n            if Input.keys[Input.C] and (!@isWaiting or (@waitCounter > 0 or @waitForKey))\n                @drawImmediately = !@waitForKey\n                @waitCounter = 0\n                @waitForKey = no\n                @isWaiting = no\n                \n            if @isWaiting and !@waitForKey and !@waitCounter and Input.keys[Input.C]\n                @continue()\n                \n            if @waitForKey\n                if Input.keys[Input.C]\n                    Input.clear()\n                    @waitForKey = no\n                    @isWaiting = no\n                \n        ), null, @object\n        \n    ###*\n    * Sets up the renderer. Registers necessary event handlers.\n    * @method setup\n    ### \n    setup: ->\n        @setupEventHandlers()\n        \n    ###*\n    * Restores the message text-renderer's state from a data-bundle.\n    * @method restore\n    * @param {Object} bundle - A data-bundle containing message text-renderer state.\n    ###\n    restore: (bundle) ->\n        for k of bundle\n            if k == \"currentSpriteIndex\"\n                @currentSprite = @sprites[bundle.currentSpriteIndex]\n            else\n                this[k] = bundle[k]\n        \n        if @sprites.length > 0\n            @currentY = @sprites.last().y - @object.origin.y - @object.dstRect.y\n            @line = @maxLines\n            @isWaiting = @isWaiting || @isRunning\n            \n        return null    \n    \n    \n    ###*\n    * Continues message-processing if currently waiting.\n    * @method continue\n    ###\n    continue: -> \n        @isWaiting = no\n   \n        if @line >= @lines.length\n            @isRunning = no\n            @object.events?.emit(\"messageFinish\", this)\n        else\n            @object.events?.emit(\"messageBatch\", this)\n            fading = GameManager.tempSettings.messageFading\n            duration = if GameManager.tempSettings.skip then 0 else fading.duration\n            @object.animator.disappear(fading.animation, fading.easing, duration, gs.CallBack(\"onBatchDisappear\", this))\n            \n    ###*\n    * Updates the text-renderer.\n    * @method update\n    ###\n    update: ->\n        for sprite in @allSprites\n            sprite.opacity = @object.opacity\n            sprite.visible = @object.visible\n            sprite.ox = -@object.offset.x\n            sprite.oy = -@object.offset.y\n            sprite.mask.value = @object.mask.value\n            sprite.mask.vague = @object.mask.vague\n            sprite.mask.source = @object.mask.source\n            sprite.mask.type = @object.mask.type\n    \n        for object in @customObjects\n            object.opacity = @object.opacity\n            object.visible = @object.visible\n            \n        if not @isRunning and @waitCounter > 0\n            @waitCounter--\n            if @waitCounter == 0\n                @continue()\n            return\n                \n        if @object.visible and @lines?.length > 0\n            @updateLineWriting()\n            @updateWaitForKey()\n            @updateWaitCounter()\n            @updateCaretPosition()\n        \n     \n    ###*\n    * Indicates if its a batched messages.\n    *\n    * @method isBatched\n    * @return If <b>true</b> it is a batched message. Otherwise <b>false</b>.\n    ###\n    isBatched: -> @lines.length > @maxLines\n    \n    ###*\n    * Indicates if the batch is still in progress and not done.\n    *\n    * @method isBatchInProgress\n    * @return If <b>true</b> the batched message is still not done. Otherwise <b>false</b>\n    ###\n    isBatchInProgress: -> @lines.length - @line > @maxLines\n    \n    ###*\n    * Starts displaying the next page of text if a message is too long to fit\n    * into one message box.\n    *\n    * @method executeBatch\n    ### \n    executeBatch: ->\n        @clearAllSprites()\n        @lines = @lines.slice(@line)\n        @line = 0\n        @currentX = 0\n        @currentY = 0  \n        @currentLineHeight = 0\n        @tokenIndex = 0\n        @charIndex = 0\n        @token = @lines[@line].content[@tokenIndex] || new gs.RendererToken(null, \"\");\n        @maxLines = @calculateMaxLines(@lines)\n        @lineAnimationCount = @speed\n        @sprites = @createSprites(@lines)\n        @allSprites = @allSprites.concat(@sprites)\n        @currentSprite = @sprites[@line]\n        @currentSprite.x = @currentX + @object.origin.x + @object.dstRect.x\n        @drawNext()\n    \n    ###*\n    * Calculates the duration(in frames) the message-renderer needs to display\n    * the message.\n    *\n    * @method calculateDuration\n    * @return {number} The duration in frames.\n    ###    \n    calculateDuration: ->\n        duration = 0\n        \n        if @lines?\n            for line in @lines\n                for token in line.content\n                    if token?\n                        duration += @calculateDurationForToken(token)\n        return duration\n    \n    ###*\n    * Calculates the duration(in frames) the message-renderer needs to display\n    * the specified line.\n    *\n    * @method calculateDurationForLine\n    * @param {gs.RendererTextLine} line The line to calculate the duration for.\n    * @return {number} The duration in frames.\n    ###      \n    calculateDurationForLine: (line) ->\n        duration = 0\n        \n        if line\n            for token in line.content\n                if token?\n                    duration += @calculateDurationForToken(token)\n                        \n        return duration\n     \n    ###*\n    * Calculates the duration(in frames) the message-renderer needs to process\n    * the specified token.\n    *\n    * @method calculateDurationForToken\n    * @param {string|Object} token - The token.\n    * @return {number} The duration in frames.\n    ###                    \n    calculateDurationForToken: (token) ->\n        duration = 0\n        \n        if token.code?\n            switch token.code\n                when \"W\"\n                    if token.value != \"A\"\n                        duration = token.value / 1000 * Graphics.frameRate\n        else\n            duration = token.value.length * @speed\n                    \n        return duration\n                        \n    ###*\n    * Calculates the maximum of lines which can be displayed in one message.\n    *\n    * @method calculateMaxLines\n    * @param {Array} lines - An array of line-objects.\n    * @return {number} The number of displayable lines.\n    ###\n    calculateMaxLines: (lines) ->\n        height = 0\n        result = 0\n        \n        for line in lines\n                height += line.height + @lineSpacing\n                if @currentY+height > (@object.dstRect.height)\n                    break\n                result++\n     \n        return Math.min(lines.length, result || 1)\n    \n    ###*\n    * Displays the character or processes the next control-token.\n    *\n    * @method drawNext\n    ###\n    drawNext: ->\n        token = @processToken()\n            \n        if token?.value.length > 0\n            @char = @token.value.charAt(@charIndex)\n            \n            size = @font.measureTextPlain(@char)  \n            lineSpacing = @lineSpacing\n            \n            if @currentLine != @line\n                @currentLine = @line\n               # @currentY += @currentLineHeight + lineSpacing * Graphics.scale\n                @currentLineHeight = 0\n\n            @currentSprite.y = @object.origin.y + @object.dstRect.y + @currentY\n            @currentSprite.visible = yes\n            @drawLineContent(@lines[@line], @currentSprite.bitmap, @charIndex+1)\n            @currentSprite.srcRect.width = @currentSprite.bitmap.width #Math.min(@currentSprite.srcRect.width + size.width, @currentSprite.bitmap.width)\n        \n            @currentLineHeight = @lines[@line].height\n            @currentX = Math.min(@lines[@line].width, @currentX + size.width)\n            \n    ###*\n    * Processes the next character/token of the message.\n    * @method nextChar\n    * @private\n    ###\n    nextChar: ->\n        loop\n            @charIndex++\n            @lineAnimationCount = @speed\n            \n            if @token.code? or @charIndex >= @token.value.length\n                @token.onEnd?()\n                @tokenIndex++\n                if @tokenIndex >= @lines[@line].content.length\n                    @tokenIndex = 0\n                    @line++\n                    @currentSprite.srcRect.width = @currentSprite.bitmap.width\n                    @currentSprite = @sprites[@line]\n                    if @currentSprite?\n                        @currentSprite.x = @object.origin.x + @object.dstRect.x\n                    if @line < @maxLines\n                        @currentY += (@currentLineHeight || @font.lineHeight) + @lineSpacing * Graphics.scale\n                        @charIndex = 0\n                        @currentX = 0\n                        @token = @lines[@line].content[@tokenIndex] || new gs.RendererToken(null, \"\")\n                else\n                    @charIndex = 0\n                    @token = @lines[@line].content[@tokenIndex] || new gs.RendererToken(null, \"\")\n                @token.onStart?()\n\n            \n            if !@token or @token.value != \"\\n\" or !@lines[@line]\n                break\n    ###*\n    * Finishes the message. Depending on the message configuration, the\n    * message text-renderer will now wait for a user-action or a certain amount\n    * of time.\n    *\n    * @method finish\n    ###\n    finish: ->\n        if @waitAtEnd\n            @isWaiting = yes\n            @object.events?.emit(\"messageWaiting\", this)\n        else if @waitAtEndTime > 0\n            @waitCounter = @waitAtEndTime\n            @isWaiting = no\n            \n            @object.events?.emit(\"messageWaiting\", this)\n        else\n            @object.events?.emit(\"messageWaiting\", this)\n            @continue()\n    \n    ###*\n    * Returns the position of the caret in pixels. The caret is like an invisible\n    * cursor pointing to the x/y coordinates of the last rendered character of\n    * the message. That position can be used to display a waiting- or processing-animation for example.\n    *\n    * @method updateCaretPosition\n    ###\n    updateCaretPosition: -> \n        @caretPosition.x = @currentX + @padding   \n        @caretPosition.y = @currentY + @currentLineHeight/2\n        \n    ###*\n    * Updates the line writing.\n    *\n    * @method updateLineWriting\n    * @private\n    ###\n    updateLineWriting: ->\n        if @isRunning and !@isWaiting and !@waitForKey and @waitCounter <= 0\n            if @lineAnimationCount <= 0\n                loop\n                    if @line < @maxLines\n                        @nextChar()\n                        \n                    if @line >= @maxLines\n                        @finish()\n                    else\n                        @drawNext()\n                        \n                    break unless (@token.code or @lineAnimationCount <= 0 or @drawImmediately) and !@waitForKey and @waitCounter <= 0 and @isRunning and @line < @maxLines\n            \n            if GameManager.tempSettings.skip\n                @lineAnimationCount = 0\n            else\n                @lineAnimationCount--\n    \n    ###*\n    * Updates wait-for-key state. If skipping is enabled, the text renderer will\n    * not wait for key press.\n    *\n    * @method updateWaitForKey\n    * @private\n    ###\n    updateWaitForKey: ->\n        if @waitForKey\n            @isWaiting = !GameManager.tempSettings.skip\n            @waitForKey = @isWaiting\n     \n    ###*\n    * Updates wait counter if the text renderer is waiting for a certain amount of time to pass. If skipping is enabled, the text renderer will\n    * not wait for the actual amount of time and sets the wait-counter to 1 frame instead.\n    *\n    * @method updateWaitForKey\n    * @private\n    ###       \n    updateWaitCounter: ->\n        if @waitCounter > 0\n            if GameManager.tempSettings.skip\n                @waitCounter = 1\n            @isWaiting = yes\n            @waitCounter--\n            if @waitCounter <= 0\n                @isWaiting = no\n                @continue() if @line >= @maxLines\n                \n    ###*\n    * Creates a token-object for a specified text-code.\n    * \n    * @method createToken\n    * @param {string} code - The code/type of the text-code.\n    * @param {string} value - The value of the text-code.\n    * @return {Object} The token-object.\n    ###\n    createToken: (code, value) ->\n        tokenObject = null\n        \n        switch code\n            when \"CE\"\n                data = value.split(\"/\")\n                value = data.shift()\n                value = if isNaN(value) then value else parseInt(value)\n                for i in [0...data]\n                    if data[i].startsWith('\"') and data[i].endsWith('\"')\n                        data[i] = data[i].substring(1, data[i].length-1)\n                    else\n                        data[i] = if isNaN(data[i]) then data[i] else parseFloat(data[i])\n                tokenObject = { code: code, value: value, values: data  }\n            else\n                tokenObject = super(code, value)\n       \n                \n        return tokenObject \n    ###*\n    * <p>Measures a control-token. If a token produces a visual result like displaying an icon then it must return the size taken by\n    * the visual result. If the token has no visual result, <b>null</b> must be returned. This method is called for every token when the message is initialized.</p> \n    *\n    * <p>This method is not called while the message is running. For that case, see <i>processControlToken</i> method which is called\n    * for every token while the message is running.</p>\n    *\n    * @param {Object} token - A control-token.\n    * @return {gs.Size} The size of the area taken by the visual result of the token or <b>null</b> if the token has no visual result.\n    * @method analyzeControlToken\n    * @protected\n    ###\n    measureControlToken: (token) -> return super(token)\n        \n    ###*\n    * <p>Draws the visual result of a token, like an icon for example, to the specified bitmap. This method is called for every token when the message is initialized and the sprites for each\n    * text-line are created.</p> \n    *\n    * <p>This method is not called while the message is running. For that case, see <i>processControlToken</i> method which is called\n    * for every token while the message is running.</p>\n    *\n    * @param {Object} token - A control-token.\n    * @param {gs.Bitmap} bitmap - The bitmap used for the current text-line. Can be used to draw something on it like an icon, etc.\n    * @param {number} offset - An x-offset for the draw-routine.\n    * @param {number} length - Determines how many characters of the token should be drawn. Can be ignored for tokens\n    * not drawing any characters.\n    * @method drawControlToken\n    * @protected\n    ###\n    drawControlToken: (token, bitmap, offset, length) ->\n        switch token.code\n            when \"RT\" # Ruby Text\n                super(token, bitmap, offset, length)\n            when \"SLK\" # Stylable Link\n                if !token.customData.offsetX?\n                    token.customData.offsetX = offset\n                if @customData.linkData\n                    linkData = @customData.linkData[@line]\n                    if linkData then for data in linkData\n                        @sprites[@line].bitmap.clearRect(data.cx,\n                                                        0,\n                                                        data.width,\n                                                        data.height)\n                \n     \n    ###*\n    * Processes a control-token. A control-token is a token which influences\n    * the text-rendering like changing the fonts color, size or style. Changes \n    * will be automatically applied to the game object's font.\n    *\n    * For message text-renderer, a few additional control-tokens like\n    * speed-change, waiting, etc. needs to be processed here.\n    *\n    * This method is called for each token while the message is initialized and\n    * also while the message is running. See <i>formattingOnly</i> parameter.\n    *\n    * @param {Object} token - A control-token.\n    * @param {boolean} formattingOnly - If <b>true</b> the message is initializing right now and only \n    * format-tokens should be processed which is necessary for the message to calculated sizes correctly.\n    * @return {Object} A new token which is processed next or <b>null</b>.\n    * @method processControlToken\n    * @protected\n    ###\n    processControlToken: (token, formattingOnly) ->\n        return super(token) if formattingOnly\n        result = null\n        \n        switch token.code\n            when \"CR\" # Change Current Character\n                character = RecordManager.charactersArray.first (c) -> (c.name.defaultText ? c.name) == token.value\n                if character\n                    SceneManager.scene.currentCharacter = character\n            when \"CE\" # Call Common Event\n                params = { \"values\": token.values }\n                @object.events?.emit(\"callCommonEvent\", @object, { commonEventId: token.value, params: params, finish: no, waiting: yes })\n            when \"X\" # Script\n                token.value?(@object)\n            when \"A\" # Play Animation\n                animation = RecordManager.animationsArray.first (a) -> a.name == token.value\n                if !animation\n                    animation = RecordManager.animations[token.value]\n                if animation?.graphic.name?\n                    bitmap = ResourceManager.getBitmap(\"Graphics/Pictures/#{animation.graphic.name}\")\n                    object = new gs.Object_Animation(animation)\n                    \n                    @addCustomObject(object)\n                    @currentX += Math.round(bitmap.width / animation.framesX)\n                    @currentSprite.srcRect.width += Math.round(bitmap.width / animation.framesX)\n            \n            when \"RT\" # Ruby Text\n                if token.rtSize.width > token.rbSize.width\n                    @currentX += token.rtSize.width\n                    @font.set(@getRubyTextFont(token))\n                else\n                    @currentX += token.rbSize.width\n                    \n            when \"LK\" # Link      \n                if token.value == 'E' # End Link\n                    object = new ui.Object_Hotspot()\n                    object.enabled = yes\n                    object.setup()\n                    \n                    @addCustomObject(object)\n                    \n                    object.dstRect.x = @object.dstRect.x + @object.origin.x + @customData.linkData.cx\n                    object.dstRect.y = @object.dstRect.y + @object.origin.y + @customData.linkData.cy\n                    object.dstRect.width = @currentX - @customData.linkData.cx\n                    object.dstRect.height = @currentLineHeight\n\n                    object.events.on(\"click\", gs.CallBack(\"onLinkClick\", this), linkData: @customData.linkData, this)\n                else # Begin Link\n                    @customData.linkData = { cx: @currentX, cy: @currentY, commonEventId: token.value, tokenIndex: @tokenIndex }\n            when \"SLK\" # Styleable Link\n                if token.value == 'E' # End Link\n                    linkData = @customData.linkData[@line].last()\n                    line = @lines[@line].content\n                    linkStart = @findToken(@tokenIndex-1, \"SLK\", -1, line)\n                    textTokens = @findTokensBetween(linkData.tokenIndex, @tokenIndex, null, line)\n                    \n                    linkData.cx = linkStart.customData.offsetX\n                    linkData.width = @currentX - linkData.cx + @padding\n                    linkData.height = @currentSprite.bitmap.height\n                    \n                    object = new ui.Object_Text()\n                    object.text = textTokens.select((x) => x.value).join(\"\")\n                    #object.sizeToFit = yes\n                    object.formatting = no\n                    object.wordWrap = no\n                    object.ui = new ui.Component_UIBehavior()\n                    object.enabled = yes\n                    object.addComponent(object.ui)\n                    object.addComponent(new gs.Component_HotspotBehavior())\n                    object.behavior.padding.left = 0\n                    object.behavior.padding.right = 0\n                    object.dstRect.width = linkData.width\n                    object.dstRect.height = linkData.height\n                    \n                    if linkData.styleIndex == -1\n                        ui.UIManager.addControlStyles(object, [\"hyperlink\"])\n                    else \n                        ui.UIManager.addControlStyles(object, [\"hyperlink-\"+linkData.styleIndex])\n                    \n                    object.setup()\n                    \n                    @addCustomObject(object)\n                    \n                    object.dstRect.x = @currentSprite.x + linkData.cx\n                    object.dstRect.y = @object.dstRect.y + @object.origin.y + linkData.cy\n\n                    object.events.on(\"click\", gs.CallBack(\"onLinkClick\", this), linkData: linkData, this)\n                else # Begin Link\n                    if !@customData.linkData\n                        @customData.linkData = []\n                    if !@customData.linkData[@line]\n                        @customData.linkData[@line] = []\n                    if token.value?.contains(\",\")\n                        values = token.value.split(\",\")\n                        @customData.linkData[@line].push({ cx: @currentX, cy: @currentY, commonEventId: values[0], styleIndex: parseInt(values[1]), tokenIndex: @tokenIndex })\n                    else\n                        @customData.linkData[@line].push({ cx: @currentY, cy: @currentY, commonEventId: token.value, tokenIndex: @tokenIndex, styleIndex: -1 })\n                    \n            when \"E\" # Change Expression\n                expression = RecordManager.characterExpressionsArray.first (c) -> (c.name.defaultText ? c.name) == token.value\n                if !expression\n                    expression = RecordManager.characterExpressions[token.value]\n                    \n                character = SceneManager.scene.currentCharacter\n                if expression? and character?.index?\n                    duration = GameManager.defaults.character.expressionDuration\n                    easing = gs.Easings.fromObject(GameManager.defaults.character.changeEasing)\n                    animation = GameManager.defaults.character.changeAnimation\n                    object = SceneManager.scene.characters.first (c) -> c.rid == character.index\n                    object?.behavior.changeExpression(expression, animation, easing, duration)\n  \n            when \"SP\" # Play Sound\n                sound = RecordManager.system.sounds[token.value-1]\n                AudioManager.playSound(sound)\n            when \"S\" # Change Speed\n                GameManager.settings.messageSpeed = token.value\n            when \"W\" # Wait\n                @drawImmediately = no\n                if !GameManager.tempSettings.skip\n                    if token.value == \"A\"\n                        @waitForKey = yes\n                    else\n                        @waitCounter = Math.round(token.value / 1000 * Graphics.frameRate)\n            when \"WE\" # Wait at End\n                @waitAtEnd = token.value == \"Y\"\n            when \"DI\" # Draw Immedialty\n                @drawImmediately = token.value == 1 or token.value == \"Y\" # Draw immediately\n            else\n                result = super(token)\n        \n        return result        \n    ###*\n    * Clears/Resets the text-renderer.\n    *\n    * @method clear\n    ###\n    clear: ->\n        @charIndex = 0\n        @currentX = 0\n        @currentY = 0\n        @line = 0\n        @lines = []\n        @clearCustomObjects()\n        @object.bitmap?.clear()\n        \n        for sprite in @allSprites\n            sprite.dispose()\n            sprite.bitmap?.dispose()\n        @allSprites = []\n        return null\n    \n    ###*\n    * Clears/Disposes all sprites used to display the text-lines/parts.\n    *\n    * @method clearAllSprites\n    ###\n    clearAllSprites: ->\n        for sprite in @allSprites\n            sprite.dispose()\n            sprite.bitmap?.dispose()\n            \n        return null\n    \n    ###*\n    * Clears/Disposes the sprites used to display the text-lines/parts of the current/last message.\n    *\n    * @method clearSprites\n    ###        \n    clearSprites: ->\n        for sprite in @sprites\n            sprite.dispose()\n            sprite.bitmap?.dispose()\n            \n        return null\n    \n    \n    ###*\n    * Removes a game object from the message.\n    *\n    * @method removeCustomObject\n    * @param object {gs.Object_Base} The game object to remove.\n    ###\n    removeCustomObject: (object) ->\n        SceneManager.scene.removeObject(object)\n        object.dispose()\n        @customObjects.remove(object)\n        \n    ###*\n    * Adds a game object to the message which is alive until the message is\n    * erased. Can be used to display animationed-icons, etc. in a message.\n    *\n    * @method addCustomObject\n    * @param object {gs.Object_Base} The game object to add.\n    ###\n    addCustomObject: (object) ->\n        object.dstRect.x = @object.dstRect.x + @object.origin.x + @currentX\n        object.dstRect.y = @object.dstRect.y + @object.origin.y + @currentY\n        object.zIndex = @object.zIndex + 1\n        object.update()\n        \n        SceneManager.scene.addObject(object)\n        @customObjects.push(object)\n     \n    ###*\n    * Clears the list of custom game objects. All game objects are disposed and removed\n    * from the scene.\n    *\n    * @method clearCustomObjects\n    * @param object {Object} The game object to add.\n    ###   \n    clearCustomObjects: ->\n        for object in @customObjects\n            object.dispose()\n            SceneManager.scene.removeObject(object)\n            \n        @customObjects = []\n    \n    ###*\n    * Creates the bitmap for a specified line-object.\n    *\n    * @method createBitmap\n    * @private\n    * @param {Object} line - A line-object.\n    * @return {Bitmap} A newly created bitmap containing the line-text.\n    ###\n    createBitmap: (line) ->\n        @font = @object.font\n        bitmap = new Bitmap(@object.dstRect.width, Math.max(@minLineHeight, line.height))\n        bitmap.font = @font\n       \n        return bitmap\n    \n    ###*\n    * Draws the line's content on the specified bitmap.\n    *\n    * @method drawLineContent\n    * @protected\n    * @param {Object} line - A line-object which should be drawn on the bitmap.\n    * @param {gs.Bitmap} bitmap - The bitmap to draw the line's content on.\n    * @param {number} length - Determines how many characters of the specified line should be drawn. You can \n    * specify -1 to draw all characters.\n    ###\n    drawLineContent: (line, bitmap, length) ->\n        bitmap.clear()\n        currentX = @padding\n        drawAll = length == -1\n        \n        for token, i in line.content\n            break if i > @tokenIndex and !drawAll\n            if token.code?\n                size = @measureControlToken(token, bitmap)\n                @drawControlToken(token, bitmap, currentX)\n                if size then currentX += size.width\n                @processControlToken(token, yes, line)\n            else if token.value.length > 0\n                token.applyFormat(@font)\n                value = token.value\n                if !drawAll and @tokenIndex == i and value.length > length\n                    value = value.substring(0, length)\n                if value != \"\\n\"\n                    size = @font.measureTextPlain(value)  \n                    bitmap.drawText(currentX, line.height - (size.height - @font.descent) - line.descent, size.width, bitmap.height, value, 0, 0)\n                    currentX += size.width\n                \n        line.contentWidth = currentX + @font.measureTextPlain(\" \").width   \n        \n    ###*\n    * Creates the sprite for a specified line-object.\n    *\n    * @method createSprite\n    * @private\n    * @param {Object} line - A line-object.\n    * @return {Sprite} A newly created sprite object containing the line-text as bitmap.\n    ###\n    createSprite: (line) ->\n        bitmap = @createBitmap(line)\n        \n        @currentX = 0\n        @waitCounter = 0\n        @waitForKey = no\n                \n        sprite = new Sprite(Graphics.viewport)\n        sprite.bitmap = bitmap\n        sprite.visible = yes\n        sprite.z = @object.zIndex + 1\n        \n        sprite.srcRect = new Rect(0, 0, 0, bitmap.height)\n        \n        return sprite\n     \n    ###*\n    * Creates the sprites for a specified array of line-objects.\n    *\n    * @method createSprites\n    * @private\n    * @see gs.Component_MessageTextRenderer.createSprite.\n    * @param {Array} lines - An array of line-objects.\n    * @return {Array} An array of sprites.\n    ###\n    createSprites: (lines) ->\n        @fontSize = @object.font.size\n        result = []\n        for line, i in lines\n            sprite = @createSprite(line)\n            result.push(sprite)\n        return result\n    \n    ###*\n    * Starts a new line.\n    *\n    * @method newLine\n    ###\n    newLine: ->\n        @currentX = 0\n        @currentY += @currentLineHeight + @lineSpacing\n        \n    ###*\n    * Displays a formatted text immediately without any delays or animations. The\n    * Component_TextRenderer.drawFormattedText method from the base-class cannot\n    * be used here because it would render to the game object's bitmap object while\n    * this method is rendering to the sprites.\n    *\n    * @method drawFormattedTextImmediately\n    * @param {number} x - The x-coordinate of the text's position.\n    * @param {number} y - The y-coordinate of the text's position.\n    * @param {number} width - Deprecated. Can be null.\n    * @param {number} height - Deprecated. Can be null.\n    * @param {string} text - The text to draw.\n    * @param {boolean} wordWrap - If wordWrap is set to true, line-breaks are automatically created.\n    ###\n    drawFormattedTextImmediately: (x, y, width, height, text, wordWrap) ->\n        @drawFormattedText(x, y, width, height, text, wordWrap)\n        \n        loop\n            @nextChar()\n                \n            if @line >= @maxLines\n                @isRunning = no\n            else\n                @drawNext()\n                \n            break unless @isRunning\n            \n        @currentY += @currentLineHeight + @lineSpacing\n            \n        return null\n    \n    \n    ###*\n    * Starts the rendering-process for the message.\n    *\n    * @method drawFormattedText\n    * @param {number} x - The x-coordinate of the text's position.\n    * @param {number} y - The y-coordinate of the text's position.\n    * @param {number} width - Deprecated. Can be null.\n    * @param {number} height - Deprecated. Can be null.\n    * @param {string} text - The text to draw.\n    * @param {boolean} wordWrap - If wordWrap is set to true, line-breaks are automatically created.\n    ###\n    drawFormattedText: (x, y, width, height, text, wordWrap) ->\n        text = text || \" \" # Use a space character if no text is specified.\n        @font.set(@object.font)\n        @speed = 11 - Math.round(GameManager.settings.messageSpeed * 2.5)\n        @isRunning = yes\n        @drawImmediately = no\n        @lineAnimationCount = @speed\n        @currentLineHeight = 0\n        @isWaiting = no\n        @waitForKey = no\n        @charIndex = 0\n        @token = null\n        @tokenIndex = 0\n        @message = text\n        @line = 0\n        @currentLine = @line\n        currentX = @currentX #Math.max(@currentX, @padding)\n        @lines = @calculateLines(lcsm(@message), wordWrap, @currentX)\n        @sprites = @createSprites(@lines)\n        @allSprites = @allSprites.concat(@sprites)\n        @currentX = currentX\n        @currentSprite = @sprites[@line]\n        @currentSprite.x = @currentX + @object.origin.x + @object.dstRect.x\n        @maxLines = @calculateMaxLines(@lines)\n        @token = @lines[@line]?.content[@tokenIndex] || new gs.RendererToken(null, \"\")\n        \n        \n        @start()\n     \n    ###*\n    * Starts the message-rendering process.\n    *\n    * @method start\n    * @protected\n    ###     \n    start: ->\n        if GameManager.tempSettings.skip and GameManager.tempSettings.skipTime == 0\n            @instantSkip()\n        else if @maxLines == 0\n            # If first line is empty then it doesn't fit into current line, so finish.\n            if @lines[0]?.content == \"\"\n                @finish()\n            else\n                @maxLines = 1\n                @drawNext()\n        else\n            @drawNext()\n     \n    ###*\n    * Skips the current message and finishes the message-processing immediately. The message\n    * tokens are processed but not rendered.\n    *\n    * @method instantSkip\n    ###  \n    instantSkip: ->\n        loop\n            if @line < @maxLines\n                @nextChar()\n                \n            if @line >= @maxLines\n                break\n            else\n                @processToken()\n                \n            break unless @isRunning and @line < @maxLines\n        \n        @object.events?.emit(\"messageWaiting\", this)\n        @continue()\n        \n    ###*\n    * Processes the current token.\n    *\n    * @method processToken\n    ###    \n    processToken: ->\n        token = null\n        \n        if @token.code?\n            token = @processControlToken(@token, no)\n            if token?\n                @token = token\n                @token.onStart?()\n        else\n            token = @token\n            \n        return token\n            \n            \n            \ngs.Component_MessageTextRenderer = Component_MessageTextRenderer"]}
//# sourceURL=Component_MessageTextRenderer_126.js