//================================================================
// ParticleEmitter.js
// ---------------------------------------------------------------
// Copyright (c) 2018 Tsukimi
// ---------------------------------------------------------------
// Version
// 0.1.2-en 2018/07/13 add english description
// 0.1.2 2018/07/13 add feature: "moveQ", "moveQR"; fix EasingFunctions
// 0.1.1 2018/07/13 add feature: "staticToPlayer", "setAsLocal"
// 0.1.0 2018/07/12 beta release
//================================================================

/*:
 * @plugindesc ParticleEmitter
 * @author Tsukimi
 *
 * @param configName
 * @type string[]
 * @desc config files downloaded from
 * https://pixijs.io/pixi-particles-editor/
 * @default []
 *
 * @param staticToPlayer
 * @type boolean
 * @desc should emitter set to player(-1) remain exist after map transition
 * @default true
 *
 * @param enabledAll-Settings
 * @text ParticlesEnabled(All) ON/OFF Settings
 *
 * @param enabledAll-ShowInOptionMenu
 * @text Show in Option Menu
 * @parent enabledAll-Settings
 * @desc Show ParticlesEnabled(All) in Option Menu
 * @type boolean
 * @default true
 *
 * @param enabledAll-Text
 * @text Option Menu Text
 * @parent enabledAll-Settings
 * @desc text of ParticlesEnabled(All) option in option menu
 * @default Show Particles
 *
 * @param enabledAll-DefaultValue
 * @text default ON/OFF state
 * @parent enabledAll-Settings
 * @desc default value of ParticlesEnabled(All), false -> don't apply any particles
 * @type boolean
 * @default true
 *
 * @help
 *
 * ParticleEmitter
 * author：tsukimi
 *
 * description：
 * A plugin controlling pixi-particles.js
 * to make particle system in RM MV.
 *
 * you can make particle emitter config files here!:
 * https://pixijs.io/pixi-particles-editor/
 * ** First scroll down and set Rederer to Canvas2D
 *    to get correct visual effects !!
 *
 * ・create a folder named "particles" inside data/
 *   and put config file inside it
 * ・create a folder named "particles" inside img/
 *   and put particle image file inside it
 *
 * for more information, check :
 * https://forums.rpgmakerweb.com/index.php?threads/.97729/
 *
 * ---------------------------------------------------
 * plugin command：
 *
 * 　*** You can brief all "PEmitter" to "PE" for short ***
 *
 * 　createPEmitter {id} {config} {eventId} {imageNames ...}
 *    create particle emitter.
 * 　　id: id of this controller. choose a name you like!
 * 　　config: config name download from the website (.json no need)
 * 　　eventId: the event which this emitter chase
 * 　　　　　　　-1：player、0：this event、1~：event#
 * 　　　　　　　x：screen、screen：screen(only on current map)
 * 　　imageNames: image name inside img/particles/.
 *
 *    ex: createPEmitter star#1 starEmitter x star1 star2
 * 　　　Create an emitter named star#1, config is starEmitter.json,
 * 　　　position based on screen. Images are star1.png & star2.png.
 *
 *
 * 　pausePEmitter {id}
 *    pause emitting.
 *
 * 　resumePEmitter {id}
 *    resume emitting.
 *
 * 　stopPEmitter {id}
 *    stop emitter and delete after all particle i dead.
 *
 * 　deletePEmitter {id}
 * 　 delete emitter and all particles immediately.
 *
 *
 * 　setPEmitterPos {id} {x} {y}
 *    set emitter (relative) position to (x,y).
 * 　　 Besides numbers, you can also set x & y as:
 * 　　 x: Don't change from current parameter value
 * 　　 v<Number>: value of Game Variable<Number>
 * 　　 r<#1>~<#2>: Random value between #1 and #2.
 * 　　             #1 and #2 can also be variables.
 *
 *    ex: setPEmitterPos star#1 10 x
 * 　　　　set emitter star#1's x coordinate to 10. (y doesn't change)
 *
 *
 * 　movePEmitterPos {id} {x} {y} {duration} (easingFunction)
 *    move emitter (relative) position to (x,y) by {duration} frame.
 * 　　input→x: don't move
 * 　　easingFunction: move easing functions at https://easings.net/
 * 　　will be 'linear' if not specified
 *
 *    ex: movePEmitterPos star#1 -10 20 60 easeOutBounce
 * 　　　　　move emitter star#1 to (-10,20) in 60 frames, with
 * 　　　　　bouncing animation.
 *
 *
 * 　setPEmitterZ {id} {z}
 *    set emitter Z layer.
 * 　　z layer：
 * 　　　0 : lower tile
 * 　　　1 : lower character
 * 　　　3 : character
 * 　　　4 : upper tile
 * 　　　5 : upper character
 * 　　　6 : shadow of airship
 * 　　　7 : Balloon
 * 　　　8 : animation
 * 　　　9 : map destination (white rectangle)
 *
 *    ex: setPEmitterZ star#1 5
 * 　　　　set emitter star#1 z-layer to upper character.
 *
 *
 * 　setPEmitterAsLocal {id} {true/false}
 * 　　create particle to event relative position
 * 　　instead of to the map.
 * 　　（if true, event move right -> all particle move right）
 *
 *
 * 　setPEmitterStaticToPlayer {id} {true/false}
 * 　　should emitter set to player(-1) remain exist
 * 　　after map transition.(true -> exist)
 * 　　*Only effect on emitter set to player.
 *
 *
 * Advanced moving：
 * （Q：Queue、R：Routine）
 *
 * 　movePEmitterPosQ {id} {x} {y} {duration} (easingFunction)
 * 　　Add move command to move queue. Will start next move
 * 　　after last move is finish.
 *
 *    ex: movePEmitterPosQ star#1 0 20 60 easeOutBounce
 *    　  movePEmitterPosQ star#1 20 x 30 easeInBounce
 * 　　　　Move to (0,20) in 60f then move to (20,20) in 30f.
 *
 *
 * 　movePEmitterPosQR {id} {x} {y} {duration} (easingFunction)
 * 　　Add move command to routine move queue.
 * 　　will repeat moving command in routine move queue.
 *
 *    ex: movePEmitterPosQR star#1 -20 20 30
 *    　  movePEmitterPosQR star#1 20 20 30
 *    　  movePEmitterPosQR star#1 20 -20 30
 *    　  movePEmitterPosQR star#1 -20 -20 30
 *
 * 　　　　(-20,20)→(20,20)→(20,-20)→(-20,-20)→(-20,20)→…
 *
 *
 * 　clearPEmitterPosQ {id}
 * 　　clear move queue.
 *
 * 　clearPEmitterPosQR {id}
 * 　　clear routine move queue.
 *
 * ---------------------------------------------------
 * You can also create by map and event tags.
 *
 * 　*** You can brief all "PEmitter" to "PE" for short ***
 *
 * Map：
 * <PEmitter:id,config,imageNames,...>
 * 　Same as createPEmitter.
 * 　However, eventId will be set to screen.
 *
 * 　　ex：<PEmitter:star#1,starEmitter,star1,star2>
 *
 * <SetPEmitterPos:id,x,y>
 * 　Same as setPEmitterPos.
 *
 * <SetPEmitterZ:id,z>
 * 　Same as setPEmitterZ.
 *
 * <MovePEmitterPosQR:id,x,y,duration,easingFunc>
 * 　Same as movePEmitterPosQR.
 *
 *
 * event：
 * <PEmitter:id,config,imageNames,...>
 * 　Same as createPEmitter.
 * 　However, eventId will be set to this event.
 *
 * 　　ex：<PEmitter:star#1,starEmitter,star1,star2>
 *
 * <SetPEmitterPos:id,x,y>
 * 　Same as setPEmitterPos.
 *
 * <SetPEmitterZ:id,z>
 * 　Same as setPEmitterZ.
 *
 * <SetPEmitterAsLocal:id>
 * 　Same as setPEmitterPosAsLocal.
 *
 * <MovePEmitterPosQR:id,x,y,duration,easingFunc>
 * 　Same as movePEmitterPosQR.
 *
 */

