Class BridgedSandbox

src/scripting/host/BridgedSandbox.ts:12–139

}

export class BridgedSandbox implements ISandbox {
  private _scripter:IScripter;
  private _scriptingContext:IScriptingContext;
  private _stage:StageElement;
  private _player:IPlayer;
  private _worker:OOAPIWorker;
  private _queue:SmartQueue<SandboxEvent>;

  private _isAvailable:boolean = false;

  constructor(scripter:IScripter, stage:StageElement, player:IPlayer) {
    this._scripter = scripter;
    this._scriptingContext = KagerouScripting.getContext(stage);
    this._stage = stage;
    this._player = player;
    this._worker = new OOAPIWorker(this._scripter.getWorker());
    this._queue = new SmartQueue<SandboxEvent>();

    this._bind();
  }

  get isAvailable():boolean {
    return this._isAvailable;
  }

  set isAvailable(b:boolean) {
    throw new Error('BridgedSandbox.isAvailable is read-only');
  }

  private _getDimensionsMessage():OOAPIMessage {
    return {
      'channel': 'Update:DimensionUpdate',
      'payload': {
        'stageWidth':this._stage.offsetWidth,
				'stageHeight':this._stage.offsetHeight,
				'screenWidth':window.screen.width,
				'screenHeight':window.screen.height
      }
    };
  }

  private _bind():void {
    // Handle all malformed packets by throwing them into the logger
    this._worker.setMalformedEventHandler(((e) => {
      if (e.stack) {
        this._scripter.logger.error(e.stack);
      } else {
        this._scripter.logger.error(e);
      }
    }).bind(this));

    // Add the default listener to catch all messages that are not caught and
    // throw them into the logger
    this._worker.setDefaultChannelListener(((m:OOAPIMessage) => {
      this._scripter.logger.warn('Got message for non-existant channel "' +
        m.channel + '".');
    }).bind(this));