/*:ja
 * @plugindesc パーティクル
 * @author Tsukimi
 *
 * @param configName
 * @text 設定ファイル名
 * @type string[]
 * @desc 使う設定ファイルの名前
 * @default []
 *
 * @param staticToPlayer
 * @text プレイヤー固定化(staticToPlayer)
 * @type boolean
 * @desc プレイヤーに設定したエミッターはマップ移動後に消さないべきか否か
 * @default true
 *
 * @param enabledAll-Settings
 * @text パーティクル表示ON/OFF設定
 *
 * @param enabledAll-ShowInOptionMenu
 * @text オプションメニューに表示する
 * @parent enabledAll-Settings
 * @desc 「パーティクル表示」のON/OFFをゲーム内のオプションメニューから設定出来るようにする
 * @type boolean
 * @default true
 *
 * @param enabledAll-Text
 * @text オプションメニューでの文言
 * @parent enabledAll-Settings
 * @desc ゲーム内オプションでのパーティクル表示ON/OFFの文言
 * @default パーティクル表示
 *
 * @param enabledAll-DefaultValue
 * @text パーティクル表示ON/OFFの初期値
 * @parent enabledAll-Settings
 * @desc パーティクル表示ON/OFFの初期値；OFF→全パーティクルを表示しない（少し軽くなる）
 * @type boolean
 * @default true
 *
 * @help
 *
 * パーティクルプラグイン
 * 作者：ツキミ
 *
 * 説明：
 * pixiビルドインの particles を pixi-particle.js で
 * コントロールするプラグインです。
 * いわゆるパーティクルシステムが出来ます！
 *
 * ・エミッターの設定ファイルは data/ に particles フォルダー
 * 　を作り、入れてください。
 * ・パーティクルの画像ファイルは img/ に particles フォルダー
 * 　を作り、入れてください。
 *
 * 詳しい説明は、
 * https://forum.tkool.jp/index.php?threads/.1073/
 * を見てください。
 *
 * ---------------------------------------------------
 * プラグインコマンド：
 *  イベントコマンド「プラグインコマンド」から実行。
 *  （パラメータの間は半角スペースで区切る）
 *
 * 　*** 以下の PEmitter を全部 PE に省略できます。 ***
 *
 * 　createPEmitter {id} {config} {eventId} {imageNames ...}
 *    エミッターを作る。
 * 　　id: エミッター識別名、調整、削除の時に使う。好きな名前をどうぞ。
 * 　　config: data/particles/ に入っているエミッターの設定ファイル
 * 　　eventId: エミッターの追従対象。
 * 　　　　　　　-1：プレイヤー、0：このイベント、1~：該当イベント
 * 　　　　　　　x：画面依存、screen：画面依存（当マップのみ）
 * 　　imageNames: img/particles/ に入っているパーティクル画像名
 * 　　　　　　　　　複数あったら半角空白で区切る
 *
 *    例: createPEmitter star#1 starEmitter x star1 star2
 * 　　　名前がstar#1のエミッターを作り、設定ファイルをstarEmitter.jsonにし、
 * 　　　画面依存にする。パーティクルの画像はstar1.pngとstar2.png。
 *
 *
 * 　pausePEmitter {id}
 *    エミッターを一時中断する。
 *
 * 　resumePEmitter {id}
 *    エミッターを再開する。
 *
 * 　stopPEmitter {id}
 *    エミッターを中止する。（パーティクルが全部消えたあと削除する）
 *
 * 　deletePEmitter {id}
 *    エミッターを中止する。（すぐにすべてのパーティクルを削除する）
 *
 *
 * 　setPEmitterPos {id} {x} {y}
 *    エミッターの相対位置を(x,y)に設置する。
 * 　　x,y の値は数字以外、以下の文字も設定可能です。
 * 　　　x: 現在のパラメータ（パラメータを変えない）
 * 　　　v<数字>: 変数番号<数字>の値を代入する
 * 　　　r<#1>~<#2>: #1~#2の間の乱数生成。
 * 　　　            #1と#2もv<数字>で指定可能。
 *
 *    例: setPEmitterPos star#1 10 x
 * 　　　　star#1のx座標を10にする。（yは変えない）
 *
 *
 * 　movePEmitterPos {id} {x} {y} {duration} (easingFunction)
 *    エミッターの相対位置を{duration}フレーム掛けて(x,y)に移動する。
 * 　　数値→x: 調整しない
 * 　　easingFunction: 移動のアニメーション（徐々に加速、減速等）
 * 　　指定が無ければ linear になります
 * 　　詳しくは：https://easings.net/ja
 *
 *    例: movePEmitterPos star#1 -10 20 60 easeOutBounce
 * 　　　　star#1を60フレームかけて(-10, 20)に移動する。
 * 　　　　（アニメ：跳ね返る）
 *
 *
 * 　setPEmitterZ {id} {z}
 *    エミッターのzレイヤーを変える。
 * 　　zレイヤー参照：
 * 　　　0 : 下層タイル
 * 　　　1 : 通常キャラの下
 * 　　　3 : 通常キャラと同じ
 * 　　　4 : 上層タイル
 * 　　　5 : 通常キャラの上
 * 　　　6 : 飛行船の影
 * 　　　7 : フキダシ
 * 　　　8 : アニメーション
 * 　　　9 : マップタッチの行き先（白く光るヤツ）
 *
 *    例: setPEmitterZ star#1 5
 * 　　　　発射位置を通常キャラの上にする。
 *
 *
 * 　setPEmitterAsLocal {id} {true/false}
 *    マップにではなく、
 * 　　イベントの相対位置にパーティクルを生成するかどうか。
 * 　　（trueにすると、キャラが右に一マス移動する
 * 　　　→全パーティクルも右に一マス移動する）
 *
 *
 * 　setPEmitterStaticToPlayer {id} {true/false}
 *    プレイヤーに設定したエミッターは
 *    　マップ移動後に消さないべきか否か。
 * 　　プレイヤーに適用しているエミッターにしか効果がない。
 *
 *
 * 高度な移動コマンド：
 * （Q：Queue、R：Routine）
 *
 * 　movePEmitterPosQ {id} {x} {y} {duration} (easingFunction)
 * 　　移動コマンドの待ち列に新しい移動を追加する。
 * 　　前の移動が終わった後、自動で次の移動が再生される。
 * 　　主に移動コマンドを一気に指定したい時に使う。
 *
 *    例: movePEmitterPosQ star#1 0 20 60 easeOutBounce
 *    　  movePEmitterPosQ star#1 20 x 30 easeInBounce
 * 　　　　(0,20)に移動した後、(20,20)に移動する
 *
 *
 * 　movePEmitterPosQR {id} {x} {y} {duration} (easingFunction)
 * 　　ループ移動コマンド配列に移動を追加する。
 *
 *    例: movePEmitterPosQR star#1 -20 20 30
 *    　  movePEmitterPosQR star#1 20 20 30
 *    　  movePEmitterPosQR star#1 20 -20 30
 *    　  movePEmitterPosQR star#1 -20 -20 30
 *
 * 　　　　(-20,20)→(20,20)→(20,-20)→(-20,-20)→(-20,20)→…
 * 　　　　辺の長さが40の正方形に沿って時計回りに移動し続ける。
 *
 *
 * 　clearPEmitterPosQ {id}
 * 　　移動コマンドの待ち列をクリアする。
 *
 * 　clearPEmitterPosQR {id}
 * 　　ループ移動コマンド配列をクリアする。
 *
 * ---------------------------------------------------
 * タグによるエミッター自動生成も可能。
 *
 * 　*** 以下の PEmitter を全部 PE に省略できます。 ***
 *
 * マップ：
 * <PEmitter:id,config,imageNames,...>
 * 　コマンド createPEmitter と同じ効果。
 * 　ただし、 eventId は screen になる。（指定できない）
 *
 * 　　例：<PEmitter:star#1,starEmitter,star1,star2>
 *
 * <SetPEmitterPos:id,x,y>
 * 　コマンド setPEmitterPos と同じ効果。
 *
 * <SetPEmitterZ:id,z>
 * 　コマンド setPEmitterZ と同じ効果。
 *
 * <MovePEmitterPosQR:id,x,y,duration,easingFunc>
 * 　コマンド movePEmitterPosQR と同じ効果。
 *
 *
 * イベント：
 * <PEmitter:id,config,imageNames,...>
 * 　コマンド createPEmitter と同じ効果。
 * 　ただし、 eventId は 該当イベントのid になる。（指定できない）
 *
 * 　　例：<PEmitter:star#1,starEmitter,star1,star2>
 *
 * <SetPEmitterPos:id,x,y>
 * 　コマンド setPEmitterPos と同じ効果。
 *
 * <SetPEmitterZ:id,z>
 * 　コマンド setPEmitterZ と同じ効果。
 *
 * <SetPEmitterAsLocal:id>
 * 　コマンド setPEmitterAsLocal id true と同じ効果。
 *
 * <MovePEmitterPosQR:id,x,y,duration,easingFunc>
 * 　コマンド movePEmitterPosQR と同じ効果。
 *
 */

var $particleConfig = {};

function Object_PEmitter() {
  this.initialize.apply(this, arguments);
}
/*
Object_PEmitter.prototype = Object.create(Sprite.prototype);
Object_PEmitter.prototype.constructor = Object_PEmitter;
*/

function Game_PEmitter() {
  this.initialize.apply(this, arguments);
}

DataManager.loadParticleConfig = function (src) {
  var xhr = new XMLHttpRequest();
  var url = "data/particles/" + src + ".json";
  xhr.open("GET", url);
  xhr.overrideMimeType("application/json");
  xhr.onload = function () {
    if (xhr.status < 400) {
      $particleConfig[src] = JSON.parse(xhr.responseText);
    }
  };
  xhr.onerror = function () {
    DataManager._errorUrl = DataManager._errorUrl || url;
  };
  xhr.send();
};

(function () {
  "use strict";

  //=============================================================================
  //  Plugin parameter
  //
  //=============================================================================
  var pluginName = "ParticleEmitter";
  var getParamString = function (paramNames) {
    if (!Array.isArray(paramNames)) paramNames = [paramNames];
    for (var i = 0; i < paramNames.length; i++) {
      var name = PluginManager.parameters(pluginName)[paramNames[i]];
      if (name) return name;
    }
    return null;
  };

  var getParamBoolean = function (paramNames) {
    var value = getParamString(paramNames);
    return (value || "").toUpperCase() === "TRUE";
  };

  var configArr = JSON.parse(getParamString(["configName"]));
  if (configArr) {
    for (var i = 0; i < configArr.length; i++) {
      DataManager.loadParticleConfig(configArr[i]);
    }
  }

  //=============================================================================
  // Game_Interpreter
  //  プラグインコマンド[P_DRAG]などを追加定義します。
  //=============================================================================

  var _Game_Interpreter_pluginCommand =
    Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    _Game_Interpreter_pluginCommand.apply(this, arguments);
    var id, dur;
    switch ((command || "").toUpperCase()) {
      case "CREATEPE":
      case "CREATEPEMITTER":
        // args: id, config, eventId, [imageNames ...]
        var id = args.shift();
        var config = args.shift();
        if (!$particleConfig[config]) return;
        var eventId = args.shift();
        if (eventId.toUpperCase() === "SCREEN") eventId = 0;
        else {
          eventId = getNumberOrX(eventId);
          if (eventId === 0) eventId = this._eventId;
        }
        $gameMap.createPEmitter(id, args, config, eventId);
        break;

      case "PAUSEPE":
      case "PAUSEPEMITTER":
        $gameMap.pausePEmitter(args[0]);
        break;

      case "RESUMEPE":
      case "RESUMEPEMITTER":
        $gameMap.resumePEmitter(args[0]);
        break;

      case "ENABLEPEMITTER":
        $gameMap.enablePEmitter(args[0], getBoolean(args[1]));
        break;

      case "STOPPE":
      case "STOPPEMITTER":
        $gameMap.stopPEmitter(args[0]);
        break;

      case "DELETEPE":
      case "DELETEPEMITTER":
        $gameMap.deletePEmitter(args[0]);
        break;

      case "SETPEPOS":
      case "SETPEMITTERPOS":
        $gameMap.setPEmitterPos(
          args[0],
          getNumberOrX(args[1]),
          getNumberOrX(args[2])
        );
        break;

      case "SETPEZ":
      case "SETPEMITTERZ":
        $gameMap.setPEmitterZ(args[0], getNumberOrX(args[1]));
        break;

      case "SETPEASLOCAL":
      case "SETPEMITTERASLOCAL":
        $gameMap.setPEmitterAsLocal(args[0], args[1].toUpperCase() === "TRUE");
        break;

      case "SETPESTATICTOPLAYER":
      case "SETPEMITTERSTATICTOPLAYER":
        $gameMap.setPEmitterStaticToPlayer(
          args[0],
          args[1].toUpperCase() === "TRUE"
        );
        break;

      case "MOVEPEPOS":
      case "MOVEPEMITTERPOS":
        $gameMap.movePEmitterPos(args[0], [
          getNumberOrX(args[1]),
          getNumberOrX(args[2]),
          Number(args[3]) || 1,
          args[4] || "linear",
        ]);
        break;

      case "MOVEPEPOSQ":
      case "MOVEPEMITTERPOSQ":
        $gameMap.movePEmitterPosQ(args[0], [
          getNumberOrX(args[1]),
          getNumberOrX(args[2]),
          Number(args[3]) || 1,
          args[4] || "linear",
        ]);
        break;

      case "MOVEPEPOSQR":
      case "MOVEPEMITTERPOSQR":
        $gameMap.movePEmitterPosQR(args[0], [
          getNumberOrX(args[1]),
          getNumberOrX(args[2]),
          Number(args[3]) || 1,
          args[4] || "linear",
        ]);
        break;

      case "CLEARPEPOSQ":
      case "CLEARPEMITTERPOSQ":
        $gameMap.ClearPEmitterPosQ(args[0]);
        break;

      case "CLEARPEPOSQR":
      case "CLEARPEMITTERPOSQR":
        $gameMap.ClearPEmitterPosQR(args[0]);
        break;
    }
  };

  // string -> number / undefined
  function getNumberOrX(string) {
    var num;
    if (string === "" || string === "x") return undefined;
    var num = Number(string);
    if (typeof num === "number" && !isNaN(num)) return num;
    if (string[0] === "v") {
      num = Number(string.slice(1)) || 0;
      return $gameVariables.value(num);
    }
    if (string[0] === "r") {
      num = string.slice(1).split("~");
      var num1 = getNumberOrX(num[0]) || 0,
        num2 = getNumberOrX(num[1]) || 0;
      if (num1 > num2) {
        var t = num1;
        num1 = num2;
        num2 = t;
      }
      return Math.random() * (num2 - num1) + num1;
    }
    return undefined;
  }

  function getBoolean(string) {
    return (string || "").toUpperCase() === "TRUE";
  }

  //==================
  // Object_PEmitter
  //==================

  Object_PEmitter.prototype.initialize = function (e) {
    this._gameObject = e;
    this.createEmitter(e);
    var origin = SceneManager._scene._spriteset._tilemap.origin;
    this._startOPos = new Point(origin.x, origin.y);
  };

  Object_PEmitter.prototype.createEmitter = function (e) {
    var emitterContainer = new PIXI.Container();
    emitterContainer.z = e._z;
    var art = [];
    for (var i = 0; i < e._imageNames.length; i++) {
      if (e._imageNames[i] === "") continue;
      art.push(new Sprite(ImageManager.loadParticle(e._imageNames[i])).texture);
    }
    var emitter = new PIXI.particles.Emitter(
      emitterContainer,
      art,
      $particleConfig[e._config]
    );
    emitter.emit = true;
    for (var key in e._totalParam) {
      if (this[key]) this[key] = e._totalParam[key];
    }

    this._emitterContainer = emitterContainer;
    this._emitter = emitter;
  };

  Object_PEmitter.prototype.update = function () {
    this.updateEnableState();
    this.updateParameter();
    this.updateEmit();
    this.updatePos();
    this.updateTime();
  };

  Object_PEmitter.prototype.updateEnableState = function () {
    this._emitterContainer.renderable =
      Game_PEmitter.enabledAll && this._gameObject.enabled;
  };

  Object_PEmitter.prototype.updateParameter = function () {
    var e = this._gameObject._updateParam;
    for (var key in e) {
      if (this[key]) this[key] = e[key];
      delete e[key];
    }
  };

  Object_PEmitter.prototype.updateEmit = function () {
    var e = this._gameObject,
      e2 = this._emitter;
    if ((e._stop && !this._emitter.particleCount) || e._delete)
      this._delete = true;
    else if (e._pause || e._stop) this._emitter._emit = false;
    else if (
      e2.emitterLifetime > 0 &&
      e2._emitterLife == e2.emitterLifetime &&
      !e2.emit
    ) {
      if (!e2.particleCount) {
        $gameMap.deletePEmitter(e._id);
        this._delete = true;
      }
    } else this._emitter._emit = true;
  };

  Object_PEmitter.prototype.updateTime = function () {
    this._emitter.update(0.016);
  };

  Object_PEmitter.prototype.updatePos = function () {
    var e = this._gameObject;
    if (!isNaN(e._eventId) && e._eventId !== 0) {
      var event;
      if (e._eventId > 0) event = $gameMap.event(e._eventId);
      else if (e._eventId < 0) event = $gamePlayer;

      if (e._isLocal) {
        this._emitterContainer.x = event.screenX();
        this._emitterContainer.y = event.screenY();
        this._emitter.updateOwnerPos(e._shiftX, e._shiftY);
      } else {
        var curOPos = SceneManager._scene._spriteset._tilemap.origin;
        var dx = curOPos.x - this._startOPos.x,
          dy = curOPos.y - this._startOPos.y;
        this._emitterContainer.x = -dx;
        this._emitterContainer.y = -dy;
        this._emitter.updateOwnerPos(
          event.screenX() + dx + e._shiftX,
          event.screenY() + dy + e._shiftY
        );
      }
    } else this._emitter.updateOwnerPos(e._shiftX, e._shiftY);
    this._emitterContainer.z = e._z;
  };

  //==================
  // Game_PEmitter
  //==================

  Game_PEmitter.enabledAll = getParamBoolean("enabledAll-DefaultValue");

  Game_PEmitter.prototype.initialize = function (
    id,
    imageNames,
    config,
    eventId
  ) {
    this._pause = false;
    this._stop = false;
    this._delete = false;

    this._id = id;
    if (typeof imageNames === "string") imageNames = [imageNames];
    this._imageNames = imageNames;
    this._config = config;

    this._eventId = eventId;
    if (this._eventId !== undefined) this._mapId = $gameMap.mapId();
    if (getParamBoolean("staticToPlayer") && this._eventId < 0)
      this._mapId = undefined;
    this._shiftX = 0;
    this._shiftY = 0;
    this._z = 3;
    this._isLocal = false;
    this._totalParam = {};
    this._updateParam = {};

    this._moveRoute = null;
    this._moveRouteQ = [];
    this._moveRouteQR = [];

    this.enabled = true;
  };

  Game_PEmitter.prototype.pause = function () {
    this._pause = true;
  };

  Game_PEmitter.prototype.resume = function () {
    this._pause = false;
  };

  Game_PEmitter.prototype.stop = function () {
    this._stop = true;
  };

  Game_PEmitter.prototype.enable = function (enabled) {
    this.enabled = enabled;
  };

  Game_PEmitter.prototype.delete = function () {
    this._delete = true;
    // if($gameMap._PEmitterArr[this._id]) delete $gameMap._PEmitterArr[this._id];
  };

  Game_PEmitter.prototype.setPos = function (x, y) {
    if (x || x === 0) this._shiftX = x;
    if (y || y === 0) this._shiftY = y;
    delete this._moveRoute;
  };

  Game_PEmitter.prototype.setZ = function (z) {
    if (z || z === 0) this._z = z;
  };

  Game_PEmitter.prototype.setAsLocal = function (isLocal) {
    this._isLocal = isLocal;
  };

  Game_PEmitter.prototype.setParam = function (key, value) {
    this._totalParam[key] = value;
    this._updateParam[key] = value;
  };

  Game_PEmitter.prototype.createMoveRoute = function (args) {
    if (!args) return;
    this._moveRoute = {
      t: 0,
      b: [this._shiftX, this._shiftY],
      c: [args[0] - this._shiftX, args[1] - this._shiftY],
      d: args[2],
      easefunc: args[3],
    };
  };

  Game_PEmitter.prototype.clearMoveRoute = function () {
    delete this._moveRoute;
  };

  Game_PEmitter.prototype.createMoveRouteQ = function (args) {
    this._moveRouteQ.push(args);
  };

  Game_PEmitter.prototype.clearMoveRouteQ = function () {
    this._moveRouteQ = [];
  };

  Game_PEmitter.prototype.createMoveRouteQR = function (args) {
    this._moveRouteQR.push(args);
  };

  Game_PEmitter.prototype.clearMoveRouteQR = function () {
    this._moveRouteQR = [];
  };

  Game_PEmitter.prototype.update = function () {
    this.updateMove();
  };

  Game_PEmitter.prototype.updateMove = function () {
    if (!this._moveRoute) {
      this.getMoveRouteFromQ();
      if (!this._moveRoute) {
        this.copyMoveRouteQR();
        this.getMoveRouteFromQ();
        if (!this._moveRoute) return;
      }
    }
    var m = this._moveRoute;
    m.t++;
    this._shiftX = EasingFunctions[m.easefunc](m.t, m.b[0], m.c[0], m.d);
    this._shiftY = EasingFunctions[m.easefunc](m.t, m.b[1], m.c[1], m.d);
    if (m.t >= m.d) delete this._moveRoute;
  };

  Game_PEmitter.prototype.getMoveRouteFromQ = function () {
    this.createMoveRoute(this._moveRouteQ.shift());
  };

  Game_PEmitter.prototype.copyMoveRouteQR = function () {
    this._moveRouteQ = this._moveRouteQR.slice();
  };

  Game_PEmitter.prototype.setStaticToPlayer = function (isStatic) {
    if (isNaN(this._eventId) || this._eventId >= 0) return;
    if (isStatic) this._mapId = undefined;
    else this._mapId = $gameMap.mapId();
  };

  //==================
  // ImageManager
  //
  // add loadParticle
  //==================

  ImageManager.loadParticle = function (filename, hue) {
    return this.loadBitmap("img/particles/", filename, hue, true);
  };

  //===================
  // Game_Map (& Game_Screen 1 function)
  //
  // add controling functions
  //===================

  var _Game_Map_initialize = Game_Map.prototype.initialize;
  Game_Map.prototype.initialize = function () {
    _Game_Map_initialize.apply(this, arguments);
    this._PEmitterArr = {};
  };

  var _Game_Screen_update = Game_Screen.prototype.update;
  Game_Screen.prototype.update = function (sceneActive) {
    _Game_Screen_update.apply(this, arguments);
    var arr = $gameMap._PEmitterArr;
    for (var key in arr) {
      if (
        arr[key]._mapId !== undefined &&
        arr[key]._mapId !== $gameMap.mapId()
      ) {
        $gameMap.deletePEmitter(key);
        continue;
      }
      arr[key].update();
    }
  };

  Game_Map.prototype.createPEmitter = function (
    id,
    imageNames,
    config,
    eventId
  ) {
    var lastEmitter = this._PEmitterArr[id];
    if (lastEmitter) {
      // TODO:
      // REMOVE EMITTER
      this.deletePEmitter(id);
    }
    var e = new Game_PEmitter(id, imageNames, config, eventId);
    this._PEmitterArr[id] = e;
  };

  Game_Map.prototype.pausePEmitter = function (id) {
    var e = this._PEmitterArr[id];
    if (!e) return;
    e.pause();
  };

  Game_Map.prototype.resumePEmitter = function (id) {
    var e = this._PEmitterArr[id];
    if (!e) return;
    e.resume();
  };

  Game_Map.prototype.enablePEmitter = function (id, enabled) {
    var e = this._PEmitterArr[id];
    if (!e) return;
    e.enable(enabled);
  };

  Game_Map.prototype.stopPEmitter = function (id) {
    var e = this._PEmitterArr[id];
    if (!e) return;
    e.stop();
    delete this._PEmitterArr[id];
  };

  Game_Map.prototype.deletePEmitter = function (id) {
    var e = this._PEmitterArr[id];
    if (!e) return;
    e.delete();
    delete this._PEmitterArr[id];
  };

  Game_Map.prototype.setPEmitterPos = function (id, x, y) {
    var e = this._PEmitterArr[id];
    if (!e) return;
    e.setPos(x, y);
  };

  Game_Map.prototype.setPEmitterZ = function (id, z) {
    var e = this._PEmitterArr[id];
    if (!e) return;
    e.setZ(z);
  };

  Game_Map.prototype.setPEmitterAsLocal = function (id, isLocal) {
    var e = this._PEmitterArr[id];
    if (!e) return;
    e.setAsLocal(isLocal);
  };

  Game_Map.prototype.setPEmitterStaticToPlayer = function (id, isStatic) {
    var e = this._PEmitterArr[id];
    if (!e) return;
    e.setStaticToPlayer(isStatic);
  };

  Game_Map.prototype.movePEmitterPos = function (id, args) {
    var e = this._PEmitterArr[id];
    if (!e) return;
    e.createMoveRoute(args);
  };

  Game_Map.prototype.movePEmitterPosQ = function (id, args) {
    var e = this._PEmitterArr[id];
    if (!e) return;
    e.createMoveRouteQ(args);
  };

  Game_Map.prototype.movePEmitterPosQR = function (id, args) {
    var e = this._PEmitterArr[id];
    if (!e) return;
    e.createMoveRouteQR(args);
  };

  Game_Map.prototype.clearPEmitterPosQ = function (id) {
    var e = this._PEmitterArr[id];
    if (!e) return;
    e.clearMoveRouteQ();
  };

  Game_Map.prototype.clearPEmitterPosQR = function (id) {
    var e = this._PEmitterArr[id];
    if (!e) return;
    e.clearMoveRouteQR();
  };

  //=========================
  // Game_Map
  //  create Emitter by tag
  //=========================

  var _Game_Map_setup = Game_Map.prototype.setup;
  Game_Map.prototype.setup = function (mapId) {
    _Game_Map_setup.apply(this, arguments);
    this.setupTKMPEmitters();
  };

  Game_Map.prototype.setupTKMPEmitters = function () {
    var ma = $dataMap.metaArray;
    if (ma === undefined) return;
    var eArray = ma.PEmitter || ma.PE;
    if (eArray) {
      for (var i = 0; i < eArray.length; i++) {
        var e = eArray[i].split(",");
        var id = e.shift().trim();
        var config = e.shift().trim();
        var eventId = 0;
        for (var i = 0; i < e.length; i++) e[i] = e[i].trim();
        this.createPEmitter(id, e, config, eventId);
      }
    }

    eArray = ma.SetPEmitterZ || ma.SetPEZ;
    if (eArray) {
      for (var i = 0; i < eArray.length; i++) {
        var e = eArray[i].split(",");
        var id = e.shift().trim();
        var z = Number(e.shift());
        if (isNaN(z)) z = 3;
        this.setPEmitterZ(id, z);
      }
    }

    eArray = ma.SetPEmitterPos || ma.SetPEPos;
    if (eArray) {
      for (var i = 0; i < eArray.length; i++) {
        var e = eArray[i].split(",");
        var id = e.shift().trim();
        var x = getNumberOrX(e.shift());
        var y = getNumberOrX(e.shift());
        this.setPEmitterPos(id, x, y);
      }
    }

    eArray = ma.MovePEmitterPosQR || ma.MovePEPosQR;
    if (eArray) {
      for (var i = 0; i < eArray.length; i++) {
        var e = eArray[i].split(",");
        var id = e.shift().trim();
        var x = getNumberOrX(e.shift());
        var y = getNumberOrX(e.shift());
        var d = Number(e.shift());
        var efunc = (e.shift() || "").trim() || "linear";
        this.movePEmitterPosQR(id, [x, y, d, efunc]);
      }
    }
  };

  //=========================
  // Game_Event
  //  create Emitter by tag
  //=========================

  var _Game_Event_initialize = Game_Event.prototype.initialize;
  Game_Event.prototype.initialize = function (mapId, eventId) {
    _Game_Event_initialize.apply(this, arguments);
    this.setupTKMPEmitters();
  };

  Game_Event.prototype.setupTKMPEmitters = function () {
    var ma = this.event().metaArray;
    if (ma === undefined) return;

    var eArray = ma.PEmitter || ma.PE;
    if (eArray) {
      for (var i = 0; i < eArray.length; i++) {
        var e = eArray[i].split(",");
        var id = e.shift().trim();
        var config = e.shift().trim();
        var eventId = this._eventId;
        for (var i = 0; i < e.length; i++) e[i] = e[i].trim();
        $gameMap.createPEmitter(id, e, config, eventId);
      }
    }

    eArray = ma.SetPEmitterZ || ma.SetPEZ;
    if (eArray) {
      for (var i = 0; i < eArray.length; i++) {
        var e = eArray[i].split(",");
        var id = e.shift().trim();
        var z = Number(e.shift());
        if (isNaN(z)) z = 3;
        $gameMap.setPEmitterZ(id, z);
      }
    }

    eArray = ma.SetPEmitterPos || ma.SetPEPos;
    if (eArray) {
      for (var i = 0; i < eArray.length; i++) {
        var e = eArray[i].split(",");
        var id = e.shift().trim();
        var x = getNumberOrX(e.shift());
        var y = getNumberOrX(e.shift());
        $gameMap.setPEmitterPos(id, x, y);
      }
    }

    eArray = ma.SetPEmitterAsLocal || ma.SetPEAsLocal;
    if (eArray) {
      for (var i = 0; i < eArray.length; i++) {
        var e = eArray[i].split(",");
        var id = e.shift().trim();
        $gameMap.setPEmitterAsLocal(id, true);
      }
    }

    eArray = ma.MovePEmitterPosQR || ma.MovePEPosQR;
    if (eArray) {
      for (var i = 0; i < eArray.length; i++) {
        var e = eArray[i].split(",");
        var id = e.shift().trim();
        var x = getNumberOrX(e.shift());
        var y = getNumberOrX(e.shift());
        var d = Number(e.shift());
        var efunc = (e.shift() || "").trim() || "linear";
        console.log(efunc);
        $gameMap.movePEmitterPosQR(id, [x, y, d, efunc]);
      }
    }
  };

  //=============================================================================
  // Scene_******
  //  拡張するプロパティを定義します。 filterConを観測してfilterを作ります。
  //=============================================================================

  var _Scene_Map_initialize = Scene_Map.prototype.initialize;
  Scene_Map.prototype.initialize = function () {
    _Scene_Map_initialize.apply(this, arguments);
    this._PEmitterArr = {};
  };

  var _Scene_Map_updateMain = Scene_Map.prototype.updateMain;
  Scene_Map.prototype.updateMain = function () {
    _Scene_Map_updateMain.apply(this, arguments);
    this.updatePEmitters();
  };

  Scene_Map.prototype.updatePEmitters = function () {
    var createArr = [];
    var obj = $gameMap._PEmitterArr;
    for (var key in obj) {
      if (!this._PEmitterArr[key]) createArr.push(obj[key]);
    }

    for (var i = 0; i < createArr.length; i++)
      this.createPEmitter(createArr[i]);

    for (var key in this._PEmitterArr) {
      var value = this._PEmitterArr[key];
      value.update();
      if (value._delete) {
        value._emitterContainer.parent.removeChild(value._emitterContainer);
        delete this._PEmitterArr[key];
      }
    }
  };

  Scene_Map.prototype.createPEmitter = function (gameEmitter) {
    var emitter = new Object_PEmitter(gameEmitter);
    this._PEmitterArr[gameEmitter._id] = emitter;
    this._spriteset._tilemap.addChild(emitter._emitterContainer);
  };

  //========================
  // DataManager
  //  multi-tag extension,
  //  load config json file
  //========================

  if (!DataManager.extractMetadataArray) {
    var _DataManager_extractMetadata = DataManager.extractMetadata;
    DataManager.extractMetadata = function (data) {
      _DataManager_extractMetadata.apply(this, arguments);
      this.extractMetadataArray(data);
    };

    DataManager.extractMetadataArray = function (data) {
      var re = /<([^<>:]+)(:?)([^>]*)>/g;
      data.metaArray = {};
      var match = true;
      while (match) {
        match = re.exec(data.note);
        if (match) {
          var metaName = match[1];
          data.metaArray[metaName] = data.metaArray[metaName] || [];
          data.metaArray[metaName].push(match[2] === ":" ? match[3] : true);
        }
      }
    };
  }

  //=============================================================================
  // Window_Options
  //  拡張するプロパティを定義します。
  //=============================================================================

  var _Window_Options_makeCommandList =
    Window_Options.prototype.makeCommandList;
  Window_Options.prototype.makeCommandList = function () {
    _Window_Options_makeCommandList.apply(this, arguments);
    this.addPEmitterOptions();
  };

  Window_Options.prototype.addPEmitterOptions = function () {
    if (getParamBoolean("enabledAll-ShowInOptionMenu"))
      this.addCommand(getParamString("enabledAll-Text"), "PEmitterEnabledAll");
  };

  Object.defineProperty(ConfigManager, "PEmitterEnabledAll", {
    get: function () {
      return !!Game_PEmitter.enabledAll;
    },
    set: function (value) {
      Game_PEmitter.enabledAll = !!value;
    },
    configurable: true,
  });

  var _ConfigManager_makeData = ConfigManager.makeData;
  ConfigManager.makeData = function () {
    var config = _ConfigManager_makeData.apply(this, arguments);
    config.PEmitterEnabledAll = this.PEmitterEnabledAll;
    return config;
  };

  var _ConfigManager_applyData = ConfigManager.applyData;
  ConfigManager.applyData = function (config) {
    _ConfigManager_applyData.apply(this, arguments);
    if (config["PEmitterEnabledAll"] === undefined) {
      // 初回読み込み？
      this.PEmitterEnabledAll = Game_PEmitter.enabledAll;
    } else
      this.PEmitterEnabledAll = this.readFlag(config, "PEmitterEnabledAll");
  };
})();

/*!
 * pixi-particles - v3.0.0
 * Compiled Mon, 12 Feb 2018 04:21:37 UTC
 * Copyright (c) 2015 CloudKid
 *
 * pixi-particles is licensed under the MIT License.
 * http://www.opensource.org/licenses/mit-license
 */
/*!
 * pixi-particles - v3.0.0
 * Compiled Mon, 12 Feb 2018 04:21:37 UTC
 *
 * pixi-particles is licensed under the MIT License.
 * http://www.opensource.org/licenses/mit-license
 */
!(function (t) {
  if ("object" == typeof exports && "undefined" != typeof module)
    module.exports = t();
  else if ("function" == typeof define && define.amd) define([], t);
  else {
    var e;
    (e =
      "undefined" != typeof window
        ? window
        : "undefined" != typeof global
        ? global
        : "undefined" != typeof self
        ? self
        : this),
      (e.pixiParticles = t());
  }
})(function () {
  return (function () {
    function t(e, i, s) {
      function a(n, o) {
        if (!i[n]) {
          if (!e[n]) {
            var h = "function" == typeof require && require;
            if (!o && h) return h(n, !0);
            if (r) return r(n, !0);
            var l = new Error("Cannot find module '" + n + "'");
            throw ((l.code = "MODULE_NOT_FOUND"), l);
          }
          var p = (i[n] = { exports: {} });
          e[n][0].call(
            p.exports,
            function (t) {
              var i = e[n][1][t];
              return a(i || t);
            },
            p,
            p.exports,
            t,
            e,
            i,
            s
          );
        }
        return i[n].exports;
      }
      for (
        var r = "function" == typeof require && require, n = 0;
        n < s.length;
        n++
      )
        a(s[n]);
      return a;
    }
    return t;
  })()(
    {
      1: [
        function (t, e, i) {
          "use strict";
          var s =
            (this && this.__extends) ||
            (function () {
              var t =
                Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array &&
                  function (t, e) {
                    t.__proto__ = e;
                  }) ||
                function (t, e) {
                  for (var i in e) e.hasOwnProperty(i) && (t[i] = e[i]);
                };
              return function (e, i) {
                function s() {
                  this.constructor = e;
                }
                t(e, i),
                  (e.prototype =
                    null === i
                      ? Object.create(i)
                      : ((s.prototype = i.prototype), new s()));
              };
            })();
          Object.defineProperty(i, "__esModule", { value: !0 });
          var a = t("./Particle"),
            r = PIXI.Texture,
            n = (function (t) {
              function e(e) {
                var i = t.call(this, e) || this;
                return (
                  (i.textures = null),
                  (i.duration = 0),
                  (i.framerate = 0),
                  (i.elapsed = 0),
                  (i.loop = !1),
                  i
                );
              }
              return (
                s(e, t),
                (e.prototype.init = function () {
                  this.Particle_init(),
                    (this.elapsed = 0),
                    this.framerate < 0 &&
                      ((this.duration = this.maxLife),
                      (this.framerate = this.textures.length / this.duration));
                }),
                (e.prototype.applyArt = function (t) {
                  (this.textures = t.textures),
                    (this.framerate = t.framerate),
                    (this.duration = t.duration),
                    (this.loop = t.loop);
                }),
                (e.prototype.update = function (t) {
                  var e = this.Particle_update(t);
                  if (e >= 0) {
                    (this.elapsed += t),
                      this.elapsed > this.duration &&
                        (this.loop
                          ? (this.elapsed = this.elapsed % this.duration)
                          : (this.elapsed = this.duration - 1e-6));
                    var i = (this.elapsed * this.framerate + 1e-7) | 0;
                    this.texture = this.textures[i] || PIXI.Texture.EMPTY;
                  }
                  return e;
                }),
                (e.prototype.destroy = function () {
                  this.Particle_destroy(), (this.textures = null);
                }),
                (e.parseArt = function (t) {
                  for (var e, i, s, a, n, o = [], h = 0; h < t.length; ++h) {
                    (e = t[h]),
                      (o[h] = i = {}),
                      (i.textures = n = []),
                      (s = e.textures);
                    for (var l = 0; l < s.length; ++l)
                      if ("string" == typeof (a = s[l])) n.push(r.fromImage(a));
                      else if (a instanceof r) n.push(a);
                      else {
                        var p = a.count || 1;
                        for (
                          a =
                            "string" == typeof a.texture
                              ? r.fromImage(a.texture)
                              : a.texture;
                          p > 0;
                          --p
                        )
                          n.push(a);
                      }
                    "matchLife" == e.framerate
                      ? ((i.framerate = -1), (i.duration = 0), (i.loop = !1))
                      : ((i.loop = !!e.loop),
                        (i.framerate = e.framerate > 0 ? e.framerate : 60),
                        (i.duration = n.length / i.framerate));
                  }
                  return o;
                }),
                e
              );
            })(a.default);
          i.default = n;
        },
        { "./Particle": 3 },
      ],
      2: [
        function (t, e, i) {
          "use strict";
          Object.defineProperty(i, "__esModule", { value: !0 });
          var s = t("./ParticleUtils"),
            a = t("./Particle"),
            r = t("./PropertyNode"),
            n = PIXI.ticker.shared,
            o = new PIXI.Point(),
            h = (function () {
              function t(t, e, i) {
                (this._particleConstructor = a.default),
                  (this.particleImages = null),
                  (this.startAlpha = null),
                  (this.startSpeed = null),
                  (this.minimumSpeedMultiplier = 1),
                  (this.acceleration = null),
                  (this.maxSpeed = NaN),
                  (this.startScale = null),
                  (this.minimumScaleMultiplier = 1),
                  (this.startColor = null),
                  (this.minLifetime = 0),
                  (this.maxLifetime = 0),
                  (this.minStartRotation = 0),
                  (this.maxStartRotation = 0),
                  (this.noRotation = !1),
                  (this.minRotationSpeed = 0),
                  (this.maxRotationSpeed = 0),
                  (this.particleBlendMode = 0),
                  (this.customEase = null),
                  (this.extraData = null),
                  (this._frequency = 1),
                  (this.spawnChance = 1),
                  (this.maxParticles = 1e3),
                  (this.emitterLifetime = -1),
                  (this.spawnPos = null),
                  (this.spawnType = null),
                  (this._spawnFunc = null),
                  (this.spawnRect = null),
                  (this.spawnCircle = null),
                  (this.particlesPerWave = 1),
                  (this.particleSpacing = 0),
                  (this.angleStart = 0),
                  (this.rotation = 0),
                  (this.ownerPos = null),
                  (this._prevEmitterPos = null),
                  (this._prevPosIsValid = !1),
                  (this._posChanged = !1),
                  (this._parent = null),
                  (this.addAtBack = !1),
                  (this.particleCount = 0),
                  (this._emit = !1),
                  (this._spawnTimer = 0),
                  (this._emitterLife = -1),
                  (this._activeParticlesFirst = null),
                  (this._activeParticlesLast = null),
                  (this._poolFirst = null),
                  (this._origConfig = null),
                  (this._origArt = null),
                  (this._autoUpdate = !1),
                  (this._destroyWhenComplete = !1),
                  (this._completeCallback = null),
                  (this.parent = t),
                  e && i && this.init(e, i),
                  (this.recycle = this.recycle),
                  (this.update = this.update),
                  (this.rotate = this.rotate),
                  (this.updateSpawnPos = this.updateSpawnPos),
                  (this.updateOwnerPos = this.updateOwnerPos);
              }
              return (
                Object.defineProperty(t.prototype, "frequency", {
                  get: function () {
                    return this._frequency;
                  },
                  set: function (t) {
                    this._frequency = "number" == typeof t && t > 0 ? t : 1;
                  },
                  enumerable: !0,
                  configurable: !0,
                }),
                Object.defineProperty(t.prototype, "particleConstructor", {
                  get: function () {
                    return this._particleConstructor;
                  },
                  set: function (t) {
                    if (t != this._particleConstructor) {
                      (this._particleConstructor = t), this.cleanup();
                      for (var e = this._poolFirst; e; e = e.next) e.destroy();
                      (this._poolFirst = null),
                        this._origConfig &&
                          this._origArt &&
                          this.init(this._origArt, this._origConfig);
                    }
                  },
                  enumerable: !0,
                  configurable: !0,
                }),
                Object.defineProperty(t.prototype, "parent", {
                  get: function () {
                    return this._parent;
                  },
                  set: function (t) {
                    this.cleanup(), (this._parent = t);
                  },
                  enumerable: !0,
                  configurable: !0,
                }),
                (t.prototype.init = function (t, e) {
                  if (t && e) {
                    this.cleanup(),
                      (this._origConfig = e),
                      (this._origArt = t),
                      (t = Array.isArray(t) ? t.slice() : [t]);
                    var i = this._particleConstructor;
                    (this.particleImages = i.parseArt ? i.parseArt(t) : t),
                      e.alpha
                        ? (this.startAlpha = r.default.createList(e.alpha))
                        : (this.startAlpha = new r.default(1, 0)),
                      e.speed
                        ? ((this.startSpeed = r.default.createList(e.speed)),
                          (this.minimumSpeedMultiplier =
                            e.speed.minimumSpeedMultiplier || 1))
                        : ((this.minimumSpeedMultiplier = 1),
                          (this.startSpeed = new r.default(0, 0)));
                    var a = e.acceleration;
                    a && (a.x || a.y)
                      ? ((this.startSpeed.next = null),
                        (this.acceleration = new PIXI.Point(a.x, a.y)),
                        (this.maxSpeed = e.maxSpeed || NaN))
                      : (this.acceleration = new PIXI.Point()),
                      e.scale
                        ? ((this.startScale = r.default.createList(e.scale)),
                          (this.minimumScaleMultiplier =
                            e.scale.minimumScaleMultiplier || 1))
                        : ((this.startScale = new r.default(1, 0)),
                          (this.minimumScaleMultiplier = 1)),
                      e.color
                        ? (this.startColor = r.default.createList(e.color))
                        : (this.startColor = new r.default(
                            { r: 255, g: 255, b: 255 },
                            0
                          )),
                      e.startRotation
                        ? ((this.minStartRotation = e.startRotation.min),
                          (this.maxStartRotation = e.startRotation.max))
                        : (this.minStartRotation = this.maxStartRotation = 0),
                      e.noRotation &&
                      (this.minStartRotation || this.maxStartRotation)
                        ? (this.noRotation = !!e.noRotation)
                        : (this.noRotation = !1),
                      e.rotationSpeed
                        ? ((this.minRotationSpeed = e.rotationSpeed.min),
                          (this.maxRotationSpeed = e.rotationSpeed.max))
                        : (this.minRotationSpeed = this.maxRotationSpeed = 0),
                      (this.minLifetime = e.lifetime.min),
                      (this.maxLifetime = e.lifetime.max),
                      (this.particleBlendMode = s.default.getBlendMode(
                        e.blendMode
                      )),
                      e.ease
                        ? (this.customEase =
                            "function" == typeof e.ease
                              ? e.ease
                              : s.default.generateEase(e.ease))
                        : (this.customEase = null),
                      i.parseData
                        ? (this.extraData = i.parseData(e.extraData))
                        : (this.extraData = e.extraData || null),
                      (this.spawnRect = this.spawnCircle = null),
                      (this.particlesPerWave = 1),
                      e.particlesPerWave &&
                        e.particlesPerWave > 1 &&
                        (this.particlesPerWave = e.particlesPerWave),
                      (this.particleSpacing = 0),
                      (this.angleStart = 0);
                    var n;
                    switch (e.spawnType) {
                      case "rect":
                        (this.spawnType = "rect"),
                          (this._spawnFunc = this._spawnRect);
                        var o = e.spawnRect;
                        this.spawnRect = new PIXI.Rectangle(o.x, o.y, o.w, o.h);
                        break;
                      case "circle":
                        (this.spawnType = "circle"),
                          (this._spawnFunc = this._spawnCircle),
                          (n = e.spawnCircle),
                          (this.spawnCircle = new PIXI.Circle(n.x, n.y, n.r));
                        break;
                      case "ring":
                        (this.spawnType = "ring"),
                          (this._spawnFunc = this._spawnRing),
                          (n = e.spawnCircle),
                          (this.spawnCircle = new PIXI.Circle(n.x, n.y, n.r)),
                          (this.spawnCircle.minRadius = n.minR);
                        break;
                      case "burst":
                        (this.spawnType = "burst"),
                          (this._spawnFunc = this._spawnBurst),
                          (this.particleSpacing = e.particleSpacing),
                          (this.angleStart = e.angleStart ? e.angleStart : 0);
                        break;
                      case "point":
                      default:
                        (this.spawnType = "point"),
                          (this._spawnFunc = this._spawnPoint);
                    }
                    (this.frequency = e.frequency),
                      (this.spawnChance =
                        "number" == typeof e.spawnChance && e.spawnChance > 0
                          ? e.spawnChance
                          : 1),
                      (this.emitterLifetime = e.emitterLifetime || -1),
                      (this.maxParticles =
                        e.maxParticles > 0 ? e.maxParticles : 1e3),
                      (this.addAtBack = !!e.addAtBack),
                      (this.rotation = 0),
                      (this.ownerPos = new PIXI.Point()),
                      (this.spawnPos = new PIXI.Point(e.pos.x, e.pos.y)),
                      (this._prevEmitterPos = this.spawnPos.clone()),
                      (this._prevPosIsValid = !1),
                      (this._spawnTimer = 0),
                      (this.emit = void 0 === e.emit || !!e.emit),
                      (this.autoUpdate =
                        void 0 !== e.autoUpdate && !!e.autoUpdate);
                  }
                }),
                (t.prototype.recycle = function (t) {
                  t.next && (t.next.prev = t.prev),
                    t.prev && (t.prev.next = t.next),
                    t == this._activeParticlesLast &&
                      (this._activeParticlesLast = t.prev),
                    t == this._activeParticlesFirst &&
                      (this._activeParticlesFirst = t.next),
                    (t.prev = null),
                    (t.next = this._poolFirst),
                    (this._poolFirst = t),
                    t.parent && t.parent.removeChild(t),
                    --this.particleCount;
                }),
                (t.prototype.rotate = function (t) {
                  if (this.rotation != t) {
                    var e = t - this.rotation;
                    (this.rotation = t),
                      s.default.rotatePoint(e, this.spawnPos),
                      (this._posChanged = !0);
                  }
                }),
                (t.prototype.updateSpawnPos = function (t, e) {
                  (this._posChanged = !0),
                    (this.spawnPos.x = t),
                    (this.spawnPos.y = e);
                }),
                (t.prototype.updateOwnerPos = function (t, e) {
                  (this._posChanged = !0),
                    (this.ownerPos.x = t),
                    (this.ownerPos.y = e);
                }),
                (t.prototype.resetPositionTracking = function () {
                  this._prevPosIsValid = !1;
                }),
                Object.defineProperty(t.prototype, "emit", {
                  get: function () {
                    return this._emit;
                  },
                  set: function (t) {
                    (this._emit = !!t),
                      (this._emitterLife = this.emitterLifetime);
                  },
                  enumerable: !0,
                  configurable: !0,
                }),
                Object.defineProperty(t.prototype, "autoUpdate", {
                  get: function () {
                    return this._autoUpdate;
                  },
                  set: function (t) {
                    this._autoUpdate && !t
                      ? n.remove(this.update, this)
                      : !this._autoUpdate && t && n.add(this.update, this),
                      (this._autoUpdate = !!t);
                  },
                  enumerable: !0,
                  configurable: !0,
                }),
                (t.prototype.playOnceAndDestroy = function (t) {
                  (this.autoUpdate = !0),
                    (this.emit = !0),
                    (this._destroyWhenComplete = !0),
                    (this._completeCallback = t);
                }),
                (t.prototype.playOnce = function (t) {
                  (this.emit = !0), (this._completeCallback = t);
                }),
                (t.prototype.update = function (t) {
                  if (
                    (this._autoUpdate &&
                      (t = t / PIXI.settings.TARGET_FPMS / 1e3),
                    this._parent)
                  ) {
                    var e, i, s;
                    for (i = this._activeParticlesFirst; i; i = s)
                      (s = i.next), i.update(t);
                    var a, r;
                    this._prevPosIsValid &&
                      ((a = this._prevEmitterPos.x),
                      (r = this._prevEmitterPos.y));
                    var n = this.ownerPos.x + this.spawnPos.x,
                      o = this.ownerPos.y + this.spawnPos.y;
                    if (this._emit)
                      for (this._spawnTimer -= t; this._spawnTimer <= 0; ) {
                        if (
                          this._emitterLife > 0 &&
                          ((this._emitterLife -= this._frequency),
                          this._emitterLife <= 0)
                        ) {
                          (this._spawnTimer = 0),
                            (this._emitterLife = 0),
                            (this.emit = !1);
                          break;
                        }
                        if (this.particleCount >= this.maxParticles)
                          this._spawnTimer += this._frequency;
                        else {
                          var h = void 0;
                          if (
                            ((h =
                              this.minLifetime == this.maxLifetime
                                ? this.minLifetime
                                : Math.random() *
                                    (this.maxLifetime - this.minLifetime) +
                                  this.minLifetime),
                            -this._spawnTimer < h)
                          ) {
                            var l = void 0,
                              p = void 0;
                            if (this._prevPosIsValid && this._posChanged) {
                              var c = 1 + this._spawnTimer / t;
                              (l = (n - a) * c + a), (p = (o - r) * c + r);
                            } else (l = n), (p = o);
                            e = 0;
                            for (
                              var u = Math.min(
                                this.particlesPerWave,
                                this.maxParticles - this.particleCount
                              );
                              e < u;
                              ++e
                            )
                              if (
                                !(
                                  this.spawnChance < 1 &&
                                  Math.random() >= this.spawnChance
                                )
                              ) {
                                var d = void 0;
                                if (
                                  (this._poolFirst
                                    ? ((d = this._poolFirst),
                                      (this._poolFirst = this._poolFirst.next),
                                      (d.next = null))
                                    : (d = new this.particleConstructor(this)),
                                  this.particleImages.length > 1
                                    ? d.applyArt(
                                        this.particleImages[
                                          Math.floor(
                                            Math.random() *
                                              this.particleImages.length
                                          )
                                        ]
                                      )
                                    : d.applyArt(this.particleImages[0]),
                                  d.alphaList.reset(this.startAlpha),
                                  1 != this.minimumSpeedMultiplier &&
                                    (d.speedMultiplier =
                                      Math.random() *
                                        (1 - this.minimumSpeedMultiplier) +
                                      this.minimumSpeedMultiplier),
                                  d.speedList.reset(this.startSpeed),
                                  (d.acceleration.x = this.acceleration.x),
                                  (d.acceleration.y = this.acceleration.y),
                                  (d.maxSpeed = this.maxSpeed),
                                  1 != this.minimumScaleMultiplier &&
                                    (d.scaleMultiplier =
                                      Math.random() *
                                        (1 - this.minimumScaleMultiplier) +
                                      this.minimumScaleMultiplier),
                                  d.scaleList.reset(this.startScale),
                                  d.colorList.reset(this.startColor),
                                  this.minRotationSpeed == this.maxRotationSpeed
                                    ? (d.rotationSpeed = this.minRotationSpeed)
                                    : (d.rotationSpeed =
                                        Math.random() *
                                          (this.maxRotationSpeed -
                                            this.minRotationSpeed) +
                                        this.minRotationSpeed),
                                  (d.noRotation = this.noRotation),
                                  (d.maxLife = h),
                                  (d.blendMode = this.particleBlendMode),
                                  (d.ease = this.customEase),
                                  (d.extraData = this.extraData),
                                  this._spawnFunc(d, l, p, e),
                                  d.init(),
                                  d.update(-this._spawnTimer),
                                  d.parent)
                                ) {
                                  var f = this._parent.children;
                                  if (f[0] == d) f.shift();
                                  else if (f[f.length - 1] == d) f.pop();
                                  else {
                                    var m = f.indexOf(d);
                                    f.splice(m, 1);
                                  }
                                  this.addAtBack ? f.unshift(d) : f.push(d);
                                } else
                                  this.addAtBack
                                    ? this._parent.addChildAt(d, 0)
                                    : this._parent.addChild(d);
                                this._activeParticlesLast
                                  ? ((this._activeParticlesLast.next = d),
                                    (d.prev = this._activeParticlesLast),
                                    (this._activeParticlesLast = d))
                                  : (this._activeParticlesLast =
                                      this._activeParticlesFirst =
                                        d),
                                  ++this.particleCount;
                              }
                          }
                          this._spawnTimer += this._frequency;
                        }
                      }
                    this._posChanged &&
                      ((this._prevEmitterPos.x = n),
                      (this._prevEmitterPos.y = o),
                      (this._prevPosIsValid = !0),
                      (this._posChanged = !1)),
                      this._emit ||
                        this._activeParticlesFirst ||
                        (this._completeCallback && this._completeCallback(),
                        this._destroyWhenComplete && this.destroy());
                  }
                }),
                (t.prototype._spawnPoint = function (t, e, i) {
                  this.minStartRotation == this.maxStartRotation
                    ? (t.rotation = this.minStartRotation + this.rotation)
                    : (t.rotation =
                        Math.random() *
                          (this.maxStartRotation - this.minStartRotation) +
                        this.minStartRotation +
                        this.rotation),
                    (t.position.x = e),
                    (t.position.y = i);
                }),
                (t.prototype._spawnRect = function (t, e, i) {
                  this.minStartRotation == this.maxStartRotation
                    ? (t.rotation = this.minStartRotation + this.rotation)
                    : (t.rotation =
                        Math.random() *
                          (this.maxStartRotation - this.minStartRotation) +
                        this.minStartRotation +
                        this.rotation),
                    (o.x =
                      Math.random() * this.spawnRect.width + this.spawnRect.x),
                    (o.y =
                      Math.random() * this.spawnRect.height + this.spawnRect.y),
                    0 !== this.rotation &&
                      s.default.rotatePoint(this.rotation, o),
                    (t.position.x = e + o.x),
                    (t.position.y = i + o.y);
                }),
                (t.prototype._spawnCircle = function (t, e, i) {
                  this.minStartRotation == this.maxStartRotation
                    ? (t.rotation = this.minStartRotation + this.rotation)
                    : (t.rotation =
                        Math.random() *
                          (this.maxStartRotation - this.minStartRotation) +
                        this.minStartRotation +
                        this.rotation),
                    (o.x = Math.random() * this.spawnCircle.radius),
                    (o.y = 0),
                    s.default.rotatePoint(360 * Math.random(), o),
                    (o.x += this.spawnCircle.x),
                    (o.y += this.spawnCircle.y),
                    0 !== this.rotation &&
                      s.default.rotatePoint(this.rotation, o),
                    (t.position.x = e + o.x),
                    (t.position.y = i + o.y);
                }),
                (t.prototype._spawnRing = function (t, e, i) {
                  var a = this.spawnCircle;
                  this.minStartRotation == this.maxStartRotation
                    ? (t.rotation = this.minStartRotation + this.rotation)
                    : (t.rotation =
                        Math.random() *
                          (this.maxStartRotation - this.minStartRotation) +
                        this.minStartRotation +
                        this.rotation),
                    a.minRadius !== a.radius
                      ? (o.x =
                          Math.random() * (a.radius - a.minRadius) +
                          a.minRadius)
                      : (o.x = a.radius),
                    (o.y = 0);
                  var r = 360 * Math.random();
                  (t.rotation += r),
                    s.default.rotatePoint(r, o),
                    (o.x += this.spawnCircle.x),
                    (o.y += this.spawnCircle.y),
                    0 !== this.rotation &&
                      s.default.rotatePoint(this.rotation, o),
                    (t.position.x = e + o.x),
                    (t.position.y = i + o.y);
                }),
                (t.prototype._spawnBurst = function (t, e, i, s) {
                  0 === this.particleSpacing
                    ? (t.rotation = 360 * Math.random())
                    : (t.rotation =
                        this.angleStart +
                        this.particleSpacing * s +
                        this.rotation),
                    (t.position.x = e),
                    (t.position.y = i);
                }),
                (t.prototype.cleanup = function () {
                  var t, e;
                  for (t = this._activeParticlesFirst; t; t = e)
                    (e = t.next),
                      this.recycle(t),
                      t.parent && t.parent.removeChild(t);
                  (this._activeParticlesFirst = this._activeParticlesLast =
                    null),
                    (this.particleCount = 0);
                }),
                (t.prototype.destroy = function () {
                  (this.autoUpdate = !1), this.cleanup();
                  for (var t, e = this._poolFirst; e; e = t)
                    (t = e.next), e.destroy();
                  this._poolFirst =
                    this._parent =
                    this.particleImages =
                    this.spawnPos =
                    this.ownerPos =
                    this.startColor =
                    this.startScale =
                    this.startAlpha =
                    this.startSpeed =
                    this.customEase =
                    this._completeCallback =
                      null;
                }),
                t
              );
            })();
          i.default = h;
        },
        { "./Particle": 3, "./ParticleUtils": 4, "./PropertyNode": 7 },
      ],
      3: [
        function (t, e, i) {
          "use strict";
          var s =
            (this && this.__extends) ||
            (function () {
              var t =
                Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array &&
                  function (t, e) {
                    t.__proto__ = e;
                  }) ||
                function (t, e) {
                  for (var i in e) e.hasOwnProperty(i) && (t[i] = e[i]);
                };
              return function (e, i) {
                function s() {
                  this.constructor = e;
                }
                t(e, i),
                  (e.prototype =
                    null === i
                      ? Object.create(i)
                      : ((s.prototype = i.prototype), new s()));
              };
            })();
          Object.defineProperty(i, "__esModule", { value: !0 });
          var a = t("./ParticleUtils"),
            r = t("./PropertyList"),
            n = PIXI.Sprite,
            o = (function (t) {
              function e(i) {
                var s = t.call(this) || this;
                return (
                  (s.emitter = i),
                  (s.anchor.x = s.anchor.y = 0.5),
                  (s.velocity = new PIXI.Point()),
                  (s.maxLife = 0),
                  (s.age = 0),
                  (s.ease = null),
                  (s.extraData = null),
                  (s.alphaList = new r.default()),
                  (s.speedList = new r.default()),
                  (s.speedMultiplier = 1),
                  (s.acceleration = new PIXI.Point()),
                  (s.maxSpeed = NaN),
                  (s.scaleList = new r.default()),
                  (s.scaleMultiplier = 1),
                  (s.colorList = new r.default(!0)),
                  (s._doAlpha = !1),
                  (s._doScale = !1),
                  (s._doSpeed = !1),
                  (s._doAcceleration = !1),
                  (s._doColor = !1),
                  (s._doNormalMovement = !1),
                  (s._oneOverLife = 0),
                  (s.next = null),
                  (s.prev = null),
                  (s.init = s.init),
                  (s.Particle_init = e.prototype.init),
                  (s.update = s.update),
                  (s.Particle_update = e.prototype.update),
                  (s.Sprite_destroy = t.prototype.destroy),
                  (s.Particle_destroy = e.prototype.destroy),
                  (s.applyArt = s.applyArt),
                  (s.kill = s.kill),
                  s
                );
              }
              return (
                s(e, t),
                (e.prototype.init = function () {
                  (this.age = 0),
                    (this.velocity.x =
                      this.speedList.current.value * this.speedMultiplier),
                    (this.velocity.y = 0),
                    a.default.rotatePoint(this.rotation, this.velocity),
                    this.noRotation
                      ? (this.rotation = 0)
                      : (this.rotation *= a.default.DEG_TO_RADS),
                    (this.rotationSpeed *= a.default.DEG_TO_RADS),
                    (this.alpha = this.alphaList.current.value),
                    (this.scale.x = this.scale.y =
                      this.scaleList.current.value),
                    (this._doAlpha = !!this.alphaList.current.next),
                    (this._doSpeed = !!this.speedList.current.next),
                    (this._doScale = !!this.scaleList.current.next),
                    (this._doColor = !!this.colorList.current.next),
                    (this._doAcceleration =
                      0 !== this.acceleration.x || 0 !== this.acceleration.y),
                    (this._doNormalMovement =
                      this._doSpeed ||
                      0 !== this.speedList.current.value ||
                      this._doAcceleration),
                    (this._oneOverLife = 1 / this.maxLife);
                  var t = this.colorList.current.value;
                  (this.tint = a.default.combineRGBComponents(t.r, t.g, t.b)),
                    (this.visible = !0);
                }),
                (e.prototype.applyArt = function (t) {
                  this.texture = t || PIXI.Texture.EMPTY;
                }),
                (e.prototype.update = function (t) {
                  if (((this.age += t), this.age >= this.maxLife))
                    return this.kill(), -1;
                  var e = this.age * this._oneOverLife;
                  if (
                    (this.ease &&
                      (e =
                        4 == this.ease.length
                          ? this.ease(e, 0, 1, 1)
                          : this.ease(e)),
                    this._doAlpha &&
                      (this.alpha = this.alphaList.interpolate(e)),
                    this._doScale)
                  ) {
                    var i =
                      this.scaleList.interpolate(e) * this.scaleMultiplier;
                    this.scale.x = this.scale.y = i;
                  }
                  if (this._doNormalMovement) {
                    if (this._doSpeed) {
                      var s =
                        this.speedList.interpolate(e) * this.speedMultiplier;
                      a.default.normalize(this.velocity),
                        a.default.scaleBy(this.velocity, s);
                    } else if (
                      this._doAcceleration &&
                      ((this.velocity.x += this.acceleration.x * t),
                      (this.velocity.y += this.acceleration.y * t),
                      this.maxSpeed)
                    ) {
                      var r = a.default.length(this.velocity);
                      r > this.maxSpeed &&
                        a.default.scaleBy(this.velocity, this.maxSpeed / r);
                    }
                    (this.position.x += this.velocity.x * t),
                      (this.position.y += this.velocity.y * t);
                  }
                  return (
                    this._doColor &&
                      (this.tint = this.colorList.interpolate(e)),
                    0 !== this.rotationSpeed
                      ? (this.rotation += this.rotationSpeed * t)
                      : this.acceleration &&
                        !this.noRotation &&
                        (this.rotation = Math.atan2(
                          this.velocity.y,
                          this.velocity.x
                        )),
                    e
                  );
                }),
                (e.prototype.kill = function () {
                  this.emitter.recycle(this);
                }),
                (e.prototype.destroy = function () {
                  this.parent && this.parent.removeChild(this),
                    this.Sprite_destroy(),
                    (this.emitter =
                      this.velocity =
                      this.colorList =
                      this.scaleList =
                      this.alphaList =
                      this.speedList =
                      this.ease =
                      this.next =
                      this.prev =
                        null);
                }),
                (e.parseArt = function (t) {
                  var e;
                  for (e = t.length; e >= 0; --e)
                    "string" == typeof t[e] &&
                      (t[e] = PIXI.Texture.fromImage(t[e]));
                  if (a.default.verbose)
                    for (e = t.length - 1; e > 0; --e)
                      if (t[e].baseTexture != t[e - 1].baseTexture) {
                        window.console &&
                          console.warn(
                            "PixiParticles: using particle textures from different images may hinder performance in WebGL"
                          );
                        break;
                      }
                  return t;
                }),
                (e.parseData = function (t) {
                  return t;
                }),
                e
              );
            })(n);
          i.default = o;
        },
        { "./ParticleUtils": 4, "./PropertyList": 6 },
      ],
      4: [
        function (t, e, i) {
          "use strict";
          Object.defineProperty(i, "__esModule", { value: !0 });
          var s = PIXI.BLEND_MODES,
            a = t("./PropertyNode"),
            r = {
              verbose: !1,
              DEG_TO_RADS: Math.PI / 180,
              rotatePoint: function (t, e) {
                if (t) {
                  t *= r.DEG_TO_RADS;
                  var i = Math.sin(t),
                    s = Math.cos(t),
                    a = e.x * s - e.y * i,
                    n = e.x * i + e.y * s;
                  (e.x = a), (e.y = n);
                }
              },
              combineRGBComponents: function (t, e, i) {
                return (t << 16) | (e << 8) | i;
              },
              normalize: function (t) {
                var e = 1 / r.length(t);
                (t.x *= e), (t.y *= e);
              },
              scaleBy: function (t, e) {
                (t.x *= e), (t.y *= e);
              },
              length: function (t) {
                return Math.sqrt(t.x * t.x + t.y * t.y);
              },
              hexToRGB: function (t, e) {
                e || (e = {}),
                  "#" == t.charAt(0)
                    ? (t = t.substr(1))
                    : 0 === t.indexOf("0x") && (t = t.substr(2));
                var i;
                return (
                  8 == t.length && ((i = t.substr(0, 2)), (t = t.substr(2))),
                  (e.r = parseInt(t.substr(0, 2), 16)),
                  (e.g = parseInt(t.substr(2, 2), 16)),
                  (e.b = parseInt(t.substr(4, 2), 16)),
                  i && (e.a = parseInt(i, 16)),
                  e
                );
              },
              generateEase: function (t) {
                var e = t.length,
                  i = 1 / e;
                return function (s) {
                  var a,
                    r,
                    n = (e * s) | 0;
                  return (
                    (a = (s - n * i) * e),
                    (r = t[n] || t[e - 1]),
                    r.s + a * (2 * (1 - a) * (r.cp - r.s) + a * (r.e - r.s))
                  );
                };
              },
              getBlendMode: function (t) {
                if (!t) return s.NORMAL;
                for (t = t.toUpperCase(); t.indexOf(" ") >= 0; )
                  t = t.replace(" ", "_");
                return s[t] || s.NORMAL;
              },
              createSteppedGradient: function (t, e) {
                void 0 === e && (e = 10),
                  ("number" != typeof e || e <= 0) && (e = 10);
                var i = new a.default(t[0].value, t[0].time);
                i.isStepped = !0;
                for (var s = i, n = t[0], o = 1, h = t[o], l = 1; l < e; ++l) {
                  for (var p = l / e; p > h.time; ) (n = h), (h = t[++o]);
                  p = (p - n.time) / (h.time - n.time);
                  var c = r.hexToRGB(n.value),
                    u = r.hexToRGB(h.value),
                    d = {};
                  (d.r = (u.r - c.r) * p + c.r),
                    (d.g = (u.g - c.g) * p + c.g),
                    (d.b = (u.b - c.b) * p + c.b),
                    (s.next = new a.default(d, l / e)),
                    (s = s.next);
                }
                return i;
              },
            };
          i.default = r;
        },
        { "./PropertyNode": 7 },
      ],
      5: [
        function (t, e, i) {
          "use strict";
          var s =
            (this && this.__extends) ||
            (function () {
              var t =
                Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array &&
                  function (t, e) {
                    t.__proto__ = e;
                  }) ||
                function (t, e) {
                  for (var i in e) e.hasOwnProperty(i) && (t[i] = e[i]);
                };
              return function (e, i) {
                function s() {
                  this.constructor = e;
                }
                t(e, i),
                  (e.prototype =
                    null === i
                      ? Object.create(i)
                      : ((s.prototype = i.prototype), new s()));
              };
            })();
          Object.defineProperty(i, "__esModule", { value: !0 });
          var a = t("./ParticleUtils"),
            r = t("./Particle"),
            n = new PIXI.Point(),
            o = [
              "pow",
              "sqrt",
              "abs",
              "floor",
              "round",
              "ceil",
              "E",
              "PI",
              "sin",
              "cos",
              "tan",
              "asin",
              "acos",
              "atan",
              "atan2",
              "log",
            ],
            h = new RegExp(
              ["[01234567890\\.\\*\\-\\+\\/\\(\\)x ,]"].concat(o).join("|"),
              "g"
            ),
            l = function (t) {
              for (var e = t.match(h), i = e.length - 1; i >= 0; --i)
                o.indexOf(e[i]) >= 0 && (e[i] = "Math." + e[i]);
              return (t = e.join("")), new Function("x", "return " + t + ";");
            },
            p = (function (t) {
              function e(e) {
                var i = t.call(this, e) || this;
                return (
                  (i.path = null),
                  (i.initialRotation = 0),
                  (i.initialPosition = new PIXI.Point()),
                  (i.movement = 0),
                  i
                );
              }
              return (
                s(e, t),
                (e.prototype.init = function () {
                  (this.initialRotation = this.rotation),
                    this.Particle_init(),
                    (this.path = this.extraData.path),
                    (this._doNormalMovement = !this.path),
                    (this.movement = 0),
                    (this.initialPosition.x = this.position.x),
                    (this.initialPosition.y = this.position.y);
                }),
                (e.prototype.update = function (t) {
                  var e = this.Particle_update(t);
                  if (e >= 0 && this.path) {
                    var i =
                      this.speedList.interpolate(e) * this.speedMultiplier;
                    (this.movement += i * t),
                      (n.x = this.movement),
                      (n.y = this.path(this.movement)),
                      a.default.rotatePoint(this.initialRotation, n),
                      (this.position.x = this.initialPosition.x + n.x),
                      (this.position.y = this.initialPosition.y + n.y);
                  }
                  return e;
                }),
                (e.prototype.destroy = function () {
                  this.Particle_destroy(),
                    (this.path = this.initialPosition = null);
                }),
                (e.parseArt = function (t) {
                  return r.default.parseArt(t);
                }),
                (e.parseData = function (t) {
                  var e = {};
                  if (t && t.path)
                    try {
                      e.path = l(t.path);
                    } catch (t) {
                      a.default.verbose &&
                        console.error(
                          "PathParticle: error in parsing path expression"
                        ),
                        (e.path = null);
                    }
                  else
                    a.default.verbose &&
                      console.error(
                        "PathParticle requires a path string in extraData!"
                      ),
                      (e.path = null);
                  return e;
                }),
                e
              );
            })(r.default);
          i.default = p;
        },
        { "./Particle": 3, "./ParticleUtils": 4 },
      ],
      6: [
        function (t, e, i) {
          "use strict";
          function s(t) {
            return (
              this.ease && (t = this.ease(t)),
              (this.next.value - this.current.value) * t + this.current.value
            );
          }
          function a(t) {
            this.ease && (t = this.ease(t));
            var e = this.current.value,
              i = this.next.value,
              s = (i.r - e.r) * t + e.r,
              a = (i.g - e.g) * t + e.g,
              r = (i.b - e.b) * t + e.b;
            return l.default.combineRGBComponents(s, a, r);
          }
          function r(t) {
            for (this.ease && (t = this.ease(t)); t > this.next.time; )
              (this.current = this.next), (this.next = this.next.next);
            return (
              (t =
                (t - this.current.time) / (this.next.time - this.current.time)),
              (this.next.value - this.current.value) * t + this.current.value
            );
          }
          function n(t) {
            for (this.ease && (t = this.ease(t)); t > this.next.time; )
              (this.current = this.next), (this.next = this.next.next);
            t = (t - this.current.time) / (this.next.time - this.current.time);
            var e = this.current.value,
              i = this.next.value,
              s = (i.r - e.r) * t + e.r,
              a = (i.g - e.g) * t + e.g,
              r = (i.b - e.b) * t + e.b;
            return l.default.combineRGBComponents(s, a, r);
          }
          function o(t) {
            for (
              this.ease && (t = this.ease(t));
              this.next && t > this.next.time;

            )
              (this.current = this.next), (this.next = this.next.next);
            return this.current.value;
          }
          function h(t) {
            for (
              this.ease && (t = this.ease(t));
              this.next && t > this.next.time;

            )
              (this.current = this.next), (this.next = this.next.next);
            var e = this.current.value;
            return l.default.combineRGBComponents(e.r, e.g, e.b);
          }
          Object.defineProperty(i, "__esModule", { value: !0 });
          var l = t("./ParticleUtils"),
            p = (function () {
              function t(t) {
                void 0 === t && (t = !1),
                  (this.current = null),
                  (this.next = null),
                  (this.isColor = !!t),
                  (this.interpolate = null),
                  (this.ease = null);
              }
              return (
                (t.prototype.reset = function (t) {
                  (this.current = t),
                    (this.next = t.next),
                    this.next && this.next.time >= 1
                      ? (this.interpolate = this.isColor ? a : s)
                      : t.isStepped
                      ? (this.interpolate = this.isColor ? h : o)
                      : (this.interpolate = this.isColor ? n : r),
                    (this.ease = this.current.ease);
                }),
                t
              );
            })();
          i.default = p;
        },
        { "./ParticleUtils": 4 },
      ],
      7: [
        function (t, e, i) {
          "use strict";
          Object.defineProperty(i, "__esModule", { value: !0 });
          var s = t("./ParticleUtils"),
            a = (function () {
              function t(t, e, i) {
                (this.value = "string" == typeof t ? s.default.hexToRGB(t) : t),
                  (this.time = e),
                  (this.next = null),
                  (this.isStepped = !1),
                  (this.ease = i
                    ? "function" == typeof i
                      ? i
                      : s.default.generateEase(i)
                    : null);
              }
              return (
                (t.createList = function (e) {
                  if (Array.isArray(e.list)) {
                    var i = e.list,
                      s = void 0,
                      a = void 0;
                    if (
                      ((a = s = new t(i[0].value, i[0].time, e.ease)),
                      i.length > 2 ||
                        (2 === i.length && i[1].value !== i[0].value))
                    )
                      for (var r = 1; r < i.length; ++r)
                        (s.next = new t(i[r].value, i[r].time)), (s = s.next);
                    return (a.isStepped = !!e.isStepped), a;
                  }
                  var n = new t(e.start, 0);
                  return e.end !== e.start && (n.next = new t(e.end, 1)), n;
                }),
                t
              );
            })();
          i.default = a;
        },
        { "./ParticleUtils": 4 },
      ],
      8: [
        function (t, e, i) {
          "use strict";
          Object.defineProperty(i, "__esModule", { value: !0 });
          var s = t("./ParticleUtils.js");
          i.ParticleUtils = s.default;
          var a = t("./Particle.js");
          i.Particle = a.default;
          var r = t("./Emitter.js");
          i.Emitter = r.default;
          var n = t("./PathParticle.js");
          i.PathParticle = n.default;
          var o = t("./AnimatedParticle.js");
          i.AnimatedParticle = o.default;
        },
        {
          "./AnimatedParticle.js": 1,
          "./Emitter.js": 2,
          "./Particle.js": 3,
          "./ParticleUtils.js": 4,
          "./PathParticle.js": 5,
        },
      ],
      9: [
        function (t, e, i) {
          "use strict";
          if (
            (Object.defineProperty(i, "__esModule", { value: !0 }),
            "undefined" == typeof PIXI)
          )
            throw "pixi-particles requires pixi.js to be loaded first";
          PIXI.particles || (PIXI.particles = {});
          var s = t("./particles");
          for (var a in s) PIXI.particles[a] = s[a];
        },
        { "./particles": 8 },
      ],
    },
    {},
    [9]
  )(9);
});
//# sourceMappingURL=pixi-particles.js.map

/* ============================================================
 * jQuery Easing v1.3 - http://gsgd.co.uk/sandbox/jquery/easing/
 *
 * Open source under the BSD License.
 *
 * Copyright c 2008 George McGinley Smith
 * All rights reserved.
 * https://raw.github.com/danro/jquery-easing/master/LICENSE
 * ======================================================== */
var EasingFunctions;
if (EasingFunctions === undefined) {
  EasingFunctions = {
    // t: current time, b: begInnIng value, c: change In value, d: duration
    linear: function (t, b, c, d) {
      return c * (t / d) + b;
    },
    easeInQuad: function (t, b, c, d) {
      return c * (t /= d) * t + b;
    },
    easeOutQuad: function (t, b, c, d) {
      return -c * (t /= d) * (t - 2) + b;
    },
    easeInOutQuad: function (t, b, c, d) {
      if ((t /= d / 2) < 1) return (c / 2) * t * t + b;
      return (-c / 2) * (--t * (t - 2) - 1) + b;
    },
    easeInCubic: function (t, b, c, d) {
      return c * (t /= d) * t * t + b;
    },
    easeOutCubic: function (t, b, c, d) {
      return c * ((t = t / d - 1) * t * t + 1) + b;
    },
    easeInOutCubic: function (t, b, c, d) {
      if ((t /= d / 2) < 1) return (c / 2) * t * t * t + b;
      return (c / 2) * ((t -= 2) * t * t + 2) + b;
    },
    easeInQuart: function (t, b, c, d) {
      return c * (t /= d) * t * t * t + b;
    },
    easeOutQuart: function (t, b, c, d) {
      return -c * ((t = t / d - 1) * t * t * t - 1) + b;
    },
    easeInOutQuart: function (t, b, c, d) {
      if ((t /= d / 2) < 1) return (c / 2) * t * t * t * t + b;
      return (-c / 2) * ((t -= 2) * t * t * t - 2) + b;
    },
    easeInQuint: function (t, b, c, d) {
      return c * (t /= d) * t * t * t * t + b;
    },
    easeOutQuint: function (t, b, c, d) {
      return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
    },
    easeInOutQuint: function (t, b, c, d) {
      if ((t /= d / 2) < 1) return (c / 2) * t * t * t * t * t + b;
      return (c / 2) * ((t -= 2) * t * t * t * t + 2) + b;
    },
    easeInSine: function (t, b, c, d) {
      return -c * Math.cos((t / d) * (Math.PI / 2)) + c + b;
    },
    easeOutSine: function (t, b, c, d) {
      return c * Math.sin((t / d) * (Math.PI / 2)) + b;
    },
    easeInOutSine: function (t, b, c, d) {
      return (-c / 2) * (Math.cos((Math.PI * t) / d) - 1) + b;
    },
    easeInExpo: function (t, b, c, d) {
      return t == 0 ? b : c * Math.pow(2, 10 * (t / d - 1)) + b;
    },
    easeOutExpo: function (t, b, c, d) {
      return t == d ? b + c : c * (-Math.pow(2, (-10 * t) / d) + 1) + b;
    },
    easeInOutExpo: function (t, b, c, d) {
      if (t == 0) return b;
      if (t == d) return b + c;
      if ((t /= d / 2) < 1) return (c / 2) * Math.pow(2, 10 * (t - 1)) + b;
      return (c / 2) * (-Math.pow(2, -10 * --t) + 2) + b;
    },
    easeInCirc: function (t, b, c, d) {
      return -c * (Math.sqrt(1 - (t /= d) * t) - 1) + b;
    },
    easeOutCirc: function (t, b, c, d) {
      return c * Math.sqrt(1 - (t = t / d - 1) * t) + b;
    },
    easeInOutCirc: function (t, b, c, d) {
      if ((t /= d / 2) < 1) return (-c / 2) * (Math.sqrt(1 - t * t) - 1) + b;
      return (c / 2) * (Math.sqrt(1 - (t -= 2) * t) + 1) + b;
    },
    easeInElastic: function (t, b, c, d) {
      var s = 1.70158;
      var p = 0;
      var a = c;
      if (c == 0 || t == 0) return b;
      if ((t /= d) == 1) return b + c;
      if (!p) p = d * 0.3;
      if (a < Math.abs(c)) {
        a = c;
        var s = p / 4;
      } else var s = (p / (2 * Math.PI)) * Math.asin(c / a);
      return (
        -(
          a *
          Math.pow(2, 10 * (t -= 1)) *
          Math.sin(((t * d - s) * (2 * Math.PI)) / p)
        ) + b
      );
    },
    easeOutElastic: function (t, b, c, d) {
      var s = 1.70158;
      var p = 0;
      var a = c;
      if (c == 0 || t == 0) return b;
      if ((t /= d) == 1) return b + c;
      if (!p) p = d * 0.3;
      if (a < Math.abs(c)) {
        a = c;
        var s = p / 4;
      } else var s = (p / (2 * Math.PI)) * Math.asin(c / a);
      return (
        a * Math.pow(2, -10 * t) * Math.sin(((t * d - s) * (2 * Math.PI)) / p) +
        c +
        b
      );
    },
    easeInOutElastic: function (t, b, c, d) {
      var s = 1.70158;
      var p = 0;
      var a = c;
      if (c == 0 || t == 0) return b;
      if ((t /= d / 2) == 2) return b + c;
      if (!p) p = d * (0.3 * 1.5);
      if (a < Math.abs(c)) {
        a = c;
        var s = p / 4;
      } else var s = (p / (2 * Math.PI)) * Math.asin(c / a);
      if (t < 1)
        return (
          -0.5 *
            (a *
              Math.pow(2, 10 * (t -= 1)) *
              Math.sin(((t * d - s) * (2 * Math.PI)) / p)) +
          b
        );
      return (
        a *
          Math.pow(2, -10 * (t -= 1)) *
          Math.sin(((t * d - s) * (2 * Math.PI)) / p) *
          0.5 +
        c +
        b
      );
    },
    easeInBack: function (t, b, c, d, s) {
      if (s == undefined) s = 1.70158;
      return c * (t /= d) * t * ((s + 1) * t - s) + b;
    },
    easeOutBack: function (t, b, c, d, s) {
      if (s == undefined) s = 1.70158;
      return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
    },
    easeInOutBack: function (t, b, c, d, s) {
      if (s == undefined) s = 1.70158;
      if ((t /= d / 2) < 1)
        return (c / 2) * (t * t * (((s *= 1.525) + 1) * t - s)) + b;
      return (c / 2) * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2) + b;
    },
    easeInBounce: function (t, b, c, d) {
      return c - this.easeOutBounce(d - t, 0, c, d) + b;
    },
    easeOutBounce: function (t, b, c, d) {
      if ((t /= d) < 1 / 2.75) {
        return c * (7.5625 * t * t) + b;
      } else if (t < 2 / 2.75) {
        return c * (7.5625 * (t -= 1.5 / 2.75) * t + 0.75) + b;
      } else if (t < 2.5 / 2.75) {
        return c * (7.5625 * (t -= 2.25 / 2.75) * t + 0.9375) + b;
      } else {
        return c * (7.5625 * (t -= 2.625 / 2.75) * t + 0.984375) + b;
      }
    },
    easeInOutBounce: function (t, b, c, d) {
      if (t < d / 2) return this.easeInBounce(t * 2, 0, c, d) * 0.5 + b;
      return this.easeOutBounce(t * 2 - d, 0, c, d) * 0.5 + c * 0.5 + b;
    },
  };
}

/*
 *
 * TERMS OF USE - EASING EQUATIONS
 *
 * Open source under the BSD License.
 *
 * Copyright c 2001 Robert Penner
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice, this list of
 * conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright notice, this list
 * of conditions and the following disclaimer in the documentation and/or other materials
 * provided with the distribution.
 *
 * Neither the name of the author nor the names of contributors may be used to endorse
 * or promote products derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 *  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */